mirrors/hdf5
2
0
Fork 0
mirror of https://github.com/HDFGroup/hdf5.git synced 2026-09-27 04:09:40 +03:00
Code Issues Packages Projects Releases Wiki Activity
Files
5deed723e5f626defd0f841bd304fbb2d052d9b1
hdf5/test/cache.c
T
Quincey Koziol 9f60f016ab [svn-r15800] Description: 
Bring file free space branch changes through r15795 into trunk, which
includes a fair bit of code cleanup & rearrangement along with a couple of
bug fixes also.

Tested on:
        Mac OS X/32 10.5.5 (amazon) in debug mode
        Mac OS X/32 10.5.5 (amazon) w/C++ & FORTRAN, w/threadsafe,
                                in production mode
        FreeBSD/32 6.3 (duty) in debug mode
        FreeBSD/64 6.3 (liberty) w/C++ & FORTRAN, in debug mode
        Linux/32 2.6 (kagiso) w/PGI compilers, w/C++ & FORTRAN, w/threadsafe,
                                in debug mode
        Linux/64-amd64 2.6 (smirom) w/Intel compilers w/default API=1.6.x,
                                w/C++ & FORTRAN, in production mode
        Solaris/32 2.10 (linew) w/deprecated symbols disabled, w/C++ & FORTRAN,
                                w/szip filter, in production mode
        Linux/64-ia64 2.6 (cobalt) w/Intel compilers, w/C++ & FORTRAN,
                                in production mode
        Linux/64-ia64 2.4 (tg-login3) w/parallel, w/FORTRAN, in production mode
        Linux/64-amd64 2.6 (abe) w/parallel, w/FORTRAN, in production mode
2008-10-06 23:17:35 -05:00

28238 lines
947 KiB
C
Raw Blame History

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Copyright by The HDF Group. *
* Copyright by the Board of Trustees of the University of Illinois. *
* All rights reserved. *
* *
* This file is part of HDF5. The full HDF5 copyright notice, including *
* terms governing use, modification, and redistribution, is contained in *
* the files COPYING and Copyright.html. COPYING can be found at the root *
* of the source code distribution tree; Copyright.html can be found at the *
* root level of an installed copy of the electronic HDF5 document set and *
* is linked from the top-level documents page. It can also be found at *
* http://hdfgroup.org/HDF5/doc/Copyright.html. If you do not have *
* access to either file, you may request a copy from help@hdfgroup.org. *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* Programmer: John Mainzer
* 6/9/04
*
* This file contains tests for the cache implemented in
* H5C.c
*/
#include "h5test.h"
#include "H5Iprivate.h"
#include "H5ACprivate.h"
#include "cache_common.h"
/* private function declarations: */
static void smoke_check_1(void);
static void smoke_check_2(void);
static void smoke_check_3(void);
static void smoke_check_4(void);
static void smoke_check_5(void);
static void smoke_check_6(void);
static void smoke_check_7(void);
static void smoke_check_8(void);
static void smoke_check_9(void);
static void smoke_check_10(void);
static void write_permitted_check(void);
static void check_insert_entry(void);
static void check_flush_cache(void);
static void check_flush_cache__empty_cache(H5C_t * cache_ptr);
static void check_flush_cache__multi_entry(H5C_t * cache_ptr);
static void check_flush_cache__multi_entry_test(H5C_t * cache_ptr,
int test_num,
unsigned int flush_flags,
int spec_size,
struct flush_cache_test_spec spec[]);
static void check_flush_cache__pe_multi_entry_test(H5C_t * cache_ptr,
int test_num,
unsigned int flush_flags,
int spec_size,
struct pe_flush_cache_test_spec spec[]);
static void check_flush_cache__single_entry(H5C_t * cache_ptr);
static void check_flush_cache__single_entry_test(H5C_t * cache_ptr,
int test_num,
int entry_type,
int entry_idx,
hbool_t insert_flag,
hbool_t dirty_flag,
unsigned int flags,
unsigned int flush_flags,
hbool_t expected_loaded,
hbool_t expected_cleared,
hbool_t expected_flushed,
hbool_t expected_destroyed);
static void check_flush_cache__pinned_single_entry_test(H5C_t * cache_ptr,
int test_num,
int entry_type,
int entry_idx,
hbool_t dirty_flag,
hbool_t mark_dirty,
hbool_t pop_mark_dirty_prot,
hbool_t pop_mark_dirty_pinned,
hbool_t unprotect_unpin,
unsigned int flags,
unsigned int flush_flags,
hbool_t expected_cleared,
hbool_t expected_flushed,
hbool_t expected_destroyed);
static void check_flush_cache__flush_ops(H5C_t * cache_ptr);
static void check_flush_cache__flush_op_test(H5C_t * cache_ptr,
int test_num,
unsigned int flush_flags,
int spec_size,
struct fo_flush_cache_test_spec spec[],
int init_expected_index_len,
size_t init_expected_index_size,
int expected_index_len,
size_t expected_index_size,
int check_size,
struct fo_flush_entry_check check[]);
static void check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr);
static void check_flush_protected_err(void);
static void check_get_entry_status(void);
static void check_expunge_entry(void);
static void check_multiple_read_protect(void);
static void check_rename_entry(void);
static void check_rename_entry__run_test(H5C_t * cache_ptr, int test_num,
struct rename_entry_test_spec * spec_ptr);
static void check_pin_protected_entry(void);
static void check_resize_entry(void);
static void check_evictions_enabled(void);
static void check_destroy_pinned_err(void);
static void check_destroy_protected_err(void);
static void check_duplicate_insert_err(void);
static void check_rename_err(void);
static void check_double_pin_err(void);
static void check_double_unpin_err(void);
static void check_pin_entry_errs(void);
static void check_double_protect_err(void);
static void check_double_unprotect_err(void);
static void check_mark_entry_dirty_errs(void);
static void check_expunge_entry_errs(void);
static void check_resize_entry_errs(void);
static void check_unprotect_ro_dirty_err(void);
static void check_protect_ro_rw_err(void);
static void check_check_evictions_enabled_err(void);
static void check_auto_cache_resize(void);
static void check_auto_cache_resize_disable(void);
static void check_auto_cache_resize_epoch_markers(void);
static void check_auto_cache_resize_input_errs(void);
static void check_auto_cache_resize_aux_fcns(void);
/**************************************************************************/
/**************************************************************************/
/********************************* tests: *********************************/
/**************************************************************************/
/**************************************************************************/
/*-------------------------------------------------------------------------
* Function: smoke_check_1()
*
* Purpose: A basic functional test, inserts, destroys, and renames in
* the mix, along with repeated protects and unprotects.
* All entries are marked as clean.
*
* Return: void
*
* Programmer: John Mainzer
* 6/16/04
*
* Modifications:
*
* JRM -- 1/18/05
* Added code to skip this test if the skip_long_tests global
* is true.
*
*-------------------------------------------------------------------------
*/
static void
smoke_check_1(void)
{
const char * fcn_name = "smoke_check_1";
hbool_t show_progress = FALSE;
hbool_t dirty_inserts = FALSE;
int dirty_unprotects = FALSE;
int dirty_destroys = FALSE;
hbool_t display_stats = FALSE;
int32_t lag = 10;
int mile_stone = 1;
H5C_t * cache_ptr = NULL;
TESTING("smoke check #1 -- all clean, ins, dest, ren, 4/2 MB cache");
if ( skip_long_tests ) {
SKIPPED();
HDfprintf(stdout, " Long tests disabled.\n");
return;
}
pass = TRUE;
if ( show_progress ) /* 1 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
reset_entries();
if ( show_progress ) /* 2 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
cache_ptr = setup_cache((size_t)(4 * 1024 * 1024),
(size_t)(2 * 1024 * 1024));
if ( show_progress ) /* 3 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
row_major_scan_forward(/* cache_ptr */ cache_ptr,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
/* display_stats */ display_stats,
/* display_detailed_stats */ TRUE,
/* do_inserts */ TRUE,
/* dirty_inserts */ dirty_inserts,
/* do_renames */ TRUE,
/* rename_to_main_addr */ FALSE,
/* do_destroys */ TRUE,
/* do_mult_ro_protects */ TRUE,
/* dirty_destroys */ dirty_destroys,
/* dirty_unprotects */ dirty_unprotects);
if ( show_progress ) /* 4 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
row_major_scan_backward(/* cache_ptr */ cache_ptr,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
/* display_stats */ display_stats,
/* display_detailed_stats */ TRUE,
/* do_inserts */ FALSE,
/* dirty_inserts */ dirty_inserts,
/* do_renames */ TRUE,
/* rename_to_main_addr */ TRUE,
/* do_destroys */ FALSE,
/* do_mult_ro_protects */ TRUE,
/* dirty_destroys */ dirty_destroys,
/* dirty_unprotects */ dirty_unprotects);
if ( show_progress ) /* 5 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
row_major_scan_forward(/* cache_ptr */ cache_ptr,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
/* display_stats */ display_stats,
/* display_detailed_stats */ TRUE,
/* do_inserts */ TRUE,
/* dirty_inserts */ dirty_inserts,
/* do_renames */ TRUE,
/* rename_to_main_addr */ FALSE,
/* do_destroys */ FALSE,
/* do_mult_ro_protects */ TRUE,
/* dirty_destroys */ dirty_destroys,
/* dirty_unprotects */ dirty_unprotects);
if ( show_progress ) /* 6 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
/* flush and destroy all entries in the cache: */
flush_cache(/* cache_ptr */ cache_ptr,
/* destroy_entries */ TRUE,
/* dump_stats */ FALSE,
/* dump_detailed_stats */ FALSE);
if ( show_progress ) /* 7 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
col_major_scan_forward(/* cache_ptr */ cache_ptr,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
/* display_stats */ display_stats,
/* display_detailed_stats */ TRUE,
/* do_inserts */ TRUE,
/* dirty_inserts */ dirty_inserts,
/* dirty_unprotects */ dirty_unprotects);
if ( show_progress ) /* 8 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
/* flush all entries in the cache: */
flush_cache(/* cache_ptr */ cache_ptr,
/* destroy_entries */ FALSE,
/* dump_stats */ FALSE,
/* dump_detailed_stats */ FALSE);
if ( show_progress ) /* 9 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
col_major_scan_backward(/* cache_ptr */ cache_ptr,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
/* display_stats */ display_stats,
/* display_detailed_stats */ TRUE,
/* do_inserts */ TRUE,
/* dirty_inserts */ dirty_inserts,
/* dirty_unprotects */ dirty_unprotects);
if ( show_progress ) /* 10 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
takedown_cache(cache_ptr, display_stats, TRUE);
if ( show_progress ) /* 11 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
verify_clean();
verify_unprotected();
if ( pass ) { PASSED(); } else { H5_FAILED(); }
if ( ! pass ) {
HDfprintf(stdout, "%s(): failure_mssg = \"%s\".\n",
fcn_name, failure_mssg);
}
return;
} /* smoke_check_1() */
/*-------------------------------------------------------------------------
* Function: smoke_check_2()
*
* Purpose: A basic functional test, with inserts, destroys, and
* renames in the mix, along with some repeated protects
* and unprotects. About half the entries are marked as
* dirty.
*
* Return: void
*
* Programmer: John Mainzer
* 6/24/04
*
* Modifications:
*
* JRM -- 1/18/05
* Added code to skip this test if the skip_long_tests global
* is true.
*
*-------------------------------------------------------------------------
*/
static void
smoke_check_2(void)
{
const char * fcn_name = "smoke_check_2";
hbool_t show_progress = FALSE;
hbool_t dirty_inserts = TRUE;
int dirty_unprotects = TRUE;
int dirty_destroys = TRUE;
hbool_t display_stats = FALSE;
int32_t lag = 10;
int mile_stone = 1;
H5C_t * cache_ptr = NULL;
TESTING("smoke check #2 -- ~1/2 dirty, ins, dest, ren, 4/2 MB cache");
if ( skip_long_tests ) {
SKIPPED();
HDfprintf(stdout, " Long tests disabled.\n");
return;
}
pass = TRUE;
if ( show_progress ) /* 1 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
reset_entries();
if ( show_progress ) /* 2 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
cache_ptr = setup_cache((size_t)(4 * 1024 * 1024),
(size_t)(2 * 1024 * 1024));
if ( show_progress ) /* 3 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
row_major_scan_forward(/* cache_ptr */ cache_ptr,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
/* display_stats */ display_stats,
/* display_detailed_stats */ TRUE,
/* do_inserts */ TRUE,
/* dirty_inserts */ dirty_inserts,
/* do_renames */ TRUE,
/* rename_to_main_addr */ FALSE,
/* do_destroys */ TRUE,
/* do_mult_ro_protects */ TRUE,
/* dirty_destroys */ dirty_destroys,
/* dirty_unprotects */ dirty_unprotects);
if ( show_progress ) /* 4 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
row_major_scan_backward(/* cache_ptr */ cache_ptr,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
/* display_stats */ display_stats,
/* display_detailed_stats */ TRUE,
/* do_inserts */ FALSE,
/* dirty_inserts */ dirty_inserts,
/* do_renames */ TRUE,
/* rename_to_main_addr */ TRUE,
/* do_destroys */ FALSE,
/* do_mult_ro_protects */ TRUE,
/* dirty_destroys */ dirty_destroys,
/* dirty_unprotects */ dirty_unprotects);
if ( show_progress ) /* 5 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
row_major_scan_forward(/* cache_ptr */ cache_ptr,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
/* display_stats */ display_stats,
/* display_detailed_stats */ TRUE,
/* do_inserts */ TRUE,
/* dirty_inserts */ dirty_inserts,
/* do_renames */ TRUE,
/* rename_to_main_addr */ FALSE,
/* do_destroys */ FALSE,
/* do_mult_ro_protects */ TRUE,
/* dirty_destroys */ dirty_destroys,
/* dirty_unprotects */ dirty_unprotects);
if ( show_progress ) /* 6 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
/* flush and destroy all entries in the cache: */
flush_cache(/* cache_ptr */ cache_ptr,
/* destroy_entries */ TRUE,
/* dump_stats */ FALSE,
/* dump_detailed_stats */ FALSE);
if ( show_progress ) /* 7 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
col_major_scan_forward(/* cache_ptr */ cache_ptr,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
/* display_stats */ display_stats,
/* display_detailed_stats */ TRUE,
/* do_inserts */ TRUE,
/* dirty_inserts */ dirty_inserts,
/* dirty_unprotects */ dirty_unprotects);
if ( show_progress ) /* 8 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
/* flush all entries in the cache: */
flush_cache(/* cache_ptr */ cache_ptr,
/* destroy_entries */ FALSE,
/* dump_stats */ FALSE,
/* dump_detailed_stats */ FALSE);
if ( show_progress ) /* 9 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
col_major_scan_backward(/* cache_ptr */ cache_ptr,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
/* display_stats */ display_stats,
/* display_detailed_stats */ TRUE,
/* do_inserts */ TRUE,
/* dirty_inserts */ dirty_inserts,
/* dirty_unprotects */ dirty_unprotects);
if ( show_progress ) /* 10 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
takedown_cache(cache_ptr, display_stats, TRUE);
if ( show_progress ) /* 11 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
verify_clean();
verify_unprotected();
if ( pass ) { PASSED(); } else { H5_FAILED(); }
if ( ! pass ) {
HDfprintf(stdout, "%s(): failure_mssg = \"%s\".\n",
fcn_name, failure_mssg);
}
return;
} /* smoke_check_2() */
/*-------------------------------------------------------------------------
* Function: smoke_check_3()
*
* Purpose: A basic functional test on a tiny cache, with inserts,
* destroys, and renames in the mix, along with repeated
* protects and unprotects. All entries are marked as clean.
*
* Return: void
*
* Programmer: John Mainzer
* 6/16/04
*
* Modifications:
*
* JRM -- 1/18/05
* Added code to skip this test if the skip_long_tests global
* is true.
*
*-------------------------------------------------------------------------
*/
static void
smoke_check_3(void)
{
const char * fcn_name = "smoke_check_3";
hbool_t show_progress = FALSE;
hbool_t dirty_inserts = FALSE;
int dirty_unprotects = FALSE;
int dirty_destroys = FALSE;
hbool_t display_stats = FALSE;
int32_t lag = 10;
int mile_stone = 1;
H5C_t * cache_ptr = NULL;
TESTING("smoke check #3 -- all clean, ins, dest, ren, 2/1 KB cache");
if ( skip_long_tests ) {
SKIPPED();
HDfprintf(stdout, " Long tests disabled.\n");
return;
}
pass = TRUE;
if ( show_progress ) /* 1 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
reset_entries();
if ( show_progress ) /* 2 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
cache_ptr = setup_cache((size_t)(2 * 1024),
(size_t)(1 * 1024));
if ( show_progress ) /* 3 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
row_major_scan_forward(/* cache_ptr */ cache_ptr,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
/* display_stats */ display_stats,
/* display_detailed_stats */ TRUE,
/* do_inserts */ TRUE,
/* dirty_inserts */ dirty_inserts,
/* do_renames */ TRUE,
/* rename_to_main_addr */ FALSE,
/* do_destroys */ TRUE,
/* do_mult_ro_protects */ TRUE,
/* dirty_destroys */ dirty_destroys,
/* dirty_unprotects */ dirty_unprotects);
if ( show_progress ) /* 4 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
row_major_scan_backward(/* cache_ptr */ cache_ptr,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
/* display_stats */ display_stats,
/* display_detailed_stats */ TRUE,
/* do_inserts */ FALSE,
/* dirty_inserts */ dirty_inserts,
/* do_renames */ TRUE,
/* rename_to_main_addr */ TRUE,
/* do_destroys */ FALSE,
/* do_mult_ro_protects */ TRUE,
/* dirty_destroys */ dirty_destroys,
/* dirty_unprotects */ dirty_unprotects);
if ( show_progress ) /* 5 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
row_major_scan_forward(/* cache_ptr */ cache_ptr,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
/* display_stats */ display_stats,
/* display_detailed_stats */ TRUE,
/* do_inserts */ TRUE,
/* dirty_inserts */ dirty_inserts,
/* do_renames */ TRUE,
/* rename_to_main_addr */ FALSE,
/* do_destroys */ FALSE,
/* do_mult_ro_protects */ TRUE,
/* dirty_destroys */ dirty_destroys,
/* dirty_unprotects */ dirty_unprotects);
if ( show_progress ) /* 6 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
/* flush and destroy all entries in the cache: */
flush_cache(/* cache_ptr */ cache_ptr,
/* destroy_entries */ TRUE,
/* dump_stats */ FALSE,
/* dump_detailed_stats */ FALSE);
if ( show_progress ) /* 7 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
col_major_scan_forward(/* cache_ptr */ cache_ptr,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
/* display_stats */ display_stats,
/* display_detailed_stats */ TRUE,
/* do_inserts */ TRUE,
/* dirty_inserts */ dirty_inserts,
/* dirty_unprotects */ dirty_unprotects);
if ( show_progress ) /* 8 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
/* flush all entries in the cache: */
flush_cache(/* cache_ptr */ cache_ptr,
/* destroy_entries */ FALSE,
/* dump_stats */ FALSE,
/* dump_detailed_stats */ FALSE);
if ( show_progress ) /* 9 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
col_major_scan_backward(/* cache_ptr */ cache_ptr,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
/* display_stats */ display_stats,
/* display_detailed_stats */ TRUE,
/* do_inserts */ TRUE,
/* dirty_inserts */ dirty_inserts,
/* dirty_unprotects */ dirty_unprotects);
if ( show_progress ) /* 10 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
takedown_cache(cache_ptr, display_stats, TRUE);
if ( show_progress ) /* 11 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
verify_clean();
verify_unprotected();
if ( pass ) { PASSED(); } else { H5_FAILED(); }
if ( ! pass ) {
HDfprintf(stdout, "%s(): failure_mssg = \"%s\".\n",
fcn_name, failure_mssg);
}
return;
} /* smoke_check_3() */
/*-------------------------------------------------------------------------
* Function: smoke_check_4()
*
* Purpose: A basic functional test on a tiny cache, with inserts,
* destroys, and renames in the mix, along with repeated
* protects and unprotects. About half the entries are
* marked as dirty.
*
* Return: void
*
* Programmer: John Mainzer
* 6/24/04
*
* Modifications:
*
* JRM -- 1/18/05
* Added code to skip this test if the skip_long_tests global
* is true.
*
*-------------------------------------------------------------------------
*/
static void
smoke_check_4(void)
{
const char * fcn_name = "smoke_check_4";
hbool_t show_progress = FALSE;
hbool_t dirty_inserts = TRUE;
int dirty_unprotects = TRUE;
int dirty_destroys = TRUE;
hbool_t display_stats = FALSE;
int32_t lag = 10;
int mile_stone = 1;
H5C_t * cache_ptr = NULL;
TESTING("smoke check #4 -- ~1/2 dirty, ins, dest, ren, 2/1 KB cache");
if ( skip_long_tests ) {
SKIPPED();
HDfprintf(stdout, " Long tests disabled.\n");
return;
}
pass = TRUE;
if ( show_progress ) /* 1 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
reset_entries();
if ( show_progress ) /* 2 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
cache_ptr = setup_cache((size_t)(2 * 1024),
(size_t)(1 * 1024));
if ( show_progress ) /* 3 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
row_major_scan_forward(/* cache_ptr */ cache_ptr,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
/* display_stats */ display_stats,
/* display_detailed_stats */ TRUE,
/* do_inserts */ TRUE,
/* dirty_inserts */ dirty_inserts,
/* do_renames */ TRUE,
/* rename_to_main_addr */ FALSE,
/* do_destroys */ TRUE,
/* do_mult_ro_protects */ TRUE,
/* dirty_destroys */ dirty_destroys,
/* dirty_unprotects */ dirty_unprotects);
if ( show_progress ) /* 4 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
row_major_scan_backward(/* cache_ptr */ cache_ptr,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
/* display_stats */ display_stats,
/* display_detailed_stats */ TRUE,
/* do_inserts */ FALSE,
/* dirty_inserts */ dirty_inserts,
/* do_renames */ TRUE,
/* rename_to_main_addr */ TRUE,
/* do_destroys */ FALSE,
/* do_mult_ro_protects */ TRUE,
/* dirty_destroys */ dirty_destroys,
/* dirty_unprotects */ dirty_unprotects);
if ( show_progress ) /* 5 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
row_major_scan_forward(/* cache_ptr */ cache_ptr,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
/* display_stats */ display_stats,
/* display_detailed_stats */ TRUE,
/* do_inserts */ TRUE,
/* dirty_inserts */ dirty_inserts,
/* do_renames */ TRUE,
/* rename_to_main_addr */ FALSE,
/* do_destroys */ FALSE,
/* do_mult_ro_protects */ TRUE,
/* dirty_destroys */ dirty_destroys,
/* dirty_unprotects */ dirty_unprotects);
if ( show_progress ) /* 6 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
/* flush and destroy all entries in the cache: */
flush_cache(/* cache_ptr */ cache_ptr,
/* destroy_entries */ TRUE,
/* dump_stats */ FALSE,
/* dump_detailed_stats */ FALSE);
if ( show_progress ) /* 7 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
col_major_scan_forward(/* cache_ptr */ cache_ptr,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
/* display_stats */ display_stats,
/* display_detailed_stats */ TRUE,
/* do_inserts */ TRUE,
/* dirty_inserts */ dirty_inserts,
/* dirty_unprotects */ dirty_unprotects);
if ( show_progress ) /* 8 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
/* flush all entries in the cache: */
flush_cache(/* cache_ptr */ cache_ptr,
/* destroy_entries */ FALSE,
/* dump_stats */ FALSE,
/* dump_detailed_stats */ FALSE);
if ( show_progress ) /* 9 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
col_major_scan_backward(/* cache_ptr */ cache_ptr,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
/* display_stats */ display_stats,
/* display_detailed_stats */ TRUE,
/* do_inserts */ TRUE,
/* dirty_inserts */ dirty_inserts,
/* dirty_unprotects */ dirty_unprotects);
if ( show_progress ) /* 10 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
takedown_cache(cache_ptr, display_stats, TRUE);
if ( show_progress ) /* 11 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
verify_clean();
verify_unprotected();
if ( pass ) { PASSED(); } else { H5_FAILED(); }
if ( ! pass ) {
HDfprintf(stdout, "%s(): failure_mssg = \"%s\".\n",
fcn_name, failure_mssg);
}
return;
} /* smoke_check_4() */
/*-------------------------------------------------------------------------
* Function: smoke_check_5()
*
* Purpose: A basic functional test on a cache with automatic cache
* resizing enabled, with inserts in the mix, along with
* repeated protects and unprotects. All entries are marked
* as clean.
*
* Return: void
*
* Programmer: John Mainzer
* 10/14/04
*
* Modifications:
*
* JRM -- 1/18/05
* Added code to skip this test if the skip_long_tests global
* is true.
*
*-------------------------------------------------------------------------
*/
static void
smoke_check_5(void)
{
const char * fcn_name = "smoke_check_5";
herr_t result;
hbool_t show_progress = FALSE;
hbool_t dirty_inserts = FALSE;
int dirty_unprotects = FALSE;
hbool_t display_stats = FALSE;
int32_t max_index = 1024;
int mile_stone = 1;
H5C_t * cache_ptr = NULL;
H5C_auto_size_ctl_t auto_size_ctl =
{
/* int32_t version = */ H5C__CURR_AUTO_SIZE_CTL_VER,
#if 1
/* H5C_auto_resize_report_fcn rpt_fcn = */ NULL,
#else
/* H5C_auto_resize_report_fcn rpt_fcn = */ H5C_def_auto_resize_rpt_fcn,
#endif
/* hbool_t set_initial_size = */ TRUE,
/* size_t initial_size = */ (2 * 1024 * 1024),
/* double min_clean_fraction = */ 0.1,
/* size_t max_size = */ (32 * 1024 * 1025),
/* size_t min_size = */ (512 * 1024),
/* int64_t epoch_length = */ 50000,
/* enum H5C_cache_incr_mode incr_mode = */ H5C_incr__threshold,
/* double lower_hr_threshold = */ 0.75,
/* double increment = */ 2.0,
/* hbool_t apply_max_increment = */ TRUE,
/* size_t max_increment = */ (4 * 1024 * 1024),
/* enum H5C_cache_flash_incr_mode */
/* flash_incr_mode = */ H5C_flash_incr__off,
/* double flash_multiple = */ 2.0,
/* double flash_threshold = */ 0.5,
/* enum H5C_cache_decr_mode decr_mode = */ H5C_decr__threshold,
/* double upper_hr_threshold = */ 0.995,
/* double decrement = */ 0.9,
/* hbool_t apply_max_decrement = */ TRUE,
/* size_t max_decrement = */ (1 * 1024 * 1024),
/* int32_t epochs_before_eviction = */ 3,
/* hbool_t apply_empty_reserve = */ TRUE,
/* double empty_reserve = */ 0.5
};
TESTING("smoke check #5 -- all clean, ins, prot, unprot, AR cache 1");
if ( skip_long_tests ) {
SKIPPED();
HDfprintf(stdout, " Long tests disabled.\n");
return;
}
if ( run_full_test ) {
max_index = (10 * 1024) - 1;
}
pass = TRUE;
if ( show_progress ) /* 1 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
reset_entries();
if ( show_progress ) /* 2 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
cache_ptr = setup_cache((size_t)(2 * 1024),
(size_t)(1 * 1024));
if ( pass ) {
result = H5C_set_cache_auto_resize_config(cache_ptr, &auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_set_cache_auto_resize_config failed 1.\n";
}
}
if ( show_progress ) /* 3 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
hl_row_major_scan_forward(/* cache_ptr */ cache_ptr,
/* max_index */ max_index,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
/* display_stats */ display_stats,
/* display_detailed_stats */ FALSE,
/* do_inserts */ FALSE,
/* dirty_inserts */ dirty_inserts);
if ( show_progress ) /* 4 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
hl_row_major_scan_backward(/* cache_ptr */ cache_ptr,
/* max_index */ max_index,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
/* display_stats */ display_stats,
/* display_detailed_stats */ FALSE,
/* do_inserts */ FALSE,
/* dirty_inserts */ dirty_inserts);
if ( show_progress ) /* 5 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
hl_row_major_scan_forward(/* cache_ptr */ cache_ptr,
/* max_index */ max_index,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
/* display_stats */ display_stats,
/* display_detailed_stats */ FALSE,
/* do_inserts */ TRUE,
/* dirty_inserts */ dirty_inserts);
if ( show_progress ) /* 6 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
/* flush and destroy all entries in the cache: */
flush_cache(/* cache_ptr */ cache_ptr,
/* destroy_entries */ TRUE,
/* dump_stats */ FALSE,
/* dump_detailed_stats */ FALSE);
if ( show_progress ) /* 7 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
hl_col_major_scan_forward(/* cache_ptr */ cache_ptr,
/* max_index */ max_index,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
/* display_stats */ display_stats,
/* display_detailed_stats */ FALSE,
/* do_inserts */ TRUE,
/* dirty_inserts */ dirty_inserts,
/* dirty_unprotects */ dirty_unprotects);
if ( show_progress ) /* 8 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
/* flush all entries in the cache: */
flush_cache(/* cache_ptr */ cache_ptr,
/* destroy_entries */ FALSE,
/* dump_stats */ FALSE,
/* dump_detailed_stats */ FALSE);
if ( show_progress ) /* 9 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
hl_col_major_scan_backward(/* cache_ptr */ cache_ptr,
/* max_index */ max_index,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
/* display_stats */ display_stats,
/* display_detailed_stats */ FALSE,
/* do_inserts */ TRUE,
/* dirty_inserts */ dirty_inserts,
/* dirty_unprotects */ dirty_unprotects);
if ( show_progress ) /* 10 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
takedown_cache(cache_ptr, display_stats, TRUE);
if ( show_progress ) /* 11 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
verify_clean();
verify_unprotected();
if ( pass ) { PASSED(); } else { H5_FAILED(); }
if ( ! pass ) {
HDfprintf(stdout, "%s(): failure_mssg = \"%s\".\n",
fcn_name, failure_mssg);
}
return;
} /* smoke_check_5() */
/*-------------------------------------------------------------------------
* Function: smoke_check_6()
*
* Purpose: A basic functional test on a cache with automatic cache
* resizing enabled, with inserts in the mix, along with
* repeated protects and unprotects. About one half of all
* entries are marked as dirty.
*
* Return: void
*
* Programmer: John Mainzer
* 10/25/04
*
* Modifications:
*
* JRM -- 1/18/05
* Added code to skip this test if the skip_long_tests global
* is true.
*
*-------------------------------------------------------------------------
*/
static void
smoke_check_6(void)
{
const char * fcn_name = "smoke_check_6";
herr_t result;
hbool_t show_progress = FALSE;
hbool_t dirty_inserts = TRUE;
int dirty_unprotects = FALSE;
hbool_t display_stats = FALSE;
int mile_stone = 1;
int32_t max_index = 1024;
H5C_t * cache_ptr = NULL;
H5C_auto_size_ctl_t auto_size_ctl =
{
/* int32_t version = */ H5C__CURR_AUTO_SIZE_CTL_VER,
#if 1
/* H5C_auto_resize_report_fcn rpt_fcn = */ NULL,
#else
/* H5C_auto_resize_report_fcn rpt_fcn = */ H5C_def_auto_resize_rpt_fcn,
#endif
/* hbool_t set_initial_size = */ TRUE,
/* size_t initial_size = */ (2 * 1024 * 1024),
/* double min_clean_fraction = */ 0.1,
/* size_t max_size = */ (32 * 1024 * 1025),
/* size_t min_size = */ (512 * 1024),
/* int64_t epoch_length = */ 50000,
/* enum H5C_cache_incr_mode incr_mode = */ H5C_incr__threshold,
/* double lower_hr_threshold = */ 0.75,
/* double increment = */ 2.0,
/* hbool_t apply_max_increment = */ TRUE,
/* size_t max_increment = */ (4 * 1024 * 1024),
/* enum H5C_cache_flash_incr_mode */
/* flash_incr_mode = */ H5C_flash_incr__off,
/* double flash_multiple = */ 2.0,
/* double flash_threshold = */ 0.5,
/* enum H5C_cache_decr_mode decr_mode = */ H5C_decr__threshold,
/* double upper_hr_threshold = */ 0.995,
/* double decrement = */ 0.9,
/* hbool_t apply_max_decrement = */ TRUE,
/* size_t max_decrement = */ (1 * 1024 * 1024),
/* int32_t epochs_before_eviction = */ 3,
/* hbool_t apply_empty_reserve = */ TRUE,
/* double empty_reserve = */ 0.05
};
TESTING("smoke check #6 -- ~1/2 dirty, ins, prot, unprot, AR cache 1");
pass = TRUE;
if ( skip_long_tests ) {
SKIPPED();
HDfprintf(stdout, " Long tests disabled.\n");
return;
}
if ( run_full_test ) {
max_index = (10 * 1024) - 1;
}
if ( show_progress ) /* 1 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
reset_entries();
if ( show_progress ) /* 2 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
cache_ptr = setup_cache((size_t)(2 * 1024),
(size_t)(1 * 1024));
if ( pass ) {
result = H5C_set_cache_auto_resize_config(cache_ptr, &auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_set_cache_auto_resize_config failed 1.\n";
}
}
if ( show_progress ) /* 3 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
hl_row_major_scan_forward(/* cache_ptr */ cache_ptr,
/* max_index */ max_index,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
/* display_stats */ display_stats,
/* display_detailed_stats */ FALSE,
/* do_inserts */ FALSE,
/* dirty_inserts */ dirty_inserts);
if ( show_progress ) /* 4 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
hl_row_major_scan_backward(/* cache_ptr */ cache_ptr,
/* max_index */ max_index,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
/* display_stats */ display_stats,
/* display_detailed_stats */ FALSE,
/* do_inserts */ FALSE,
/* dirty_inserts */ dirty_inserts);
if ( show_progress ) /* 5 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
hl_row_major_scan_forward(/* cache_ptr */ cache_ptr,
/* max_index */ max_index,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
/* display_stats */ display_stats,
/* display_detailed_stats */ FALSE,
/* do_inserts */ TRUE,
/* dirty_inserts */ dirty_inserts);
if ( show_progress ) /* 6 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
/* flush and destroy all entries in the cache: */
flush_cache(/* cache_ptr */ cache_ptr,
/* destroy_entries */ TRUE,
/* dump_stats */ FALSE,
/* dump_detailed_stats */ FALSE);
if ( show_progress ) /* 7 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
hl_col_major_scan_forward(/* cache_ptr */ cache_ptr,
/* max_index */ max_index,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
/* display_stats */ display_stats,
/* display_detailed_stats */ FALSE,
/* do_inserts */ TRUE,
/* dirty_inserts */ dirty_inserts,
/* dirty_unprotects */ dirty_unprotects);
if ( show_progress ) /* 8 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
/* flush all entries in the cache: */
flush_cache(/* cache_ptr */ cache_ptr,
/* destroy_entries */ FALSE,
/* dump_stats */ FALSE,
/* dump_detailed_stats */ FALSE);
if ( show_progress ) /* 9 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
hl_col_major_scan_backward(/* cache_ptr */ cache_ptr,
/* max_index */ max_index,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
/* display_stats */ display_stats,
/* display_detailed_stats */ FALSE,
/* do_inserts */ TRUE,
/* dirty_inserts */ dirty_inserts,
/* dirty_unprotects */ dirty_unprotects);
if ( show_progress ) /* 10 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
takedown_cache(cache_ptr, display_stats, TRUE);
if ( show_progress ) /* 11 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
verify_clean();
verify_unprotected();
if ( pass ) { PASSED(); } else { H5_FAILED(); }
if ( ! pass ) {
HDfprintf(stdout, "%s(): failure_mssg = \"%s\".\n",
fcn_name, failure_mssg);
}
return;
} /* smoke_check_6() */
/*-------------------------------------------------------------------------
* Function: smoke_check_7()
*
* Purpose: A basic functional test on a cache with automatic cache
* resizing enabled, with inserts in the mix, along with
* repeated protects and unprotects. All entries are marked
* as clean.
*
* Return: void
*
* Programmer: John Mainzer
* 12/2/04
*
* Modifications:
*
* JRM -- 1/18/05
* Added code to skip this test if the skip_long_tests global
* is true.
*
*-------------------------------------------------------------------------
*/
static void
smoke_check_7(void)
{
const char * fcn_name = "smoke_check_7";
herr_t result;
hbool_t show_progress = FALSE;
hbool_t dirty_inserts = FALSE;
int dirty_unprotects = FALSE;
hbool_t display_stats = FALSE;
int mile_stone = 1;
int32_t max_index = 1024;
H5C_t * cache_ptr = NULL;
H5C_auto_size_ctl_t auto_size_ctl =
{
/* int32_t version = */ H5C__CURR_AUTO_SIZE_CTL_VER,
#if 1
/* H5C_auto_resize_report_fcn rpt_fcn = */ NULL,
#else
/* H5C_auto_resize_report_fcn rpt_fcn = */ H5C_def_auto_resize_rpt_fcn,
#endif
/* hbool_t set_initial_size = */ TRUE,
/* size_t initial_size = */ (2 * 1024 * 1024),
/* double min_clean_fraction = */ 0.1,
/* size_t max_size = */ (32 * 1024 * 1025),
/* size_t min_size = */ (512 * 1024),
/* int64_t epoch_length = */ 100000,
/* enum H5C_cache_incr_mode incr_mode = */ H5C_incr__threshold,
/* double lower_hr_threshold = */ 0.75,
/* double increment = */ 2.0,
/* hbool_t apply_max_increment = */ TRUE,
/* size_t max_increment = */ (8 * 1024 * 1024),
/* enum H5C_cache_flash_incr_mode */
/* flash_incr_mode = */ H5C_flash_incr__off,
/* double flash_multiple = */ 2.0,
/* double flash_threshold = */ 0.5,
/* enum H5C_cache_decr_mode decr_mode = */
H5C_decr__age_out_with_threshold,
/* double upper_hr_threshold = */ 0.995,
/* double decrement = */ 0.9,
/* hbool_t apply_max_decrement = */ TRUE,
/* size_t max_decrement = */ (1 * 1024 * 1024),
/* int32_t epochs_before_eviction = */ 3,
/* hbool_t apply_empty_reserve = */ TRUE,
/* double empty_reserve = */ 0.1
};
TESTING("smoke check #7 -- all clean, ins, prot, unprot, AR cache 2");
if ( skip_long_tests ) {
SKIPPED();
HDfprintf(stdout, " Long tests disabled.\n");
return;
}
if ( run_full_test ) {
max_index = (10 * 1024) - 1;
}
pass = TRUE;
if ( show_progress ) /* 1 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
reset_entries();
if ( show_progress ) /* 2 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
cache_ptr = setup_cache((size_t)(2 * 1024),
(size_t)(1 * 1024));
if ( pass ) {
result = H5C_set_cache_auto_resize_config(cache_ptr, &auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_set_cache_auto_resize_config failed 1.\n";
}
}
if ( show_progress ) /* 3 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
hl_row_major_scan_forward(/* cache_ptr */ cache_ptr,
/* max_index */ max_index,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
/* display_stats */ display_stats,
/* display_detailed_stats */ FALSE,
/* do_inserts */ FALSE,
/* dirty_inserts */ dirty_inserts);
if ( show_progress ) /* 4 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
hl_row_major_scan_backward(/* cache_ptr */ cache_ptr,
/* max_index */ max_index,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
/* display_stats */ display_stats,
/* display_detailed_stats */ FALSE,
/* do_inserts */ FALSE,
/* dirty_inserts */ dirty_inserts);
if ( show_progress ) /* 5 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
hl_row_major_scan_forward(/* cache_ptr */ cache_ptr,
/* max_index */ max_index,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
/* display_stats */ display_stats,
/* display_detailed_stats */ FALSE,
/* do_inserts */ TRUE,
/* dirty_inserts */ dirty_inserts);
if ( show_progress ) /* 6 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
/* flush and destroy all entries in the cache: */
flush_cache(/* cache_ptr */ cache_ptr,
/* destroy_entries */ TRUE,
/* dump_stats */ FALSE,
/* dump_detailed_stats */ FALSE);
if ( show_progress ) /* 7 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
hl_col_major_scan_forward(/* cache_ptr */ cache_ptr,
/* max_index */ max_index,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
/* display_stats */ display_stats,
/* display_detailed_stats */ FALSE,
/* do_inserts */ TRUE,
/* dirty_inserts */ dirty_inserts,
/* dirty_unprotects */ dirty_unprotects);
if ( show_progress ) /* 8 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
/* flush all entries in the cache: */
flush_cache(/* cache_ptr */ cache_ptr,
/* destroy_entries */ FALSE,
/* dump_stats */ FALSE,
/* dump_detailed_stats */ FALSE);
if ( show_progress ) /* 9 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
hl_col_major_scan_backward(/* cache_ptr */ cache_ptr,
/* max_index */ max_index,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
/* display_stats */ display_stats,
/* display_detailed_stats */ FALSE,
/* do_inserts */ TRUE,
/* dirty_inserts */ dirty_inserts,
/* dirty_unprotects */ dirty_unprotects);
if ( show_progress ) /* 10 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
takedown_cache(cache_ptr, display_stats, TRUE);
if ( show_progress ) /* 11 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
verify_clean();
verify_unprotected();
if ( pass ) { PASSED(); } else { H5_FAILED(); }
if ( ! pass ) {
HDfprintf(stdout, "%s(): failure_mssg = \"%s\".\n",
fcn_name, failure_mssg);
}
return;
} /* smoke_check_7() */
/*-------------------------------------------------------------------------
* Function: smoke_check_8()
*
* Purpose: A basic functional test on a cache with automatic cache
* resizing enabled, with inserts in the mix, along with
* repeated protects and unprotects. About one half of all
* entries are marked as dirty.
*
* Return: void
*
* Programmer: John Mainzer
* 10/25/04
*
* Modifications:
*
* JRM -- 1/18/05
* Added code to skip this test if the skip_long_tests global
* is true.
*
*-------------------------------------------------------------------------
*/
static void
smoke_check_8(void)
{
const char * fcn_name = "smoke_check_8";
herr_t result;
hbool_t show_progress = FALSE;
hbool_t dirty_inserts = TRUE;
int dirty_unprotects = FALSE;
hbool_t display_stats = FALSE;
int mile_stone = 1;
int32_t max_index = 1024;
H5C_t * cache_ptr = NULL;
H5C_auto_size_ctl_t auto_size_ctl =
{
/* int32_t version = */ H5C__CURR_AUTO_SIZE_CTL_VER,
#if 1
/* H5C_auto_resize_report_fcn rpt_fcn = */ NULL,
#else
/* H5C_auto_resize_report_fcn rpt_fcn = */ H5C_def_auto_resize_rpt_fcn,
#endif
/* hbool_t set_initial_size = */ TRUE,
/* size_t initial_size = */ (2 * 1024 * 1024),
/* double min_clean_fraction = */ 0.1,
/* size_t max_size = */ (32 * 1024 * 1025),
/* size_t min_size = */ (512 * 1024),
/* int64_t epoch_length = */ 100000,
/* enum H5C_cache_incr_mode incr_mode = */ H5C_incr__threshold,
/* double lower_hr_threshold = */ 0.75,
/* double increment = */ 2.0,
/* hbool_t apply_max_increment = */ TRUE,
/* size_t max_increment = */ (4 * 1024 * 1024),
/* enum H5C_cache_flash_incr_mode */
/* flash_incr_mode = */ H5C_flash_incr__off,
/* double flash_multiple = */ 2.0,
/* double flash_threshold = */ 0.5,
/* enum H5C_cache_decr_mode decr_mode = */
H5C_decr__age_out_with_threshold,
/* double upper_hr_threshold = */ 0.995,
/* double decrement = */ 0.9,
/* hbool_t apply_max_decrement = */ TRUE,
/* size_t max_decrement = */ (1 * 1024 * 1024),
/* int32_t epochs_before_eviction = */ 3,
/* hbool_t apply_empty_reserve = */ TRUE,
/* double empty_reserve = */ 0.1
};
TESTING("smoke check #8 -- ~1/2 dirty, ins, prot, unprot, AR cache 2");
if ( skip_long_tests ) {
SKIPPED();
HDfprintf(stdout, " Long tests disabled.\n");
return;
}
if ( run_full_test ) {
max_index = (10 * 1024) - 1;
}
pass = TRUE;
if ( show_progress ) /* 1 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
reset_entries();
if ( show_progress ) /* 2 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
cache_ptr = setup_cache((size_t)(2 * 1024),
(size_t)(1 * 1024));
if ( pass ) {
result = H5C_set_cache_auto_resize_config(cache_ptr, &auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_set_cache_auto_resize_config failed 1.\n";
}
}
if ( show_progress ) /* 3 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
hl_row_major_scan_forward(/* cache_ptr */ cache_ptr,
/* max_index */ max_index,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
/* display_stats */ display_stats,
/* display_detailed_stats */ FALSE,
/* do_inserts */ FALSE,
/* dirty_inserts */ dirty_inserts);
if ( show_progress ) /* 4 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
hl_row_major_scan_backward(/* cache_ptr */ cache_ptr,
/* max_index */ max_index,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
/* display_stats */ display_stats,
/* display_detailed_stats */ FALSE,
/* do_inserts */ FALSE,
/* dirty_inserts */ dirty_inserts);
if ( show_progress ) /* 5 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
hl_row_major_scan_forward(/* cache_ptr */ cache_ptr,
/* max_index */ max_index,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
/* display_stats */ display_stats,
/* display_detailed_stats */ FALSE,
/* do_inserts */ TRUE,
/* dirty_inserts */ dirty_inserts);
if ( show_progress ) /* 6 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
/* flush and destroy all entries in the cache: */
flush_cache(/* cache_ptr */ cache_ptr,
/* destroy_entries */ TRUE,
/* dump_stats */ FALSE,
/* dump_detailed_stats */ FALSE);
if ( show_progress ) /* 7 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
hl_col_major_scan_forward(/* cache_ptr */ cache_ptr,
/* max_index */ max_index,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
/* display_stats */ display_stats,
/* display_detailed_stats */ FALSE,
/* do_inserts */ TRUE,
/* dirty_inserts */ dirty_inserts,
/* dirty_unprotects */ dirty_unprotects);
if ( show_progress ) /* 8 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
/* flush all entries in the cache: */
flush_cache(/* cache_ptr */ cache_ptr,
/* destroy_entries */ FALSE,
/* dump_stats */ FALSE,
/* dump_detailed_stats */ FALSE);
if ( show_progress ) /* 9 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
hl_col_major_scan_backward(/* cache_ptr */ cache_ptr,
/* max_index */ max_index,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
/* display_stats */ display_stats,
/* display_detailed_stats */ FALSE,
/* do_inserts */ TRUE,
/* dirty_inserts */ dirty_inserts,
/* dirty_unprotects */ dirty_unprotects);
if ( show_progress ) /* 10 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
takedown_cache(cache_ptr, display_stats, TRUE);
if ( show_progress ) /* 11 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
verify_clean();
verify_unprotected();
if ( pass ) { PASSED(); } else { H5_FAILED(); }
if ( ! pass ) {
HDfprintf(stdout, "%s(): failure_mssg = \"%s\".\n",
fcn_name, failure_mssg);
}
return;
} /* smoke_check_8() */
/*-------------------------------------------------------------------------
* Function: smoke_check_9()
*
* Purpose: A repeat of smoke check 1, only with the cache corked
* part of the time.
*
* Recall that smoke check 1 is a basic functional test,
* with inserts, destroys, and renames in the mix, along
* with repeated protects and unprotects. All entries are
* marked as clean.
*
* Return: void
*
* Programmer: John Mainzer
* 8/1/07
*
* Modifications:
*
* None.
*
*-------------------------------------------------------------------------
*/
static void
smoke_check_9(void)
{
const char * fcn_name = "smoke_check_9";
herr_t result;
hbool_t show_progress = FALSE;
hbool_t dirty_inserts = FALSE;
int dirty_unprotects = FALSE;
int dirty_destroys = FALSE;
hbool_t display_stats = FALSE;
hbool_t display_detailed_stats = FALSE;
int32_t lag = 10;
int mile_stone = 1;
H5C_t * cache_ptr = NULL;
TESTING("smoke check #9 -- all clean, ins, dest, ren, 4/2 MB, corked");
if ( skip_long_tests ) {
SKIPPED();
HDfprintf(stdout, " Long tests disabled.\n");
return;
}
pass = TRUE;
if ( show_progress ) /* 1 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
reset_entries();
if ( show_progress ) /* 2 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
cache_ptr = setup_cache((size_t)(4 * 1024 * 1024),
(size_t)(2 * 1024 * 1024));
/* disable evictions */
if ( show_progress ) /* 3 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
if ( pass ) {
result = H5C_set_evictions_enabled(cache_ptr, FALSE);
if ( result < 0 ) {
pass = FALSE;
failure_mssg = "can't disable evictions 1.\n";
}
}
if ( show_progress ) /* 4 */
HDfprintf(stdout, "%s() - %0d -- pass = %d -- evictions disabled\n",
fcn_name, mile_stone++, (int)pass);
row_major_scan_forward(/* cache_ptr */ cache_ptr,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
/* display_stats */ display_stats,
/* display_detailed_stats */ display_detailed_stats,
/* do_inserts */ TRUE,
/* dirty_inserts */ dirty_inserts,
/* do_renames */ TRUE,
/* rename_to_main_addr */ FALSE,
/* do_destroys */ TRUE,
/* do_mult_ro_protects */ TRUE,
/* dirty_destroys */ dirty_destroys,
/* dirty_unprotects */ dirty_unprotects);
/* enable evictions */
if ( show_progress ) /* 5 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
if ( pass ) {
result = H5C_set_evictions_enabled(cache_ptr, TRUE);
if ( result < 0 ) {
pass = FALSE;
failure_mssg = "can't enable evictions 1.\n";
}
}
if ( show_progress ) /* 6 */
HDfprintf(stdout, "%s() - %0d -- pass = %d -- evictions enabled \n",
fcn_name, mile_stone++, (int)pass);
row_major_scan_backward(/* cache_ptr */ cache_ptr,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
/* display_stats */ display_stats,
/* display_detailed_stats */ display_detailed_stats,
/* do_inserts */ FALSE,
/* dirty_inserts */ dirty_inserts,
/* do_renames */ TRUE,
/* rename_to_main_addr */ TRUE,
/* do_destroys */ FALSE,
/* do_mult_ro_protects */ TRUE,
/* dirty_destroys */ dirty_destroys,
/* dirty_unprotects */ dirty_unprotects);
if ( show_progress ) /* 7 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
if ( pass ) {
result = H5C_set_evictions_enabled(cache_ptr, FALSE);
if ( result < 0 ) {
pass = FALSE;
failure_mssg = "can't disable evictions 2.\n";
}
}
if ( show_progress ) /* 8 */
HDfprintf(stdout, "%s() - %0d -- pass = %d -- evictions disabled \n",
fcn_name, mile_stone++, (int)pass);
row_major_scan_forward(/* cache_ptr */ cache_ptr,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
/* display_stats */ display_stats,
/* display_detailed_stats */ display_detailed_stats,
/* do_inserts */ TRUE,
/* dirty_inserts */ dirty_inserts,
/* do_renames */ TRUE,
/* rename_to_main_addr */ FALSE,
/* do_destroys */ FALSE,
/* do_mult_ro_protects */ TRUE,
/* dirty_destroys */ dirty_destroys,
/* dirty_unprotects */ dirty_unprotects);
if ( show_progress ) /* 9 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
if ( pass ) {
result = H5C_set_evictions_enabled(cache_ptr, TRUE);
if ( result < 0 ) {
pass = FALSE;
failure_mssg = "can't enable evictions 2.\n";
}
}
if ( show_progress ) /* 10 */
HDfprintf(stdout, "%s() - %0d -- pass = %d -- evictions enabled \n",
fcn_name, mile_stone++, (int)pass);
/* flush and destroy all entries in the cache: */
flush_cache(/* cache_ptr */ cache_ptr,
/* destroy_entries */ TRUE,
/* dump_stats */ FALSE,
/* dump_detailed_stats */ FALSE);
if ( show_progress ) /* 11 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
if ( pass ) {
result = H5C_set_evictions_enabled(cache_ptr, FALSE);
if ( result < 0 ) {
pass = FALSE;
failure_mssg = "can't disable evictions 3.\n";
}
}
if ( show_progress ) /* 12 */
HDfprintf(stdout, "%s() - %0d -- pass = %d -- evictions disabled\n",
fcn_name, mile_stone++, (int)pass);
col_major_scan_forward(/* cache_ptr */ cache_ptr,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
/* display_stats */ display_stats,
/* display_detailed_stats */ display_detailed_stats,
/* do_inserts */ TRUE,
/* dirty_inserts */ dirty_inserts,
/* dirty_unprotects */ dirty_unprotects);
if ( show_progress ) /* 13 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
/* flush all entries in the cache: */
flush_cache(/* cache_ptr */ cache_ptr,
/* destroy_entries */ FALSE,
/* dump_stats */ FALSE,
/* dump_detailed_stats */ FALSE);
if ( show_progress ) /* 14 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
if ( pass ) {
result = H5C_set_evictions_enabled(cache_ptr, TRUE);
if ( result < 0 ) {
pass = FALSE;
failure_mssg = "can't enable evictions 3.\n";
}
}
if ( show_progress ) /* 15 */
HDfprintf(stdout, "%s() - %0d -- pass = %d -- evictions enabled\n",
fcn_name, mile_stone++, (int)pass);
col_major_scan_backward(/* cache_ptr */ cache_ptr,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
/* display_stats */ display_stats,
/* display_detailed_stats */ display_detailed_stats,
/* do_inserts */ TRUE,
/* dirty_inserts */ dirty_inserts,
/* dirty_unprotects */ dirty_unprotects);
if ( show_progress ) /* 16 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
if ( pass ) {
result = H5C_set_evictions_enabled(cache_ptr, FALSE);
if ( result < 0 ) {
pass = FALSE;
failure_mssg = "can't disable evictions 4.\n";
}
}
if ( show_progress ) /* 17 */
HDfprintf(stdout, "%s() - %0d -- pass = %d -- evictions disabled\n",
fcn_name, mile_stone++, (int)pass);
takedown_cache(cache_ptr, display_stats, TRUE);
if ( show_progress ) /* 18 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
verify_clean();
verify_unprotected();
if ( pass ) { PASSED(); } else { H5_FAILED(); }
if ( ! pass ) {
HDfprintf(stdout, "%s(): failure_mssg = \"%s\".\n",
fcn_name, failure_mssg);
}
return;
} /* smoke_check_9() */
/*-------------------------------------------------------------------------
* Function: smoke_check_10()
*
* Purpose: A repeat of smoke check 2, only with the cache corked
* part of the time.
*
* Recall that smoke check 2 is a basic functional test,
* with inserts, destroys, and renames in the mix, along
* with some repeated protects and unprotects. About half
* the entries are marked as dirty.
*
* Return: void
*
* Programmer: John Mainzer
* 8/1/07
*
* Modifications:
*
* None.
*
*-------------------------------------------------------------------------
*/
static void
smoke_check_10(void)
{
const char * fcn_name = "smoke_check_10";
herr_t result;
hbool_t show_progress = FALSE;
hbool_t dirty_inserts = TRUE;
int dirty_unprotects = TRUE;
int dirty_destroys = TRUE;
hbool_t display_stats = FALSE;
hbool_t display_detailed_stats = FALSE;
int32_t lag = 10;
int mile_stone = 1;
H5C_t * cache_ptr = NULL;
TESTING("smoke check #10 -- ~1/2 dirty, ins, dest, ren, 4/2 MB, corked");
if ( skip_long_tests ) {
SKIPPED();
HDfprintf(stdout, " Long tests disabled.\n");
return;
}
pass = TRUE;
if ( show_progress ) /* 1 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
reset_entries();
if ( show_progress ) /* 2 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
cache_ptr = setup_cache((size_t)(4 * 1024 * 1024),
(size_t)(2 * 1024 * 1024));
if ( show_progress ) /* 3 */
HDfprintf(stdout, "%s() - %0d -- pass = %d -- evictions enabled\n",
fcn_name, mile_stone++, (int)pass);
row_major_scan_forward(/* cache_ptr */ cache_ptr,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
/* display_stats */ display_stats,
/* display_detailed_stats */ display_detailed_stats,
/* do_inserts */ TRUE,
/* dirty_inserts */ dirty_inserts,
/* do_renames */ TRUE,
/* rename_to_main_addr */ FALSE,
/* do_destroys */ TRUE,
/* do_mult_ro_protects */ TRUE,
/* dirty_destroys */ dirty_destroys,
/* dirty_unprotects */ dirty_unprotects);
if ( show_progress ) /* 4 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
if ( pass ) {
result = H5C_set_evictions_enabled(cache_ptr, FALSE);
if ( result < 0 ) {
pass = FALSE;
failure_mssg = "can't disable evictions 1.\n";
}
}
if ( show_progress ) /* 5 */
HDfprintf(stdout, "%s() - %0d -- pass = %d -- evictions disabled\n",
fcn_name, mile_stone++, (int)pass);
row_major_scan_backward(/* cache_ptr */ cache_ptr,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
/* display_stats */ display_stats,
/* display_detailed_stats */ display_detailed_stats,
/* do_inserts */ FALSE,
/* dirty_inserts */ dirty_inserts,
/* do_renames */ TRUE,
/* rename_to_main_addr */ TRUE,
/* do_destroys */ FALSE,
/* do_mult_ro_protects */ TRUE,
/* dirty_destroys */ dirty_destroys,
/* dirty_unprotects */ dirty_unprotects);
if ( show_progress ) /* 6 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
if ( pass ) {
result = H5C_set_evictions_enabled(cache_ptr, TRUE);
if ( result < 0 ) {
pass = FALSE;
failure_mssg = "can't enable evictions 1.\n";
}
}
if ( show_progress ) /* 7 */
HDfprintf(stdout, "%s() - %0d -- pass = %d -- evictions enabled\n",
fcn_name, mile_stone++, (int)pass);
row_major_scan_forward(/* cache_ptr */ cache_ptr,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
/* display_stats */ display_stats,
/* display_detailed_stats */ display_detailed_stats,
/* do_inserts */ TRUE,
/* dirty_inserts */ dirty_inserts,
/* do_renames */ TRUE,
/* rename_to_main_addr */ FALSE,
/* do_destroys */ FALSE,
/* do_mult_ro_protects */ TRUE,
/* dirty_destroys */ dirty_destroys,
/* dirty_unprotects */ dirty_unprotects);
if ( show_progress ) /* 8 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
if ( pass ) {
result = H5C_set_evictions_enabled(cache_ptr, FALSE);
if ( result < 0 ) {
pass = FALSE;
failure_mssg = "can't disable evictions 2.\n";
}
}
if ( show_progress ) /* 9 */
HDfprintf(stdout, "%s() - %0d -- pass = %d -- evictions disabled\n",
fcn_name, mile_stone++, (int)pass);
/* flush and destroy all entries in the cache: */
flush_cache(/* cache_ptr */ cache_ptr,
/* destroy_entries */ TRUE,
/* dump_stats */ FALSE,
/* dump_detailed_stats */ FALSE);
if ( show_progress ) /* 10 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
if ( pass ) {
result = H5C_set_evictions_enabled(cache_ptr, TRUE);
if ( result < 0 ) {
pass = FALSE;
failure_mssg = "can't enable evictions 2.\n";
}
}
if ( show_progress ) /* 11 */
HDfprintf(stdout, "%s() - %0d -- pass = %d -- evictions enabled\n",
fcn_name, mile_stone++, (int)pass);
col_major_scan_forward(/* cache_ptr */ cache_ptr,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
/* display_stats */ display_stats,
/* display_detailed_stats */ display_detailed_stats,
/* do_inserts */ TRUE,
/* dirty_inserts */ dirty_inserts,
/* dirty_unprotects */ dirty_unprotects);
if ( show_progress ) /* 12 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
if ( pass ) {
result = H5C_set_evictions_enabled(cache_ptr, FALSE);
if ( result < 0 ) {
pass = FALSE;
failure_mssg = "can't disable evictions 3.\n";
}
}
if ( show_progress ) /* 13 */
HDfprintf(stdout, "%s() - %0d -- pass = %d -- evictions disabled\n",
fcn_name, mile_stone++, (int)pass);
/* flush all entries in the cache: */
flush_cache(/* cache_ptr */ cache_ptr,
/* destroy_entries */ FALSE,
/* dump_stats */ FALSE,
/* dump_detailed_stats */ FALSE);
if ( show_progress ) /* 14 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
if ( pass ) {
result = H5C_set_evictions_enabled(cache_ptr, TRUE);
if ( result < 0 ) {
pass = FALSE;
failure_mssg = "can't enable evictions 3.\n";
}
}
if ( show_progress ) /* 15 */
HDfprintf(stdout, "%s() - %0d -- pass = %d -- evictions enabled\n",
fcn_name, mile_stone++, (int)pass);
col_major_scan_backward(/* cache_ptr */ cache_ptr,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
/* display_stats */ display_stats,
/* display_detailed_stats */ display_detailed_stats,
/* do_inserts */ TRUE,
/* dirty_inserts */ dirty_inserts,
/* dirty_unprotects */ dirty_unprotects);
if ( show_progress ) /* 16 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
if ( pass ) {
result = H5C_set_evictions_enabled(cache_ptr, FALSE);
if ( result < 0 ) {
pass = FALSE;
failure_mssg = "can't disable evictions 4.\n";
}
}
if ( show_progress ) /* 17 */
HDfprintf(stdout, "%s() - %0d -- pass = %d -- evictions disabled\n",
fcn_name, mile_stone++, (int)pass);
takedown_cache(cache_ptr, display_stats, TRUE);
if ( show_progress ) /* 18 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
verify_clean();
verify_unprotected();
if ( pass ) { PASSED(); } else { H5_FAILED(); }
if ( ! pass ) {
HDfprintf(stdout, "%s(): failure_mssg = \"%s\".\n",
fcn_name, failure_mssg);
}
return;
} /* smoke_check_10() */
/*-------------------------------------------------------------------------
* Function: write_permitted_check()
*
* Purpose: A basic test of the write permitted function. In essence,
* we load the cache up with dirty entryies, set
* write_permitted to FALSE, and then protect a bunch of
* entries. If there are any writes while write_permitted is
* FALSE, the test will fail.
*
* Return: void
*
* Programmer: John Mainzer
* 6/24/04
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static void
write_permitted_check(void)
{
#if H5C_MAINTAIN_CLEAN_AND_DIRTY_LRU_LISTS
const char * fcn_name = "write_permitted_check";
hbool_t show_progress = FALSE;
hbool_t display_stats = FALSE;
int32_t lag = 10;
int mile_stone = 1;
H5C_t * cache_ptr = NULL;
#endif /* H5C_MAINTAIN_CLEAN_AND_DIRTY_LRU_LISTS */
TESTING("write permitted check -- 1/0 MB cache");
#if H5C_MAINTAIN_CLEAN_AND_DIRTY_LRU_LISTS
pass = TRUE;
if ( show_progress ) /* 1 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
reset_entries();
if ( show_progress ) /* 2 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
cache_ptr = setup_cache((size_t)(1 * 1024 * 1024),
(size_t)(0));
if ( show_progress ) /* 3 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
row_major_scan_forward(/* cache_ptr */ cache_ptr,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
/* display_stats */ display_stats,
/* display_detailed_stats */ TRUE,
/* do_inserts */ TRUE,
/* dirty_inserts */ TRUE,
/* do_renames */ TRUE,
/* rename_to_main_addr */ FALSE,
/* do_destroys */ TRUE,
/* do_mult_ro_protects */ TRUE,
/* dirty_destroys */ TRUE,
/* dirty_unprotects */ TRUE);
if ( show_progress ) /* 4 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
write_permitted = FALSE;
row_major_scan_backward(/* cache_ptr */ cache_ptr,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
/* display_stats */ display_stats,
/* display_detailed_stats */ TRUE,
/* do_inserts */ FALSE,
/* dirty_inserts */ FALSE,
/* do_renames */ TRUE,
/* rename_to_main_addr */ TRUE,
/* do_destroys */ FALSE,
/* do_mult_ro_protects */ TRUE,
/* dirty_destroys */ FALSE,
/* dirty_unprotects */ NO_CHANGE);
if ( show_progress ) /* 5 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
write_permitted = TRUE;
row_major_scan_forward(/* cache_ptr */ cache_ptr,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
/* display_stats */ display_stats,
/* display_detailed_stats */ TRUE,
/* do_inserts */ TRUE,
/* dirty_inserts */ TRUE,
/* do_renames */ TRUE,
/* rename_to_main_addr */ FALSE,
/* do_destroys */ FALSE,
/* do_mult_ro_protects */ TRUE,
/* dirty_destroys */ TRUE,
/* dirty_unprotects */ TRUE);
if ( show_progress ) /* 6 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
/* flush and destroy all entries in the cache: */
flush_cache(/* cache_ptr */ cache_ptr,
/* destroy_entries */ TRUE,
/* dump_stats */ FALSE,
/* dump_detailed_stats */ FALSE);
if ( show_progress ) /* 7 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
col_major_scan_forward(/* cache_ptr */ cache_ptr,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
/* display_stats */ display_stats,
/* display_detailed_stats */ TRUE,
/* do_inserts */ TRUE,
/* dirty_inserts */ TRUE,
/* dirty_unprotects */ TRUE);
if ( show_progress ) /* 8 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
write_permitted = FALSE;
col_major_scan_backward(/* cache_ptr */ cache_ptr,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
/* display_stats */ display_stats,
/* display_detailed_stats */ TRUE,
/* do_inserts */ FALSE,
/* dirty_inserts */ FALSE,
/* dirty_unprotects */ NO_CHANGE);
write_permitted = TRUE;
if ( show_progress ) /* 9 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
takedown_cache(cache_ptr, display_stats, TRUE);
if ( show_progress ) /* 10 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
verify_clean();
verify_unprotected();
if ( pass ) { PASSED(); } else { H5_FAILED(); }
if ( ! pass ) {
HDfprintf(stdout, "%s(): failure_mssg = \"%s\".\n",
fcn_name, failure_mssg);
}
#else /* H5C_MAINTAIN_CLEAN_AND_DIRTY_LRU_LISTS */
SKIPPED();
HDfprintf(stdout, " Clean and dirty LRU lists disabled.\n");
#endif /* H5C_MAINTAIN_CLEAN_AND_DIRTY_LRU_LISTS */
return;
} /* write_permitted_check() */
/*-------------------------------------------------------------------------
* Function: check_insert_entry()
*
* Purpose: Verify that H5C_insert_entry behaves as expected.
* Test the behaviour with different flags.
*
* This test was added primarily to test basic insert
* pinned entry functionallity, but I through in explicit
* tests for other functionallity that is tested implicitly
* elsewhere.
*
* Return: void
*
* Programmer: John Mainzer
* 8/10/06
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static void
check_insert_entry(void)
{
const char * fcn_name = "check_insert_entry";
int entry_type = PICO_ENTRY_TYPE;
int i;
herr_t result;
hbool_t in_cache;
hbool_t is_dirty;
hbool_t is_protected;
hbool_t is_pinned;
size_t entry_size;
H5C_t * cache_ptr = NULL;
test_entry_t * base_addr;
test_entry_t * entry_ptr;
struct H5C_cache_entry_t * search_ptr;
TESTING("H5C_insert_entry() functionality");
pass = TRUE;
/* Allocate a cache, and insert entries into it using all
* combinations of flags. Verify that the entries are inserted,
* and that the flags have the desired effects.
*
* Note that the dirty parameter in insert_entry is no longer
* used, as we have decided that all inserted entries are
* dirty by definition. (Which sounds very reasonable, but didn't
* used to be the case.)
*/
if ( pass ) {
reset_entries();
cache_ptr = setup_cache((size_t)(2 * 1024 * 1024),
(size_t)(1 * 1024 * 1024));
}
if ( pass ) {
insert_entry(cache_ptr, entry_type, 0, TRUE, H5C__NO_FLAGS_SET);
insert_entry(cache_ptr, entry_type, 1, TRUE,
H5C__SET_FLUSH_MARKER_FLAG);
insert_entry(cache_ptr, entry_type, 2, TRUE, H5C__PIN_ENTRY_FLAG);
insert_entry(cache_ptr, entry_type, 3, TRUE,
(H5C__SET_FLUSH_MARKER_FLAG | H5C__PIN_ENTRY_FLAG));
}
/* Verify that the entries are inserted as desired. */
i = 0;
base_addr = entries[0];
while ( ( pass ) && ( i < 4 ) )
{
entry_ptr = &(base_addr[i]);
/* Start by checking everything we can via H5C_get_entry_status() */
result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, &entry_size,
&in_cache, &is_dirty, &is_protected,
&is_pinned);
if ( result < 0 ) {
pass = FALSE;
failure_mssg = "H5AC_get_entry_status() reports failure.";
}
if ( pass ) {
/* check the universals */
if ( ( ! in_cache ) || ( ! is_dirty ) || ( is_protected ) ||
( entry_size != entry_sizes[entry_type] ) ) {
pass = FALSE;
failure_mssg = "Unexpected insert results 1.";
}
}
if ( pass ) {
/* verify that the pinned flag got set correctly */
if ( ( i == 2 ) || ( i == 3 ) ) {
if ( ! is_pinned ) {
pass = FALSE;
failure_mssg = "Unexpected insert results 2.";
}
} else if ( is_pinned ) {
pass = FALSE;
failure_mssg = "Unexpected insert results 3.";
} else if ( is_pinned != ((entry_ptr->header).is_pinned) ) {
pass = FALSE;
failure_mssg = "Unexpected insert results 4.";
}
}
/* Thats all we can get from H5AC_get_entry_status().
* Now start looking at the cache data structures directly.
*/
if ( pass ) {
/* Verify that the flush marker got set correctly */
if ( ( i == 1 ) || ( i == 3 ) ) {
if ( ! ((entry_ptr->header).flush_marker) ) {
pass = FALSE;
failure_mssg = "Unexpected insert results 5.";
}
} else if ( (entry_ptr->header).flush_marker ) {
pass = FALSE;
failure_mssg = "Unexpected insert results 6.";
}
}
if ( pass ) {
/* Verify that pinned entries are in the pinned entry list */
if ( (entry_ptr->header).is_pinned ) {
search_ptr = cache_ptr->pel_head_ptr;
while ( ( search_ptr != NULL ) &&
( search_ptr !=
(struct H5C_cache_entry_t *)entry_ptr ) )
{
search_ptr = search_ptr->next;
}
if ( search_ptr == NULL ) {
pass = FALSE;
failure_mssg = "Unexpected insert results 7.";
}
}
}
if ( pass ) {
/* Verify that unpinned entries are in the LRU list */
if ( ! ((entry_ptr->header).is_pinned) ) {
search_ptr = cache_ptr->LRU_head_ptr;
while ( ( search_ptr != NULL ) &&
( search_ptr !=
(struct H5C_cache_entry_t *)entry_ptr ) )
{
search_ptr = search_ptr->next;
}
if ( search_ptr == NULL ) {
pass = FALSE;
failure_mssg = "Unexpected insert results 8.";
}
}
}
#if H5C_MAINTAIN_CLEAN_AND_DIRTY_LRU_LISTS
if ( pass ) {
/* Verify that unpinned entries are in the dirty LRU list */
if ( ! ((entry_ptr->header).is_pinned) ) {
search_ptr = cache_ptr->dLRU_head_ptr;
while ( ( search_ptr != NULL ) &&
( search_ptr !=
(struct H5C_cache_entry_t *)entry_ptr ) )
{
search_ptr = search_ptr->aux_next;
}
if ( search_ptr == NULL ) {
pass = FALSE;
failure_mssg = "Unexpected insert results 9.";
}
}
}
#endif /* H5C_MAINTAIN_CLEAN_AND_DIRTY_LRU_LISTS */
i++;
} /* while */
/* So much for looking at the individual entries. Now verify
* that the various counts and sized in the cache header are
* as expected.
*/
if ( pass ) {
if ( ( cache_ptr->index_len != 4 ) ||
( cache_ptr->index_size != 4 * entry_sizes[entry_type] ) ||
( cache_ptr->slist_len != 4 ) ||
( cache_ptr->slist_size != 4 * entry_sizes[entry_type] ) ||
( cache_ptr->pl_len != 0 ) ||
( cache_ptr->pl_size != (size_t)0 ) ||
( cache_ptr->pel_len != 2 ) ||
( cache_ptr->pel_size != 2 * entry_sizes[entry_type] ) ||
( cache_ptr->LRU_list_len != 2 ) ||
( cache_ptr->LRU_list_size != 2 * entry_sizes[entry_type] ) ||
#if H5C_MAINTAIN_CLEAN_AND_DIRTY_LRU_LISTS
( cache_ptr->dLRU_list_len != 2 ) ||
( cache_ptr->dLRU_list_size != 2 * entry_sizes[entry_type] ) ||
#endif /* H5C_MAINTAIN_CLEAN_AND_DIRTY_LRU_LISTS */
( cache_ptr->cLRU_list_len != 0 ) ||
( cache_ptr->cLRU_list_size != (size_t)0 ) ) {
pass = FALSE;
failure_mssg = "Unexpected insert results 10.";
}
}
/* Finally, if stats collection is enabled, verify that the expected
* stats are collected.
*/
#if H5C_COLLECT_CACHE_STATS
if ( pass ) {
if ( ( cache_ptr->insertions[entry_type] != 4 ) ||
( cache_ptr->pinned_insertions[entry_type] != 2 ) ||
( cache_ptr->pins[entry_type] != 2 ) ||
( cache_ptr->unpins[entry_type] != 0 ) ||
( cache_ptr->dirty_pins[entry_type] != 0 ) ||
( cache_ptr->max_index_len != 4 ) ||
( cache_ptr->max_index_size != 4 * entry_sizes[entry_type] ) ||
( cache_ptr->max_slist_len != 4 ) ||
( cache_ptr->max_slist_size != 4 * entry_sizes[entry_type] ) ||
( cache_ptr->max_pl_len != 0 ) ||
( cache_ptr->max_pl_size != (size_t)0 ) ||
( cache_ptr->max_pel_len != 2 ) ||
( cache_ptr->max_pel_size != 2 * entry_sizes[entry_type] ) ) {
pass = FALSE;
failure_mssg = "Unexpected insert results 11.";
}
}
#endif /* H5C_COLLECT_CACHE_STATS */
/* Unpin the pinned entries so we can take down the cache cleanly. */
if ( pass ) {
unpin_entry(cache_ptr, entry_type, 2);
unpin_entry(cache_ptr, entry_type, 3);
}
if ( pass ) {
takedown_cache(cache_ptr, FALSE, FALSE);
}
if ( pass ) { PASSED(); } else { H5_FAILED(); }
if ( ! pass ) {
HDfprintf(stdout, "%s(): failure_mssg = \"%s\".\n",
fcn_name, failure_mssg);
}
return;
} /* check_insert_entry() */
/*-------------------------------------------------------------------------
* Function: check_flush_cache()
*
* Purpose: Verify that flush_cache behaves as expected. In particular,
* test the behaviour with different flags.
*
* Return: void
*
* Programmer: John Mainzer
* 1/10/05
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static void
check_flush_cache(void)
{
const char * fcn_name = "check_flush_cache";
H5C_t * cache_ptr = NULL;
TESTING("H5C_flush_cache() functionality");
pass = TRUE;
/* allocate a cache, and flush it under various circumstances.
* To the extent possible, verify that the desired actions took
* place.
*/
if ( pass ) {
reset_entries();
cache_ptr = setup_cache((size_t)(2 * 1024 * 1024),
(size_t)(1 * 1024 * 1024));
}
/* first test behaviour on an empty cache. Can't do much sanity
* checking in this case, so simply check the return values.
*/
if ( pass ) {
check_flush_cache__empty_cache(cache_ptr);
}
/* now do a series of similar tests with a cache with a single entry.
* Start with a clean entry, with no flags set.
*/
if ( pass ) {
check_flush_cache__single_entry(cache_ptr);
}
if ( pass ) {
check_flush_cache__multi_entry(cache_ptr);
}
if ( pass ) {
check_flush_cache__flush_ops(cache_ptr);
}
if ( pass ) {
takedown_cache(cache_ptr, FALSE, FALSE);
}
if ( pass ) { PASSED(); } else { H5_FAILED(); }
if ( ! pass ) {
HDfprintf(stdout, "%s(): failure_mssg = \"%s\".\n",
fcn_name, failure_mssg);
}
return;
} /* check_flush_cache() */
/*-------------------------------------------------------------------------
* Function: check_flush_cache__empty_cache()
*
* Purpose: Verify that flush_cache behaves as expected with an empty
* cache.
*
* Return: void
*
* Programmer: John Mainzer
* 1/12/05
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static void
check_flush_cache__empty_cache(H5C_t * cache_ptr)
{
/* const char * fcn_name = "check_flush_cache__empty_cache"; */
herr_t result;
if ( cache_ptr == NULL ) {
pass = FALSE;
failure_mssg = "cache_ptr NULL on entry to empty cache case.";
}
else if ( ( cache_ptr->index_len != 0 ) ||
( cache_ptr->index_size != 0 ) ) {
pass = FALSE;
failure_mssg = "cache not empty at beginning of empty cache case.";
}
/* Test behaviour on an empty cache. Can't do much sanity
* checking in this case, so simply check the return values.
*/
if ( pass ) {
result = H5C_flush_cache(NULL, -1, -1, cache_ptr, H5C__NO_FLAGS_SET);
if ( result < 0 ) {
pass = FALSE;
failure_mssg = "flush with flags = 0x00 failed on empty cache.\n";
}
}
if ( pass ) {
result = H5C_flush_cache(NULL, -1, -1, cache_ptr,
H5C__FLUSH_INVALIDATE_FLAG);
if ( result < 0 ) {
pass = FALSE;
failure_mssg = "flush with flags = 0x04 failed on empty cache.\n";
}
}
if ( pass ) {
result = H5C_flush_cache(NULL, -1, -1, cache_ptr,
H5C__FLUSH_CLEAR_ONLY_FLAG);
if ( result < 0 ) {
pass = FALSE;
failure_mssg = "flush with flags = 0x08 failed on empty cache.\n";
}
}
if ( pass ) {
result = H5C_flush_cache(NULL, -1, -1, cache_ptr,
H5C__FLUSH_MARKED_ENTRIES_FLAG);
if ( result < 0 ) {
pass = FALSE;
failure_mssg = "flush with flags = 0x10 failed on empty cache.\n";
}
}
} /* check_flush_cache__empty_cache() */
/*-------------------------------------------------------------------------
* Function: check_flush_cache__multi_entry()
*
* Purpose: Verify that flush_cache behaves as expected when the cache
* contains multiple elements.
*
* Return: void
*
* Programmer: John Mainzer
* 1/14/05
*
* Modifications:
*
* JRM -- 4/5/06
* Added pinned entry tests.
*
*-------------------------------------------------------------------------
*/
static void
check_flush_cache__multi_entry(H5C_t * cache_ptr)
{
/* const char * fcn_name = "check_flush_cache__multi_entry"; */
if ( cache_ptr == NULL ) {
pass = FALSE;
failure_mssg = "cache_ptr NULL on entry to multi entry case.";
}
else if ( ( cache_ptr->index_len != 0 ) ||
( cache_ptr->index_size != 0 ) ) {
pass = FALSE;
failure_mssg = "cache not empty at beginning of multi entry case.";
}
if ( pass )
{
int test_num = 1;
unsigned int flush_flags = H5C__NO_FLAGS_SET;
int spec_size = 8;
struct flush_cache_test_spec spec[8] =
{
{
/* entry_num = */ 0,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 100,
/* insert_flag = */ FALSE,
/* dirty_flag = */ FALSE,
/* flags = */ H5C__NO_FLAGS_SET,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 1,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 75,
/* insert_flag = */ FALSE,
/* dirty_flag = */ TRUE,
/* flags = */ H5C__NO_FLAGS_SET,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 2,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 25,
/* insert_flag = */ TRUE,
/* dirty_flag = */ FALSE,
/* flags = */ H5C__NO_FLAGS_SET,
/* expected_loaded = */ FALSE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 3,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 50,
/* insert_flag = */ TRUE,
/* dirty_flag = */ TRUE,
/* flags = */ H5C__NO_FLAGS_SET,
/* expected_loaded = */ FALSE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 4,
/* entry_type = */ MONSTER_ENTRY_TYPE,
/* entry_index = */ 10,
/* insert_flag = */ FALSE,
/* dirty_flag = */ FALSE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 5,
/* entry_type = */ MONSTER_ENTRY_TYPE,
/* entry_index = */ 20,
/* insert_flag = */ FALSE,
/* dirty_flag = */ TRUE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 6,
/* entry_type = */ MONSTER_ENTRY_TYPE,
/* entry_index = */ 30,
/* insert_flag = */ TRUE,
/* dirty_flag = */ FALSE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
/* expected_loaded = */ FALSE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 7,
/* entry_type = */ MONSTER_ENTRY_TYPE,
/* entry_index = */ 40,
/* insert_flag = */ TRUE,
/* dirty_flag = */ TRUE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
/* expected_loaded = */ FALSE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
}
};
check_flush_cache__multi_entry_test(cache_ptr, test_num,
flush_flags, spec_size, spec);
}
if ( pass )
{
int test_num = 2;
unsigned int flush_flags = H5C__FLUSH_INVALIDATE_FLAG;
int spec_size = 8;
struct flush_cache_test_spec spec[8] =
{
{
/* entry_num = */ 0,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 100,
/* insert_flag = */ FALSE,
/* dirty_flag = */ FALSE,
/* flags = */ H5C__NO_FLAGS_SET,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 1,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 75,
/* insert_flag = */ FALSE,
/* dirty_flag = */ TRUE,
/* flags = */ H5C__NO_FLAGS_SET,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 2,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 25,
/* insert_flag = */ TRUE,
/* dirty_flag = */ FALSE,
/* flags = */ H5C__NO_FLAGS_SET,
/* expected_loaded = */ FALSE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 3,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 50,
/* insert_flag = */ TRUE,
/* dirty_flag = */ TRUE,
/* flags = */ H5C__NO_FLAGS_SET,
/* expected_loaded = */ FALSE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 4,
/* entry_type = */ MONSTER_ENTRY_TYPE,
/* entry_index = */ 10,
/* insert_flag = */ FALSE,
/* dirty_flag = */ FALSE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 5,
/* entry_type = */ MONSTER_ENTRY_TYPE,
/* entry_index = */ 20,
/* insert_flag = */ FALSE,
/* dirty_flag = */ TRUE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 6,
/* entry_type = */ MONSTER_ENTRY_TYPE,
/* entry_index = */ 30,
/* insert_flag = */ TRUE,
/* dirty_flag = */ FALSE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
/* expected_loaded = */ FALSE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 7,
/* entry_type = */ MONSTER_ENTRY_TYPE,
/* entry_index = */ 40,
/* insert_flag = */ TRUE,
/* dirty_flag = */ TRUE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
/* expected_loaded = */ FALSE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
}
};
check_flush_cache__multi_entry_test(cache_ptr, test_num,
flush_flags, spec_size, spec);
}
if ( pass )
{
int test_num = 3;
unsigned int flush_flags = H5C__FLUSH_CLEAR_ONLY_FLAG;
int spec_size = 8;
struct flush_cache_test_spec spec[8] =
{
{
/* entry_num = */ 0,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 100,
/* insert_flag = */ FALSE,
/* dirty_flag = */ FALSE,
/* flags = */ H5C__NO_FLAGS_SET,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 1,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 75,
/* insert_flag = */ FALSE,
/* dirty_flag = */ TRUE,
/* flags = */ H5C__NO_FLAGS_SET,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ TRUE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 2,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 25,
/* insert_flag = */ TRUE,
/* dirty_flag = */ FALSE,
/* flags = */ H5C__NO_FLAGS_SET,
/* expected_loaded = */ FALSE,
/* expected_cleared = */ TRUE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 3,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 50,
/* insert_flag = */ TRUE,
/* dirty_flag = */ TRUE,
/* flags = */ H5C__NO_FLAGS_SET,
/* expected_loaded = */ FALSE,
/* expected_cleared = */ TRUE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 4,
/* entry_type = */ MONSTER_ENTRY_TYPE,
/* entry_index = */ 10,
/* insert_flag = */ FALSE,
/* dirty_flag = */ FALSE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 5,
/* entry_type = */ MONSTER_ENTRY_TYPE,
/* entry_index = */ 20,
/* insert_flag = */ FALSE,
/* dirty_flag = */ TRUE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ TRUE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 6,
/* entry_type = */ MONSTER_ENTRY_TYPE,
/* entry_index = */ 30,
/* insert_flag = */ TRUE,
/* dirty_flag = */ FALSE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
/* expected_loaded = */ FALSE,
/* expected_cleared = */ TRUE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 7,
/* entry_type = */ MONSTER_ENTRY_TYPE,
/* entry_index = */ 40,
/* insert_flag = */ TRUE,
/* dirty_flag = */ TRUE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
/* expected_loaded = */ FALSE,
/* expected_cleared = */ TRUE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ FALSE
}
};
check_flush_cache__multi_entry_test(cache_ptr, test_num,
flush_flags, spec_size, spec);
}
if ( pass )
{
int test_num = 4;
unsigned int flush_flags = H5C__FLUSH_MARKED_ENTRIES_FLAG;
int spec_size = 8;
struct flush_cache_test_spec spec[8] =
{
{
/* entry_num = */ 0,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 100,
/* insert_flag = */ FALSE,
/* dirty_flag = */ FALSE,
/* flags = */ H5C__NO_FLAGS_SET,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 1,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 75,
/* insert_flag = */ FALSE,
/* dirty_flag = */ TRUE,
/* flags = */ H5C__NO_FLAGS_SET,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 2,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 25,
/* insert_flag = */ TRUE,
/* dirty_flag = */ FALSE,
/* flags = */ H5C__NO_FLAGS_SET,
/* expected_loaded = */ FALSE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 3,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 50,
/* insert_flag = */ TRUE,
/* dirty_flag = */ TRUE,
/* flags = */ H5C__NO_FLAGS_SET,
/* expected_loaded = */ FALSE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 4,
/* entry_type = */ MONSTER_ENTRY_TYPE,
/* entry_index = */ 10,
/* insert_flag = */ FALSE,
/* dirty_flag = */ FALSE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 5,
/* entry_type = */ MONSTER_ENTRY_TYPE,
/* entry_index = */ 20,
/* insert_flag = */ FALSE,
/* dirty_flag = */ TRUE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 6,
/* entry_type = */ MONSTER_ENTRY_TYPE,
/* entry_index = */ 30,
/* insert_flag = */ TRUE,
/* dirty_flag = */ FALSE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
/* expected_loaded = */ FALSE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 7,
/* entry_type = */ MONSTER_ENTRY_TYPE,
/* entry_index = */ 40,
/* insert_flag = */ TRUE,
/* dirty_flag = */ TRUE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
/* expected_loaded = */ FALSE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
}
};
check_flush_cache__multi_entry_test(cache_ptr, test_num,
flush_flags, spec_size, spec);
}
if ( pass )
{
int test_num = 5;
unsigned int flush_flags = H5C__FLUSH_INVALIDATE_FLAG |
H5C__FLUSH_CLEAR_ONLY_FLAG;
int spec_size = 8;
struct flush_cache_test_spec spec[8] =
{
{
/* entry_num = */ 0,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 100,
/* insert_flag = */ FALSE,
/* dirty_flag = */ FALSE,
/* flags = */ H5C__NO_FLAGS_SET,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ TRUE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 1,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 75,
/* insert_flag = */ FALSE,
/* dirty_flag = */ TRUE,
/* flags = */ H5C__NO_FLAGS_SET,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ TRUE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 2,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 25,
/* insert_flag = */ TRUE,
/* dirty_flag = */ FALSE,
/* flags = */ H5C__NO_FLAGS_SET,
/* expected_loaded = */ FALSE,
/* expected_cleared = */ TRUE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 3,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 50,
/* insert_flag = */ TRUE,
/* dirty_flag = */ TRUE,
/* flags = */ H5C__NO_FLAGS_SET,
/* expected_loaded = */ FALSE,
/* expected_cleared = */ TRUE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 4,
/* entry_type = */ MONSTER_ENTRY_TYPE,
/* entry_index = */ 10,
/* insert_flag = */ FALSE,
/* dirty_flag = */ FALSE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ TRUE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 5,
/* entry_type = */ MONSTER_ENTRY_TYPE,
/* entry_index = */ 20,
/* insert_flag = */ FALSE,
/* dirty_flag = */ TRUE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ TRUE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 6,
/* entry_type = */ MONSTER_ENTRY_TYPE,
/* entry_index = */ 30,
/* insert_flag = */ TRUE,
/* dirty_flag = */ FALSE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
/* expected_loaded = */ FALSE,
/* expected_cleared = */ TRUE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 7,
/* entry_type = */ MONSTER_ENTRY_TYPE,
/* entry_index = */ 40,
/* insert_flag = */ TRUE,
/* dirty_flag = */ TRUE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
/* expected_loaded = */ FALSE,
/* expected_cleared = */ TRUE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ TRUE
}
};
check_flush_cache__multi_entry_test(cache_ptr, test_num,
flush_flags, spec_size, spec);
}
if ( pass )
{
int test_num = 6;
unsigned int flush_flags = H5C__FLUSH_INVALIDATE_FLAG |
H5C__FLUSH_MARKED_ENTRIES_FLAG;
int spec_size = 8;
struct flush_cache_test_spec spec[8] =
{
{
/* entry_num = */ 0,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 100,
/* insert_flag = */ FALSE,
/* dirty_flag = */ FALSE,
/* flags = */ H5C__NO_FLAGS_SET,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 1,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 75,
/* insert_flag = */ FALSE,
/* dirty_flag = */ TRUE,
/* flags = */ H5C__NO_FLAGS_SET,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 2,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 25,
/* insert_flag = */ TRUE,
/* dirty_flag = */ FALSE,
/* flags = */ H5C__NO_FLAGS_SET,
/* expected_loaded = */ FALSE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 3,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 50,
/* insert_flag = */ TRUE,
/* dirty_flag = */ TRUE,
/* flags = */ H5C__NO_FLAGS_SET,
/* expected_loaded = */ FALSE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 4,
/* entry_type = */ MONSTER_ENTRY_TYPE,
/* entry_index = */ 10,
/* insert_flag = */ FALSE,
/* dirty_flag = */ FALSE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 5,
/* entry_type = */ MONSTER_ENTRY_TYPE,
/* entry_index = */ 20,
/* insert_flag = */ FALSE,
/* dirty_flag = */ TRUE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 6,
/* entry_type = */ MONSTER_ENTRY_TYPE,
/* entry_index = */ 30,
/* insert_flag = */ TRUE,
/* dirty_flag = */ FALSE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
/* expected_loaded = */ FALSE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 7,
/* entry_type = */ MONSTER_ENTRY_TYPE,
/* entry_index = */ 40,
/* insert_flag = */ TRUE,
/* dirty_flag = */ TRUE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
/* expected_loaded = */ FALSE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
}
};
check_flush_cache__multi_entry_test(cache_ptr, test_num,
flush_flags, spec_size, spec);
}
if ( pass )
{
int test_num = 7;
unsigned int flush_flags = H5C__FLUSH_CLEAR_ONLY_FLAG |
H5C__FLUSH_MARKED_ENTRIES_FLAG;
int spec_size = 8;
struct flush_cache_test_spec spec[8] =
{
{
/* entry_num = */ 0,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 100,
/* insert_flag = */ FALSE,
/* dirty_flag = */ FALSE,
/* flags = */ H5C__NO_FLAGS_SET,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 1,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 75,
/* insert_flag = */ FALSE,
/* dirty_flag = */ TRUE,
/* flags = */ H5C__NO_FLAGS_SET,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 2,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 25,
/* insert_flag = */ TRUE,
/* dirty_flag = */ FALSE,
/* flags = */ H5C__NO_FLAGS_SET,
/* expected_loaded = */ FALSE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 3,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 50,
/* insert_flag = */ TRUE,
/* dirty_flag = */ TRUE,
/* flags = */ H5C__NO_FLAGS_SET,
/* expected_loaded = */ FALSE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 4,
/* entry_type = */ MONSTER_ENTRY_TYPE,
/* entry_index = */ 10,
/* insert_flag = */ FALSE,
/* dirty_flag = */ FALSE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 5,
/* entry_type = */ MONSTER_ENTRY_TYPE,
/* entry_index = */ 20,
/* insert_flag = */ FALSE,
/* dirty_flag = */ TRUE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ TRUE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 6,
/* entry_type = */ MONSTER_ENTRY_TYPE,
/* entry_index = */ 30,
/* insert_flag = */ TRUE,
/* dirty_flag = */ FALSE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
/* expected_loaded = */ FALSE,
/* expected_cleared = */ TRUE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 7,
/* entry_type = */ MONSTER_ENTRY_TYPE,
/* entry_index = */ 40,
/* insert_flag = */ TRUE,
/* dirty_flag = */ TRUE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
/* expected_loaded = */ FALSE,
/* expected_cleared = */ TRUE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ FALSE
}
};
check_flush_cache__multi_entry_test(cache_ptr, test_num,
flush_flags, spec_size, spec);
}
if ( pass )
{
int test_num = 8;
unsigned int flush_flags = H5C__FLUSH_INVALIDATE_FLAG |
H5C__FLUSH_CLEAR_ONLY_FLAG |
H5C__FLUSH_MARKED_ENTRIES_FLAG;
int spec_size = 8;
struct flush_cache_test_spec spec[8] =
{
{
/* entry_num = */ 0,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 100,
/* insert_flag = */ FALSE,
/* dirty_flag = */ FALSE,
/* flags = */ H5C__NO_FLAGS_SET,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ TRUE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 1,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 75,
/* insert_flag = */ FALSE,
/* dirty_flag = */ TRUE,
/* flags = */ H5C__NO_FLAGS_SET,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ TRUE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 2,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 25,
/* insert_flag = */ TRUE,
/* dirty_flag = */ FALSE,
/* flags = */ H5C__NO_FLAGS_SET,
/* expected_loaded = */ FALSE,
/* expected_cleared = */ TRUE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 3,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 50,
/* insert_flag = */ TRUE,
/* dirty_flag = */ TRUE,
/* flags = */ H5C__NO_FLAGS_SET,
/* expected_loaded = */ FALSE,
/* expected_cleared = */ TRUE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 4,
/* entry_type = */ MONSTER_ENTRY_TYPE,
/* entry_index = */ 10,
/* insert_flag = */ FALSE,
/* dirty_flag = */ FALSE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ TRUE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 5,
/* entry_type = */ MONSTER_ENTRY_TYPE,
/* entry_index = */ 20,
/* insert_flag = */ FALSE,
/* dirty_flag = */ TRUE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ TRUE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 6,
/* entry_type = */ MONSTER_ENTRY_TYPE,
/* entry_index = */ 30,
/* insert_flag = */ TRUE,
/* dirty_flag = */ FALSE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
/* expected_loaded = */ FALSE,
/* expected_cleared = */ TRUE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 7,
/* entry_type = */ MONSTER_ENTRY_TYPE,
/* entry_index = */ 40,
/* insert_flag = */ TRUE,
/* dirty_flag = */ TRUE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
/* expected_loaded = */ FALSE,
/* expected_cleared = */ TRUE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ TRUE
}
};
check_flush_cache__multi_entry_test(cache_ptr, test_num,
flush_flags, spec_size, spec);
}
/* verify that all other flags are ignored */
if ( pass )
{
int test_num = 9;
unsigned int flush_flags = (unsigned)
~(H5C__FLUSH_INVALIDATE_FLAG |
H5C__FLUSH_CLEAR_ONLY_FLAG |
H5C__FLUSH_MARKED_ENTRIES_FLAG);
int spec_size = 8;
struct flush_cache_test_spec spec[8] =
{
{
/* entry_num = */ 0,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 100,
/* insert_flag = */ FALSE,
/* dirty_flag = */ FALSE,
/* flags = */ H5C__NO_FLAGS_SET,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 1,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 75,
/* insert_flag = */ FALSE,
/* dirty_flag = */ TRUE,
/* flags = */ H5C__NO_FLAGS_SET,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 2,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 25,
/* insert_flag = */ TRUE,
/* dirty_flag = */ FALSE,
/* flags = */ H5C__NO_FLAGS_SET,
/* expected_loaded = */ FALSE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 3,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 50,
/* insert_flag = */ TRUE,
/* dirty_flag = */ TRUE,
/* flags = */ H5C__NO_FLAGS_SET,
/* expected_loaded = */ FALSE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 4,
/* entry_type = */ MONSTER_ENTRY_TYPE,
/* entry_index = */ 10,
/* insert_flag = */ FALSE,
/* dirty_flag = */ FALSE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 5,
/* entry_type = */ MONSTER_ENTRY_TYPE,
/* entry_index = */ 20,
/* insert_flag = */ FALSE,
/* dirty_flag = */ TRUE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 6,
/* entry_type = */ MONSTER_ENTRY_TYPE,
/* entry_index = */ 30,
/* insert_flag = */ TRUE,
/* dirty_flag = */ FALSE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
/* expected_loaded = */ FALSE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 7,
/* entry_type = */ MONSTER_ENTRY_TYPE,
/* entry_index = */ 40,
/* insert_flag = */ TRUE,
/* dirty_flag = */ TRUE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
/* expected_loaded = */ FALSE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
}
};
check_flush_cache__multi_entry_test(cache_ptr, test_num,
flush_flags, spec_size, spec);
}
/* Now do pinned entry tests:
*
* For the most part, this test is directed at testing the ability
* of the flush routine to unravel collections of pinned entries.
*/
if ( pass )
{
int test_num = 1;
unsigned int flush_flags = H5C__NO_FLAGS_SET;
int spec_size = 8;
struct pe_flush_cache_test_spec spec[8] =
{
{
/* entry_num = */ 0,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 100,
/* insert_flag = */ FALSE,
/* dirty_flag = */ FALSE,
/* flags = */ H5C__NO_FLAGS_SET,
/* num_pins = */ 0,
/* pin_type[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
/* pin_idx[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 1,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 75,
/* insert_flag = */ FALSE,
/* dirty_flag = */ TRUE,
/* flags = */ H5C__NO_FLAGS_SET,
/* num_pins = */ 1,
/* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
-1, -1, -1, -1, -1, -1, -1},
/* pin_idx[MAX_PINS] = */ {100, -1, -1, -1, -1, -1, -1, -1},
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 2,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 25,
/* insert_flag = */ TRUE,
/* dirty_flag = */ FALSE,
/* flags = */ H5C__NO_FLAGS_SET,
/* num_pins = */ 2,
/* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
PICO_ENTRY_TYPE,
-1, -1, -1, -1, -1, -1},
/* pin_idx[MAX_PINS] = */ {100, 75, -1, -1, -1, -1, -1, -1},
/* expected_loaded = */ FALSE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 3,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 50,
/* insert_flag = */ TRUE,
/* dirty_flag = */ TRUE,
/* flags = */ H5C__NO_FLAGS_SET,
/* num_pins = */ 3,
/* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
PICO_ENTRY_TYPE,
PICO_ENTRY_TYPE,
-1, -1, -1, -1, -1},
/* pin_idx[MAX_PINS] = */ {100, 75, 25, -1, -1, -1, -1, -1},
/* expected_loaded = */ FALSE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 4,
/* entry_type = */ MONSTER_ENTRY_TYPE,
/* entry_index = */ 10,
/* insert_flag = */ FALSE,
/* dirty_flag = */ FALSE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
/* num_pins = */ 4,
/* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
PICO_ENTRY_TYPE,
PICO_ENTRY_TYPE,
PICO_ENTRY_TYPE,
-1, -1, -1, -1},
/* pin_idx[MAX_PINS] = */ {100, 75, 25, 50, -1, -1, -1, -1},
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 5,
/* entry_type = */ MONSTER_ENTRY_TYPE,
/* entry_index = */ 20,
/* insert_flag = */ FALSE,
/* dirty_flag = */ TRUE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
/* num_pins = */ 5,
/* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
PICO_ENTRY_TYPE,
PICO_ENTRY_TYPE,
PICO_ENTRY_TYPE,
MONSTER_ENTRY_TYPE,
-1, -1, -1},
/* pin_idx[MAX_PINS] = */ {100, 75, 25, 50, 10, -1, -1, -1},
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 6,
/* entry_type = */ MONSTER_ENTRY_TYPE,
/* entry_index = */ 30,
/* insert_flag = */ TRUE,
/* dirty_flag = */ FALSE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
/* num_pins = */ 6,
/* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
PICO_ENTRY_TYPE,
PICO_ENTRY_TYPE,
PICO_ENTRY_TYPE,
MONSTER_ENTRY_TYPE,
MONSTER_ENTRY_TYPE,
-1, -1},
/* pin_idx[MAX_PINS] = */ {100, 75, 25, 50, 10, 20, -1, -1},
/* expected_loaded = */ FALSE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 7,
/* entry_type = */ MONSTER_ENTRY_TYPE,
/* entry_index = */ 40,
/* insert_flag = */ TRUE,
/* dirty_flag = */ TRUE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
/* num_pins = */ 7,
/* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
PICO_ENTRY_TYPE,
PICO_ENTRY_TYPE,
PICO_ENTRY_TYPE,
MONSTER_ENTRY_TYPE,
MONSTER_ENTRY_TYPE,
MONSTER_ENTRY_TYPE,
-1},
/* pin_idx[MAX_PINS] = */ {100, 75, 25, 50, 10, 20, 30, -1},
/* expected_loaded = */ FALSE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
}
};
check_flush_cache__pe_multi_entry_test(cache_ptr, test_num,
flush_flags, spec_size, spec);
}
if ( pass )
{
int test_num = 2;
unsigned int flush_flags = H5C__FLUSH_INVALIDATE_FLAG;
int spec_size = 8;
struct pe_flush_cache_test_spec spec[8] =
{
{
/* entry_num = */ 0,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 100,
/* insert_flag = */ FALSE,
/* dirty_flag = */ FALSE,
/* flags = */ H5C__NO_FLAGS_SET,
/* num_pins = */ 0,
/* pin_type[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
/* pin_idx[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 1,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 75,
/* insert_flag = */ FALSE,
/* dirty_flag = */ TRUE,
/* flags = */ H5C__NO_FLAGS_SET,
/* num_pins = */ 1,
/* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
-1, -1, -1, -1, -1, -1, -1},
/* pin_idx[MAX_PINS] = */ {100, -1, -1, -1, -1, -1, -1, -1},
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 2,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 25,
/* insert_flag = */ TRUE,
/* dirty_flag = */ FALSE,
/* flags = */ H5C__NO_FLAGS_SET,
/* num_pins = */ 2,
/* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
PICO_ENTRY_TYPE,
-1, -1, -1, -1, -1, -1},
/* pin_idx[MAX_PINS] = */ {100, 75, -1, -1, -1, -1, -1, -1},
/* expected_loaded = */ FALSE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 3,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 50,
/* insert_flag = */ TRUE,
/* dirty_flag = */ TRUE,
/* flags = */ H5C__NO_FLAGS_SET,
/* num_pins = */ 3,
/* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
PICO_ENTRY_TYPE,
PICO_ENTRY_TYPE,
-1, -1, -1, -1, -1},
/* pin_idx[MAX_PINS] = */ {100, 75, 25, -1, -1, -1, -1, -1},
/* expected_loaded = */ FALSE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 4,
/* entry_type = */ MONSTER_ENTRY_TYPE,
/* entry_index = */ 10,
/* insert_flag = */ FALSE,
/* dirty_flag = */ FALSE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
/* num_pins = */ 0,
/* pin_type[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
/* pin_idx[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 5,
/* entry_type = */ MONSTER_ENTRY_TYPE,
/* entry_index = */ 20,
/* insert_flag = */ FALSE,
/* dirty_flag = */ TRUE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
/* num_pins = */ 1,
/* pin_type[MAX_PINS] = */ {MONSTER_ENTRY_TYPE,
-1, -1, -1, -1 -1, -1, -1},
/* pin_idx[MAX_PINS] = */ {10, -1, -1, -1 -1, -1, -1, -1},
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 6,
/* entry_type = */ MONSTER_ENTRY_TYPE,
/* entry_index = */ 30,
/* insert_flag = */ TRUE,
/* dirty_flag = */ FALSE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
/* num_pins = */ 2,
/* pin_type[MAX_PINS] = */ {MONSTER_ENTRY_TYPE,
MONSTER_ENTRY_TYPE,
-1, -1, -1, -1, -1, -1},
/* pin_idx[MAX_PINS] = */ {10, 20, -1, -1, -1, -1, -1, -1},
/* expected_loaded = */ FALSE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 7,
/* entry_type = */ MONSTER_ENTRY_TYPE,
/* entry_index = */ 40,
/* insert_flag = */ TRUE,
/* dirty_flag = */ TRUE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
/* num_pins = */ 3,
/* pin_type[MAX_PINS] = */ {MONSTER_ENTRY_TYPE,
MONSTER_ENTRY_TYPE,
MONSTER_ENTRY_TYPE,
-1, -1, -1, -1, -1},
/* pin_idx[MAX_PINS] = */ {10, 20, 30, -1, -1, -1, -1, -1},
/* expected_loaded = */ FALSE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
}
};
check_flush_cache__pe_multi_entry_test(cache_ptr, test_num,
flush_flags, spec_size, spec);
}
if ( pass )
{
int test_num = 3;
unsigned int flush_flags = H5C__FLUSH_INVALIDATE_FLAG |
H5C__FLUSH_CLEAR_ONLY_FLAG;
int spec_size = 8;
struct pe_flush_cache_test_spec spec[8] =
{
{
/* entry_num = */ 0,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 100,
/* insert_flag = */ FALSE,
/* dirty_flag = */ FALSE,
/* flags = */ H5C__NO_FLAGS_SET,
/* num_pins = */ 0,
/* pin_type[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
/* pin_idx[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
/* expected_loaded = */ TRUE,
/* expected_cleared = */ TRUE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 1,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 75,
/* insert_flag = */ FALSE,
/* dirty_flag = */ TRUE,
/* flags = */ H5C__NO_FLAGS_SET,
/* num_pins = */ 1,
/* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
-1, -1, -1, -1, -1, -1, -1},
/* pin_idx[MAX_PINS] = */ {100, -1, -1, -1, -1, -1, -1, -1},
/* expected_loaded = */ TRUE,
/* expected_cleared = */ TRUE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 2,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 25,
/* insert_flag = */ TRUE,
/* dirty_flag = */ FALSE,
/* flags = */ H5C__NO_FLAGS_SET,
/* num_pins = */ 1,
/* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
-1, -1, -1, -1, -1, -1, -1},
/* pin_idx[MAX_PINS] = */ {100, -1, -1, -1, -1, -1, -1, -1},
/* expected_loaded = */ FALSE,
/* expected_cleared = */ TRUE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 3,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 50,
/* insert_flag = */ TRUE,
/* dirty_flag = */ TRUE,
/* flags = */ H5C__NO_FLAGS_SET,
/* num_pins = */ 1,
/* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
-1, -1, -1, -1, -1, -1, -1},
/* pin_idx[MAX_PINS] = */ {100, -1, -1, -1, -1, -1, -1, -1},
/* expected_loaded = */ FALSE,
/* expected_cleared = */ TRUE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 4,
/* entry_type = */ MONSTER_ENTRY_TYPE,
/* entry_index = */ 10,
/* insert_flag = */ FALSE,
/* dirty_flag = */ FALSE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
/* num_pins = */ 0,
/* pin_type[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
/* pin_idx[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
/* expected_loaded = */ TRUE,
/* expected_cleared = */ TRUE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 5,
/* entry_type = */ MONSTER_ENTRY_TYPE,
/* entry_index = */ 20,
/* insert_flag = */ FALSE,
/* dirty_flag = */ TRUE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
/* num_pins = */ 0,
/* pin_type[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
/* pin_idx[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
/* expected_loaded = */ TRUE,
/* expected_cleared = */ TRUE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 6,
/* entry_type = */ MONSTER_ENTRY_TYPE,
/* entry_index = */ 30,
/* insert_flag = */ TRUE,
/* dirty_flag = */ FALSE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
/* num_pins = */ 0,
/* pin_type[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
/* pin_idx[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
/* expected_loaded = */ FALSE,
/* expected_cleared = */ TRUE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 7,
/* entry_type = */ MONSTER_ENTRY_TYPE,
/* entry_index = */ 40,
/* insert_flag = */ TRUE,
/* dirty_flag = */ TRUE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
/* num_pins = */ 0,
/* pin_type[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
/* pin_idx[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
/* expected_loaded = */ FALSE,
/* expected_cleared = */ TRUE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ TRUE
}
};
check_flush_cache__pe_multi_entry_test(cache_ptr, test_num,
flush_flags, spec_size, spec);
}
if ( pass )
{
int test_num = 4;
unsigned int flush_flags = H5C__FLUSH_INVALIDATE_FLAG |
H5C__FLUSH_MARKED_ENTRIES_FLAG;
int spec_size = 8;
struct pe_flush_cache_test_spec spec[8] =
{
{
/* entry_num = */ 0,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 100,
/* insert_flag = */ FALSE,
/* dirty_flag = */ FALSE,
/* flags = */ H5C__NO_FLAGS_SET,
/* num_pins = */ 0,
/* pin_type[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
/* pin_idx[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 1,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 75,
/* insert_flag = */ FALSE,
/* dirty_flag = */ TRUE,
/* flags = */ H5C__NO_FLAGS_SET,
/* num_pins = */ 1,
/* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
-1, -1, -1, -1, -1, -1, -1},
/* pin_idx[MAX_PINS] = */ {100, -1, -1, -1, -1, -1, -1, -1},
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 2,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 25,
/* insert_flag = */ TRUE,
/* dirty_flag = */ FALSE,
/* flags = */ H5C__NO_FLAGS_SET,
/* num_pins = */ 1,
/* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
-1, -1, -1, -1, -1, -1, -1},
/* pin_idx[MAX_PINS] = */ {100, -1, -1, -1, -1, -1, -1, -1},
/* expected_loaded = */ FALSE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 3,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 50,
/* insert_flag = */ TRUE,
/* dirty_flag = */ TRUE,
/* flags = */ H5C__NO_FLAGS_SET,
/* num_pins = */ 1,
/* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
-1, -1, -1, -1, -1, -1, -1},
/* pin_idx[MAX_PINS] = */ {100, -1, -1, -1, -1, -1, -1, -1},
/* expected_loaded = */ FALSE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 4,
/* entry_type = */ MONSTER_ENTRY_TYPE,
/* entry_index = */ 10,
/* insert_flag = */ FALSE,
/* dirty_flag = */ FALSE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
/* num_pins = */ 0,
/* pin_type[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
/* pin_idx[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 5,
/* entry_type = */ MONSTER_ENTRY_TYPE,
/* entry_index = */ 20,
/* insert_flag = */ FALSE,
/* dirty_flag = */ TRUE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
/* num_pins = */ 4,
/* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
PICO_ENTRY_TYPE,
PICO_ENTRY_TYPE,
PICO_ENTRY_TYPE,
-1, -1, -1, -1},
/* pin_idx[MAX_PINS] = */ {100, 75, 25, 50, -1, -1, -1, -1},
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 6,
/* entry_type = */ MONSTER_ENTRY_TYPE,
/* entry_index = */ 30,
/* insert_flag = */ TRUE,
/* dirty_flag = */ FALSE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
/* num_pins = */ 4,
/* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
PICO_ENTRY_TYPE,
PICO_ENTRY_TYPE,
PICO_ENTRY_TYPE,
-1, -1, -1, -1},
/* pin_idx[MAX_PINS] = */ {100, 75, 25, 50, -1, -1, -1, -1},
/* expected_loaded = */ FALSE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 7,
/* entry_type = */ MONSTER_ENTRY_TYPE,
/* entry_index = */ 40,
/* insert_flag = */ TRUE,
/* dirty_flag = */ TRUE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
/* num_pins = */ 0,
/* pin_type[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
/* pin_idx[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
/* expected_loaded = */ FALSE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
}
};
check_flush_cache__pe_multi_entry_test(cache_ptr, test_num,
flush_flags, spec_size, spec);
}
if ( pass )
{
int test_num = 5;
unsigned int flush_flags = H5C__FLUSH_INVALIDATE_FLAG |
H5C__FLUSH_CLEAR_ONLY_FLAG |
H5C__FLUSH_MARKED_ENTRIES_FLAG;
int spec_size = 8;
struct pe_flush_cache_test_spec spec[8] =
{
{
/* entry_num = */ 0,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 100,
/* insert_flag = */ FALSE,
/* dirty_flag = */ FALSE,
/* flags = */ H5C__NO_FLAGS_SET,
/* num_pins = */ 0,
/* pin_type[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
/* pin_idx[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
/* expected_loaded = */ TRUE,
/* expected_cleared = */ TRUE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 1,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 75,
/* insert_flag = */ FALSE,
/* dirty_flag = */ TRUE,
/* flags = */ H5C__NO_FLAGS_SET,
/* num_pins = */ 1,
/* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
-1, -1, -1, -1, -1, -1, -1},
/* pin_idx[MAX_PINS] = */ {100, -1, -1, -1, -1, -1, -1, -1},
/* expected_loaded = */ TRUE,
/* expected_cleared = */ TRUE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 2,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 25,
/* insert_flag = */ TRUE,
/* dirty_flag = */ FALSE,
/* flags = */ H5C__NO_FLAGS_SET,
/* num_pins = */ 1,
/* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
-1, -1, -1, -1, -1, -1, -1},
/* pin_idx[MAX_PINS] = */ {100, -1, -1, -1, -1, -1, -1, -1},
/* expected_loaded = */ FALSE,
/* expected_cleared = */ TRUE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 3,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 50,
/* insert_flag = */ TRUE,
/* dirty_flag = */ TRUE,
/* flags = */ H5C__NO_FLAGS_SET,
/* num_pins = */ 1,
/* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
-1, -1, -1, -1, -1, -1, -1},
/* pin_idx[MAX_PINS] = */ {100, -1, -1, -1, -1, -1, -1, -1},
/* expected_loaded = */ FALSE,
/* expected_cleared = */ TRUE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 4,
/* entry_type = */ MONSTER_ENTRY_TYPE,
/* entry_index = */ 10,
/* insert_flag = */ FALSE,
/* dirty_flag = */ FALSE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
/* num_pins = */ 1,
/* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
-1, -1, -1, -1, -1, -1, -1},
/* pin_idx[MAX_PINS] = */ {100, -1, -1, -1, -1, -1, -1, -1},
/* expected_loaded = */ TRUE,
/* expected_cleared = */ TRUE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 5,
/* entry_type = */ MONSTER_ENTRY_TYPE,
/* entry_index = */ 20,
/* insert_flag = */ FALSE,
/* dirty_flag = */ TRUE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
/* num_pins = */ 1,
/* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
-1, -1, -1, -1, -1, -1, -1},
/* pin_idx[MAX_PINS] = */ {100, -1, -1, -1, -1, -1, -1, -1},
/* expected_loaded = */ TRUE,
/* expected_cleared = */ TRUE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 6,
/* entry_type = */ MONSTER_ENTRY_TYPE,
/* entry_index = */ 30,
/* insert_flag = */ TRUE,
/* dirty_flag = */ FALSE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
/* num_pins = */ 1,
/* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
-1, -1, -1, -1, -1, -1, -1},
/* pin_idx[MAX_PINS] = */ {100, -1, -1, -1, -1, -1, -1, -1},
/* expected_loaded = */ FALSE,
/* expected_cleared = */ TRUE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 7,
/* entry_type = */ MONSTER_ENTRY_TYPE,
/* entry_index = */ 40,
/* insert_flag = */ TRUE,
/* dirty_flag = */ TRUE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
/* num_pins = */ 1,
/* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
-1, -1, -1, -1, -1, -1, -1},
/* pin_idx[MAX_PINS] = */ {100, -1, -1, -1, -1, -1, -1, -1},
/* expected_loaded = */ FALSE,
/* expected_cleared = */ TRUE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ TRUE
}
};
check_flush_cache__pe_multi_entry_test(cache_ptr, test_num,
flush_flags, spec_size, spec);
}
return;
} /* check_flush_cache__multi_entry() */
/*-------------------------------------------------------------------------
* Function: check_flush_cache__multi_entry_test()
*
* Purpose: Run a multi entry flush cache test.
*
* Return: void
*
* Programmer: John Mainzer
* 1/13/05
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static void
check_flush_cache__multi_entry_test(H5C_t * cache_ptr,
int test_num,
unsigned int flush_flags,
int spec_size,
struct flush_cache_test_spec spec[])
{
/* const char * fcn_name = "check_flush_cache__multi_entry_test"; */
static char msg[128];
herr_t result;
int i;
size_t total_entry_size = 0;
test_entry_t * base_addr;
test_entry_t * entry_ptr;
#if 0 /* JRM */
/* This gets used a lot, so lets leave it in. */
HDfprintf(stdout, "check_flush_cache__multi_entry_test: test %d\n",
test_num);
#endif /* JRM */
if ( cache_ptr == NULL ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"cache_ptr NULL on entry to single entry test #%d.",
test_num);
failure_mssg = msg;
}
else if ( ( cache_ptr->index_len != 0 ) ||
( cache_ptr->index_size != 0 ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"cache not empty at beginning of multi entry test #%d.",
test_num);
failure_mssg = msg;
}
else if ( ( spec_size < 1 ) || ( spec == NULL ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"missing/bad test spec on entry to multi entry test #%d.",
test_num);
failure_mssg = msg;
}
i = 0;
while ( ( pass ) && ( i < 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] ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"bad data in spec[%d] on entry to multi entry test #%d.",
i, test_num);
failure_mssg = msg;
}
i++;
}
i = 0;
while ( ( pass ) && ( i < spec_size ) )
{
if ( spec[i].insert_flag ) {
insert_entry(cache_ptr, spec[i].entry_type, spec[i].entry_index,
spec[i].dirty_flag, spec[i].flags);
} else {
protect_entry(cache_ptr, spec[i].entry_type, spec[i].entry_index);
unprotect_entry(cache_ptr, spec[i].entry_type, spec[i].entry_index,
(int)(spec[i].dirty_flag), spec[i].flags);
}
total_entry_size += entry_sizes[spec[i].entry_type];
i++;
}
if ( pass ) {
result = H5C_flush_cache(NULL, -1, -1, cache_ptr, flush_flags);
if ( result < 0 ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"flush with flags 0x%x failed in multi entry test #%d.",
flush_flags, test_num);
failure_mssg = msg;
}
}
i = 0;
while ( ( pass ) && ( i < spec_size ) )
{
base_addr = entries[spec[i].entry_type];
entry_ptr = &(base_addr[spec[i].entry_index]);
if ( ( entry_ptr->loaded != spec[i].expected_loaded ) ||
( entry_ptr->cleared != spec[i].expected_cleared ) ||
( entry_ptr->flushed != spec[i].expected_flushed ) ||
( entry_ptr->destroyed != spec[i].expected_destroyed ) ) {
#if 0 /* This is useful debugging code. Lets keep it around. */
HDfprintf(stdout,
"loaded = %d(%d), clrd = %d(%d), flshd = %d(%d), dest = %d(%d)\n",
(int)(entry_ptr->loaded),
(int)(spec[i].expected_loaded),
(int)(entry_ptr->cleared),
(int)(spec[i].expected_cleared),
(int)(entry_ptr->flushed),
(int)(spec[i].expected_flushed),
(int)(entry_ptr->destroyed),
(int)(spec[i].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);
failure_mssg = msg;
}
i++;
}
if ( pass ) {
if ( ( ( (flush_flags & H5C__FLUSH_INVALIDATE_FLAG) == 0 )
&&
( ( cache_ptr->index_len != spec_size )
||
( cache_ptr->index_size != total_entry_size )
)
)
||
( ( (flush_flags & H5C__FLUSH_INVALIDATE_FLAG) != 0 )
&&
( ( cache_ptr->index_len != 0 )
||
( cache_ptr->index_size != 0 )
)
)
) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"Unexpected cache len/size after flush in multi entry test #%d.",
test_num);
failure_mssg = msg;
}
}
/* clean up the cache to prep for the next test */
if ( pass ) {
result = H5C_flush_cache(NULL, -1, -1, cache_ptr,
H5C__FLUSH_INVALIDATE_FLAG);
if ( result < 0 ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"Flush failed on cleanup in multi entry test #%d.",
test_num);
failure_mssg = msg;
}
else if ( ( cache_ptr->index_len != 0 ) ||
( cache_ptr->index_size != 0 ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"Unexpected cache len/size after cleanup in multi entry test #%d.",
test_num);
failure_mssg = msg;
}
}
i = 0;
while ( ( pass ) && ( i < spec_size ) )
{
base_addr = entries[spec[i].entry_type];
entry_ptr = &(base_addr[spec[i].entry_index]);
entry_ptr->loaded = FALSE;
entry_ptr->cleared = FALSE;
entry_ptr->flushed = FALSE;
entry_ptr->destroyed = FALSE;
i++;
}
return;
} /* check_flush_cache__multi_entry_test() */
/*-------------------------------------------------------------------------
* Function: check_flush_cache__pe_multi_entry_test()
*
* Purpose: Run a multi entry flush cache test.
*
* Return: void
*
* Programmer: John Mainzer
* 4/5/06
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static void
check_flush_cache__pe_multi_entry_test(H5C_t * cache_ptr,
int test_num,
unsigned int flush_flags,
int spec_size,
struct pe_flush_cache_test_spec spec[])
{
/* const char * fcn_name = "check_flush_cache__pe_multi_entry_test"; */
static char msg[128];
herr_t result;
int i;
int j;
size_t total_entry_size = 0;
test_entry_t * base_addr;
test_entry_t * entry_ptr;
#if 0 /* JRM */
/* This is useful debugging code. Leave it in for now. */
HDfprintf(stdout, "check_flush_cache__pe_multi_entry_test: test %d\n",
test_num);
#endif /* JRM */
if ( cache_ptr == NULL ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"cache_ptr NULL on entry to pe multi entry test #%d.",
test_num);
failure_mssg = msg;
}
else if ( ( cache_ptr->index_len != 0 ) ||
( cache_ptr->index_size != 0 ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"cache not empty at beginning of pe multi entry test #%d.",
test_num);
failure_mssg = msg;
}
else if ( ( spec_size < 1 ) || ( spec == NULL ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"missing/bad test spec on entry to pe multi entry test #%d.",
test_num);
failure_mssg = msg;
}
i = 0;
while ( ( pass ) && ( i < 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 ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"bad data in spec[%d] on entry to pe multi entry test #%d.",
i, test_num);
failure_mssg = msg;
}
i++;
}
i = 0;
while ( ( pass ) && ( i < spec_size ) )
{
if ( spec[i].insert_flag ) {
insert_entry(cache_ptr, spec[i].entry_type, spec[i].entry_index,
spec[i].dirty_flag, spec[i].flags);
} else {
protect_entry(cache_ptr, spec[i].entry_type, spec[i].entry_index);
unprotect_entry(cache_ptr, spec[i].entry_type, spec[i].entry_index,
(int)(spec[i].dirty_flag), spec[i].flags);
}
total_entry_size += entry_sizes[spec[i].entry_type];
for ( j = 0; j < spec[i].num_pins; j++ )
{
create_pinned_entry_dependency(cache_ptr,
spec[i].entry_type,
spec[i].entry_index,
spec[i].pin_type[j],
spec[i].pin_idx[j]);
}
i++;
}
if ( pass ) {
result = H5C_flush_cache(NULL, -1, -1, cache_ptr, flush_flags);
if ( result < 0 ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"flush with flags 0x%x failed in pe multi entry test #%d.",
flush_flags, test_num);
failure_mssg = msg;
}
}
i = 0;
while ( ( pass ) && ( i < spec_size ) )
{
base_addr = entries[spec[i].entry_type];
entry_ptr = &(base_addr[spec[i].entry_index]);
if ( ( entry_ptr->loaded != spec[i].expected_loaded ) ||
( entry_ptr->cleared != spec[i].expected_cleared ) ||
( entry_ptr->flushed != spec[i].expected_flushed ) ||
( entry_ptr->destroyed != spec[i].expected_destroyed ) ) {
#if 0 /* This is useful debugging code. Lets keep it around. */
HDfprintf(stdout,
"loaded = %d(%d), clrd = %d(%d), flshd = %d(%d), dest = %d(%d)\n",
(int)(entry_ptr->loaded),
(int)(spec[i].expected_loaded),
(int)(entry_ptr->cleared),
(int)(spec[i].expected_cleared),
(int)(entry_ptr->flushed),
(int)(spec[i].expected_flushed),
(int)(entry_ptr->destroyed),
(int)(spec[i].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);
failure_mssg = msg;
}
i++;
}
if ( pass ) {
if ( ( ( (flush_flags & H5C__FLUSH_INVALIDATE_FLAG) == 0 )
&&
( ( cache_ptr->index_len != spec_size )
||
( cache_ptr->index_size != total_entry_size )
)
)
||
( ( (flush_flags & H5C__FLUSH_INVALIDATE_FLAG) != 0 )
&&
( ( cache_ptr->index_len != 0 )
||
( cache_ptr->index_size != 0 )
)
)
) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"Unexpected cache len/size after flush in pe multi entry test #%d.",
test_num);
failure_mssg = msg;
}
}
/* clean up the cache to prep for the next test */
if ( pass ) {
result = H5C_flush_cache(NULL, -1, -1, cache_ptr,
H5C__FLUSH_INVALIDATE_FLAG);
if ( result < 0 ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"Flush failed on cleanup in pe multi entry test #%d.",
test_num);
failure_mssg = msg;
}
else if ( ( cache_ptr->index_len != 0 ) ||
( cache_ptr->index_size != 0 ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"Unexpected cache len/size after cleanup in pe multi entry test #%d.",
test_num);
failure_mssg = msg;
}
}
i = 0;
while ( ( pass ) && ( i < spec_size ) )
{
base_addr = entries[spec[i].entry_type];
entry_ptr = &(base_addr[spec[i].entry_index]);
entry_ptr->loaded = FALSE;
entry_ptr->cleared = FALSE;
entry_ptr->flushed = FALSE;
entry_ptr->destroyed = FALSE;
i++;
}
return;
} /* check_flush_cache__pe_multi_entry_test() */
/*-------------------------------------------------------------------------
* Function: check_flush_cache__flush_ops()
*
* Purpose: Run the flush ops cache tests.
*
* These are tests that test the cache's ability to handle
* the case in which the flush callback dirties, resizes,
* and/or renames entries.
*
* Do nothing if pass is FALSE on entry.
*
* Return: void
*
* Programmer: John Mainzer
* 9/3/06
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static void
check_flush_cache__flush_ops(H5C_t * cache_ptr)
{
/* const char * fcn_name = "check_flush_cache__flush_ops"; */
if ( cache_ptr == NULL ) {
pass = FALSE;
failure_mssg = "cache_ptr NULL on entry to flush ops test.";
}
else if ( ( cache_ptr->index_len != 0 ) ||
( cache_ptr->index_size != 0 ) ) {
pass = FALSE;
failure_mssg = "cache not empty at beginning of flush ops test.";
}
if ( pass ) /* test #1 */
{
/* start with a very simple test, in which there are two entries
* resident in cache, and the second entry dirties the first in
* the flush callback. No size changes, and no flush flags.
*/
int test_num = 1;
unsigned int flush_flags = H5C__NO_FLAGS_SET;
int spec_size = 2;
int init_expected_index_len = 2;
size_t init_expected_index_size = 2 * PICO_ENTRY_SIZE;
int expected_index_len = 2;
size_t expected_index_size = 2 * PICO_ENTRY_SIZE;
struct fo_flush_cache_test_spec spec[2] =
{
{
/* entry_num = */ 0,
/* entry_type = */ 0,
/* entry_index = */ 0,
/* insert_flag = */ FALSE,
/* flags = */ H5C__NO_FLAGS_SET,
/* new_size = */ 0,
/* num_pins = */ 0,
/* pin_type = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 0,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 1,
/* entry_type = */ 0,
/* entry_index = */ 1,
/* insert_flag = */ FALSE,
/* flags = */ H5C__DIRTIED_FLAG,
/* new_size = */ 0,
/* num_pins = */ 0,
/* pin_type = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 1,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__DIRTY, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
}
};
int check_size = 0;
struct fo_flush_entry_check checks[1] =
{
{
/* entry_num = */ 0,
/* entry_type = */ 0,
/* entry_index = */ 0,
/* expected_size = */ (size_t)0,
/* in_cache = */ FALSE,
/* at_main_addr = */ FALSE,
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
/* expected_loaded = */ FALSE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ FALSE
}
};
check_flush_cache__flush_op_test(cache_ptr,
test_num,
flush_flags,
spec_size,
spec,
init_expected_index_len,
init_expected_index_size,
expected_index_len,
expected_index_size,
check_size,
checks);
}
if ( pass ) /* test #2 */
{
/* Same as test 1, only this time set the flush invalidate flag.
* Note that we must repeat all tests with the flush invalidate flag
* as this triggers a different set of code to execute the flush.
*
* Create two entries resident in cache, and have the second entry
* dirty the first in the flush callback.
*/
int test_num = 2;
unsigned int flush_flags = H5C__FLUSH_INVALIDATE_FLAG;
int spec_size = 2;
int init_expected_index_len = 2;
size_t init_expected_index_size = 2 * PICO_ENTRY_SIZE;
int expected_index_len = 0;
size_t expected_index_size = 0;
struct fo_flush_cache_test_spec spec[2] =
{
{
/* entry_num = */ 0,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 0,
/* insert_flag = */ FALSE,
/* flags = */ H5C__NO_FLAGS_SET,
/* new_size = */ 0,
/* num_pins = */ 0,
/* pin_type = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 0,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 1,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 1,
/* insert_flag = */ FALSE,
/* flags = */ H5C__DIRTIED_FLAG,
/* new_size = */ 0,
/* num_pins = */ 0,
/* pin_type = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 1,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__DIRTY, PICO_ENTRY_TYPE,0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
}
};
int check_size = 0;
struct fo_flush_entry_check checks[1] =
{
{
/* entry_num = */ 0,
/* entry_type = */ 0,
/* entry_index = */ 0,
/* expected_size = */ (size_t)0,
/* in_cache = */ FALSE,
/* at_main_addr = */ FALSE,
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
/* expected_loaded = */ FALSE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ FALSE
}
};
check_flush_cache__flush_op_test(cache_ptr,
test_num,
flush_flags,
spec_size,
spec,
init_expected_index_len,
init_expected_index_size,
expected_index_len,
expected_index_size,
check_size,
checks);
}
if ( pass ) /* test #3 */
{
/* Single entry test verifying that the cache can handle the case in
* which the call back function resizes the entry for which it has
* been called.
*/
int test_num = 3;
unsigned int flush_flags = H5C__NO_FLAGS_SET;
int spec_size = 1;
int init_expected_index_len = 1;
size_t init_expected_index_size = VARIABLE_ENTRY_SIZE / 4;
int expected_index_len = 1;
size_t expected_index_size = VARIABLE_ENTRY_SIZE / 2;
struct fo_flush_cache_test_spec spec[1] =
{
{
/* entry_num = */ 0,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 0,
/* insert_flag = */ FALSE,
/* flags = */ H5C__SIZE_CHANGED_FLAG,
/* new_size = */ VARIABLE_ENTRY_SIZE / 4,
/* num_pins = */ 0,
/* pin_type = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 1,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__RESIZE, VARIABLE_ENTRY_TYPE, 0, FALSE, VARIABLE_ENTRY_SIZE / 2 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
}
};
int check_size = 0;
struct fo_flush_entry_check checks[1] =
{
{
/* entry_num = */ 0,
/* entry_type = */ 0,
/* entry_index = */ 0,
/* expected_size = */ (size_t)0,
/* in_cache = */ FALSE,
/* at_main_addr = */ FALSE,
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
/* expected_loaded = */ FALSE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ FALSE
}
};
check_flush_cache__flush_op_test(cache_ptr,
test_num,
flush_flags,
spec_size,
spec,
init_expected_index_len,
init_expected_index_size,
expected_index_len,
expected_index_size,
check_size,
checks);
}
if ( pass ) /* test #4 */
{
/* Repeat test #4 with the flush invalidate flag.
*
* Single entry test verifying that the cache can handle the case in
* which the call back function resizes the entry for which it has
* been called.
*/
int test_num = 4;
unsigned int flush_flags = H5C__FLUSH_INVALIDATE_FLAG;
int spec_size = 1;
int init_expected_index_len = 1;
size_t init_expected_index_size = VARIABLE_ENTRY_SIZE / 4;
int expected_index_len = 0;
size_t expected_index_size = 0;
struct fo_flush_cache_test_spec spec[1] =
{
{
/* entry_num = */ 0,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 0,
/* insert_flag = */ FALSE,
/* flags = */ H5C__SIZE_CHANGED_FLAG,
/* new_size = */ VARIABLE_ENTRY_SIZE / 4,
/* num_pins = */ 0,
/* pin_type = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 1,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__RESIZE, VARIABLE_ENTRY_TYPE, 0, FALSE, VARIABLE_ENTRY_SIZE / 2 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
}
};
int check_size = 0;
struct fo_flush_entry_check checks[1] =
{
{
/* entry_num = */ 0,
/* entry_type = */ 0,
/* entry_index = */ 0,
/* expected_size = */ (size_t)0,
/* in_cache = */ FALSE,
/* at_main_addr = */ FALSE,
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
/* expected_loaded = */ FALSE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ FALSE
}
};
check_flush_cache__flush_op_test(cache_ptr,
test_num,
flush_flags,
spec_size,
spec,
init_expected_index_len,
init_expected_index_size,
expected_index_len,
expected_index_size,
check_size,
checks);
}
if ( pass ) /* test #5 & #6 */
{
/* Single entry test verifying that the cache can handle the case in
* which the call back function renames the entry for which it has
* been called.
*
* Run this entry twice, as the first run moves the entry to its
* alternate address, and the second moves it back.
*/
int test_num = 5; /* and 6 */
unsigned int flush_flags = H5C__NO_FLAGS_SET;
int spec_size = 1;
int init_expected_index_len = 1;
size_t init_expected_index_size = VARIABLE_ENTRY_SIZE;
int expected_index_len = 1;
size_t expected_index_size = VARIABLE_ENTRY_SIZE;
struct fo_flush_cache_test_spec spec[1] =
{
{
/* entry_num = */ 0,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 0,
/* insert_flag = */ FALSE,
/* flags = */ H5C__DIRTIED_FLAG,
/* new_size = */ 0,
/* num_pins = */ 0,
/* pin_type = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 1,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__RENAME, VARIABLE_ENTRY_TYPE, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
}
};
int check_size = 0;
struct fo_flush_entry_check checks[1] =
{
{
/* entry_num = */ 0,
/* entry_type = */ 0,
/* entry_index = */ 0,
/* expected_size = */ (size_t)0,
/* in_cache = */ FALSE,
/* at_main_addr = */ FALSE,
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
/* expected_loaded = */ FALSE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ FALSE
}
};
check_flush_cache__flush_op_test(cache_ptr,
test_num,
flush_flags,
spec_size,
spec,
init_expected_index_len,
init_expected_index_size,
expected_index_len,
expected_index_size,
check_size,
checks);
/* this change forces the rename to move the target entry back to its
* main address. The first test moved it to its alternate address.
*
* Note that these two tests are not the same, as in the first test,
* the renamed entry is moved forward in the slist. In the second
* it is moved backwards.
*
* Since there is only one entry in the cache, this doesn't really
* matter in this case. But we will do similar tests later with
* other entries in the cache.
*/
if ( pass ) {
spec[0].flush_ops[0].flag = TRUE;
test_num = 6;
check_flush_cache__flush_op_test(cache_ptr,
test_num,
flush_flags,
spec_size,
spec,
init_expected_index_len,
init_expected_index_size,
expected_index_len,
expected_index_size,
check_size,
checks);
}
}
if ( pass ) /* test #7 & #8 */
{
/* Run tests 5 & 6 again, using the flush invalidate flag on the
* second test.
*
* Single entry test verifying that the cache can handle the case in
* which the call back function renames the entry for which it has
* been called.
*
* Run this entry twice, as the first run moves the entry to its
* alternate address, and the second moves it back.
*/
int test_num = 7; /* and 8 */
unsigned int flush_flags = H5C__NO_FLAGS_SET;
int spec_size = 1;
int init_expected_index_len = 1;
size_t init_expected_index_size = VARIABLE_ENTRY_SIZE;
int expected_index_len = 1;
size_t expected_index_size = VARIABLE_ENTRY_SIZE;
struct fo_flush_cache_test_spec spec[1] =
{
{
/* entry_num = */ 0,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 0,
/* insert_flag = */ FALSE,
/* flags = */ H5C__DIRTIED_FLAG,
/* new_size = */ 0,
/* num_pins = */ 0,
/* pin_type = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 1,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__RENAME, VARIABLE_ENTRY_TYPE, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
}
};
int check_size = 0;
struct fo_flush_entry_check checks[1] =
{
{
/* entry_num = */ 0,
/* entry_type = */ 0,
/* entry_index = */ 0,
/* expected_size = */ (size_t)0,
/* in_cache = */ FALSE,
/* at_main_addr = */ FALSE,
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
/* expected_loaded = */ FALSE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ FALSE
}
};
check_flush_cache__flush_op_test(cache_ptr,
test_num,
flush_flags,
spec_size,
spec,
init_expected_index_len,
init_expected_index_size,
expected_index_len,
expected_index_size,
check_size,
checks);
/* this change forces the rename to move the target entry back to its
* main address. The first test moved it to its alternate address.
*
* Note that these two tests are not the same, as in the first test,
* the renamed entry is moved forward in the slist. In the second
* it is moved backwards.
*
* Since there is only one entry in the cache, this doesn't really
* matter in this case. But we will do similar tests later with
* other entries in the cache.
*/
if ( pass ) {
test_num = 8;
flush_flags = H5C__FLUSH_INVALIDATE_FLAG;
expected_index_len = 0;
expected_index_size = 0;
spec[0].flush_ops[0].flag = TRUE;
spec[0].expected_destroyed = TRUE;
check_flush_cache__flush_op_test(cache_ptr,
test_num,
flush_flags,
spec_size,
spec,
init_expected_index_len,
init_expected_index_size,
expected_index_len,
expected_index_size,
check_size,
checks);
}
}
if ( pass ) /* test #9 & #10 */
{
/* Single entry test verifying that the cache can handle the case in
* which the call back function both resizes and renames the entry
* for which it has been called.
*
* Again, we run this entry twice, as the first run moves the entry to its
* alternate address, and the second moves it back.
*/
int test_num = 9; /* and 10 */
unsigned int flush_flags = H5C__NO_FLAGS_SET;
int spec_size = 1;
int init_expected_index_len = 1;
size_t init_expected_index_size = VARIABLE_ENTRY_SIZE / 2;
int expected_index_len = 1;
size_t expected_index_size = VARIABLE_ENTRY_SIZE / 4;
struct fo_flush_cache_test_spec spec[1] =
{
{
/* entry_num = */ 0,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 0,
/* insert_flag = */ FALSE,
/* flags = */ H5C__SIZE_CHANGED_FLAG,
/* new_size = */ VARIABLE_ENTRY_SIZE / 2,
/* num_pins = */ 0,
/* pin_type = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 2,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__RESIZE, VARIABLE_ENTRY_TYPE, 0, FALSE, VARIABLE_ENTRY_SIZE / 4 },
{ FLUSH_OP__RENAME, VARIABLE_ENTRY_TYPE, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
}
};
int check_size = 0;
struct fo_flush_entry_check checks[1] =
{
{
/* entry_num = */ 0,
/* entry_type = */ 0,
/* entry_index = */ 0,
/* expected_size = */ (size_t)0,
/* in_cache = */ FALSE,
/* at_main_addr = */ FALSE,
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
/* expected_loaded = */ FALSE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ FALSE
}
};
check_flush_cache__flush_op_test(cache_ptr,
test_num,
flush_flags,
spec_size,
spec,
init_expected_index_len,
init_expected_index_size,
expected_index_len,
expected_index_size,
check_size,
checks);
/* this change forces the rename to move the target entry back to its
* main address. The first test moved it to its alternate address.
*
* Note that these two tests are not the same, as in the first test,
* the renamed entry is moved forward in the slist. In the second
* it is moved backwards.
*
* Since there is only one entry in the cache, this doesn't really
* matter in this case. But we will do similar tests later with
* other entries in the cache.
*/
if ( pass ) {
spec[0].flush_ops[0].flag = TRUE;
test_num = 10;
check_flush_cache__flush_op_test(cache_ptr,
test_num,
flush_flags,
spec_size,
spec,
init_expected_index_len,
init_expected_index_size,
expected_index_len,
expected_index_size,
check_size,
checks);
}
}
if ( pass ) /* test #11 & #12 */
{
/* Repeat the previous test with the flush invalidate flag on the
* second test.
*
* Single entry test verifying that the cache can handle the case in
* which the call back function both resizes and renames the entry
* for which it has been called.
*
* Again, we run this entry twice, as the first run moves the entry to its
* alternate address, and the second moves it back.
*/
int test_num = 11; /* and 12 */
unsigned int flush_flags = H5C__NO_FLAGS_SET;
int spec_size = 1;
int init_expected_index_len = 1;
size_t init_expected_index_size = VARIABLE_ENTRY_SIZE / 2;
int expected_index_len = 1;
size_t expected_index_size = VARIABLE_ENTRY_SIZE / 4;
struct fo_flush_cache_test_spec spec[1] =
{
{
/* entry_num = */ 0,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 0,
/* insert_flag = */ FALSE,
/* flags = */ H5C__SIZE_CHANGED_FLAG,
/* new_size = */ VARIABLE_ENTRY_SIZE / 2,
/* num_pins = */ 0,
/* pin_type = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 2,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__RESIZE, VARIABLE_ENTRY_TYPE, 0, FALSE, VARIABLE_ENTRY_SIZE / 4 },
{ FLUSH_OP__RENAME, VARIABLE_ENTRY_TYPE, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
}
};
int check_size = 0;
struct fo_flush_entry_check checks[1] =
{
{
/* entry_num = */ 0,
/* entry_type = */ 0,
/* entry_index = */ 0,
/* expected_size = */ (size_t)0,
/* in_cache = */ FALSE,
/* at_main_addr = */ FALSE,
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
/* expected_loaded = */ FALSE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ FALSE
}
};
check_flush_cache__flush_op_test(cache_ptr,
test_num,
flush_flags,
spec_size,
spec,
init_expected_index_len,
init_expected_index_size,
expected_index_len,
expected_index_size,
check_size,
checks);
/* this change forces the rename to move the target entry back to its
* main address. The first test moved it to its alternate address.
*
* Note that these two tests are not the same, as in the first test,
* the renamed entry is moved forward in the slist. In the second
* it is moved backwards.
*
* Since there is only one entry in the cache, this doesn't really
* matter in this case. But we will do similar tests later with
* other entries in the cache.
*/
if ( pass ) {
test_num = 12;
flush_flags = H5C__FLUSH_INVALIDATE_FLAG;
expected_index_len = 0;
expected_index_size = 0;
spec[0].flush_ops[1].flag = TRUE;
spec[0].expected_destroyed = TRUE;
check_flush_cache__flush_op_test(cache_ptr,
test_num,
flush_flags,
spec_size,
spec,
init_expected_index_len,
init_expected_index_size,
expected_index_len,
expected_index_size,
check_size,
checks);
}
}
if ( pass ) /* test #13 */
{
/* Test the ability of the cache to handle the case in which
* the flush function of an entry that is resident in cache
* dirties two entries that are not in cache. No size
* changes.
*
* At present, I am assured that this case will never occur, but
* lets make sure we can handle it regardless.
*/
int test_num = 13;
unsigned int flush_flags = H5C__NO_FLAGS_SET;
int spec_size = 1;
int init_expected_index_len = 1;
size_t init_expected_index_size = 1 * PICO_ENTRY_SIZE;
int expected_index_len = 3;
size_t expected_index_size = 3 * PICO_ENTRY_SIZE;
struct fo_flush_cache_test_spec spec[1] =
{
{
/* entry_num = */ 0,
/* entry_type = */ 0,
/* entry_index = */ 1,
/* insert_flag = */ FALSE,
/* flags = */ H5C__DIRTIED_FLAG,
/* new_size = */ 0,
/* num_pins = */ 0,
/* pin_type = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 2,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__DIRTY, 0, 0, FALSE, 0 },
{ FLUSH_OP__DIRTY, 0, 2, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
}
};
int check_size = 2;
struct fo_flush_entry_check checks[2] =
{
{
/* entry_num = */ 0,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 0,
/* expected_size = */ PICO_ENTRY_SIZE,
/* in_cache = */ TRUE,
/* at_main_addr = */ TRUE,
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 1,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 2,
/* expected_size = */ PICO_ENTRY_SIZE,
/* in_cache = */ TRUE,
/* at_main_addr = */ TRUE,
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
}
};
check_flush_cache__flush_op_test(cache_ptr,
test_num,
flush_flags,
spec_size,
spec,
init_expected_index_len,
init_expected_index_size,
expected_index_len,
expected_index_size,
check_size,
checks);
}
if ( pass ) /* test #14 */
{
/* Repeat previous test with the flush invalidate flag.
*
* Test the ability of the cache to handle the case in which
* the flush function of an entry that is resident in cache
* dirties two entries that are not in cache. No size
* changes.
*
* At present, I am assured that this case will never occur, but
* lets make sure we can handle it regardless.
*/
int test_num = 14;
unsigned int flush_flags = H5C__FLUSH_INVALIDATE_FLAG;
int spec_size = 1;
int init_expected_index_len = 1;
size_t init_expected_index_size = 1 * PICO_ENTRY_SIZE;
int expected_index_len = 0;
size_t expected_index_size = (size_t)0;
struct fo_flush_cache_test_spec spec[1] =
{
{
/* entry_num = */ 0,
/* entry_type = */ 0,
/* entry_index = */ 1,
/* insert_flag = */ FALSE,
/* flags = */ H5C__DIRTIED_FLAG,
/* new_size = */ 0,
/* num_pins = */ 0,
/* pin_type = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 2,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__DIRTY, 0, 0, FALSE, 0 },
{ FLUSH_OP__DIRTY, 0, 2, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
}
};
int check_size = 2;
struct fo_flush_entry_check checks[2] =
{
{
/* entry_num = */ 0,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 0,
/* expected_size = */ PICO_ENTRY_SIZE,
/* in_cache = */ FALSE,
/* at_main_addr = */ TRUE,
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 1,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 2,
/* expected_size = */ PICO_ENTRY_SIZE,
/* in_cache = */ FALSE,
/* at_main_addr = */ TRUE,
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
}
};
check_flush_cache__flush_op_test(cache_ptr,
test_num,
flush_flags,
spec_size,
spec,
init_expected_index_len,
init_expected_index_size,
expected_index_len,
expected_index_size,
check_size,
checks);
}
if ( pass ) /* test #15 */
{
/* Test the ability of the cache to handle the case in which
* the flush function of an entry that is resident in cache
* resizes and dirties two entries that are not in cache.
*
* At present, I am assured that this case will never occur, but
* lets make sure we can handle it regardless.
*/
int test_num = 15;
unsigned int flush_flags = H5C__NO_FLAGS_SET;
int spec_size = 1;
int init_expected_index_len = 1;
size_t init_expected_index_size = 1 * VARIABLE_ENTRY_SIZE;
int expected_index_len = 3;
size_t expected_index_size = VARIABLE_ENTRY_SIZE +
(VARIABLE_ENTRY_SIZE / 4) +
(VARIABLE_ENTRY_SIZE / 2);
struct fo_flush_cache_test_spec spec[1] =
{
{
/* entry_num = */ 0,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 1,
/* insert_flag = */ FALSE,
/* flags = */ H5C__DIRTIED_FLAG,
/* new_size = */ 0,
/* num_pins = */ 0,
/* pin_type = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 4,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__RESIZE, VARIABLE_ENTRY_TYPE, 0, FALSE, VARIABLE_ENTRY_SIZE / 4 },
{ FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 0, FALSE, 0 },
{ FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 2, FALSE, 0 },
{ FLUSH_OP__RESIZE, VARIABLE_ENTRY_TYPE, 2, FALSE, VARIABLE_ENTRY_SIZE / 2 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
}
};
int check_size = 2;
struct fo_flush_entry_check checks[2] =
{
{
/* entry_num = */ 0,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 0,
/* expected_size = */ VARIABLE_ENTRY_SIZE / 4,
/* in_cache = */ TRUE,
/* at_main_addr = */ TRUE,
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 1,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 2,
/* expected_size = */ VARIABLE_ENTRY_SIZE / 2,
/* in_cache = */ TRUE,
/* at_main_addr = */ TRUE,
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
}
};
check_flush_cache__flush_op_test(cache_ptr,
test_num,
flush_flags,
spec_size,
spec,
init_expected_index_len,
init_expected_index_size,
expected_index_len,
expected_index_size,
check_size,
checks);
}
if ( pass ) /* test #16 */
{
/* Repeat previous test with the flush invalidate flag.
*
* Test the ability of the cache to handle the case in which
* the flush function of an entry that is resident in cache
* resizes and dirties two entries that are not in cache.
*
* At present, I am assured that this case will never occur, but
* lets make sure we can handle it regardless.
*/
int test_num = 16;
unsigned int flush_flags = H5C__FLUSH_INVALIDATE_FLAG;
int spec_size = 1;
int init_expected_index_len = 1;
size_t init_expected_index_size = 1 * VARIABLE_ENTRY_SIZE;
int expected_index_len = 0;
size_t expected_index_size = (size_t)0;
struct fo_flush_cache_test_spec spec[1] =
{
{
/* entry_num = */ 0,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 1,
/* insert_flag = */ FALSE,
/* flags = */ H5C__DIRTIED_FLAG,
/* new_size = */ 0,
/* num_pins = */ 0,
/* pin_type = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 4,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__RESIZE, VARIABLE_ENTRY_TYPE, 0, FALSE, VARIABLE_ENTRY_SIZE / 4 },
{ FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 0, FALSE, 0 },
{ FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 2, FALSE, 0 },
{ FLUSH_OP__RESIZE, VARIABLE_ENTRY_TYPE, 2, FALSE, VARIABLE_ENTRY_SIZE / 2 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
}
};
int check_size = 2;
struct fo_flush_entry_check checks[2] =
{
{
/* entry_num = */ 0,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 0,
/* expected_size = */ VARIABLE_ENTRY_SIZE / 4,
/* in_cache = */ FALSE,
/* at_main_addr = */ TRUE,
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 1,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 2,
/* expected_size = */ VARIABLE_ENTRY_SIZE / 2,
/* in_cache = */ FALSE,
/* at_main_addr = */ TRUE,
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
}
};
check_flush_cache__flush_op_test(cache_ptr,
test_num,
flush_flags,
spec_size,
spec,
init_expected_index_len,
init_expected_index_size,
expected_index_len,
expected_index_size,
check_size,
checks);
}
if ( pass ) /* test #17 & #18 */
{
/* Test the ability of the cache to handle the case in which
* the flush function of an entry that is resident in cache
* resizes, dirties, and renames two entries that are not in cache.
*
* At present, I am assured that this case will never occur, but
* lets make sure we can handle it regardless.
*/
int test_num = 17; /* and 18 */
unsigned int flush_flags = H5C__NO_FLAGS_SET;
int spec_size = 1;
int init_expected_index_len = 1;
size_t init_expected_index_size = 1 * VARIABLE_ENTRY_SIZE;
int expected_index_len = 3;
size_t expected_index_size = VARIABLE_ENTRY_SIZE +
(VARIABLE_ENTRY_SIZE / 4) +
(VARIABLE_ENTRY_SIZE / 2);
struct fo_flush_cache_test_spec spec[1] =
{
{
/* entry_num = */ 0,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 1,
/* insert_flag = */ FALSE,
/* flags = */ H5C__DIRTIED_FLAG,
/* new_size = */ 0,
/* num_pins = */ 0,
/* pin_type = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 6,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__RESIZE, VARIABLE_ENTRY_TYPE, 0, FALSE, VARIABLE_ENTRY_SIZE / 4 },
{ FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 0, FALSE, 0 },
{ FLUSH_OP__RENAME, VARIABLE_ENTRY_TYPE, 0, FALSE, 0 },
{ FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 2, FALSE, 0 },
{ FLUSH_OP__RESIZE, VARIABLE_ENTRY_TYPE, 2, FALSE, VARIABLE_ENTRY_SIZE / 2 },
{ FLUSH_OP__RENAME, VARIABLE_ENTRY_TYPE, 2, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
}
};
int check_size = 2;
struct fo_flush_entry_check checks[2] =
{
{
/* entry_num = */ 0,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 0,
/* expected_size = */ VARIABLE_ENTRY_SIZE / 4,
/* in_cache = */ TRUE,
/* at_main_addr = */ FALSE,
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 1,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 2,
/* expected_size = */ VARIABLE_ENTRY_SIZE / 2,
/* in_cache = */ TRUE,
/* at_main_addr = */ FALSE,
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
}
};
check_flush_cache__flush_op_test(cache_ptr,
test_num,
flush_flags,
spec_size,
spec,
init_expected_index_len,
init_expected_index_size,
expected_index_len,
expected_index_size,
check_size,
checks);
/* this change forces the renames to move the target entries back to
* their main address. The first test moved them to their alternate
* address.
*
* Note that these two tests are not the same, as in the first test,
* the renamed entries are moved forward in the slist. In the second
* they are moved backwards.
*/
if ( pass ) {
test_num = 18;
spec[0].flush_ops[2].flag = TRUE;
spec[0].flush_ops[5].flag = TRUE;
checks[0].at_main_addr = TRUE;
checks[1].at_main_addr = TRUE;
check_flush_cache__flush_op_test(cache_ptr,
test_num,
flush_flags,
spec_size,
spec,
init_expected_index_len,
init_expected_index_size,
expected_index_len,
expected_index_size,
check_size,
checks);
}
}
if ( pass ) /* test #19 & #20 */
{
/* Repeat the above test with the flush invalidate flag on the
* second test.
*
* Test the ability of the cache to handle the case in which
* the flush function of an entry that is resident in cache
* resizes, dirties, and renames two entries that are not in cache.
*
* At present, I am assured that this case will never occur, but
* lets make sure we can handle it regardless.
*/
int test_num = 19; /* and 20 */
unsigned int flush_flags = H5C__NO_FLAGS_SET;
int spec_size = 1;
int init_expected_index_len = 1;
size_t init_expected_index_size = 1 * VARIABLE_ENTRY_SIZE;
int expected_index_len = 3;
size_t expected_index_size = VARIABLE_ENTRY_SIZE +
(VARIABLE_ENTRY_SIZE / 4) +
(VARIABLE_ENTRY_SIZE / 2);
struct fo_flush_cache_test_spec spec[1] =
{
{
/* entry_num = */ 0,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 1,
/* insert_flag = */ FALSE,
/* flags = */ H5C__DIRTIED_FLAG,
/* new_size = */ 0,
/* num_pins = */ 0,
/* pin_type = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 6,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__RESIZE, VARIABLE_ENTRY_TYPE, 0, FALSE, VARIABLE_ENTRY_SIZE / 4 },
{ FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 0, FALSE, 0 },
{ FLUSH_OP__RENAME, VARIABLE_ENTRY_TYPE, 0, FALSE, 0 },
{ FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 2, FALSE, 0 },
{ FLUSH_OP__RESIZE, VARIABLE_ENTRY_TYPE, 2, FALSE, VARIABLE_ENTRY_SIZE / 2 },
{ FLUSH_OP__RENAME, VARIABLE_ENTRY_TYPE, 2, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
}
};
int check_size = 2;
struct fo_flush_entry_check checks[2] =
{
{
/* entry_num = */ 0,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 0,
/* expected_size = */ VARIABLE_ENTRY_SIZE / 4,
/* in_cache = */ TRUE,
/* at_main_addr = */ FALSE,
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 1,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 2,
/* expected_size = */ VARIABLE_ENTRY_SIZE / 2,
/* in_cache = */ TRUE,
/* at_main_addr = */ FALSE,
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
}
};
check_flush_cache__flush_op_test(cache_ptr,
test_num,
flush_flags,
spec_size,
spec,
init_expected_index_len,
init_expected_index_size,
expected_index_len,
expected_index_size,
check_size,
checks);
/* this change forces the renames to move the target entries back to
* their main address. The first test moved them to their alternate
* address.
*
* Note that these two tests are not the same, as in the first test,
* the renamed entries are moved forward in the slist. In the second
* they are moved backwards.
*/
if ( pass ) {
test_num = 20;
flush_flags = H5C__FLUSH_INVALIDATE_FLAG;
expected_index_len = 0;
expected_index_size = (size_t)0;
spec[0].expected_destroyed = TRUE;
spec[0].flush_ops[2].flag = TRUE;
spec[0].flush_ops[5].flag = TRUE;
checks[0].at_main_addr = TRUE;
checks[0].in_cache = FALSE;
checks[0].expected_destroyed = TRUE;
checks[1].at_main_addr = TRUE;
checks[1].in_cache = FALSE;
checks[1].expected_destroyed = TRUE;
check_flush_cache__flush_op_test(cache_ptr,
test_num,
flush_flags,
spec_size,
spec,
init_expected_index_len,
init_expected_index_size,
expected_index_len,
expected_index_size,
check_size,
checks);
}
}
if ( pass ) /* test #21 */
{
/* Now mix things up a bit.
*
* Load several entries, two of which have flush functions that
* resize, dirty, and rename two entries that are not in the
* cache. Mark only one of these entries, and then flush the
* cache with the flush marked entries flag.
*
* This is the only test in which we test the
* H5C__FLUSH_MARKED_ENTRIES_FLAG. The hope is that since
* we test the two features extensively by themselves, so
* it should be sufficient to verify that they play together
* as expected.
*/
int test_num = 21;
unsigned int flush_flags = H5C__FLUSH_MARKED_ENTRIES_FLAG;
int spec_size = 4;
int init_expected_index_len = 4;
size_t init_expected_index_size = (2 * VARIABLE_ENTRY_SIZE) + (2 * PICO_ENTRY_SIZE);
int expected_index_len = 6;
size_t expected_index_size = (2 * VARIABLE_ENTRY_SIZE) +
(VARIABLE_ENTRY_SIZE / 4) +
(VARIABLE_ENTRY_SIZE / 2) +
(2 * PICO_ENTRY_SIZE);
struct fo_flush_cache_test_spec spec[4] =
{
{
/* entry_num = */ 0,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 1,
/* insert_flag = */ FALSE,
/* flags = */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
/* new_size = */ 0,
/* num_pins = */ 0,
/* pin_type = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 6,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__RESIZE, VARIABLE_ENTRY_TYPE, 0, FALSE, VARIABLE_ENTRY_SIZE / 4 },
{ FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 0, FALSE, 0 },
{ FLUSH_OP__RENAME, VARIABLE_ENTRY_TYPE, 0, FALSE, 0 },
{ FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 2, FALSE, 0 },
{ FLUSH_OP__RESIZE, VARIABLE_ENTRY_TYPE, 2, FALSE, VARIABLE_ENTRY_SIZE / 2 },
{ FLUSH_OP__RENAME, VARIABLE_ENTRY_TYPE, 2, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 1,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 11,
/* insert_flag = */ FALSE,
/* flags = */ H5C__DIRTIED_FLAG,
/* new_size = */ 0,
/* num_pins = */ 0,
/* pin_type = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 6,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__RESIZE, VARIABLE_ENTRY_TYPE, 10, FALSE, VARIABLE_ENTRY_SIZE / 4 },
{ FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 10, FALSE, 0 },
{ FLUSH_OP__RENAME, VARIABLE_ENTRY_TYPE, 10, FALSE, 0 },
{ FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 12, FALSE, 0 },
{ FLUSH_OP__RESIZE, VARIABLE_ENTRY_TYPE, 12, FALSE, VARIABLE_ENTRY_SIZE / 2 },
{ FLUSH_OP__RENAME, VARIABLE_ENTRY_TYPE, 12, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 2,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 0,
/* insert_flag = */ FALSE,
/* flags = */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
/* new_size = */ 0,
/* num_pins = */ 0,
/* pin_type = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 0,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 3,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 1,
/* insert_flag = */ FALSE,
/* flags = */ H5C__DIRTIED_FLAG,
/* new_size = */ 0,
/* num_pins = */ 0,
/* pin_type = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 0,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ FALSE
}
};
int check_size = 4;
struct fo_flush_entry_check checks[4] =
{
{
/* entry_num = */ 0,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 0,
/* expected_size = */ VARIABLE_ENTRY_SIZE / 4,
/* in_cache = */ TRUE,
/* at_main_addr = */ FALSE,
/* is_dirty = */ TRUE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 1,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 2,
/* expected_size = */ VARIABLE_ENTRY_SIZE / 2,
/* in_cache = */ TRUE,
/* at_main_addr = */ FALSE,
/* is_dirty = */ TRUE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 2,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 10,
/* expected_size = */ VARIABLE_ENTRY_SIZE,
/* in_cache = */ FALSE,
/* at_main_addr = */ TRUE,
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
/* expected_loaded = */ FALSE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 3,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 12,
/* expected_size = */ VARIABLE_ENTRY_SIZE,
/* in_cache = */ FALSE,
/* at_main_addr = */ TRUE,
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
/* expected_loaded = */ FALSE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ FALSE
}
};
check_flush_cache__flush_op_test(cache_ptr,
test_num,
flush_flags,
spec_size,
spec,
init_expected_index_len,
init_expected_index_size,
expected_index_len,
expected_index_size,
check_size,
checks);
reset_entries();
}
if ( pass ) /* test #22 */
{
/* Mix things up some more.
*
* Load lots of entries, some of which have flush functions that
* resize, dirty, and rename two entries that are not in the
* cache.
*
* Also load entries that have flush ops on entries that are in
* cache.
*/
int test_num = 22;
unsigned int flush_flags = H5C__NO_FLAGS_SET;
int spec_size = 6;
int init_expected_index_len = 6;
size_t init_expected_index_size = (2 * VARIABLE_ENTRY_SIZE) + (4 * PICO_ENTRY_SIZE);
int expected_index_len = 10;
size_t expected_index_size = (2 * VARIABLE_ENTRY_SIZE) +
(2 * (VARIABLE_ENTRY_SIZE / 4)) +
(2 * (VARIABLE_ENTRY_SIZE / 2)) +
(4 * PICO_ENTRY_SIZE);
struct fo_flush_cache_test_spec spec[6] =
{
{
/* entry_num = */ 0,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 1,
/* insert_flag = */ FALSE,
/* flags = */ H5C__DIRTIED_FLAG,
/* new_size = */ 0,
/* num_pins = */ 0,
/* pin_type = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 6,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__RESIZE, VARIABLE_ENTRY_TYPE, 0, FALSE, VARIABLE_ENTRY_SIZE / 4 },
{ FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 0, FALSE, 0 },
{ FLUSH_OP__RENAME, VARIABLE_ENTRY_TYPE, 0, FALSE, 0 },
{ FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 2, FALSE, 0 },
{ FLUSH_OP__RESIZE, VARIABLE_ENTRY_TYPE, 2, FALSE, VARIABLE_ENTRY_SIZE / 2 },
{ FLUSH_OP__RENAME, VARIABLE_ENTRY_TYPE, 2, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 1,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 11,
/* insert_flag = */ FALSE,
/* flags = */ H5C__DIRTIED_FLAG,
/* new_size = */ 0,
/* num_pins = */ 0,
/* pin_type = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 6,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__RESIZE, VARIABLE_ENTRY_TYPE, 10, FALSE, VARIABLE_ENTRY_SIZE / 4 },
{ FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 10, FALSE, 0 },
{ FLUSH_OP__RENAME, VARIABLE_ENTRY_TYPE, 10, FALSE, 0 },
{ FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 12, FALSE, 0 },
{ FLUSH_OP__RESIZE, VARIABLE_ENTRY_TYPE, 12, FALSE, VARIABLE_ENTRY_SIZE / 2 },
{ FLUSH_OP__RENAME, VARIABLE_ENTRY_TYPE, 12, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 2,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 0,
/* insert_flag = */ FALSE,
/* flags = */ H5C__NO_FLAGS_SET,
/* new_size = */ 0,
/* num_pins = */ 0,
/* pin_type = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 0,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 3,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 1,
/* insert_flag = */ FALSE,
/* flags = */ H5C__NO_FLAGS_SET,
/* new_size = */ 0,
/* num_pins = */ 0,
/* pin_type = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 0,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 4,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 10,
/* insert_flag = */ FALSE,
/* flags = */ H5C__DIRTIED_FLAG,
/* new_size = */ 0,
/* num_pins = */ 0,
/* pin_type = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 1,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__DIRTY, PICO_ENTRY_TYPE, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 5,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 20,
/* insert_flag = */ FALSE,
/* flags = */ H5C__DIRTIED_FLAG,
/* new_size = */ 0,
/* num_pins = */ 0,
/* pin_type = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 1,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__DIRTY, PICO_ENTRY_TYPE, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
}
};
int check_size = 4;
struct fo_flush_entry_check checks[4] =
{
{
/* entry_num = */ 0,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 0,
/* expected_size = */ VARIABLE_ENTRY_SIZE / 4,
/* in_cache = */ TRUE,
/* at_main_addr = */ FALSE,
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 1,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 2,
/* expected_size = */ VARIABLE_ENTRY_SIZE / 2,
/* in_cache = */ TRUE,
/* at_main_addr = */ FALSE,
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 2,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 10,
/* expected_size = */ VARIABLE_ENTRY_SIZE / 4,
/* in_cache = */ TRUE,
/* at_main_addr = */ FALSE,
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 3,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 12,
/* expected_size = */ VARIABLE_ENTRY_SIZE / 2,
/* in_cache = */ TRUE,
/* at_main_addr = */ FALSE,
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
}
};
check_flush_cache__flush_op_test(cache_ptr,
test_num,
flush_flags,
spec_size,
spec,
init_expected_index_len,
init_expected_index_size,
expected_index_len,
expected_index_size,
check_size,
checks);
reset_entries();
}
if ( pass ) /* test #23 */
{
/* Repeat test #23 with the flush invalidate flag set.
*
* Mix things up some more.
*
* Load lots of entries, some of which have flush functions that
* resize, dirty, and rename two entries that are not in the
* cache.
*
* Also load entries that have flush ops on entries that are in
* cache.
*/
int test_num = 23;
unsigned int flush_flags = H5C__FLUSH_INVALIDATE_FLAG;
int spec_size = 6;
int init_expected_index_len = 6;
size_t init_expected_index_size = (2 * VARIABLE_ENTRY_SIZE) + (4 * PICO_ENTRY_SIZE);
int expected_index_len = 0;
size_t expected_index_size = 0;
struct fo_flush_cache_test_spec spec[6] =
{
{
/* entry_num = */ 0,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 1,
/* insert_flag = */ FALSE,
/* flags = */ H5C__DIRTIED_FLAG,
/* new_size = */ 0,
/* num_pins = */ 0,
/* pin_type = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 6,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__RESIZE, VARIABLE_ENTRY_TYPE, 0, FALSE, VARIABLE_ENTRY_SIZE / 4 },
{ FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 0, FALSE, 0 },
{ FLUSH_OP__RENAME, VARIABLE_ENTRY_TYPE, 0, FALSE, 0 },
{ FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 2, FALSE, 0 },
{ FLUSH_OP__RESIZE, VARIABLE_ENTRY_TYPE, 2, FALSE, VARIABLE_ENTRY_SIZE / 2 },
{ FLUSH_OP__RENAME, VARIABLE_ENTRY_TYPE, 2, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 1,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 11,
/* insert_flag = */ FALSE,
/* flags = */ H5C__DIRTIED_FLAG,
/* new_size = */ 0,
/* num_pins = */ 0,
/* pin_type = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 6,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__RESIZE, VARIABLE_ENTRY_TYPE, 10, FALSE, VARIABLE_ENTRY_SIZE / 4 },
{ FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 10, FALSE, 0 },
{ FLUSH_OP__RENAME, VARIABLE_ENTRY_TYPE, 10, FALSE, 0 },
{ FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 12, FALSE, 0 },
{ FLUSH_OP__RESIZE, VARIABLE_ENTRY_TYPE, 12, FALSE, VARIABLE_ENTRY_SIZE / 2 },
{ FLUSH_OP__RENAME, VARIABLE_ENTRY_TYPE, 12, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 2,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 0,
/* insert_flag = */ FALSE,
/* flags = */ H5C__NO_FLAGS_SET,
/* new_size = */ 0,
/* num_pins = */ 0,
/* pin_type = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 0,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 3,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 1,
/* insert_flag = */ FALSE,
/* flags = */ H5C__NO_FLAGS_SET,
/* new_size = */ 0,
/* num_pins = */ 0,
/* pin_type = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 0,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 4,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 10,
/* insert_flag = */ FALSE,
/* flags = */ H5C__DIRTIED_FLAG,
/* new_size = */ 0,
/* num_pins = */ 0,
/* pin_type = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 1,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__DIRTY, PICO_ENTRY_TYPE, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 5,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 20,
/* insert_flag = */ FALSE,
/* flags = */ H5C__DIRTIED_FLAG,
/* new_size = */ 0,
/* num_pins = */ 0,
/* pin_type = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 1,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__DIRTY, PICO_ENTRY_TYPE, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
}
};
int check_size = 4;
struct fo_flush_entry_check checks[4] =
{
{
/* entry_num = */ 0,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 0,
/* expected_size = */ VARIABLE_ENTRY_SIZE / 4,
/* in_cache = */ FALSE,
/* at_main_addr = */ FALSE,
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 1,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 2,
/* expected_size = */ VARIABLE_ENTRY_SIZE / 2,
/* in_cache = */ FALSE,
/* at_main_addr = */ FALSE,
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 2,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 10,
/* expected_size = */ VARIABLE_ENTRY_SIZE / 4,
/* in_cache = */ FALSE,
/* at_main_addr = */ FALSE,
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 3,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 12,
/* expected_size = */ VARIABLE_ENTRY_SIZE / 2,
/* in_cache = */ FALSE,
/* at_main_addr = */ FALSE,
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
}
};
check_flush_cache__flush_op_test(cache_ptr,
test_num,
flush_flags,
spec_size,
spec,
init_expected_index_len,
init_expected_index_size,
expected_index_len,
expected_index_size,
check_size,
checks);
reset_entries();
}
/* So much for tests involving only flush operations.
*
* Now create some tests mixing flush ops and pins.
*/
if ( pass ) /* test #24 */
{
/* Pico entries 50 and 150 pin pico entry 100, and also dirty
* pico entry 100 on flush.
*/
int test_num = 24;
unsigned int flush_flags = H5C__NO_FLAGS_SET;
int spec_size = 3;
int init_expected_index_len = 3;
size_t init_expected_index_size = 3 * PICO_ENTRY_SIZE;
int expected_index_len = 3;
size_t expected_index_size = 3 * PICO_ENTRY_SIZE;
struct fo_flush_cache_test_spec spec[3] =
{
{
/* entry_num = */ 0,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 100,
/* insert_flag = */ FALSE,
/* flags = */ H5C__NO_FLAGS_SET,
/* new_size = */ 0,
/* num_pins = */ 0,
/* pin_type = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 0,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 1,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 50,
/* insert_flag = */ FALSE,
/* flags = */ H5C__DIRTIED_FLAG,
/* new_size = */ 0,
/* num_pins = */ 1,
/* pin_type = */ {PICO_ENTRY_TYPE, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {100, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 1,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__DIRTY, PICO_ENTRY_TYPE, 100, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 2,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 150,
/* insert_flag = */ TRUE,
/* flags = */ H5C__NO_FLAGS_SET,
/* new_size = */ 0,
/* num_pins = */ 1,
/* pin_type = */ {PICO_ENTRY_TYPE, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {100, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 1,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__DIRTY, PICO_ENTRY_TYPE, 100, FALSE, 0 },
{ FLUSH_OP__DIRTY, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ FALSE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
}
};
int check_size = 0;
struct fo_flush_entry_check checks[1] =
{
{
/* entry_num = */ 0,
/* entry_type = */ 0,
/* entry_index = */ 0,
/* expected_size = */ (size_t)0,
/* in_cache = */ FALSE,
/* at_main_addr = */ FALSE,
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
/* expected_loaded = */ FALSE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ FALSE
}
};
check_flush_cache__flush_op_test(cache_ptr,
test_num,
flush_flags,
spec_size,
spec,
init_expected_index_len,
init_expected_index_size,
expected_index_len,
expected_index_size,
check_size,
checks);
}
if ( pass ) /* test #25 */
{
/* Repeat the previous test with the flush invalidate flag.
*
* Pico entries 50 and 150 pin pico entry 100, and also dirty
* pico entry 100 on flush.
*/
int test_num = 25;
unsigned int flush_flags = H5C__FLUSH_INVALIDATE_FLAG;
int spec_size = 3;
int init_expected_index_len = 3;
size_t init_expected_index_size = 3 * PICO_ENTRY_SIZE;
int expected_index_len = 0;
size_t expected_index_size = (size_t)0;
struct fo_flush_cache_test_spec spec[3] =
{
{
/* entry_num = */ 0,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 100,
/* insert_flag = */ FALSE,
/* flags = */ H5C__NO_FLAGS_SET,
/* new_size = */ 0,
/* num_pins = */ 0,
/* pin_type = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 0,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 1,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 50,
/* insert_flag = */ FALSE,
/* flags = */ H5C__DIRTIED_FLAG,
/* new_size = */ 0,
/* num_pins = */ 1,
/* pin_type = */ {PICO_ENTRY_TYPE, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {100, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 1,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__DIRTY, PICO_ENTRY_TYPE, 100, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 2,
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 150,
/* insert_flag = */ TRUE,
/* flags = */ H5C__NO_FLAGS_SET,
/* new_size = */ 0,
/* num_pins = */ 1,
/* pin_type = */ {PICO_ENTRY_TYPE, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {100, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 1,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__DIRTY, PICO_ENTRY_TYPE, 100, FALSE, 0 },
{ FLUSH_OP__DIRTY, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ FALSE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
}
};
int check_size = 0;
struct fo_flush_entry_check checks[1] =
{
{
/* entry_num = */ 0,
/* entry_type = */ 0,
/* entry_index = */ 0,
/* expected_size = */ (size_t)0,
/* in_cache = */ FALSE,
/* at_main_addr = */ FALSE,
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
/* expected_loaded = */ FALSE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ FALSE
}
};
check_flush_cache__flush_op_test(cache_ptr,
test_num,
flush_flags,
spec_size,
spec,
init_expected_index_len,
init_expected_index_size,
expected_index_len,
expected_index_size,
check_size,
checks);
}
if ( pass ) /* test #26 */
{
/* This one is complex.
*
* In the following overvies table, VET stands for
* VARIABLE_ENTRY_TYPE.
*
* In trying to follow what happens when we flush the
* set of entries constructed below, recall that each
* flush operation is executed the first time the
* entry is flushed, and then not executed again.
* This may be a weakness in the tests, but that
* is the way it is for now.
*
* After thinking about it for a while, I'm not sure that
* the interaction between pins and flush operations needs
* all that much testing, as the two are essentially
* orthoginal. Thus this is a bit of a smoke check to
* verify that we get the expected results.
*
* (VET, 100) initially not resident in cache
*
* (VET, 200) initially clean and resident in cache
*
* (VET, 300) initially not resident in cache
*
* (VET, 2100) initially clean and resident in cache
*
* (VET, 2200) initially not resident in cache
*
* (VET, 2300) initially clean and resident in cache
*
* (VET, 1000) initially clean, and in cache
* dirties (VET, 100)
* resizes (VET, 200)
* dirty (VET, 300) -- dirty first to bring into cache.
* renames (VET, 300)
*
* (VET, 2000) initially clean, and in cache
* dirties (VET, 2100)
* resizes (VET, 2200)
* renames (VET, 2300)
*
* (VET, 350) initially clean, and in cache
* pins (VET, 1000)
* dirties (VET, 1000)
* resizes (VET, 350)
* pins (VET, 2000)
* dirties (VET, 2000)
*
* (VET, 450) initially dirty, and in cache
* pins (VET, 1000)
* dirties (VET, 1000)
* renames (VET, 450)
* pins (VET, 2000)
* dirties (VET, 2000)
*
* (VET, 650) initially clean, and in cache
* pins (VET, 1000)
* dirties (VET, 1000)
* resizes (VET, 650)
* pins (VET, 2000)
* dirties (VET, 2000)
*
* (VET, 750) initially dirty, and in cache
* pins (VET, 1000)
* dirties (VET, 1000)
* resizes (VET, 750)
* pins (VET, 2000)
* dirties (VET, 2000)
*
* (VET, 500) initially dirty, and in cache
* dirties (VET, 350)
* dirties (VET, 450)
* dirties (VET, 650)
* dirties (VET, 750)
*/
int test_num = 26;
unsigned int flush_flags = H5C__NO_FLAGS_SET;
int spec_size = 10;
int init_expected_index_len = 10;
size_t init_expected_index_size = 10 * VARIABLE_ENTRY_SIZE;
int expected_index_len = 13;
size_t expected_index_size = 9 * VARIABLE_ENTRY_SIZE;
struct fo_flush_cache_test_spec spec[10] =
{
{
/* entry_num = */ 0,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 200,
/* insert_flag = */ FALSE,
/* flags = */ H5C__NO_FLAGS_SET,
/* new_size = */ 0,
/* num_pins = */ 0,
/* pin_type = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 0,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 1,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 2100,
/* insert_flag = */ FALSE,
/* flags = */ H5C__NO_FLAGS_SET,
/* new_size = */ 0,
/* num_pins = */ 0,
/* pin_type = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 0,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 2,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 2300,
/* insert_flag = */ TRUE,
/* flags = */ H5C__NO_FLAGS_SET,
/* new_size = */ 0,
/* num_pins = */ 0,
/* pin_type = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 0,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ FALSE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 3,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 1000,
/* insert_flag = */ TRUE,
/* flags = */ H5C__NO_FLAGS_SET,
/* new_size = */ 0,
/* num_pins = */ 0,
/* pin_type = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 4,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 100, FALSE, 0 },
{ FLUSH_OP__RESIZE, VARIABLE_ENTRY_TYPE, 200, FALSE, VARIABLE_ENTRY_SIZE / 2 },
{ FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 300, FALSE, 0 },
{ FLUSH_OP__RENAME, VARIABLE_ENTRY_TYPE, 300, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ FALSE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 4,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 2000,
/* insert_flag = */ FALSE,
/* flags = */ H5C__NO_FLAGS_SET,
/* new_size = */ 0,
/* num_pins = */ 0,
/* pin_type = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 3,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 2100, FALSE, 0 },
{ FLUSH_OP__RESIZE, VARIABLE_ENTRY_TYPE, 2200, FALSE, VARIABLE_ENTRY_SIZE / 2 },
{ FLUSH_OP__RENAME, VARIABLE_ENTRY_TYPE, 2300, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 5,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 350,
/* insert_flag = */ FALSE,
/* flags = */ H5C__NO_FLAGS_SET,
/* new_size = */ 0,
/* num_pins = */ 2,
/* pin_type = */ {VARIABLE_ENTRY_TYPE, VARIABLE_ENTRY_TYPE, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {1000, 2000, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 3,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 1000, FALSE, 0 },
{ FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 2000, FALSE, 0 },
{ FLUSH_OP__RESIZE, VARIABLE_ENTRY_TYPE, 350, FALSE, VARIABLE_ENTRY_SIZE / 4 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 6,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 450,
/* insert_flag = */ FALSE,
/* flags = */ H5C__DIRTIED_FLAG,
/* new_size = */ 0,
/* num_pins = */ 2,
/* pin_type = */ {VARIABLE_ENTRY_TYPE, VARIABLE_ENTRY_TYPE, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {1000, 2000, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 3,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 1000, FALSE, 0 },
{ FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 2000, FALSE, 0 },
{ FLUSH_OP__RESIZE, VARIABLE_ENTRY_TYPE, 450, FALSE, VARIABLE_ENTRY_SIZE / 4 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 7,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 650,
/* insert_flag = */ TRUE,
/* flags = */ H5C__NO_FLAGS_SET,
/* new_size = */ 0,
/* num_pins = */ 2,
/* pin_type = */ {VARIABLE_ENTRY_TYPE, VARIABLE_ENTRY_TYPE, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {1000, 2000, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 3,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 1000, FALSE, 0 },
{ FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 2000, FALSE, 0 },
{ FLUSH_OP__RESIZE, VARIABLE_ENTRY_TYPE, 650, FALSE, VARIABLE_ENTRY_SIZE / 4 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ FALSE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 8,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 750,
/* insert_flag = */ FALSE,
/* flags = */ H5C__DIRTIED_FLAG,
/* new_size = */ 0,
/* num_pins = */ 2,
/* pin_type = */ {VARIABLE_ENTRY_TYPE, VARIABLE_ENTRY_TYPE, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {1000, 2000, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 3,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 1000, FALSE, 0 },
{ FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 2000, FALSE, 0 },
{ FLUSH_OP__RESIZE, VARIABLE_ENTRY_TYPE, 750, FALSE, VARIABLE_ENTRY_SIZE / 4 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 9,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 500,
/* insert_flag = */ FALSE,
/* flags = */ H5C__DIRTIED_FLAG,
/* new_size = */ 0,
/* num_pins = */ 0,
/* pin_type = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 4,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 350, FALSE, 0 },
{ FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 450, FALSE, 0 },
{ FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 650, FALSE, 0 },
{ FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 750, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
}
};
int check_size = 3;
struct fo_flush_entry_check checks[3] =
{
{
/* entry_num = */ 0,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 100,
/* expected_size = */ VARIABLE_ENTRY_SIZE,
/* in_cache = */ TRUE,
/* at_main_addr = */ TRUE,
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 1,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 300,
/* expected_size = */ VARIABLE_ENTRY_SIZE,
/* in_cache = */ TRUE,
/* at_main_addr = */ FALSE,
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 2,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 2200,
/* expected_size = */ VARIABLE_ENTRY_SIZE / 2,
/* in_cache = */ TRUE,
/* at_main_addr = */ TRUE,
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
}
};
check_flush_cache__flush_op_test(cache_ptr,
test_num,
flush_flags,
spec_size,
spec,
init_expected_index_len,
init_expected_index_size,
expected_index_len,
expected_index_size,
check_size,
checks);
reset_entries();
}
if ( pass ) /* test #27 */
{
/* Repeat test #26 with the flush invalidate flag.
*
* In the following overview table, VET stands for
* VARIABLE_ENTRY_TYPE.
*
* In trying to follow what happens when we flush the
* set of entries constructed below, recall that each
* flush operation is executed the first time the
* entry is flushed, and then not executed again.
* This may be a weakness in the tests, but that
* is the way it is for now.
*
* After thinking about it for a while, I'm not sure that
* the interaction between pins and flush operations needs
* all that much testing, as the two are essentially
* orthoginal. The big thing is to verify that flushes of
* pinned entries with flush ops result in the expected
* updates of the cache.
*
* Thus this is a bit of a smoke check to * verify that we
* get the expected results.
*
* (VET, 100) initially not resident in cache
*
* (VET, 200) initially clean and resident in cache
*
* (VET, 300) initially not resident in cache
*
* (VET, 2100) initially clean and resident in cache
*
* (VET, 2200) initially not resident in cache
*
* (VET, 2300) initially clean and resident in cache
*
* (VET, 1000) initially clean, and in cache
* dirties (VET, 100)
* resizes (VET, 200)
* dirty (VET, 300) -- dirty first to bring into cache.
* renames (VET, 300)
*
* (VET, 2000) initially clean, and in cache
* dirties (VET, 2100)
* resizes (VET, 2200)
* renames (VET, 2300)
*
* (VET, 350) initially clean, and in cache
* pins (VET, 1000)
* dirties (VET, 1000)
* resizes (VET, 350)
* pins (VET, 2000)
* dirties (VET, 2000)
*
* (VET, 450) initially dirty, and in cache
* pins (VET, 1000)
* dirties (VET, 1000)
* renames (VET, 450)
* pins (VET, 2000)
* dirties (VET, 2000)
*
* (VET, 650) initially clean, and in cache
* pins (VET, 1000)
* dirties (VET, 1000)
* resizes (VET, 650)
* pins (VET, 2000)
* dirties (VET, 2000)
*
* (VET, 750) initially dirty, and in cache
* pins (VET, 1000)
* dirties (VET, 1000)
* resizes (VET, 750)
* pins (VET, 2000)
* dirties (VET, 2000)
*
* (VET, 500) initially dirty, and in cache
* dirties (VET, 350)
* dirties (VET, 450)
* dirties (VET, 650)
* dirties (VET, 750)
*/
int test_num = 27;
unsigned int flush_flags = H5C__FLUSH_INVALIDATE_FLAG;
int spec_size = 10;
int init_expected_index_len = 10;
size_t init_expected_index_size = 10 * VARIABLE_ENTRY_SIZE;
int expected_index_len = 0;
size_t expected_index_size = (size_t)0;
struct fo_flush_cache_test_spec spec[10] =
{
{
/* entry_num = */ 0,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 200,
/* insert_flag = */ FALSE,
/* flags = */ H5C__NO_FLAGS_SET,
/* new_size = */ 0,
/* num_pins = */ 0,
/* pin_type = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 0,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 1,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 2100,
/* insert_flag = */ FALSE,
/* flags = */ H5C__NO_FLAGS_SET,
/* new_size = */ 0,
/* num_pins = */ 0,
/* pin_type = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 0,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 2,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 2300,
/* insert_flag = */ TRUE,
/* flags = */ H5C__NO_FLAGS_SET,
/* new_size = */ 0,
/* num_pins = */ 0,
/* pin_type = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 0,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ FALSE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 3,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 1000,
/* insert_flag = */ TRUE,
/* flags = */ H5C__NO_FLAGS_SET,
/* new_size = */ 0,
/* num_pins = */ 0,
/* pin_type = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 4,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 100, FALSE, 0 },
{ FLUSH_OP__RESIZE, VARIABLE_ENTRY_TYPE, 200, FALSE, VARIABLE_ENTRY_SIZE / 2 },
{ FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 300, FALSE, 0 },
{ FLUSH_OP__RENAME, VARIABLE_ENTRY_TYPE, 300, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ FALSE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 4,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 2000,
/* insert_flag = */ FALSE,
/* flags = */ H5C__NO_FLAGS_SET,
/* new_size = */ 0,
/* num_pins = */ 0,
/* pin_type = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 3,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 2100, FALSE, 0 },
{ FLUSH_OP__RESIZE, VARIABLE_ENTRY_TYPE, 2200, FALSE, VARIABLE_ENTRY_SIZE / 2 },
{ FLUSH_OP__RENAME, VARIABLE_ENTRY_TYPE, 2300, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 5,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 350,
/* insert_flag = */ FALSE,
/* flags = */ H5C__NO_FLAGS_SET,
/* new_size = */ 0,
/* num_pins = */ 2,
/* pin_type = */ {VARIABLE_ENTRY_TYPE, VARIABLE_ENTRY_TYPE, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {1000, 2000, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 3,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 1000, FALSE, 0 },
{ FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 2000, FALSE, 0 },
{ FLUSH_OP__RESIZE, VARIABLE_ENTRY_TYPE, 350, FALSE, VARIABLE_ENTRY_SIZE / 4 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 6,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 450,
/* insert_flag = */ FALSE,
/* flags = */ H5C__DIRTIED_FLAG,
/* new_size = */ 0,
/* num_pins = */ 2,
/* pin_type = */ {VARIABLE_ENTRY_TYPE, VARIABLE_ENTRY_TYPE, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {1000, 2000, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 3,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 1000, FALSE, 0 },
{ FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 2000, FALSE, 0 },
{ FLUSH_OP__RESIZE, VARIABLE_ENTRY_TYPE, 450, FALSE, VARIABLE_ENTRY_SIZE / 4 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 7,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 650,
/* insert_flag = */ TRUE,
/* flags = */ H5C__NO_FLAGS_SET,
/* new_size = */ 0,
/* num_pins = */ 2,
/* pin_type = */ {VARIABLE_ENTRY_TYPE, VARIABLE_ENTRY_TYPE, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {1000, 2000, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 3,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 1000, FALSE, 0 },
{ FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 2000, FALSE, 0 },
{ FLUSH_OP__RESIZE, VARIABLE_ENTRY_TYPE, 650, FALSE, VARIABLE_ENTRY_SIZE / 4 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ FALSE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 8,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 750,
/* insert_flag = */ FALSE,
/* flags = */ H5C__DIRTIED_FLAG,
/* new_size = */ 0,
/* num_pins = */ 2,
/* pin_type = */ {VARIABLE_ENTRY_TYPE, VARIABLE_ENTRY_TYPE, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {1000, 2000, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 3,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 1000, FALSE, 0 },
{ FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 2000, FALSE, 0 },
{ FLUSH_OP__RESIZE, VARIABLE_ENTRY_TYPE, 750, FALSE, VARIABLE_ENTRY_SIZE / 4 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 9,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 500,
/* insert_flag = */ FALSE,
/* flags = */ H5C__DIRTIED_FLAG,
/* new_size = */ 0,
/* num_pins = */ 0,
/* pin_type = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 4,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 350, FALSE, 0 },
{ FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 450, FALSE, 0 },
{ FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 650, FALSE, 0 },
{ FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 750, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
}
};
int check_size = 3;
struct fo_flush_entry_check checks[3] =
{
{
/* entry_num = */ 0,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 100,
/* expected_size = */ VARIABLE_ENTRY_SIZE,
/* in_cache = */ FALSE,
/* at_main_addr = */ TRUE,
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 1,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 300,
/* expected_size = */ VARIABLE_ENTRY_SIZE,
/* in_cache = */ FALSE,
/* at_main_addr = */ FALSE,
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 2,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 2200,
/* expected_size = */ VARIABLE_ENTRY_SIZE / 2,
/* in_cache = */ FALSE,
/* at_main_addr = */ TRUE,
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
}
};
check_flush_cache__flush_op_test(cache_ptr,
test_num,
flush_flags,
spec_size,
spec,
init_expected_index_len,
init_expected_index_size,
expected_index_len,
expected_index_size,
check_size,
checks);
reset_entries();
}
if ( pass ) /* test #28 */
{
/* Test the expected fheap case, in which an entry dirties
* and resizes itself, and dirties an entry which it has
* pinned.
*/
int test_num = 28;
unsigned int flush_flags = H5C__NO_FLAGS_SET;
int spec_size = 5;
int init_expected_index_len = 5;
size_t init_expected_index_size = 3 * VARIABLE_ENTRY_SIZE;
int expected_index_len = 5;
size_t expected_index_size = 4 * VARIABLE_ENTRY_SIZE;
struct fo_flush_cache_test_spec spec[5] =
{
{
/* entry_num = */ 0,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 100,
/* insert_flag = */ FALSE,
/* flags = */ H5C__NO_FLAGS_SET,
/* new_size = */ 0,
/* num_pins = */ 0,
/* pin_type = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 0,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 1,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 200,
/* insert_flag = */ FALSE,
/* flags = */ H5C__DIRTIED_FLAG | H5C__SIZE_CHANGED_FLAG,
/* new_size = */ VARIABLE_ENTRY_SIZE / 2,
/* num_pins = */ 1,
/* pin_type = */ {VARIABLE_ENTRY_TYPE, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {100, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 3,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 100, FALSE, 0 },
{ FLUSH_OP__RESIZE, VARIABLE_ENTRY_TYPE, 200, FALSE, VARIABLE_ENTRY_SIZE },
{ FLUSH_OP__RENAME, VARIABLE_ENTRY_TYPE, 200, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 2,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 300,
/* insert_flag = */ FALSE,
/* flags = */ H5C__DIRTIED_FLAG | H5C__SIZE_CHANGED_FLAG,
/* new_size = */ VARIABLE_ENTRY_SIZE / 4,
/* num_pins = */ 1,
/* pin_type = */ {VARIABLE_ENTRY_TYPE, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {400, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 3,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 400, FALSE, 0 },
{ FLUSH_OP__RESIZE, VARIABLE_ENTRY_TYPE, 300, FALSE, VARIABLE_ENTRY_SIZE / 2 },
{ FLUSH_OP__RENAME, VARIABLE_ENTRY_TYPE, 300, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 3,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 400,
/* insert_flag = */ FALSE,
/* flags = */ H5C__NO_FLAGS_SET,
/* new_size = */ 0,
/* num_pins = */ 0,
/* pin_type = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 0,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
/* entry_num = */ 4,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 500,
/* insert_flag = */ FALSE,
/* flags = */ H5C__DIRTIED_FLAG | H5C__SIZE_CHANGED_FLAG,
/* new_size = */ VARIABLE_ENTRY_SIZE / 4,
/* num_pins = */ 1,
/* pin_type = */ {VARIABLE_ENTRY_TYPE, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {100, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 3,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 100, FALSE, 0 },
{ FLUSH_OP__RESIZE, VARIABLE_ENTRY_TYPE, 500, FALSE, VARIABLE_ENTRY_SIZE / 2 },
{ FLUSH_OP__RENAME, VARIABLE_ENTRY_TYPE, 500, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ FALSE
}
};
int check_size = 0;
struct fo_flush_entry_check checks[1] =
{
{
/* entry_num = */ 0,
/* entry_type = */ 0,
/* entry_index = */ 0,
/* expected_size = */ 0,
/* in_cache = */ FALSE,
/* at_main_addr = */ FALSE,
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
/* expected_loaded = */ FALSE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ FALSE
}
};
check_flush_cache__flush_op_test(cache_ptr,
test_num,
flush_flags,
spec_size,
spec,
init_expected_index_len,
init_expected_index_size,
expected_index_len,
expected_index_size,
check_size,
checks);
reset_entries();
}
if ( pass ) /* test #29 */
{
/* Repeat test #28 with the flush invalidate flag.
*
* Test the expected fheap case, in which an entry dirties
* and resizes itself, and dirties an entry which it has
* pinned.
*/
int test_num = 29;
unsigned int flush_flags = H5C__FLUSH_INVALIDATE_FLAG;
int spec_size = 5;
int init_expected_index_len = 5;
size_t init_expected_index_size = 3 * VARIABLE_ENTRY_SIZE;
int expected_index_len = 0;
size_t expected_index_size = 0;
struct fo_flush_cache_test_spec spec[5] =
{
{
/* entry_num = */ 0,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 100,
/* insert_flag = */ FALSE,
/* flags = */ H5C__NO_FLAGS_SET,
/* new_size = */ 0,
/* num_pins = */ 0,
/* pin_type = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 0,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 1,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 200,
/* insert_flag = */ FALSE,
/* flags = */ H5C__DIRTIED_FLAG | H5C__SIZE_CHANGED_FLAG,
/* new_size = */ VARIABLE_ENTRY_SIZE / 2,
/* num_pins = */ 1,
/* pin_type = */ {VARIABLE_ENTRY_TYPE, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {100, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 3,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 100, FALSE, 0 },
{ FLUSH_OP__RESIZE, VARIABLE_ENTRY_TYPE, 200, FALSE, VARIABLE_ENTRY_SIZE },
{ FLUSH_OP__RENAME, VARIABLE_ENTRY_TYPE, 200, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 2,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 300,
/* insert_flag = */ FALSE,
/* flags = */ H5C__DIRTIED_FLAG | H5C__SIZE_CHANGED_FLAG,
/* new_size = */ VARIABLE_ENTRY_SIZE / 4,
/* num_pins = */ 1,
/* pin_type = */ {VARIABLE_ENTRY_TYPE, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {400, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 3,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 400, FALSE, 0 },
{ FLUSH_OP__RESIZE, VARIABLE_ENTRY_TYPE, 300, FALSE, VARIABLE_ENTRY_SIZE / 2 },
{ FLUSH_OP__RENAME, VARIABLE_ENTRY_TYPE, 300, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 3,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 400,
/* insert_flag = */ FALSE,
/* flags = */ H5C__NO_FLAGS_SET,
/* new_size = */ 0,
/* num_pins = */ 0,
/* pin_type = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 0,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
/* entry_num = */ 4,
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 500,
/* insert_flag = */ FALSE,
/* flags = */ H5C__DIRTIED_FLAG | H5C__SIZE_CHANGED_FLAG,
/* new_size = */ VARIABLE_ENTRY_SIZE / 4,
/* num_pins = */ 1,
/* pin_type = */ {VARIABLE_ENTRY_TYPE, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {100, 0, 0, 0, 0, 0, 0, 0},
/* num_flush_ops = */ 3,
/* flush_ops = */
/* op_code: type: idx: flag: size: */
{ { FLUSH_OP__DIRTY, VARIABLE_ENTRY_TYPE, 100, FALSE, 0 },
{ FLUSH_OP__RESIZE, VARIABLE_ENTRY_TYPE, 500, FALSE, VARIABLE_ENTRY_SIZE / 2 },
{ FLUSH_OP__RENAME, VARIABLE_ENTRY_TYPE, 500, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0 } },
/* expected_loaded = */ TRUE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ TRUE,
/* expected_destroyed = */ TRUE
}
};
int check_size = 0;
struct fo_flush_entry_check checks[1] =
{
{
/* entry_num = */ 0,
/* entry_type = */ 0,
/* entry_index = */ 0,
/* expected_size = */ 0,
/* in_cache = */ FALSE,
/* at_main_addr = */ FALSE,
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
/* expected_loaded = */ FALSE,
/* expected_cleared = */ FALSE,
/* expected_flushed = */ FALSE,
/* expected_destroyed = */ FALSE
}
};
check_flush_cache__flush_op_test(cache_ptr,
test_num,
flush_flags,
spec_size,
spec,
init_expected_index_len,
init_expected_index_size,
expected_index_len,
expected_index_size,
check_size,
checks);
reset_entries();
}
/* finally finish up with the flush ops eviction test */
check_flush_cache__flush_op_eviction_test(cache_ptr);
return;
} /* check_flush_cache__flush_ops() */
/*-------------------------------------------------------------------------
* Function: check_flush_cache__flush_op_test()
*
* Purpose: Run a flush op flush cache test. Of the nature of
* flush operations, this is a multi-entry test.
*
* Return: void
*
* Programmer: John Mainzer
* 9/3/06
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static void
check_flush_cache__flush_op_test(H5C_t * cache_ptr,
int test_num,
unsigned int flush_flags,
int spec_size,
struct fo_flush_cache_test_spec spec[],
int init_expected_index_len,
size_t init_expected_index_size,
int expected_index_len,
size_t expected_index_size,
int check_size,
struct fo_flush_entry_check check[])
{
/* const char * fcn_name = "check_flush_cache__flush_op_test"; */
static char msg[128];
herr_t result;
int i;
int j;
test_entry_t * base_addr;
test_entry_t * entry_ptr;
#if 0 /* This is useful debugging code -- lets keep it around. */
HDfprintf(stdout, "check_flush_cache__flush_op_test: test %d\n",
test_num);
#endif
if ( cache_ptr == NULL ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"cache_ptr NULL on entry to flush op test #%d.",
test_num);
failure_mssg = msg;
}
else if ( ( cache_ptr->index_len != 0 ) ||
( cache_ptr->index_size != 0 ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"cache not empty at beginning of flush op test #%d.",
test_num);
failure_mssg = msg;
}
else if ( ( spec_size < 1 ) || ( spec == NULL ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"missing/bad test spec on entry to flush op test #%d.",
test_num);
failure_mssg = msg;
}
i = 0;
while ( ( pass ) && ( i < 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 ) ||
( spec[i].num_flush_ops < 0 ) ||
( spec[i].num_flush_ops > MAX_FLUSH_OPS ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"bad data in spec[%d] on entry to flush op test #%d.",
i, test_num);
failure_mssg = msg;
}
i++;
}
i = 0;
while ( ( pass ) && ( i < check_size ) )
{
if ( ( check[i].entry_num != i ) ||
( check[i].entry_type < 0 ) ||
( check[i].entry_type >= NUMBER_OF_ENTRY_TYPES ) ||
( check[i].entry_index < 0 ) ||
( check[i].entry_index > max_indices[check[i].entry_type] ) ||
( check[i].expected_size <= (size_t)0 ) ||
( ( check[i].in_cache != TRUE ) &&
( check[i].in_cache != FALSE ) ) ||
( ( check[i].at_main_addr != TRUE ) &&
( check[i].at_main_addr != FALSE ) ) ||
( ( check[i].is_dirty != TRUE ) &&
( check[i].is_dirty != FALSE ) ) ||
( ( check[i].is_protected != TRUE ) &&
( check[i].is_protected != FALSE ) ) ||
( ( check[i].is_pinned != TRUE ) &&
( check[i].is_pinned != FALSE ) ) ||
( ( check[i].expected_loaded != TRUE ) &&
( check[i].expected_loaded != FALSE ) ) ||
( ( check[i].expected_cleared != TRUE ) &&
( check[i].expected_cleared != FALSE ) ) ||
( ( check[i].expected_flushed != TRUE ) &&
( check[i].expected_flushed != FALSE ) ) ||
( ( check[i].expected_destroyed != TRUE ) &&
( check[i].expected_destroyed != FALSE ) ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"bad data in check[%d] on entry to flush op test #%d.",
i, test_num);
failure_mssg = msg;
}
i++;
}
i = 0;
while ( ( pass ) && ( i < spec_size ) )
{
if ( spec[i].insert_flag ) {
insert_entry(cache_ptr, spec[i].entry_type, spec[i].entry_index,
TRUE, spec[i].flags);
} else {
protect_entry(cache_ptr, spec[i].entry_type, spec[i].entry_index);
unprotect_entry_with_size_change(cache_ptr, spec[i].entry_type,
spec[i].entry_index,
spec[i].flags, spec[i].new_size);
}
for ( j = 0; j < spec[i].num_pins; j++ )
{
create_pinned_entry_dependency(cache_ptr,
spec[i].entry_type,
spec[i].entry_index,
spec[i].pin_type[j],
spec[i].pin_idx[j]);
}
for ( j = 0; j < spec[i].num_flush_ops; j++ )
{
add_flush_op(spec[i].entry_type,
spec[i].entry_index,
spec[i].flush_ops[j].op_code,
spec[i].flush_ops[j].type,
spec[i].flush_ops[j].idx,
spec[i].flush_ops[j].flag,
spec[i].flush_ops[j].size);
}
i++;
}
if ( pass ) {
if ( ( cache_ptr->index_len != init_expected_index_len ) ||
( cache_ptr->index_size != init_expected_index_size ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"Unexpected cache len/size before flush in flush op test #%d.",
test_num);
failure_mssg = msg;
}
}
if ( pass ) {
result = H5C_flush_cache(NULL, -1, -1, cache_ptr, flush_flags);
if ( result < 0 ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"flush with flags 0x%x failed in flush op test #%d.",
flush_flags, test_num);
failure_mssg = msg;
}
}
i = 0;
while ( ( pass ) && ( i < spec_size ) )
{
base_addr = entries[spec[i].entry_type];
entry_ptr = &(base_addr[spec[i].entry_index]);
if ( ( entry_ptr->loaded != spec[i].expected_loaded ) ||
( entry_ptr->cleared != spec[i].expected_cleared ) ||
( entry_ptr->flushed != spec[i].expected_flushed ) ||
( entry_ptr->destroyed != spec[i].expected_destroyed ) ) {
#if 0 /* This is useful debugging code. Lets keep it around. */
HDfprintf(stdout,
"loaded = %d(%d), clrd = %d(%d), flshd = %d(%d), dest = %d(%d)\n",
(int)(entry_ptr->loaded),
(int)(spec[i].expected_loaded),
(int)(entry_ptr->cleared),
(int)(spec[i].expected_cleared),
(int)(entry_ptr->flushed),
(int)(spec[i].expected_flushed),
(int)(entry_ptr->destroyed),
(int)(spec[i].expected_destroyed));
HDfprintf(stdout, "entry_ptr->header.is_dirty = %d\n",
(int)(entry_ptr->header.is_dirty));
#endif
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"Bad status on entry %d after flush op test #%d.",
i, test_num);
failure_mssg = msg;
}
i++;
}
if ( pass ) {
i = 0;
while ( ( pass ) && ( i < check_size ) )
{
if ( check[i].in_cache != entry_in_cache(cache_ptr,
check[i].entry_type,
check[i].entry_index) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"Check1 failed on entry %d after flush op test #%d.",
i, test_num);
failure_mssg = msg;
}
base_addr = entries[check[i].entry_type];
entry_ptr = &(base_addr[check[i].entry_index]);
if ( ( entry_ptr->size != check[i].expected_size ) ||
( ( ! entry_ptr->header.destroy_in_progress ) &&
( check[i].in_cache ) &&
( entry_ptr->header.size != check[i].expected_size ) ) ||
( entry_ptr->at_main_addr != check[i].at_main_addr ) ||
( entry_ptr->is_dirty != check[i].is_dirty ) ||
( entry_ptr->header.is_dirty != check[i].is_dirty ) ||
( entry_ptr->is_protected != check[i].is_protected ) ||
( entry_ptr->header.is_protected != check[i].is_protected ) ||
( entry_ptr->is_pinned != check[i].is_pinned ) ||
( entry_ptr->header.is_pinned != check[i].is_pinned ) ||
( entry_ptr->loaded != check[i].expected_loaded ) ||
( entry_ptr->cleared != check[i].expected_cleared ) ||
( entry_ptr->flushed != check[i].expected_flushed ) ||
( entry_ptr->destroyed != check[i].expected_destroyed ) ) {
#if 0 /* This is useful debugging code. Lets keep it around for a while. */
if ( entry_ptr->size != check[i].expected_size ) {
HDfprintf(stdout, "entry_ptr->size (expected) = %d (%d).\n",
(int)(entry_ptr->size),
(int)(check[i].expected_size));
}
if ( ( ! entry_ptr->header.destroy_in_progress ) &&
( check[i].in_cache ) &&
( entry_ptr->header.size != check[i].expected_size ) ) {
HDfprintf(stdout,
"(!destroy in progress and in cache and size (expected) = %d (%d).\n",
(int)(entry_ptr->header.size),
(int)(check[i].expected_size));
}
if ( entry_ptr->at_main_addr != check[i].at_main_addr ) {
HDfprintf(stdout, "(%d,%d) at main addr (expected) = %d (%d).\n",
(int)(check[i].entry_type),
(int)(check[i].entry_index),
(int)(entry_ptr->at_main_addr),
(int)(check[i].at_main_addr));
}
if ( entry_ptr->is_dirty != check[i].is_dirty ) {
HDfprintf(stdout, "entry_ptr->is_dirty (expected) = %d (%d).\n",
(int)(entry_ptr->is_dirty),
(int)(check[i].is_dirty));
}
if ( entry_ptr->header.is_dirty != check[i].is_dirty ) {
HDfprintf(stdout, "entry_ptr->header.is_dirty (expected) = %d (%d).\n",
(int)(entry_ptr->header.is_dirty),
(int)(check[i].is_dirty));
}
if ( entry_ptr->is_protected != check[i].is_protected ) {
HDfprintf(stdout, "entry_ptr->is_protected (expected) = %d (%d).\n",
(int)(entry_ptr->is_protected),
(int)(check[i].is_protected));
}
if ( entry_ptr->header.is_protected != check[i].is_protected ) {
HDfprintf(stdout, "entry_ptr->header.is_protected (expected) = %d (%d).\n",
(int)(entry_ptr->is_protected),
(int)(check[i].is_protected));
}
if ( entry_ptr->is_pinned != check[i].is_pinned ) {
HDfprintf(stdout, "entry_ptr->is_pinned (expected) = %d (%d).\n",
(int)(entry_ptr->is_pinned),
(int)(check[i].is_pinned));
}
if ( entry_ptr->header.is_pinned != check[i].is_pinned ) {
HDfprintf(stdout, "entry_ptr->header.is_pinned (expected) = %d (%d).\n",
(int)(entry_ptr->header.is_pinned),
(int)(check[i].is_pinned));
}
if ( entry_ptr->loaded != check[i].expected_loaded ) {
HDfprintf(stdout, "entry_ptr->loaded (expected) = %d (%d).\n",
(int)(entry_ptr->loaded),
(int)(check[i].expected_loaded));
}
if ( entry_ptr->cleared != check[i].expected_cleared ) {
HDfprintf(stdout, "entry_ptr->cleared (expected) = %d (%d).\n",
(int)(entry_ptr->cleared),
(int)(check[i].expected_cleared));
}
if ( entry_ptr->flushed != check[i].expected_flushed ) {
HDfprintf(stdout, "entry_ptr->flushed (expected) = %d (%d).\n",
(int)(entry_ptr->flushed),
(int)(check[i].expected_flushed));
}
if ( entry_ptr->destroyed != check[i].expected_destroyed ) {
HDfprintf(stdout, "entry_ptr->destroyed (expected) = %d (%d).\n",
(int)(entry_ptr->destroyed),
(int)(check[i].expected_destroyed));
}
#endif
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"Check2 failed on entry %d after flush op test #%d.",
i, test_num);
failure_mssg = msg;
}
i++;
}
}
if ( pass ) {
if ( ( ( (flush_flags & H5C__FLUSH_INVALIDATE_FLAG) == 0 )
&&
( ( cache_ptr->index_len != expected_index_len )
||
( cache_ptr->index_size != expected_index_size )
)
)
||
( ( (flush_flags & H5C__FLUSH_INVALIDATE_FLAG) != 0 )
&&
( ( cache_ptr->index_len != 0 )
||
( cache_ptr->index_size != 0 )
)
)
) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"Unexpected cache len/size after flush in flush op test #%d.",
test_num);
failure_mssg = msg;
}
}
/* clean up the cache to prep for the next test */
if ( pass ) {
result = H5C_flush_cache(NULL, -1, -1, cache_ptr,
H5C__FLUSH_INVALIDATE_FLAG);
if ( result < 0 ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"Flush failed on cleanup in flush op test #%d.",
test_num);
failure_mssg = msg;
}
else if ( ( cache_ptr->index_len != 0 ) ||
( cache_ptr->index_size != 0 ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"Unexpected cache len/size after cleanup in flush op test #%d.",
test_num);
failure_mssg = msg;
}
}
i = 0;
while ( ( pass ) && ( i < spec_size ) )
{
base_addr = entries[spec[i].entry_type];
entry_ptr = &(base_addr[spec[i].entry_index]);
entry_ptr->size = entry_sizes[spec[i].entry_type];
entry_ptr->loaded = FALSE;
entry_ptr->cleared = FALSE;
entry_ptr->flushed = FALSE;
entry_ptr->destroyed = FALSE;
i++;
}
i = 0;
while ( ( pass ) && ( i < check_size ) )
{
base_addr = entries[check[i].entry_type];
entry_ptr = &(base_addr[check[i].entry_index]);
entry_ptr->size = entry_sizes[check[i].entry_type];
entry_ptr->loaded = FALSE;
entry_ptr->cleared = FALSE;
entry_ptr->flushed = FALSE;
entry_ptr->destroyed = FALSE;
i++;
}
return;
} /* check_flush_cache__flush_op_test() */
/*-------------------------------------------------------------------------
* Function: check_flush_cache__flush_op_eviction_test()
*
* Purpose: Verify that flush operations work as expected when an
* entry is evicted.
*
* Do nothing if pass is FALSE on entry.
*
* Return: void
*
* Programmer: John Mainzer
* 10/3/06
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static void
check_flush_cache__flush_op_eviction_test(H5C_t * cache_ptr)
{
/* const char * fcn_name = "check_flush_cache__flush_op_eviction_test"; */
int i;
int num_variable_entries = 8;
int num_monster_entries = 31;
int num_large_entries = 0;
herr_t result;
test_entry_t * entry_ptr;
test_entry_t * base_addr;
struct expected_entry_status expected[8 + 31 + 14] =
{
/* the expected array is used to maintain a table of the expected status of every
* entry used in this test. Note that since the function that processes this
* array only processes as much of it as it is told to, we don't have to
* worry about maintaining the status of entries that we haven't used yet.
*/
/* entry entry in at main */
/* type: index: size: cache: addr: dirty: prot: pinned: loaded: clrd: flshd: dest: */
{ VARIABLE_ENTRY_TYPE, 0, VARIABLE_ENTRY_SIZE/2, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE },
{ VARIABLE_ENTRY_TYPE, 1, VARIABLE_ENTRY_SIZE, TRUE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE },
{ VARIABLE_ENTRY_TYPE, 2, VARIABLE_ENTRY_SIZE, TRUE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE },
{ VARIABLE_ENTRY_TYPE, 3, VARIABLE_ENTRY_SIZE/2, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE },
{ VARIABLE_ENTRY_TYPE, 4, VARIABLE_ENTRY_SIZE/2, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE },
{ VARIABLE_ENTRY_TYPE, 5, VARIABLE_ENTRY_SIZE/2, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE },
{ VARIABLE_ENTRY_TYPE, 6, VARIABLE_ENTRY_SIZE, TRUE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE },
{ VARIABLE_ENTRY_TYPE, 7, VARIABLE_ENTRY_SIZE, TRUE, TRUE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE },
{ MONSTER_ENTRY_TYPE, 0, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE },
{ MONSTER_ENTRY_TYPE, 1, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE },
{ MONSTER_ENTRY_TYPE, 2, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE },
{ MONSTER_ENTRY_TYPE, 3, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE },
{ MONSTER_ENTRY_TYPE, 4, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE },
{ MONSTER_ENTRY_TYPE, 5, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE },
{ MONSTER_ENTRY_TYPE, 6, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE },
{ MONSTER_ENTRY_TYPE, 7, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE },
{ MONSTER_ENTRY_TYPE, 8, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE },
{ MONSTER_ENTRY_TYPE, 9, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE },
{ MONSTER_ENTRY_TYPE, 10, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE },
{ MONSTER_ENTRY_TYPE, 11, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE },
{ MONSTER_ENTRY_TYPE, 12, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE },
{ MONSTER_ENTRY_TYPE, 13, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE },
{ MONSTER_ENTRY_TYPE, 14, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE },
{ MONSTER_ENTRY_TYPE, 15, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE },
{ MONSTER_ENTRY_TYPE, 16, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE },
{ MONSTER_ENTRY_TYPE, 17, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE },
{ MONSTER_ENTRY_TYPE, 18, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE },
{ MONSTER_ENTRY_TYPE, 19, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE },
{ MONSTER_ENTRY_TYPE, 20, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE },
{ MONSTER_ENTRY_TYPE, 21, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE },
{ MONSTER_ENTRY_TYPE, 22, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE },
{ MONSTER_ENTRY_TYPE, 23, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE },
{ MONSTER_ENTRY_TYPE, 24, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE },
{ MONSTER_ENTRY_TYPE, 25, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE },
{ MONSTER_ENTRY_TYPE, 26, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE },
{ MONSTER_ENTRY_TYPE, 27, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE },
{ MONSTER_ENTRY_TYPE, 28, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE },
{ MONSTER_ENTRY_TYPE, 29, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE },
{ MONSTER_ENTRY_TYPE, 30, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE },
{ LARGE_ENTRY_TYPE, 0, LARGE_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE },
{ LARGE_ENTRY_TYPE, 1, LARGE_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE },
{ LARGE_ENTRY_TYPE, 2, LARGE_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE },
{ LARGE_ENTRY_TYPE, 3, LARGE_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE },
{ LARGE_ENTRY_TYPE, 4, LARGE_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE },
{ LARGE_ENTRY_TYPE, 5, LARGE_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE },
{ LARGE_ENTRY_TYPE, 6, LARGE_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE },
{ LARGE_ENTRY_TYPE, 7, LARGE_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE },
{ LARGE_ENTRY_TYPE, 8, LARGE_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE },
{ LARGE_ENTRY_TYPE, 9, LARGE_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE },
{ LARGE_ENTRY_TYPE, 10, LARGE_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE },
{ LARGE_ENTRY_TYPE, 11, LARGE_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE },
{ LARGE_ENTRY_TYPE, 12, LARGE_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE },
{ LARGE_ENTRY_TYPE, 13, LARGE_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE }
};
if ( cache_ptr == NULL ) {
pass = FALSE;
failure_mssg = "cache_ptr NULL on entry to flush ops test.";
}
else if ( ( cache_ptr->index_len != 0 ) ||
( cache_ptr->index_size != 0 ) ) {
pass = FALSE;
failure_mssg = "cache not empty at start of flush ops eviction test.";
}
else if ( ( cache_ptr->max_cache_size != (2 * 1024 * 1024 ) ) ||
( cache_ptr->min_clean_size != (1 * 1024 * 1024 ) ) ) {
pass = FALSE;
failure_mssg = "unexpected cache config at start of flush op eviction test.";
} else {
/* set min clean size to zero for this test as it simplifies
* computing the expected cache size after each operation.
*/
cache_ptr->min_clean_size = 0;
}
if ( pass ) {
/* the basic idea in this test is to insert a bunch of entries
* with flush operations associated with them, and then load
* other entries into the cache until the cache is full. At
* that point, load yet more entries into the cache, and see
* if the flush operations are performed as expected.
*
* To make things a bit more interesting, we also include a
* couple of pins.
*/
/* reset the stats before we start. If stats are enabled, we will
* check to see if they are as expected at the end.
*/
H5C_stats__reset(cache_ptr);
/* load a few entries with pin relationships and flush ops.
* Start by just loading the entries.
*/
protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 0);
unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 0,
H5C__DIRTIED_FLAG | H5C__SIZE_CHANGED_FLAG,
(VARIABLE_ENTRY_SIZE / 2));
protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 1);
unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 1,
H5C__NO_FLAGS_SET, (size_t)0);
protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 2);
unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 2,
H5C__NO_FLAGS_SET, (size_t)0);
protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 3);
unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 3,
H5C__DIRTIED_FLAG | H5C__SIZE_CHANGED_FLAG,
(VARIABLE_ENTRY_SIZE / 2));
protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 4);
unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 4,
H5C__DIRTIED_FLAG | H5C__SIZE_CHANGED_FLAG,
(VARIABLE_ENTRY_SIZE / 2));
protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 5);
unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 5,
H5C__DIRTIED_FLAG | H5C__SIZE_CHANGED_FLAG,
(VARIABLE_ENTRY_SIZE / 2));
protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 6);
unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 6,
H5C__NO_FLAGS_SET, (size_t)0);
protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 7);
unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 7,
H5C__NO_FLAGS_SET, (size_t)0);
if ( ( cache_ptr->index_len != 8 ) ||
( cache_ptr->index_size != (4 * (VARIABLE_ENTRY_SIZE / 2)) +
(4 * VARIABLE_ENTRY_SIZE) ) ) {
pass = FALSE;
failure_mssg = "unexpected size/len in flush op eviction test 1.";
}
}
if ( pass ) {
/* Now set up the pinning relationships:
*
* Briefly, (VET, 0) is pinned by (VET, 1), (VET, 2), and (VET, 3)
* (VET, 7) is pinned by (VET, 3), and (VET, 5)
*/
create_pinned_entry_dependency(cache_ptr, VARIABLE_ENTRY_TYPE, 1,
VARIABLE_ENTRY_TYPE, 0);
create_pinned_entry_dependency(cache_ptr, VARIABLE_ENTRY_TYPE, 2,
VARIABLE_ENTRY_TYPE, 0);
create_pinned_entry_dependency(cache_ptr, VARIABLE_ENTRY_TYPE, 3,
VARIABLE_ENTRY_TYPE, 0);
create_pinned_entry_dependency(cache_ptr, VARIABLE_ENTRY_TYPE, 3,
VARIABLE_ENTRY_TYPE, 7);
create_pinned_entry_dependency(cache_ptr, VARIABLE_ENTRY_TYPE, 5,
VARIABLE_ENTRY_TYPE, 7);
/* Next, set up the flush operations:
*
* Briefly, (VET, 1) dirties (VET, 0)
* resizes (VET, 0) to 3/4 VARIABLE_ENTRY_SIZE
*
* (VET, 2) dirties (VET, 0)
* resizes (VET, 0) to VARIABLE_ENTRY_SIZE
* renames (VET, 0) to its alternate address
*
* (VET, 3) dirties (VET, 0)
* resizes itself to VARIABLE_ENTRY_SIZE
*
* (VET, 7) dirties (VET, 6)
*/
add_flush_op(VARIABLE_ENTRY_TYPE, 1, FLUSH_OP__DIRTY,
VARIABLE_ENTRY_TYPE, 0, FALSE, (size_t)0);
add_flush_op(VARIABLE_ENTRY_TYPE, 1, FLUSH_OP__RESIZE,
VARIABLE_ENTRY_TYPE, 0, FALSE,
3 * VARIABLE_ENTRY_SIZE / 4);
add_flush_op(VARIABLE_ENTRY_TYPE, 2, FLUSH_OP__DIRTY,
VARIABLE_ENTRY_TYPE, 0, FALSE, (size_t)0);
add_flush_op(VARIABLE_ENTRY_TYPE, 2, FLUSH_OP__RESIZE,
VARIABLE_ENTRY_TYPE, 0, FALSE, VARIABLE_ENTRY_SIZE);
add_flush_op(VARIABLE_ENTRY_TYPE, 2, FLUSH_OP__RENAME,
VARIABLE_ENTRY_TYPE, 0, FALSE, (size_t)0);
add_flush_op(VARIABLE_ENTRY_TYPE, 3, FLUSH_OP__DIRTY,
VARIABLE_ENTRY_TYPE, 0, FALSE, (size_t)0);
add_flush_op(VARIABLE_ENTRY_TYPE, 3, FLUSH_OP__RESIZE,
VARIABLE_ENTRY_TYPE, 3, FALSE, VARIABLE_ENTRY_SIZE);
add_flush_op(VARIABLE_ENTRY_TYPE, 7, FLUSH_OP__DIRTY,
VARIABLE_ENTRY_TYPE, 6, FALSE, (size_t)0);
}
if ( pass ) {
/* to summarize, at present the following variable size entries
* are in cache with the following characteristics:
*
* in
* entry: cache? size: dirty? pinned? pins: flush operations:
*
* (VET, 0) Y 5 KB Y Y - -
*
* (VET, 1) Y 10 KB N N 0 dirty (VET, 0),
* resize (VET, 0) to 7.5 KB
*
* (VET, 2) Y 10 KB N N 0 dirty (VET, 0)
* resize (VET, 0) to 10 KB
* rename (VET, 0) to its alternate address
*
* (VET, 3) Y 5 KB Y N 0, 7 dirty (VET, 0)
* resize (VET, 3) to 10 KB
*
* (VET, 4) Y 5 KB Y N - -
*
* (VET, 5) Y 5 KB Y N 7 -
*
* (VET, 6) Y 10 KB N N - -
*
* (VET, 7) Y 10 KB N Y - dirty (VET, 6)
*
* Recall that in this test bed, flush operations are excuted the
* first time the associated entry is flushed, and are then
* deleted.
*/
/* Now fill up the cache with other, unrelated entries */
for ( i = 0; i < 31; i++ )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i);
unprotect_entry_with_size_change(cache_ptr, MONSTER_ENTRY_TYPE, i,
H5C__DIRTIED_FLAG, (size_t)0);
}
for ( i = 0; i < 1; i++ )
{
protect_entry(cache_ptr, LARGE_ENTRY_TYPE, i);
unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, i,
H5C__DIRTIED_FLAG, (size_t)0);
}
/* The cache should now be exactly full */
if ( ( cache_ptr->index_len != 40 ) ||
( cache_ptr->index_size != 2 * 1024 * 1024 ) ||
( cache_ptr->index_size != ((4 * VARIABLE_ENTRY_SIZE / 2) +
(4 * VARIABLE_ENTRY_SIZE) +
(31 * MONSTER_ENTRY_SIZE) +
(1 * LARGE_ENTRY_SIZE)) ) ) {
pass = FALSE;
failure_mssg = "unexpected size/len in flush op eviction test 2.";
} else {
/* verify the expected status of all entries we have loaded to date: */
num_large_entries = 1;
verify_entry_status(cache_ptr,
0,
(num_variable_entries + num_monster_entries + num_large_entries),
expected);
}
}
if ( pass ) {
/* Now load a large entry. This should result in the eviction
* of (VET,1), and the increase in the size of (VET, 0) from .5
* VARIABLE_ENTRY_SIZE to .75 VARIABLE_ENTRY_SIZE.
*
* The following table illustrates the intended state of affairs
* after the eviction:
*
* in
* entry: cache? size: dirty? pinned? pins: flush operations:
*
* (VET, 0) Y 7.5 KB Y Y - -
*
* (VET, 1) N 10 KB N N - -
*
* (VET, 2) Y 10 KB N N 0 dirty (VET, 0)
* resize (VET, 0) to 10 KB
* rename (VET, 0) to its alternate address
*
* (VET, 3) Y 5 KB Y N 0, 7 dirty (VET, 0)
* resize (VET, 3) to 10 KB
*
* (VET, 4) Y 5 KB Y N - -
*
* (VET, 5) Y 5 KB Y N 7 -
*
* (VET, 6) Y 10 KB N N - -
*
* (VET, 7) Y 10 KB Y Y - dirty (VET, 6)
*
* Start by updating the expected table for the expected changes in entry status:
*/
expected[0].size = 3 * VARIABLE_ENTRY_SIZE / 4;
expected[1].in_cache = FALSE;
expected[1].flushed = TRUE;
expected[1].destroyed = TRUE;
num_large_entries = 2;
protect_entry(cache_ptr, LARGE_ENTRY_TYPE, 1);
unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, 1,
H5C__DIRTIED_FLAG, (size_t)0);
if ( ( cache_ptr->index_len != 40 ) ||
( cache_ptr->index_size != (2 * 1024 * 1024) -
(VARIABLE_ENTRY_SIZE) +
(VARIABLE_ENTRY_SIZE / 4) +
(LARGE_ENTRY_SIZE) ) ||
( cache_ptr->index_size != ((1 * 3 * VARIABLE_ENTRY_SIZE / 4 ) +
(3 * VARIABLE_ENTRY_SIZE / 2 ) +
(3 * VARIABLE_ENTRY_SIZE) +
(31 * MONSTER_ENTRY_SIZE) +
(2 * LARGE_ENTRY_SIZE)) ) ) {
pass = FALSE;
failure_mssg = "unexpected size/len in flush op eviction test 3.";
}
/* verify entry status */
verify_entry_status(cache_ptr,
1,
(num_variable_entries + num_monster_entries + num_large_entries),
expected);
}
if ( pass ) {
/* Now load another large entry. This should result in the eviction
* of (VET, 2), the increase in the size of (VET, 0) from .75
* VARIABLE_ENTRY_SIZE to 1.0 VARIABLE_ENTRY_SIZE, and the renaming
* of (VET, 0) to its alternate address.
*
* The following table shows the expected states of the variable
* size entries after the test.
*
* in
* entry: cache? size: dirty? pinned? pins: flush operations:
*
* (VET, 0) Y 10 KB Y Y - -
*
* (VET, 1) N 10 KB N N - -
*
* (VET, 2) N 10 KB N N - -
*
* (VET, 3) Y 5 KB Y N 0, 7 dirty (VET, 0)
* resize (VET, 3) to 10 KB
*
* (VET, 4) Y 5 KB Y N - -
*
* (VET, 5) Y 5 KB Y N 7 -
*
* (VET, 6) Y 10 KB N N - -
*
* (VET, 7) Y 10 KB Y Y - dirty (VET, 6)
*
* Start by updating the expected table for the expected changes in entry status:
*/
expected[0].size = VARIABLE_ENTRY_SIZE;
expected[0].at_main_addr = FALSE;
expected[2].in_cache = FALSE;
expected[2].flushed = TRUE;
expected[2].destroyed = TRUE;
num_large_entries = 3;
protect_entry(cache_ptr, LARGE_ENTRY_TYPE, 2);
unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, 2,
H5C__DIRTIED_FLAG, (size_t)0);
if ( ( cache_ptr->index_len != 40 ) ||
( cache_ptr->index_size != (2 * 1024 * 1024) -
(2 * VARIABLE_ENTRY_SIZE) +
(VARIABLE_ENTRY_SIZE / 2) +
(2 * LARGE_ENTRY_SIZE) ) ||
( cache_ptr->index_size != ((3 * VARIABLE_ENTRY_SIZE / 2) +
(3 * VARIABLE_ENTRY_SIZE) +
(31 * MONSTER_ENTRY_SIZE) +
(3 * LARGE_ENTRY_SIZE)) ) ) {
pass = FALSE;
failure_mssg = "unexpected size/len in flush op eviction test 4.";
}
/* verify entry status */
verify_entry_status(cache_ptr,
2,
(num_variable_entries + num_monster_entries + num_large_entries),
expected);
}
if ( pass ) {
/* load two more large entries. This should result in (VET, 3) being
* flushed, and increasing its size from 1/2 VARIABLE_ENTRY_SIZE to
* VARIABLE_ENTRY_SIZE.
*
* As a result of this size increase, the cache will have to look
* for another entry to evict. After flushing (VET, 4) and (VET, 5),
* it should evict (VET, 6), yielding the needed memory.
*
* The following table shows the expected states of the variable
* size entries after the test.
*
* in
* entry: cache? size: dirty? pinned? pins: flush operations:
*
* (VET, 0) Y 10 KB Y Y - -
*
* (VET, 1) N 10 KB N N - -
*
* (VET, 2) N 10 KB N N - -
*
* (VET, 3) Y 10 KB N N 0, 7 -
*
* (VET, 4) Y 5 KB N N - -
*
* (VET, 5) Y 5 KB N N 7 -
*
* (VET, 6) N 10 KB N N - -
*
* (VET, 7) Y 10 KB Y Y - dirty (VET, 6)
*
* Start by updating the expected table for the expected changes in entry status:
*/
expected[3].size = VARIABLE_ENTRY_SIZE;
expected[3].is_dirty = FALSE;
expected[3].flushed = TRUE;
expected[4].is_dirty = FALSE;
expected[4].flushed = TRUE;
expected[5].is_dirty = FALSE;
expected[5].flushed = TRUE;
expected[6].in_cache = FALSE;
expected[6].flushed = TRUE;
expected[6].destroyed = TRUE;
num_large_entries = 5;
protect_entry(cache_ptr, LARGE_ENTRY_TYPE, 3);
unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, 3,
H5C__DIRTIED_FLAG, (size_t)0);
protect_entry(cache_ptr, LARGE_ENTRY_TYPE, 4);
unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, 4,
H5C__DIRTIED_FLAG, (size_t)0);
/* verify cache size */
if ( ( cache_ptr->index_len != 41 ) ||
( cache_ptr->index_size != (2 * 1024 * 1024) -
(3 * VARIABLE_ENTRY_SIZE) +
(1 * VARIABLE_ENTRY_SIZE ) + /* size increases of (VET, 0) & (VET, 3) */
(4 * LARGE_ENTRY_SIZE) ) ||
( cache_ptr->index_size != ((2 * VARIABLE_ENTRY_SIZE / 2) +
(3 * VARIABLE_ENTRY_SIZE) +
(31 * MONSTER_ENTRY_SIZE) +
(5 * LARGE_ENTRY_SIZE)) ) ) {
pass = FALSE;
failure_mssg = "unexpected size/len in flush op eviction test 5.";
}
/* verify entry status */
verify_entry_status(cache_ptr,
3,
(num_variable_entries + num_monster_entries + num_large_entries),
expected);
}
if ( pass ) {
/* now touch all the non VARIABLE_ENTRY_TYPE entries in the
* cache to bring all the VARIABLE_ENTRY_TYPE entries to the
* end of the LRU list.
*
* Note that we don't have to worry about (VET, 0) and (VET, 7)
* as they are pinned and thus not in the LRU list to begin with.
*/
for ( i = 0; i < 31; i++ )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i);
unprotect_entry_with_size_change(cache_ptr, MONSTER_ENTRY_TYPE, i,
H5C__DIRTIED_FLAG, (size_t)0);
}
for ( i = 0; i < 5; i++ )
{
protect_entry(cache_ptr, LARGE_ENTRY_TYPE, i);
unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, i,
H5C__DIRTIED_FLAG, (size_t)0);
}
/* verify cache size */
if ( ( cache_ptr->index_len != 41 ) ||
( cache_ptr->index_size != (2 * 1024 * 1024) -
(2 * VARIABLE_ENTRY_SIZE) +
(4 * LARGE_ENTRY_SIZE) ) ) {
pass = FALSE;
failure_mssg = "unexpected size/len in flush op eviction test 6.";
}
/* verify entry status */
verify_entry_status(cache_ptr,
4,
(num_variable_entries + num_monster_entries + num_large_entries),
expected);
}
if ( pass ) {
/* Now load three more large entries. This should result
* in the eviction of (VET, 3), and the unpinning of (VET, 0)
*
* The following table shows the expected states of the variable
* size entries after the test.
*
* in
* entry: cache? size: dirty? pinned? pins: flush operations:
*
* (VET, 0) Y 10 KB Y N - -
*
* (VET, 1) N 10 KB N N - -
*
* (VET, 2) N 10 KB N N - -
*
* (VET, 3) N 10 KB N N - -
*
* (VET, 4) Y 5 KB N N - -
*
* (VET, 5) Y 5 KB N N 7 -
*
* (VET, 6) N 10 KB N N - -
*
* (VET, 7) Y 10 KB Y Y - dirty (VET, 6)
*
* Start by updating the expected table for the expected changes in entry status:
*/
expected[0].is_pinned = FALSE;
expected[3].in_cache = FALSE;
expected[3].destroyed = TRUE;
num_large_entries = 8;
for ( i = 5; i < 8; i++ )
{
protect_entry(cache_ptr, LARGE_ENTRY_TYPE, i);
unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, i,
H5C__DIRTIED_FLAG, (size_t)0);
}
/* verify cache size */
if ( ( cache_ptr->index_len != 43 ) ||
( cache_ptr->index_size != (2 * 1024 * 1024) -
(3 * VARIABLE_ENTRY_SIZE) +
(7 * LARGE_ENTRY_SIZE) ) ||
( cache_ptr->index_size != ((2 * VARIABLE_ENTRY_SIZE / 2) +
(2 * VARIABLE_ENTRY_SIZE) +
(31 * MONSTER_ENTRY_SIZE) +
(8 * LARGE_ENTRY_SIZE)) ) ) {
pass = FALSE;
failure_mssg = "unexpected size/len in flush op eviction test 7.";
}
/* verify entry status */
verify_entry_status(cache_ptr,
5,
(num_variable_entries + num_monster_entries + num_large_entries),
expected);
}
if ( pass ) {
/* load another large entry. (VET, 4) should be evicted.
*
* The following table shows the expected states of the variable
* size entries after the test.
*
* in
* entry: cache? size: dirty? pinned? pins: flush operations:
*
* (VET, 0) Y 10 KB Y N - -
*
* (VET, 1) N 10 KB N N - -
*
* (VET, 2) N 10 KB N N - -
*
* (VET, 3) N 10 KB N N - -
*
* (VET, 4) N 5 KB N N - -
*
* (VET, 5) Y 5 KB N N 7 -
*
* (VET, 6) N 10 KB N N - -
*
* (VET, 7) Y 10 KB Y Y - dirty (VET, 6)
*
* Start by updating the expected table for the expected changes in entry status:
*/
expected[4].in_cache = FALSE;
expected[4].destroyed = TRUE;
num_large_entries = 9;
for ( i = 8; i < 9; i++ )
{
protect_entry(cache_ptr, LARGE_ENTRY_TYPE, i);
unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, i,
H5C__DIRTIED_FLAG, (size_t)0);
}
/* verify cache size */
if ( ( cache_ptr->index_len != 43 ) ||
( cache_ptr->index_size != (2 * 1024 * 1024) -
(3 * VARIABLE_ENTRY_SIZE) -
(VARIABLE_ENTRY_SIZE / 2) +
(8 * LARGE_ENTRY_SIZE) ) ||
( cache_ptr->index_size != ((1 * VARIABLE_ENTRY_SIZE / 2) +
(2 * VARIABLE_ENTRY_SIZE) +
(31 * MONSTER_ENTRY_SIZE) +
(9 * LARGE_ENTRY_SIZE)) ) ) {
pass = FALSE;
failure_mssg = "unexpected size/len in flush op eviction test 8.";
}
/* verify entry status */
verify_entry_status(cache_ptr,
6,
(num_variable_entries + num_monster_entries + num_large_entries),
expected);
}
if ( pass ) {
/* Load another large entry.
*
* (VET, 5) should be evicted, and (VET, 7) should be unpinned.
*
* The following table shows the expected states of the variable
* size entries after the test.
*
* in
* entry: cache? size: dirty? pinned? pins: flush operations:
*
* (VET, 0) Y 10 KB Y N - -
*
* (VET, 1) N 10 KB N N - -
*
* (VET, 2) N 10 KB N N - -
*
* (VET, 3) N 10 KB N N - -
*
* (VET, 4) N 5 KB N N - -
*
* (VET, 5) N 5 KB N N - -
*
* (VET, 6) N 10 KB N N - -
*
* (VET, 7) Y 10 KB Y N - dirty (VET, 6)
*
* Start by updating the expected table for the expected changes in entry status:
*/
expected[5].in_cache = FALSE;
expected[5].destroyed = TRUE;
expected[7].is_pinned = FALSE;
num_large_entries = 10;
for ( i = 9; i < 10; i++ )
{
protect_entry(cache_ptr, LARGE_ENTRY_TYPE, i);
unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, i,
H5C__DIRTIED_FLAG, (size_t)0);
}
/* verify cache size */
if ( ( cache_ptr->index_len != 43 ) ||
( cache_ptr->index_size != (2 * 1024 * 1024) -
(4 * VARIABLE_ENTRY_SIZE) +
(9 * LARGE_ENTRY_SIZE) ) ||
( cache_ptr->index_size != ((2 * VARIABLE_ENTRY_SIZE) +
(31 * MONSTER_ENTRY_SIZE) +
(10 * LARGE_ENTRY_SIZE)) ) ) {
pass = FALSE;
failure_mssg = "unexpected size/len in flush op eviction test 9.";
}
/* verify entry status */
verify_entry_status(cache_ptr,
7,
(num_variable_entries + num_monster_entries + num_large_entries),
expected);
}
if ( pass ) {
/* Again, touch all the non VARIABLE_ENTRY_TYPE entries in the
* cache to bring all the VARIABLE_ENTRY_TYPE entries to the
* end of the LRU list.
*
* Both (VET, 0) and (VET, 7) have been unpinned, so they are
* now in the LRU list.
*/
for ( i = 0; i < 31; i++ )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i);
unprotect_entry_with_size_change(cache_ptr, MONSTER_ENTRY_TYPE, i,
H5C__DIRTIED_FLAG, (size_t)0);
}
for ( i = 0; i < 10; i++ )
{
protect_entry(cache_ptr, LARGE_ENTRY_TYPE, i);
unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, i,
H5C__DIRTIED_FLAG, (size_t)0);
}
/* verify cache size */
if ( ( cache_ptr->index_len != 43 ) ||
( cache_ptr->index_size != (2 * 1024 * 1024) -
(4 * VARIABLE_ENTRY_SIZE) +
(9 * LARGE_ENTRY_SIZE) ) ||
( cache_ptr->index_size != ((2 * VARIABLE_ENTRY_SIZE) +
(31 * MONSTER_ENTRY_SIZE) +
(10 * LARGE_ENTRY_SIZE)) ) ) {
pass = FALSE;
failure_mssg = "unexpected size/len in flush op eviction test 10.";
}
/* verify entry status */
verify_entry_status(cache_ptr,
8,
(num_variable_entries + num_monster_entries + num_large_entries),
expected);
}
if ( pass ) {
/* load two more large entries.
*
* (VET, 0) should be flushed, but not evicted initially since it is dirty.
*
* (VET, 7) should be evicted, but (VET, 7) has an eviction operation that
* dirties (VET, 6). Since (VET, 6) is not in the cache, it will be loaded.
* Since this results in no net increase in free space, the cache will
* continue to attempt to create free space.
*
* The cache will then flush all the monster and large entries, but since they
* are all dirty, they will not be evicted.
*
* Finally, it will reach (VET, 0) again, and evict it on the second pass.
* This finally makes the necessary space.
*
* The following table shows the expected states of the variable
* size entries after the test.
*
* in
* entry: cache? size: dirty? pinned? pins: flush operations:
*
* (VET, 0) N 10 KB N N - -
*
* (VET, 1) N 10 KB N N - -
*
* (VET, 2) N 10 KB N N - -
*
* (VET, 3) N 10 KB N N - -
*
* (VET, 4) N 5 KB N N - -
*
* (VET, 5) N 5 KB N N - -
*
* (VET, 6) Y 10 KB Y N - -
*
* (VET, 7) N 10 KB N N - -
*
* Start by updating the expected table for the expected changes in entry status:
*
* Note that we reset the loaded, cleared, flushed, and destroyed fields of
* (VET,6) so we can track what is happening.
*/
base_addr = entries[VARIABLE_ENTRY_TYPE];
entry_ptr = &(base_addr[6]);
entry_ptr->loaded = FALSE;
entry_ptr->cleared = FALSE;
entry_ptr->flushed = FALSE;
entry_ptr->destroyed = FALSE;
expected[0].in_cache = FALSE;
expected[0].is_dirty = FALSE;
expected[0].flushed = TRUE;
expected[0].destroyed = TRUE;
expected[6].in_cache = TRUE;
expected[6].is_dirty = TRUE;
expected[6].loaded = TRUE;
expected[6].flushed = FALSE;
expected[6].destroyed = FALSE;
expected[7].in_cache = FALSE;
expected[7].flushed = TRUE;
expected[7].destroyed = TRUE;
num_large_entries = 12;
/* a newly loaded entry is not inserted in the cache until after space has been
* made for it. Thus (LET, 11) will not be flushed.
*/
for ( i = num_variable_entries;
i < num_variable_entries + num_monster_entries + num_large_entries - 1;
i++ )
{
expected[i].is_dirty = FALSE;
expected[i].flushed = TRUE;
}
for ( i = 10; i < 12; i++ )
{
protect_entry(cache_ptr, LARGE_ENTRY_TYPE, i);
unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, i,
H5C__DIRTIED_FLAG, (size_t)0);
}
/* verify cache size */
if ( ( cache_ptr->index_len != 44 ) ||
( cache_ptr->index_size != (2 * 1024 * 1024) -
(5 * VARIABLE_ENTRY_SIZE) +
(11 * LARGE_ENTRY_SIZE) ) ||
( cache_ptr->index_size != ((1 * VARIABLE_ENTRY_SIZE) +
(31 * MONSTER_ENTRY_SIZE) +
(12 * LARGE_ENTRY_SIZE)) ) ) {
pass = FALSE;
failure_mssg = "unexpected size/len in flush op eviction test 11.";
}
/* verify entry status */
verify_entry_status(cache_ptr,
9,
(num_variable_entries + num_monster_entries + num_large_entries),
expected);
}
if ( pass ) {
/* Again, touch all the non VARIABLE_ENTRY_TYPE entries in the
* cache to bring the last remaining VARIABLE_ENTRY_TYPE entry to the
* end of the LRU list.
*/
for ( i = 0; i < num_monster_entries; i++ )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i);
unprotect_entry_with_size_change(cache_ptr, MONSTER_ENTRY_TYPE, i,
H5C__DIRTIED_FLAG, (size_t)0);
}
for ( i = 0; i < num_large_entries; i++ )
{
protect_entry(cache_ptr, LARGE_ENTRY_TYPE, i);
unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, i,
H5C__DIRTIED_FLAG, (size_t)0);
}
/* update the expected array to mark all these entries dirty again. */
for ( i = num_variable_entries;
i < num_variable_entries + num_monster_entries + num_large_entries - 1;
i++ )
{
expected[i].is_dirty = TRUE;
}
/* verify cache size */
if ( ( cache_ptr->index_len != 44 ) ||
( cache_ptr->index_size != (2 * 1024 * 1024) -
(5 * VARIABLE_ENTRY_SIZE) +
(11 * LARGE_ENTRY_SIZE) ) ||
( cache_ptr->index_size != ((1 * VARIABLE_ENTRY_SIZE) +
(31 * MONSTER_ENTRY_SIZE) +
(12 * LARGE_ENTRY_SIZE)) ) ) {
pass = FALSE;
failure_mssg = "unexpected size/len in flush op eviction test 12.";
}
/* verify entry status */
verify_entry_status(cache_ptr,
10,
(num_variable_entries + num_monster_entries + num_large_entries),
expected);
}
if ( pass ) {
/* Load two more large entries.
*
* Since (VET, 6) is dirty, at first this will just cause (VET, 6) to be flushed.
*
* But all other entries in the cache are dirty, so the cache will flush them all,
* and then evict (VET, 6) on the second pass.
*
* The following table shows the expected states of the variable
* size entries after the test.
*
* in
* entry: cache? size: dirty? pinned? pins: flush operations:
*
* (VET, 0) N 10 KB N N - -
*
* (VET, 1) N 10 KB N N - -
*
* (VET, 2) N 10 KB N N - -
*
* (VET, 3) N 10 KB N N - -
*
* (VET, 4) N 5 KB N N - -
*
* (VET, 5) N 5 KB N N - -
*
* (VET, 6) N 10 KB N N - -
*
* (VET, 7) N 10 KB N N - -
*
* Start by updating the expected table for the expected changes in entry status:
*/
expected[6].in_cache = FALSE;
expected[6].is_dirty = FALSE;
expected[6].flushed = TRUE;
expected[6].destroyed = TRUE;
num_large_entries = 14;
/* a newly loaded entry is not inserted in the cache until after space has been
* made for it. Thus (LET, 13) will not be flushed.
*/
for ( i = num_variable_entries;
i < num_variable_entries + num_monster_entries + num_large_entries - 1;
i++ )
{
expected[i].is_dirty = FALSE;
expected[i].flushed = TRUE;
}
for ( i = 12; i < 14; i++ )
{
protect_entry(cache_ptr, LARGE_ENTRY_TYPE, i);
unprotect_entry_with_size_change(cache_ptr, LARGE_ENTRY_TYPE, i,
H5C__DIRTIED_FLAG, (size_t)0);
}
/* verify cache size */
if ( ( cache_ptr->index_len != 45 ) ||
( cache_ptr->index_size != (2 * 1024 * 1024) -
(6 * VARIABLE_ENTRY_SIZE) +
(13 * LARGE_ENTRY_SIZE) ) ||
( cache_ptr->index_size != ((31 * MONSTER_ENTRY_SIZE) +
(14 * LARGE_ENTRY_SIZE)) ) ) {
pass = FALSE;
failure_mssg = "unexpected size/len in flush op eviction test 13.";
}
/* verify entry status */
verify_entry_status(cache_ptr,
11,
(num_variable_entries + num_monster_entries + num_large_entries),
expected);
}
/* at this point we have cycled all the variable size entries through the cache.
*
* flush the cache and end the test.
*/
if ( pass ) {
result = H5C_flush_cache(NULL, -1, -1, cache_ptr,
H5C__FLUSH_INVALIDATE_FLAG);
if ( result < 0 ) {
pass = FALSE;
failure_mssg = "Cache flush invalidate failed after flush op eviction test";
}
else if ( ( cache_ptr->index_len != 0 ) ||
( cache_ptr->index_size != 0 ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache len/size after cleanup of flush op eviction test";
}
}
#if H5C_COLLECT_CACHE_STATS
/* If we are collecting stats, check to see if we get the expected
* values.
*
* Testing the stats code is fairly new, but given the extent
* to which I find myself depending on the stats, I've decided
* to start testing the stats whenever it is convenient to do
* so.
*/
if ( pass ) {
if ( ( cache_ptr->insertions[VARIABLE_ENTRY_TYPE] != 0 ) ||
( cache_ptr->pinned_insertions[VARIABLE_ENTRY_TYPE] != 0 ) ||
( cache_ptr->clears[VARIABLE_ENTRY_TYPE] != 0 ) ||
( cache_ptr->flushes[VARIABLE_ENTRY_TYPE] != 14 ) ||
( cache_ptr->evictions[VARIABLE_ENTRY_TYPE] != 9 ) ||
( cache_ptr->renames[VARIABLE_ENTRY_TYPE] != 1 ) ||
( cache_ptr->entry_flush_renames[VARIABLE_ENTRY_TYPE] != 0 ) ||
( cache_ptr->cache_flush_renames[VARIABLE_ENTRY_TYPE] != 0 ) ||
( cache_ptr->pins[VARIABLE_ENTRY_TYPE] != 2 ) ||
( cache_ptr->unpins[VARIABLE_ENTRY_TYPE] != 2 ) ||
( cache_ptr->dirty_pins[VARIABLE_ENTRY_TYPE] != 0 ) ||
( cache_ptr->pinned_flushes[VARIABLE_ENTRY_TYPE] != 0 ) ||
( cache_ptr->pinned_clears[VARIABLE_ENTRY_TYPE] != 0 ) ||
( cache_ptr->size_increases[VARIABLE_ENTRY_TYPE] != 3 ) ||
( cache_ptr->size_decreases[VARIABLE_ENTRY_TYPE] != 4 ) ||
( cache_ptr->entry_flush_size_changes[VARIABLE_ENTRY_TYPE] != 1 ) ||
( cache_ptr->cache_flush_size_changes[VARIABLE_ENTRY_TYPE] != 0 ) ) {
pass = FALSE;
failure_mssg = "Unexpected variable size entry stats.";
}
}
if ( pass ) {
if ( ( cache_ptr->insertions[LARGE_ENTRY_TYPE] != 0 ) ||
( cache_ptr->pinned_insertions[LARGE_ENTRY_TYPE] != 0 ) ||
( cache_ptr->clears[LARGE_ENTRY_TYPE] != 0 ) ||
( cache_ptr->flushes[LARGE_ENTRY_TYPE] != 38 ) ||
( cache_ptr->evictions[LARGE_ENTRY_TYPE] != 14 ) ||
( cache_ptr->renames[LARGE_ENTRY_TYPE] != 0 ) ||
( cache_ptr->entry_flush_renames[LARGE_ENTRY_TYPE] != 0 ) ||
( cache_ptr->cache_flush_renames[LARGE_ENTRY_TYPE] != 0 ) ||
( cache_ptr->pins[LARGE_ENTRY_TYPE] != 0 ) ||
( cache_ptr->unpins[LARGE_ENTRY_TYPE] != 0 ) ||
( cache_ptr->dirty_pins[LARGE_ENTRY_TYPE] != 0 ) ||
( cache_ptr->pinned_flushes[LARGE_ENTRY_TYPE] != 0 ) ||
( cache_ptr->pinned_clears[LARGE_ENTRY_TYPE] != 0 ) ||
( cache_ptr->size_increases[LARGE_ENTRY_TYPE] != 0 ) ||
( cache_ptr->size_decreases[LARGE_ENTRY_TYPE] != 0 ) ||
( cache_ptr->entry_flush_size_changes[LARGE_ENTRY_TYPE] != 0 ) ||
( cache_ptr->cache_flush_size_changes[LARGE_ENTRY_TYPE] != 0 ) ) {
pass = FALSE;
failure_mssg = "Unexpected monster entry stats.";
}
}
if ( pass ) {
if ( ( cache_ptr->insertions[MONSTER_ENTRY_TYPE] != 0 ) ||
( cache_ptr->pinned_insertions[MONSTER_ENTRY_TYPE] != 0 ) ||
( cache_ptr->clears[MONSTER_ENTRY_TYPE] != 0 ) ||
( cache_ptr->flushes[MONSTER_ENTRY_TYPE] != 93 ) ||
( cache_ptr->evictions[MONSTER_ENTRY_TYPE] != 31 ) ||
( cache_ptr->renames[MONSTER_ENTRY_TYPE] != 0 ) ||
( cache_ptr->entry_flush_renames[MONSTER_ENTRY_TYPE] != 0 ) ||
( cache_ptr->cache_flush_renames[MONSTER_ENTRY_TYPE] != 0 ) ||
( cache_ptr->pins[MONSTER_ENTRY_TYPE] != 0 ) ||
( cache_ptr->unpins[MONSTER_ENTRY_TYPE] != 0 ) ||
( cache_ptr->dirty_pins[MONSTER_ENTRY_TYPE] != 0 ) ||
( cache_ptr->pinned_flushes[MONSTER_ENTRY_TYPE] != 0 ) ||
( cache_ptr->pinned_clears[MONSTER_ENTRY_TYPE] != 0 ) ||
( cache_ptr->size_increases[MONSTER_ENTRY_TYPE] != 0 ) ||
( cache_ptr->size_decreases[MONSTER_ENTRY_TYPE] != 0 ) ||
( cache_ptr->entry_flush_size_changes[MONSTER_ENTRY_TYPE] != 0 ) ||
( cache_ptr->cache_flush_size_changes[MONSTER_ENTRY_TYPE] != 0 ) ) {
pass = FALSE;
failure_mssg = "Unexpected monster entry stats.";
}
}
#endif /* H5C_COLLECT_CACHE_STATS */
if ( pass ) {
reset_entries();
}
return;
} /* check_flush_cache__flush_op_eviction_test() */
/*-------------------------------------------------------------------------
* Function: check_flush_cache__single_entry()
*
* Purpose: Verify that flush_cache behaves as expected when the cache
* contains only one element.
*
* Return: void
*
* Programmer: John Mainzer
* 1/12/05
*
* Modifications:
*
* JRM -- 3/29/06
* Added tests for pinned entries.
*
* JRM -- 5/17/06
* Complete reqrite of pinned entry tests to accomodate
* the new H5C_mark_pinned_or_protected_entry_dirty()
* call.
*
*-------------------------------------------------------------------------
*/
static void
check_flush_cache__single_entry(H5C_t * cache_ptr)
{
/* const char * fcn_name = "check_flush_cache__single_entry"; */
if ( cache_ptr == NULL ) {
pass = FALSE;
failure_mssg = "cache_ptr NULL on entry to single entry case.";
}
else if ( ( cache_ptr->index_len != 0 ) ||
( cache_ptr->index_size != 0 ) ) {
pass = FALSE;
failure_mssg = "cache not empty at beginning of single entry case.";
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 1,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ FALSE,
/* dirty_flag */ FALSE,
/* flags */ H5C__NO_FLAGS_SET,
/* flush_flags */ H5C__NO_FLAGS_SET,
/* expected_loaded */ TRUE,
/* expected_cleared */ FALSE,
/* expected_flushed */ FALSE,
/* expected_destroyed */ FALSE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 2,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ FALSE,
/* dirty_flag */ TRUE,
/* flags */ H5C__NO_FLAGS_SET,
/* flush_flags */ H5C__NO_FLAGS_SET,
/* expected_loaded */ TRUE,
/* expected_cleared */ FALSE,
/* expected_flushed */ TRUE,
/* expected_destroyed */ FALSE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 3,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ FALSE,
/* dirty_flag */ FALSE,
/* flags */ H5C__NO_FLAGS_SET,
/* flush_flags */ H5C__FLUSH_CLEAR_ONLY_FLAG,
/* expected_loaded */ TRUE,
/* expected_cleared */ FALSE,
/* expected_flushed */ FALSE,
/* expected_destroyed */ FALSE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 4,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ FALSE,
/* dirty_flag */ TRUE,
/* flags */ H5C__NO_FLAGS_SET,
/* flush_flags */ H5C__FLUSH_CLEAR_ONLY_FLAG,
/* expected_loaded */ TRUE,
/* expected_cleared */ TRUE,
/* expected_flushed */ FALSE,
/* expected_destroyed */ FALSE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 5,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ FALSE,
/* dirty_flag */ FALSE,
/* flags */ H5C__NO_FLAGS_SET,
/* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG,
/* expected_loaded */ TRUE,
/* expected_cleared */ FALSE,
/* expected_flushed */ TRUE,
/* expected_destroyed */ TRUE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 6,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ FALSE,
/* dirty_flag */ TRUE,
/* flags */ H5C__NO_FLAGS_SET,
/* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG,
/* expected_loaded */ TRUE,
/* expected_cleared */ FALSE,
/* expected_flushed */ TRUE,
/* expected_destroyed */ TRUE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 7,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ FALSE,
/* dirty_flag */ FALSE,
/* flags */ H5C__NO_FLAGS_SET,
/* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG,
/* expected_loaded */ TRUE,
/* expected_cleared */ FALSE,
/* expected_flushed */ FALSE,
/* expected_destroyed */ FALSE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 8,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ FALSE,
/* dirty_flag */ TRUE,
/* flags */ H5C__NO_FLAGS_SET,
/* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG,
/* expected_loaded */ TRUE,
/* expected_cleared */ FALSE,
/* expected_flushed */ FALSE,
/* expected_destroyed */ FALSE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 9,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ FALSE,
/* dirty_flag */ FALSE,
/* flags */ H5C__NO_FLAGS_SET,
/* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG |
H5C__FLUSH_CLEAR_ONLY_FLAG,
/* expected_loaded */ TRUE,
/* expected_cleared */ TRUE,
/* expected_flushed */ FALSE,
/* expected_destroyed */ TRUE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 10,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ FALSE,
/* dirty_flag */ TRUE,
/* flags */ H5C__NO_FLAGS_SET,
/* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG |
H5C__FLUSH_CLEAR_ONLY_FLAG,
/* expected_loaded */ TRUE,
/* expected_cleared */ TRUE,
/* expected_flushed */ FALSE,
/* expected_destroyed */ TRUE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 11,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ FALSE,
/* dirty_flag */ FALSE,
/* flags */ H5C__NO_FLAGS_SET,
/* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG |
H5C__FLUSH_CLEAR_ONLY_FLAG,
/* expected_loaded */ TRUE,
/* expected_cleared */ FALSE,
/* expected_flushed */ FALSE,
/* expected_destroyed */ FALSE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 12,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ FALSE,
/* dirty_flag */ TRUE,
/* flags */ H5C__NO_FLAGS_SET,
/* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG |
H5C__FLUSH_CLEAR_ONLY_FLAG,
/* expected_loaded */ TRUE,
/* expected_cleared */ FALSE,
/* expected_flushed */ FALSE,
/* expected_destroyed */ FALSE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 13,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ FALSE,
/* dirty_flag */ FALSE,
/* flags */ H5C__NO_FLAGS_SET,
/* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG |
H5C__FLUSH_INVALIDATE_FLAG,
/* expected_loaded */ TRUE,
/* expected_cleared */ FALSE,
/* expected_flushed */ TRUE,
/* expected_destroyed */ TRUE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 14,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ FALSE,
/* dirty_flag */ TRUE,
/* flags */ H5C__NO_FLAGS_SET,
/* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG |
H5C__FLUSH_INVALIDATE_FLAG,
/* expected_loaded */ TRUE,
/* expected_cleared */ FALSE,
/* expected_flushed */ TRUE,
/* expected_destroyed */ TRUE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 15,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ FALSE,
/* dirty_flag */ FALSE,
/* flags */ H5C__NO_FLAGS_SET,
/* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG |
H5C__FLUSH_CLEAR_ONLY_FLAG |
H5C__FLUSH_MARKED_ENTRIES_FLAG,
/* expected_loaded */ TRUE,
/* expected_cleared */ TRUE,
/* expected_flushed */ FALSE,
/* expected_destroyed */ TRUE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 16,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ FALSE,
/* dirty_flag */ TRUE,
/* flags */ H5C__NO_FLAGS_SET,
/* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG |
H5C__FLUSH_CLEAR_ONLY_FLAG |
H5C__FLUSH_MARKED_ENTRIES_FLAG,
/* expected_loaded */ TRUE,
/* expected_cleared */ TRUE,
/* expected_flushed */ FALSE,
/* expected_destroyed */ TRUE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 17,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ FALSE,
/* dirty_flag */ FALSE,
/* flags */ H5C__SET_FLUSH_MARKER_FLAG,
/* flush_flags */ H5C__NO_FLAGS_SET,
/* expected_loaded */ TRUE,
/* expected_cleared */ FALSE,
/* expected_flushed */ FALSE,
/* expected_destroyed */ FALSE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 18,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ FALSE,
/* dirty_flag */ TRUE,
/* flags */ H5C__SET_FLUSH_MARKER_FLAG,
/* flush_flags */ H5C__NO_FLAGS_SET,
/* expected_loaded */ TRUE,
/* expected_cleared */ FALSE,
/* expected_flushed */ TRUE,
/* expected_destroyed */ FALSE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 19,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ FALSE,
/* dirty_flag */ FALSE,
/* flags */ H5C__SET_FLUSH_MARKER_FLAG,
/* flush_flags */ H5C__FLUSH_CLEAR_ONLY_FLAG,
/* expected_loaded */ TRUE,
/* expected_cleared */ FALSE,
/* expected_flushed */ FALSE,
/* expected_destroyed */ FALSE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 20,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ FALSE,
/* dirty_flag */ TRUE,
/* flags */ H5C__SET_FLUSH_MARKER_FLAG,
/* flush_flags */ H5C__FLUSH_CLEAR_ONLY_FLAG,
/* expected_loaded */ TRUE,
/* expected_cleared */ TRUE,
/* expected_flushed */ FALSE,
/* expected_destroyed */ FALSE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 21,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ FALSE,
/* dirty_flag */ FALSE,
/* flags */ H5C__SET_FLUSH_MARKER_FLAG,
/* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG,
/* expected_loaded */ TRUE,
/* expected_cleared */ FALSE,
/* expected_flushed */ TRUE,
/* expected_destroyed */ TRUE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 22,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ FALSE,
/* dirty_flag */ TRUE,
/* flags */ H5C__SET_FLUSH_MARKER_FLAG,
/* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG,
/* expected_loaded */ TRUE,
/* expected_cleared */ FALSE,
/* expected_flushed */ TRUE,
/* expected_destroyed */ TRUE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 23,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ FALSE,
/* dirty_flag */ FALSE,
/* flags */ H5C__SET_FLUSH_MARKER_FLAG,
/* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG,
/* expected_loaded */ TRUE,
/* expected_cleared */ FALSE,
/* expected_flushed */ FALSE,
/* expected_destroyed */ FALSE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 24,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ FALSE,
/* dirty_flag */ TRUE,
/* flags */ H5C__SET_FLUSH_MARKER_FLAG,
/* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG,
/* expected_loaded */ TRUE,
/* expected_cleared */ FALSE,
/* expected_flushed */ TRUE,
/* expected_destroyed */ FALSE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 25,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ FALSE,
/* dirty_flag */ FALSE,
/* flags */ H5C__SET_FLUSH_MARKER_FLAG,
/* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG |
H5C__FLUSH_CLEAR_ONLY_FLAG,
/* expected_loaded */ TRUE,
/* expected_cleared */ TRUE,
/* expected_flushed */ FALSE,
/* expected_destroyed */ TRUE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 26,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ FALSE,
/* dirty_flag */ TRUE,
/* flags */ H5C__SET_FLUSH_MARKER_FLAG,
/* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG |
H5C__FLUSH_CLEAR_ONLY_FLAG,
/* expected_loaded */ TRUE,
/* expected_cleared */ TRUE,
/* expected_flushed */ FALSE,
/* expected_destroyed */ TRUE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 27,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ FALSE,
/* dirty_flag */ FALSE,
/* flags */ H5C__SET_FLUSH_MARKER_FLAG,
/* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG |
H5C__FLUSH_CLEAR_ONLY_FLAG,
/* expected_loaded */ TRUE,
/* expected_cleared */ FALSE,
/* expected_flushed */ FALSE,
/* expected_destroyed */ FALSE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 28,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ FALSE,
/* dirty_flag */ TRUE,
/* flags */ H5C__SET_FLUSH_MARKER_FLAG,
/* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG |
H5C__FLUSH_CLEAR_ONLY_FLAG,
/* expected_loaded */ TRUE,
/* expected_cleared */ TRUE,
/* expected_flushed */ FALSE,
/* expected_destroyed */ FALSE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 29,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ FALSE,
/* dirty_flag */ FALSE,
/* flags */ H5C__SET_FLUSH_MARKER_FLAG,
/* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG |
H5C__FLUSH_INVALIDATE_FLAG,
/* expected_loaded */ TRUE,
/* expected_cleared */ FALSE,
/* expected_flushed */ TRUE,
/* expected_destroyed */ TRUE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 30,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ FALSE,
/* dirty_flag */ TRUE,
/* flags */ H5C__SET_FLUSH_MARKER_FLAG,
/* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG |
H5C__FLUSH_INVALIDATE_FLAG,
/* expected_loaded */ TRUE,
/* expected_cleared */ FALSE,
/* expected_flushed */ TRUE,
/* expected_destroyed */ TRUE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 31,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ FALSE,
/* dirty_flag */ FALSE,
/* flags */ H5C__SET_FLUSH_MARKER_FLAG,
/* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG |
H5C__FLUSH_CLEAR_ONLY_FLAG |
H5C__FLUSH_MARKED_ENTRIES_FLAG,
/* expected_loaded */ TRUE,
/* expected_cleared */ TRUE,
/* expected_flushed */ FALSE,
/* expected_destroyed */ TRUE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 32,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ FALSE,
/* dirty_flag */ TRUE,
/* flags */ H5C__SET_FLUSH_MARKER_FLAG,
/* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG |
H5C__FLUSH_CLEAR_ONLY_FLAG |
H5C__FLUSH_MARKED_ENTRIES_FLAG,
/* expected_loaded */ TRUE,
/* expected_cleared */ TRUE,
/* expected_flushed */ FALSE,
/* expected_destroyed */ TRUE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 33,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ TRUE,
/* dirty_flag */ FALSE,
/* flags */ H5C__NO_FLAGS_SET,
/* flush_flags */ H5C__NO_FLAGS_SET,
/* expected_loaded */ FALSE,
/* expected_cleared */ FALSE,
/* expected_flushed */ TRUE,
/* expected_destroyed */ FALSE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 34,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ TRUE,
/* dirty_flag */ TRUE,
/* flags */ H5C__NO_FLAGS_SET,
/* flush_flags */ H5C__NO_FLAGS_SET,
/* expected_loaded */ FALSE,
/* expected_cleared */ FALSE,
/* expected_flushed */ TRUE,
/* expected_destroyed */ FALSE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 35,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ TRUE,
/* dirty_flag */ FALSE,
/* flags */ H5C__NO_FLAGS_SET,
/* flush_flags */ H5C__FLUSH_CLEAR_ONLY_FLAG,
/* expected_loaded */ FALSE,
/* expected_cleared */ TRUE,
/* expected_flushed */ FALSE,
/* expected_destroyed */ FALSE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 36,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ TRUE,
/* dirty_flag */ TRUE,
/* flags */ H5C__NO_FLAGS_SET,
/* flush_flags */ H5C__FLUSH_CLEAR_ONLY_FLAG,
/* expected_loaded */ FALSE,
/* expected_cleared */ TRUE,
/* expected_flushed */ FALSE,
/* expected_destroyed */ FALSE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 37,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ TRUE,
/* dirty_flag */ FALSE,
/* flags */ H5C__NO_FLAGS_SET,
/* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG,
/* expected_loaded */ FALSE,
/* expected_cleared */ FALSE,
/* expected_flushed */ TRUE,
/* expected_destroyed */ TRUE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 38,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ TRUE,
/* dirty_flag */ TRUE,
/* flags */ H5C__NO_FLAGS_SET,
/* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG,
/* expected_loaded */ FALSE,
/* expected_cleared */ FALSE,
/* expected_flushed */ TRUE,
/* expected_destroyed */ TRUE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 39,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ TRUE,
/* dirty_flag */ FALSE,
/* flags */ H5C__NO_FLAGS_SET,
/* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG,
/* expected_loaded */ FALSE,
/* expected_cleared */ FALSE,
/* expected_flushed */ FALSE,
/* expected_destroyed */ FALSE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 40,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ TRUE,
/* dirty_flag */ TRUE,
/* flags */ H5C__NO_FLAGS_SET,
/* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG,
/* expected_loaded */ FALSE,
/* expected_cleared */ FALSE,
/* expected_flushed */ FALSE,
/* expected_destroyed */ FALSE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 41,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ TRUE,
/* dirty_flag */ FALSE,
/* flags */ H5C__NO_FLAGS_SET,
/* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG |
H5C__FLUSH_CLEAR_ONLY_FLAG,
/* expected_loaded */ FALSE,
/* expected_cleared */ TRUE,
/* expected_flushed */ FALSE,
/* expected_destroyed */ TRUE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 42,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ TRUE,
/* dirty_flag */ TRUE,
/* flags */ H5C__NO_FLAGS_SET,
/* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG |
H5C__FLUSH_CLEAR_ONLY_FLAG,
/* expected_loaded */ FALSE,
/* expected_cleared */ TRUE,
/* expected_flushed */ FALSE,
/* expected_destroyed */ TRUE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 43,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ TRUE,
/* dirty_flag */ FALSE,
/* flags */ H5C__NO_FLAGS_SET,
/* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG |
H5C__FLUSH_CLEAR_ONLY_FLAG,
/* expected_loaded */ FALSE,
/* expected_cleared */ FALSE,
/* expected_flushed */ FALSE,
/* expected_destroyed */ FALSE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 44,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ TRUE,
/* dirty_flag */ TRUE,
/* flags */ H5C__NO_FLAGS_SET,
/* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG |
H5C__FLUSH_CLEAR_ONLY_FLAG,
/* expected_loaded */ FALSE,
/* expected_cleared */ FALSE,
/* expected_flushed */ FALSE,
/* expected_destroyed */ FALSE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 45,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ TRUE,
/* dirty_flag */ FALSE,
/* flags */ H5C__NO_FLAGS_SET,
/* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG |
H5C__FLUSH_INVALIDATE_FLAG,
/* expected_loaded */ FALSE,
/* expected_cleared */ FALSE,
/* expected_flushed */ TRUE,
/* expected_destroyed */ TRUE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 46,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ TRUE,
/* dirty_flag */ TRUE,
/* flags */ H5C__NO_FLAGS_SET,
/* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG |
H5C__FLUSH_INVALIDATE_FLAG,
/* expected_loaded */ FALSE,
/* expected_cleared */ FALSE,
/* expected_flushed */ TRUE,
/* expected_destroyed */ TRUE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 47,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ TRUE,
/* dirty_flag */ FALSE,
/* flags */ H5C__NO_FLAGS_SET,
/* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG |
H5C__FLUSH_CLEAR_ONLY_FLAG |
H5C__FLUSH_MARKED_ENTRIES_FLAG,
/* expected_loaded */ FALSE,
/* expected_cleared */ TRUE,
/* expected_flushed */ FALSE,
/* expected_destroyed */ TRUE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 48,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ TRUE,
/* dirty_flag */ TRUE,
/* flags */ H5C__NO_FLAGS_SET,
/* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG |
H5C__FLUSH_CLEAR_ONLY_FLAG |
H5C__FLUSH_MARKED_ENTRIES_FLAG,
/* expected_loaded */ FALSE,
/* expected_cleared */ TRUE,
/* expected_flushed */ FALSE,
/* expected_destroyed */ TRUE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 49,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ TRUE,
/* dirty_flag */ FALSE,
/* flags */ H5C__SET_FLUSH_MARKER_FLAG,
/* flush_flags */ H5C__NO_FLAGS_SET,
/* expected_loaded */ FALSE,
/* expected_cleared */ FALSE,
/* expected_flushed */ TRUE,
/* expected_destroyed */ FALSE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 50,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ TRUE,
/* dirty_flag */ TRUE,
/* flags */ H5C__SET_FLUSH_MARKER_FLAG,
/* flush_flags */ H5C__NO_FLAGS_SET,
/* expected_loaded */ FALSE,
/* expected_cleared */ FALSE,
/* expected_flushed */ TRUE,
/* expected_destroyed */ FALSE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 51,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ TRUE,
/* dirty_flag */ FALSE,
/* flags */ H5C__SET_FLUSH_MARKER_FLAG,
/* flush_flags */ H5C__FLUSH_CLEAR_ONLY_FLAG,
/* expected_loaded */ FALSE,
/* expected_cleared */ TRUE,
/* expected_flushed */ FALSE,
/* expected_destroyed */ FALSE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 52,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ TRUE,
/* dirty_flag */ TRUE,
/* flags */ H5C__SET_FLUSH_MARKER_FLAG,
/* flush_flags */ H5C__FLUSH_CLEAR_ONLY_FLAG,
/* expected_loaded */ FALSE,
/* expected_cleared */ TRUE,
/* expected_flushed */ FALSE,
/* expected_destroyed */ FALSE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 53,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ TRUE,
/* dirty_flag */ FALSE,
/* flags */ H5C__SET_FLUSH_MARKER_FLAG,
/* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG,
/* expected_loaded */ FALSE,
/* expected_cleared */ FALSE,
/* expected_flushed */ TRUE,
/* expected_destroyed */ TRUE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 54,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ TRUE,
/* dirty_flag */ TRUE,
/* flags */ H5C__SET_FLUSH_MARKER_FLAG,
/* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG,
/* expected_loaded */ FALSE,
/* expected_cleared */ FALSE,
/* expected_flushed */ TRUE,
/* expected_destroyed */ TRUE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 55,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ TRUE,
/* dirty_flag */ FALSE,
/* flags */ H5C__SET_FLUSH_MARKER_FLAG,
/* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG,
/* expected_loaded */ FALSE,
/* expected_cleared */ FALSE,
/* expected_flushed */ TRUE,
/* expected_destroyed */ FALSE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 56,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ TRUE,
/* dirty_flag */ TRUE,
/* flags */ H5C__SET_FLUSH_MARKER_FLAG,
/* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG,
/* expected_loaded */ FALSE,
/* expected_cleared */ FALSE,
/* expected_flushed */ TRUE,
/* expected_destroyed */ FALSE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 57,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ TRUE,
/* dirty_flag */ FALSE,
/* flags */ H5C__SET_FLUSH_MARKER_FLAG,
/* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG |
H5C__FLUSH_CLEAR_ONLY_FLAG,
/* expected_loaded */ FALSE,
/* expected_cleared */ TRUE,
/* expected_flushed */ FALSE,
/* expected_destroyed */ TRUE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 58,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ TRUE,
/* dirty_flag */ TRUE,
/* flags */ H5C__SET_FLUSH_MARKER_FLAG,
/* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG |
H5C__FLUSH_CLEAR_ONLY_FLAG,
/* expected_loaded */ FALSE,
/* expected_cleared */ TRUE,
/* expected_flushed */ FALSE,
/* expected_destroyed */ TRUE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 59,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ TRUE,
/* dirty_flag */ FALSE,
/* flags */ H5C__SET_FLUSH_MARKER_FLAG,
/* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG |
H5C__FLUSH_CLEAR_ONLY_FLAG,
/* expected_loaded */ FALSE,
/* expected_cleared */ TRUE,
/* expected_flushed */ FALSE,
/* expected_destroyed */ FALSE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 60,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ TRUE,
/* dirty_flag */ TRUE,
/* flags */ H5C__SET_FLUSH_MARKER_FLAG,
/* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG |
H5C__FLUSH_CLEAR_ONLY_FLAG,
/* expected_loaded */ FALSE,
/* expected_cleared */ TRUE,
/* expected_flushed */ FALSE,
/* expected_destroyed */ FALSE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 61,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ TRUE,
/* dirty_flag */ FALSE,
/* flags */ H5C__SET_FLUSH_MARKER_FLAG,
/* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG |
H5C__FLUSH_INVALIDATE_FLAG,
/* expected_loaded */ FALSE,
/* expected_cleared */ FALSE,
/* expected_flushed */ TRUE,
/* expected_destroyed */ TRUE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 62,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ TRUE,
/* dirty_flag */ TRUE,
/* flags */ H5C__SET_FLUSH_MARKER_FLAG,
/* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG |
H5C__FLUSH_INVALIDATE_FLAG,
/* expected_loaded */ FALSE,
/* expected_cleared */ FALSE,
/* expected_flushed */ TRUE,
/* expected_destroyed */ TRUE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 63,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ TRUE,
/* dirty_flag */ FALSE,
/* flags */ H5C__SET_FLUSH_MARKER_FLAG,
/* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG |
H5C__FLUSH_CLEAR_ONLY_FLAG |
H5C__FLUSH_MARKED_ENTRIES_FLAG,
/* expected_loaded */ FALSE,
/* expected_cleared */ TRUE,
/* expected_flushed */ FALSE,
/* expected_destroyed */ TRUE
);
}
if ( pass ) {
check_flush_cache__single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ 64,
/* entry_type */ PICO_ENTRY_TYPE,
/* entry_idx */ 0,
/* insert_flag */ TRUE,
/* dirty_flag */ TRUE,
/* flags */ H5C__SET_FLUSH_MARKER_FLAG,
/* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG |
H5C__FLUSH_CLEAR_ONLY_FLAG |
H5C__FLUSH_MARKED_ENTRIES_FLAG,
/* expected_loaded */ FALSE,
/* expected_cleared */ TRUE,
/* expected_flushed */ FALSE,
/* expected_destroyed */ TRUE
);
}
/* Now run single entry tests for pinned entries. Test all combinations
* of:
*
* 1) Unpin by unprotect vs. unpin by call to H5C_unpin_entry().
*
* 2) Marked dirty by unprotect or not.
*
* 3) Marked dirty by call to H5C_mark_pinned_entry_dirty() or not.
*
* 4) Marked dirty by call to H5C_mark_pinned_or_protected_entry_dirty()
* while protected or not.
*
* 5) Marked dirty by call to H5C_mark_pinned_or_protected_entry_dirty()
* while pinned or not.
*
* 6) Entry marked for flush or not.
*
* 7) Call flush with H5C__FLUSH_MARKED_ENTRIES_FLAG or not.
*
* 8) Call flush with H5C__FLUSH_CLEAR_ONLY_FLAG or not.
*
* This yields a total of 256 tests.
*
* The tests and their expected results are given in the spec table
* below. The values assigned to the expected_cleared, expected_flushed,
* and expected_destroyed fields are somewhat arcane, so the following
* overview may be useful.
*
* In addition to simply checking to see if the test case runs,
* we also check to see if the desired operations take place on the
* cache entry. Thus expected_cleared is set to TRUE if we expect
* the entry to be flushed, expected_flushed is set to TRUE if we
* we expect the entry to be flushed, and expected_destroyed is set
* to TRUE if we expect the entry to be destroyed.
*
* In this test, we are working with pinned entries which can't be
* evicted, so expected_destroyed is always FALSE. We could pull it
* from the table, but it is a hold over from the code this test
* was adapted from, and it doesn't do any particular harm.
*
* In general, we expect an entry to be flushed if it is dirty, and
* flush in invoked WITHOUT the H5C__FLUSH_CLEAR_ONLY_FLAG. However,
* there are exceptions: If flush is invoked with the
* H5C__FLUSH_MARKED_ENTRIES_FLAG, only marked entries will be flushed.
*
* Further, unprotecting an entry with the H5C__SET_FLUSH_MARKER_FLAG
* will NOT mark the entry unless the entry has either been marked
* dirty either before or durting the unprotect call. This results in
* some counterintuitive entries in the table. It make be useful to
* look in the test code to see the exact order of operations.
*
* Similarly, we expect an entry to be cleared if it is dirty, and
* flush is invoked WITH the H5C__FLUSH_CLEAR_ONLY_FLAG. Again, there
* are exceptions -- If flush is also invoked with the
* H5C__FLUSH_MARKED_ENTRIES_FLAG, only the marked entries will be
* cleared.
*
* The above comments about applying unprotect with the
* H5C__SET_FLUSH_MARKER_FLAG apply here as well.
*/
if ( pass ) {
int i;
struct pinned_single_entry_test_spec
{
int test_num;
int entry_type;
int entry_idx;
hbool_t dirty_flag;
hbool_t mark_dirty;
hbool_t pop_mark_dirty_prot;
hbool_t pop_mark_dirty_pinned;
hbool_t unprotect_unpin;
unsigned int flags;
unsigned int flush_flags;
hbool_t expected_cleared;
hbool_t expected_flushed;
hbool_t expected_destroyed;
} spec[256] =
/* pop pop
* ent mark mark
* test entry -ry dirty mark dirty dirty unprot flush expect expect expect
* num type idx flag dirty prot pinned unpin flags flags clear flush destroy
*/
{ { 1, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, FALSE, FALSE, FALSE },
{ 2, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, FALSE, FALSE, FALSE },
{ 3, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 4, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 5, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 6, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 7, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 8, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 9, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 10, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 11, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 12, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 13, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 14, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 15, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 16, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 17, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 18, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 19, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 20, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 21, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 22, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 23, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 24, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 25, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 26, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 27, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 28, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 29, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 30, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 31, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 32, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 33, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, FALSE, FALSE },
{ 34, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, FALSE, FALSE },
{ 35, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 36, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 37, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 38, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 39, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 40, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 41, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 42, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 43, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 44, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 45, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 46, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 47, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 48, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 49, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 50, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 51, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 52, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 53, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 54, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 55, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 56, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 57, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 58, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 59, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 60, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 61, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 62, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 63, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 64, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
{ 65, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
{ 66, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
{ 67, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
{ 68, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
{ 69, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
{ 70, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
{ 71, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
{ 72, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
{ 73, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
{ 74, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
{ 75, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
{ 76, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
{ 77, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
{ 78, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
{ 79, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
{ 80, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
{ 81, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
{ 82, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
{ 83, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
{ 84, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
{ 85, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
{ 86, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
{ 87, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
{ 88, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
{ 89, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
{ 90, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
{ 91, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
{ 92, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
{ 93, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
{ 94, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
{ 95, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
{ 96, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
{ 97, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
{ 98, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
{ 99, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
{ 100, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
{ 101, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, TRUE, FALSE },
{ 102, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, TRUE, FALSE },
{ 103, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, TRUE, FALSE },
{ 104, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, TRUE, FALSE },
{ 105, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
{ 106, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
{ 107, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
{ 108, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
{ 109, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, TRUE, FALSE },
{ 110, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, TRUE, FALSE },
{ 111, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, TRUE, FALSE },
{ 112, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, TRUE, FALSE },
{ 113, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, TRUE, FALSE },
{ 114, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, TRUE, FALSE },
{ 115, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, TRUE, FALSE },
{ 116, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, TRUE, FALSE },
{ 117, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, TRUE, FALSE },
{ 118, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, TRUE, FALSE },
{ 119, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, TRUE, FALSE },
{ 120, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, TRUE, FALSE },
{ 121, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, TRUE, FALSE },
{ 122, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, TRUE, FALSE },
{ 123, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, TRUE, FALSE },
{ 124, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, TRUE, FALSE },
{ 125, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, TRUE, FALSE },
{ 126, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, TRUE, FALSE },
{ 127, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, TRUE, FALSE },
{ 128, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, TRUE, FALSE },
{ 129, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
{ 130, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
{ 131, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 132, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 133, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 134, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 135, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 136, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 137, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 138, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 139, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 140, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 141, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 142, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 143, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 144, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 145, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 146, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 147, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 148, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 149, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 150, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 151, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 152, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 153, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 154, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 155, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 156, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 157, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 158, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 159, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 160, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 161, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
{ 162, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
{ 163, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 164, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 165, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 166, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 167, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 168, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 169, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 170, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 171, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 172, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 173, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 174, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 175, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 176, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 177, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 178, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 179, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 180, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 181, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 182, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 183, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 184, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 185, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 186, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 187, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 188, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 189, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 190, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 191, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 192, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 193, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
{ 194, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
{ 195, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
{ 196, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
{ 197, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
{ 198, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
{ 199, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
{ 200, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
{ 201, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
{ 202, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
{ 203, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
{ 204, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
{ 205, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
{ 206, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
{ 207, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
{ 208, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
{ 209, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
{ 210, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
{ 211, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
{ 212, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
{ 213, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
{ 214, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
{ 215, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
{ 216, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
{ 217, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
{ 218, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
{ 219, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
{ 220, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
{ 221, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
{ 222, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
{ 223, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
{ 224, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
{ 225, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
{ 226, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
{ 227, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
{ 228, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
{ 229, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 230, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 231, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 232, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 233, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
{ 234, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
{ 235, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
{ 236, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
{ 237, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 238, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 239, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 240, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 241, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 242, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 243, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 244, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 245, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 246, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 247, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 248, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 249, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 250, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 251, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 252, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 253, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 254, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 255, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
{ 256, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE } };
i = 0;
while ( ( pass ) && ( i < 256 ) )
{
check_flush_cache__pinned_single_entry_test
(
/* cache_ptr */ cache_ptr,
/* test_num */ spec[i].test_num,
/* entry_type */ spec[i].entry_type,
/* entry_idx */ spec[i].entry_idx,
/* dirty_flag */ spec[i].dirty_flag,
/* mark_dirty */ spec[i].mark_dirty,
/* pop_mark_dirty_prot */ spec[i].pop_mark_dirty_prot,
/* pop_mark_dirty_pinned */ spec[i].pop_mark_dirty_pinned,
/* unprotect_unpin */ spec[i].unprotect_unpin,
/* flags */ spec[i].flags,
/* flush_flags */ spec[i].flush_flags,
/* expected_cleared */ spec[i].expected_cleared,
/* expected_flushed */ spec[i].expected_flushed,
/* expected_destroyed */ spec[i].expected_destroyed
);
i++;
}
}
return;
} /* check_flush_cache__single_entry() */
/*-------------------------------------------------------------------------
* Function: check_flush_cache__single_entry_test()
*
* Purpose: Run a single entry flush cache test.
*
* Return: void
*
* Programmer: John Mainzer
* 1/12/05
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static void
check_flush_cache__single_entry_test(H5C_t * cache_ptr,
int test_num,
int entry_type,
int entry_idx,
hbool_t insert_flag,
hbool_t dirty_flag,
unsigned int flags,
unsigned int flush_flags,
hbool_t expected_loaded,
hbool_t expected_cleared,
hbool_t expected_flushed,
hbool_t expected_destroyed)
{
/* const char * fcn_name = "check_flush_cache__single_entry_test"; */
static char msg[128];
herr_t result;
test_entry_t * base_addr;
test_entry_t * entry_ptr;
if ( cache_ptr == NULL ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"cache_ptr NULL on entry to single entry test #%d.",
test_num);
failure_mssg = msg;
}
else if ( ( cache_ptr->index_len != 0 ) ||
( cache_ptr->index_size != 0 ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"cache not empty at beginning of single entry test #%d.",
test_num);
failure_mssg = msg;
}
else if ( ( entry_type < 0 ) || ( entry_type >= NUMBER_OF_ENTRY_TYPES ) ||
( entry_idx < 0 ) || ( entry_idx > max_indices[entry_type] ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"Bad parameters on entry to single entry test #%d.",
test_num);
failure_mssg = msg;
}
if ( pass ) {
base_addr = entries[entry_type];
entry_ptr = &(base_addr[entry_idx]);
if ( insert_flag ) {
insert_entry(cache_ptr, entry_type, entry_idx, dirty_flag, flags);
} else {
protect_entry(cache_ptr, entry_type, entry_idx);
unprotect_entry(cache_ptr, entry_type, entry_idx,
(int)dirty_flag, flags);
}
}
if ( pass ) {
result = H5C_flush_cache(NULL, -1, -1, cache_ptr, flush_flags);
if ( result < 0 ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"flush with flags 0x%x failed in single entry test #%d.",
flush_flags, test_num);
failure_mssg = msg;
}
else if ( ( entry_ptr->loaded != expected_loaded ) ||
( entry_ptr->cleared != expected_cleared ) ||
( entry_ptr->flushed != expected_flushed ) ||
( entry_ptr->destroyed != expected_destroyed ) ) {
#if 0 /* This is useful debugging code -- lets keep it for a while */
HDfprintf(stdout,
"loaded = %d(%d), clrd = %d(%d), flshd = %d(%d), dest = %d(%d)\n",
(int)(entry_ptr->loaded),
(int)expected_loaded,
(int)(entry_ptr->cleared),
(int)expected_cleared,
(int)(entry_ptr->flushed),
(int)expected_flushed,
(int)(entry_ptr->destroyed),
(int)expected_destroyed);
#endif
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"Unexpected entry status after flush in single entry test #%d.",
test_num);
failure_mssg = msg;
}
else if ( ( ( (flush_flags & H5C__FLUSH_INVALIDATE_FLAG) == 0 )
&&
( ( cache_ptr->index_len != 1 )
||
( cache_ptr->index_size != entry_sizes[entry_type] )
)
)
||
( ( (flush_flags & H5C__FLUSH_INVALIDATE_FLAG) != 0 )
&&
( ( cache_ptr->index_len != 0 )
||
( cache_ptr->index_size != 0 )
)
)
) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"Unexpected cache len/size after flush in single entry test #%d.",
test_num);
failure_mssg = msg;
}
}
/* clean up the cache to prep for the next test */
if ( pass ) {
result = H5C_flush_cache(NULL, -1, -1, cache_ptr,
H5C__FLUSH_INVALIDATE_FLAG);
if ( result < 0 ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"Flush failed on cleanup in single entry test #%d.",
test_num);
failure_mssg = msg;
}
else if ( ( cache_ptr->index_len != 0 ) ||
( cache_ptr->index_size != 0 ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"Unexpected cache len/size after cleanup in single entry test #%d.",
test_num);
failure_mssg = msg;
} else {
entry_ptr->loaded = FALSE;
entry_ptr->cleared = FALSE;
entry_ptr->flushed = FALSE;
entry_ptr->destroyed = FALSE;
}
}
return;
} /* check_flush_cache__single_entry_test() */
/*-------------------------------------------------------------------------
* Function: check_flush_cache__pinned_single_entry_test()
*
* Purpose: Run a pinned single entry flush cache test.
*
* Return: void
*
* Programmer: John Mainzer
* 3/28/06
*
* Modifications:
*
* JRM -- 5/17/06
* Added the pop_mark_dirty_prot and pop_mark_dirty_pinned
* flags and supporting code to allow us to test the
* H5C_mark_pinned_or_protected_entry_dirty() call. Use the
* call to mark the entry dirty while the entry is protected
* if pop_mark_dirty_prot is TRUE, and to mark the entry
* dirty while it is pinned if pop_mark_dirty_pinned is TRUE.
*
*-------------------------------------------------------------------------
*/
static void
check_flush_cache__pinned_single_entry_test(H5C_t * cache_ptr,
int test_num,
int entry_type,
int entry_idx,
hbool_t dirty_flag,
hbool_t mark_dirty,
hbool_t pop_mark_dirty_prot,
hbool_t pop_mark_dirty_pinned,
hbool_t unprotect_unpin,
unsigned int flags,
unsigned int flush_flags,
hbool_t expected_cleared,
hbool_t expected_flushed,
hbool_t expected_destroyed)
{
/* const char *fcn_name = "check_flush_cache__pinned_single_entry_test"; */
static char msg[128];
hbool_t expected_loaded = TRUE;
herr_t result;
test_entry_t * base_addr;
test_entry_t * entry_ptr;
if ( cache_ptr == NULL ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"cache_ptr NULL on entry to pinned single entry test #%d.",
test_num);
failure_mssg = msg;
}
else if ( ( cache_ptr->index_len != 0 ) ||
( cache_ptr->index_size != 0 ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"cache not empty at beginning of pinned single entry test #%d.",
test_num);
failure_mssg = msg;
}
else if ( ( entry_type < 0 ) || ( entry_type >= NUMBER_OF_ENTRY_TYPES ) ||
( entry_idx < 0 ) || ( entry_idx > max_indices[entry_type] ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"Bad parameters on entry to pinned single entry test #%d.",
test_num);
failure_mssg = msg;
}
if ( pass ) {
base_addr = entries[entry_type];
entry_ptr = &(base_addr[entry_idx]);
protect_entry(cache_ptr, entry_type, entry_idx);
if ( pop_mark_dirty_prot ) {
mark_pinned_or_protected_entry_dirty(cache_ptr,
entry_type,
entry_idx);
}
unprotect_entry(cache_ptr, entry_type, entry_idx,
(int)dirty_flag, (flags | H5C__PIN_ENTRY_FLAG));
if ( mark_dirty ) {
mark_pinned_entry_dirty(cache_ptr, entry_type, entry_idx,
FALSE, (size_t)0);
}
if ( pop_mark_dirty_pinned ) {
mark_pinned_or_protected_entry_dirty(cache_ptr,
entry_type,
entry_idx);
}
}
if ( pass ) {
result = H5C_flush_cache(NULL, -1, -1, cache_ptr, flush_flags);
if ( result < 0 ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"flush with flags 0x%x failed in pinned single entry test #%d.",
flush_flags, test_num);
failure_mssg = msg;
}
else if ( ( entry_ptr->loaded != expected_loaded ) ||
( entry_ptr->cleared != expected_cleared ) ||
( entry_ptr->flushed != expected_flushed ) ||
( entry_ptr->destroyed != expected_destroyed ) ) {
HDfprintf(stdout,
"loaded = %d(%d), clrd = %d(%d), flshd = %d(%d), dest = %d(%d)\n",
(int)(entry_ptr->loaded),
(int)expected_loaded,
(int)(entry_ptr->cleared),
(int)expected_cleared,
(int)(entry_ptr->flushed),
(int)expected_flushed,
(int)(entry_ptr->destroyed),
(int)expected_destroyed);
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"Unexpected entry status after flush in pinned single entry test #%d.",
test_num);
failure_mssg = msg;
}
else if ( ( ( (flush_flags & H5C__FLUSH_INVALIDATE_FLAG) == 0 )
&&
( ( cache_ptr->index_len != 1 )
||
( cache_ptr->index_size != entry_sizes[entry_type] )
)
)
||
( ( (flush_flags & H5C__FLUSH_INVALIDATE_FLAG) != 0 )
&&
( ( cache_ptr->index_len != 0 )
||
( cache_ptr->index_size != 0 )
)
)
) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"Unexpected cache len/size after flush in pinned single entry test #%d.",
test_num);
failure_mssg = msg;
}
}
/* clean up the cache to prep for the next test */
if ( pass ) {
if ( unprotect_unpin ) {
protect_entry(cache_ptr, entry_type, entry_idx);
unprotect_entry(cache_ptr, entry_type, entry_idx,
(int)dirty_flag, H5C__UNPIN_ENTRY_FLAG);
} else {
unpin_entry(cache_ptr, entry_type, entry_idx);
}
}
if ( pass ) {
result = H5C_flush_cache(NULL, -1, -1, cache_ptr,
H5C__FLUSH_INVALIDATE_FLAG);
if ( result < 0 ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"Flush failed on cleanup in pinned single entry test #%d.",
test_num);
failure_mssg = msg;
}
else if ( ( cache_ptr->index_len != 0 ) ||
( cache_ptr->index_size != 0 ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"Unexpected cache len/size after cleanup in pinned single entry test #%d.",
test_num);
failure_mssg = msg;
} else {
entry_ptr->loaded = FALSE;
entry_ptr->cleared = FALSE;
entry_ptr->flushed = FALSE;
entry_ptr->destroyed = FALSE;
}
}
return;
} /* check_flush_cache__pinned_single_entry_test() */
/*-------------------------------------------------------------------------
* Function: check_get_entry_status()
*
* Purpose: Verify that H5C_get_entry_status() behaves as expected.
*
* Return: void
*
* Programmer: John Mainzer
* 4/28/06
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static void
check_get_entry_status(void)
{
const char * fcn_name = "check_get_entry_status";
static char msg[128];
herr_t result;
hbool_t in_cache;
hbool_t is_dirty;
hbool_t is_protected;
hbool_t is_pinned;
size_t entry_size;
H5C_t * cache_ptr = NULL;
test_entry_t * base_addr;
test_entry_t * entry_ptr;
TESTING("H5C_get_entry_status() functionality");
pass = TRUE;
if ( pass ) {
reset_entries();
cache_ptr = setup_cache((size_t)(2 * 1024 * 1024),
(size_t)(1 * 1024 * 1024));
base_addr = entries[0];
entry_ptr = &(base_addr[0]);
}
if ( pass ) {
/* entry not in cache -- only in_cache should be touched by
* the call. Thus, only check that boolean.
*/
result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, &entry_size,
&in_cache, &is_dirty, &is_protected, &is_pinned);
if ( result < 0 ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"H5AC_get_entry_status() reports failure 1.");
failure_mssg = msg;
} else if ( in_cache ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected status 1.");
failure_mssg = msg;
}
}
protect_entry(cache_ptr, 0, 0);
unprotect_entry(cache_ptr, 0, 0, FALSE, H5C__NO_FLAGS_SET);
if ( pass ) {
result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, &entry_size,
&in_cache, &is_dirty, &is_protected, &is_pinned);
if ( result < 0 ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"H5AC_get_entry_status() reports failure 2.");
failure_mssg = msg;
} else if ( !in_cache || is_dirty || is_protected || is_pinned ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected status 2.");
failure_mssg = msg;
}
}
protect_entry(cache_ptr, 0, 0);
if ( pass ) {
result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, &entry_size,
&in_cache, &is_dirty, &is_protected, &is_pinned);
if ( result < 0 ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"H5AC_get_entry_status() reports failure 3.");
failure_mssg = msg;
} else if ( !in_cache || is_dirty || !is_protected || is_pinned ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected status 3.");
failure_mssg = msg;
}
}
unprotect_entry(cache_ptr, 0, 0, FALSE, H5C__PIN_ENTRY_FLAG);
if ( pass ) {
result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, &entry_size,
&in_cache, &is_dirty, &is_protected, &is_pinned);
if ( result < 0 ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"H5AC_get_entry_status() reports failure 4.");
failure_mssg = msg;
} else if ( !in_cache || is_dirty || is_protected || !is_pinned ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected status 4.");
failure_mssg = msg;
}
}
mark_pinned_entry_dirty(cache_ptr, 0, 0, FALSE, (size_t)0);
if ( pass ) {
result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, &entry_size,
&in_cache, &is_dirty, &is_protected, &is_pinned);
if ( result < 0 ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"H5AC_get_entry_status() reports failure 5.");
failure_mssg = msg;
} else if ( !in_cache || !is_dirty || is_protected || !is_pinned ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected status 5.");
failure_mssg = msg;
}
}
unpin_entry(cache_ptr, 0, 0);
if ( pass ) {
result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, &entry_size,
&in_cache, &is_dirty, &is_protected, &is_pinned);
if ( result < 0 ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"H5AC_get_entry_status() reports failure 6.");
failure_mssg = msg;
} else if ( !in_cache || !is_dirty || is_protected || is_pinned ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected status 6.");
failure_mssg = msg;
}
}
if ( pass ) {
takedown_cache(cache_ptr, FALSE, FALSE);
}
if ( pass ) { PASSED(); } else { H5_FAILED(); }
if ( ! pass ) {
HDfprintf(stdout, "%s(): failure_mssg = \"%s\".\n",
fcn_name, failure_mssg);
}
return;
} /* check_get_entry_status() */
/*-------------------------------------------------------------------------
* Function: check_expunge_entry()
*
* Purpose: Verify that H5C_expunge_entry() behaves as expected.
*
* Return: void
*
* Programmer: John Mainzer
* 7/5/06
*
* Modifications:
*
* None.
*
*-------------------------------------------------------------------------
*/
static void
check_expunge_entry(void)
{
const char * fcn_name = "check_expunge_entry";
static char msg[128];
herr_t result;
hbool_t in_cache;
hbool_t is_dirty;
hbool_t is_protected;
hbool_t is_pinned;
size_t entry_size;
H5C_t * cache_ptr = NULL;
test_entry_t * base_addr;
test_entry_t * entry_ptr;
TESTING("H5C_expunge_entry() functionality");
pass = TRUE;
if ( pass ) {
reset_entries();
cache_ptr = setup_cache((size_t)(2 * 1024 * 1024),
(size_t)(1 * 1024 * 1024));
base_addr = entries[0];
entry_ptr = &(base_addr[0]);
}
if ( pass ) {
/* entry not in cache -- only in_cache should be touched by
* the status call. Thus, only check that boolean.
*/
result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, &entry_size,
&in_cache, &is_dirty, &is_protected,
&is_pinned);
if ( result < 0 ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"H5AC_get_entry_status() reports failure 1.");
failure_mssg = msg;
} else if ( in_cache ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected status 1.");
failure_mssg = msg;
} else if ( ( entry_ptr->loaded ) ||
( entry_ptr->cleared ) ||
( entry_ptr->flushed ) ||
( entry_ptr->destroyed ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected entry history 1.");
failure_mssg = msg;
}
}
/* protect an entry to force the cache to load it, and then unprotect
* it without marking it dirty.
*/
protect_entry(cache_ptr, 0, 0);
unprotect_entry(cache_ptr, 0, 0, FALSE, H5C__NO_FLAGS_SET);
if ( pass ) {
result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, &entry_size,
&in_cache, &is_dirty, &is_protected, &is_pinned);
if ( result < 0 ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"H5AC_get_entry_status() reports failure 2.");
failure_mssg = msg;
} else if ( !in_cache || is_dirty || is_protected || is_pinned ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected status 2.");
failure_mssg = msg;
} else if ( ( ! entry_ptr->loaded ) ||
( entry_ptr->cleared ) ||
( entry_ptr->flushed ) ||
( entry_ptr->destroyed ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected entry history 2.");
failure_mssg = msg;
}
}
/* Expunge the entry and then verify that it is no longer in the cache.
* Also verify that the entry was loaded, cleared, and destroyed, but
* not flushed.
*/
expunge_entry(cache_ptr, 0, 0);
if ( pass ) {
/* entry shouldn't be in cache -- only in_cache should be touched
* by the status call. Thus, only check that boolean.
*/
result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, &entry_size,
&in_cache, &is_dirty, &is_protected, &is_pinned);
if ( result < 0 ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"H5AC_get_entry_status() reports failure 3.");
failure_mssg = msg;
} else if ( in_cache ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected status 3.");
failure_mssg = msg;
} else if ( ( ! entry_ptr->loaded ) ||
( ! entry_ptr->cleared ) ||
( entry_ptr->flushed ) ||
( ! entry_ptr->destroyed ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected entry history 3.");
failure_mssg = msg;
}
}
/* now repeat the process with a different entry. On unprotect
* mark the entry as dirty. Verify that it is not flushed.
*/
base_addr = entries[0];
entry_ptr = &(base_addr[1]);
if ( pass ) {
/* entry not in cache -- only in_cache should be touched by
* the status call. Thus, only check that boolean.
*/
result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, &entry_size,
&in_cache, &is_dirty, &is_protected,
&is_pinned);
if ( result < 0 ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"H5AC_get_entry_status() reports failure 4.");
failure_mssg = msg;
} else if ( in_cache ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected status 4.");
failure_mssg = msg;
} else if ( ( entry_ptr->loaded ) ||
( entry_ptr->cleared ) ||
( entry_ptr->flushed ) ||
( entry_ptr->destroyed ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected entry history 4.");
failure_mssg = msg;
}
}
/* protect the entry to force the cache to load it, and then unprotect
* it with the dirty flag set.
*/
protect_entry(cache_ptr, 0, 1);
unprotect_entry(cache_ptr, 0, 1, TRUE, H5C__NO_FLAGS_SET);
if ( pass ) {
result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, &entry_size,
&in_cache, &is_dirty, &is_protected,
&is_pinned);
if ( result < 0 ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"H5AC_get_entry_status() reports failure 5.");
failure_mssg = msg;
} else if ( !in_cache || !is_dirty || is_protected || is_pinned ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected status 5.");
failure_mssg = msg;
} else if ( ( ! entry_ptr->loaded ) ||
( entry_ptr->cleared ) ||
( entry_ptr->flushed ) ||
( entry_ptr->destroyed ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected entry history 5.");
failure_mssg = msg;
}
}
/* Expunge the entry and then verify that it is no longer in the cache.
* Also verify that the entry was loaded, cleared and destroyed, but not
* flushed.
*/
expunge_entry(cache_ptr, 0, 1);
if ( pass ) {
/* entry shouldn't be in cache -- only in_cache should be touched
* by the status call. Thus, only check that boolean.
*/
result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, &entry_size,
&in_cache, &is_dirty, &is_protected,
&is_pinned);
if ( result < 0 ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"H5AC_get_entry_status() reports failure 6.");
failure_mssg = msg;
} else if ( in_cache ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected status 6.");
failure_mssg = msg;
} else if ( ( ! entry_ptr->loaded ) ||
( ! entry_ptr->cleared ) ||
( entry_ptr->flushed ) ||
( ! entry_ptr->destroyed ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected entry history 6.");
failure_mssg = msg;
}
}
if ( pass ) {
takedown_cache(cache_ptr, FALSE, FALSE);
}
if ( pass ) { PASSED(); } else { H5_FAILED(); }
if ( ! pass ) {
HDfprintf(stdout, "%s(): failure_mssg = \"%s\".\n",
fcn_name, failure_mssg);
}
return;
} /* check_expunge_entry() */
/*-------------------------------------------------------------------------
* Function: check_multiple_read_protect()
*
* Purpose: Verify that multiple, simultaneous read protects of a
* single entry perform as expectd.
*
* Return: void
*
* Programmer: John Mainzer
* 4/1/07
*
* Modifications:
*
* None.
*
*-------------------------------------------------------------------------
*/
static void
check_multiple_read_protect(void)
{
const char * fcn_name = "check_multiple_read_protect()";
H5C_t * cache_ptr = NULL;
test_entry_t * entry_ptr;
TESTING("multiple read only protects on a single entry");
pass = TRUE;
/* allocate a cache. Should succeed.
*
* Then to start with, proceed as follows:
*
* Read protect an entry.
*
* Then read protect the entry again. Should succeed.
*
* Read protect yet again. Should succeed.
*
* Unprotect with no changes, and then read protect twice again.
* Should succeed.
*
* Now unprotect three times. Should succeed.
*
* If stats are enabled, verify that correct stats are collected at
* every step.
*
* Also, verify internal state of read protects at every step.
*/
if ( pass ) {
reset_entries();
cache_ptr = setup_cache((size_t)(2 * 1024),
(size_t)(1 * 1024));
entry_ptr = &((entries[0])[0]);
if ( ( entry_ptr->header.is_protected ) ||
( entry_ptr->header.is_read_only ) ||
( entry_ptr->header.ro_ref_count != 0 ) ) {
pass = FALSE;
failure_mssg = "Unexpected ro protected status 1.\n";
}
}
#if H5C_COLLECT_CACHE_STATS
if ( ( cache_ptr->write_protects[0] != 0 ) ||
( cache_ptr->read_protects[0] != 0 ) ||
( cache_ptr->max_read_protects[0] != 0 ) ) {
pass = FALSE;
failure_mssg = "Unexpected protect stats 1.\n";
}
#endif /* H5C_COLLECT_CACHE_STATS */
if ( pass )
{
protect_entry_ro(cache_ptr, 0, 0);
if ( ( ! ( entry_ptr->header.is_protected ) ) ||
( ! ( entry_ptr->header.is_read_only ) ) ||
( entry_ptr->header.ro_ref_count != 1 ) ) {
pass = FALSE;
failure_mssg = "Unexpected ro protected status 2.\n";
}
}
#if H5C_COLLECT_CACHE_STATS
if ( ( cache_ptr->write_protects[0] != 0 ) ||
( cache_ptr->read_protects[0] != 1 ) ||
( cache_ptr->max_read_protects[0] != 1 ) ) {
pass = FALSE;
failure_mssg = "Unexpected protect stats 2.\n";
}
#endif /* H5C_COLLECT_CACHE_STATS */
if ( pass )
{
protect_entry_ro(cache_ptr, 0, 0);
if ( ( ! ( entry_ptr->header.is_protected ) ) ||
( ! ( entry_ptr->header.is_read_only ) ) ||
( entry_ptr->header.ro_ref_count != 2 ) ) {
pass = FALSE;
failure_mssg = "Unexpected ro protected status 3.\n";
}
}
#if H5C_COLLECT_CACHE_STATS
if ( ( cache_ptr->write_protects[0] != 0 ) ||
( cache_ptr->read_protects[0] != 2 ) ||
( cache_ptr->max_read_protects[0] != 2 ) ) {
pass = FALSE;
failure_mssg = "Unexpected protect stats 3.\n";
}
#endif /* H5C_COLLECT_CACHE_STATS */
if ( pass )
{
unprotect_entry(cache_ptr, 0, 0, FALSE, H5C__NO_FLAGS_SET);
if ( ( ! ( entry_ptr->header.is_protected ) ) ||
( ! ( entry_ptr->header.is_read_only ) ) ||
( entry_ptr->header.ro_ref_count != 1 ) ) {
pass = FALSE;
failure_mssg = "Unexpected ro protected status 4.\n";
}
}
#if H5C_COLLECT_CACHE_STATS
if ( ( cache_ptr->write_protects[0] != 0 ) ||
( cache_ptr->read_protects[0] != 2 ) ||
( cache_ptr->max_read_protects[0] != 2 ) ) {
pass = FALSE;
failure_mssg = "Unexpected protect stats 4.\n";
}
#endif /* H5C_COLLECT_CACHE_STATS */
if ( pass )
{
protect_entry_ro(cache_ptr, 0, 0);
if ( ( ! ( entry_ptr->header.is_protected ) ) ||
( ! ( entry_ptr->header.is_read_only ) ) ||
( entry_ptr->header.ro_ref_count != 2 ) ) {
pass = FALSE;
failure_mssg = "Unexpected ro protected status 5.\n";
}
}
#if H5C_COLLECT_CACHE_STATS
if ( ( cache_ptr->write_protects[0] != 0 ) ||
( cache_ptr->read_protects[0] != 3 ) ||
( cache_ptr->max_read_protects[0] != 2 ) ) {
pass = FALSE;
failure_mssg = "Unexpected protect stats 5.\n";
}
#endif /* H5C_COLLECT_CACHE_STATS */
if ( pass )
{
protect_entry_ro(cache_ptr, 0, 0);
if ( ( ! ( entry_ptr->header.is_protected ) ) ||
( ! ( entry_ptr->header.is_read_only ) ) ||
( entry_ptr->header.ro_ref_count != 3 ) ) {
pass = FALSE;
failure_mssg = "Unexpected ro protected status 6.\n";
}
}
#if H5C_COLLECT_CACHE_STATS
if ( ( cache_ptr->write_protects[0] != 0 ) ||
( cache_ptr->read_protects[0] != 4 ) ||
( cache_ptr->max_read_protects[0] != 3 ) ) {
pass = FALSE;
failure_mssg = "Unexpected protect stats 6.\n";
}
#endif /* H5C_COLLECT_CACHE_STATS */
if ( pass )
{
unprotect_entry(cache_ptr, 0, 0, FALSE, H5C__NO_FLAGS_SET);
if ( ( ! ( entry_ptr->header.is_protected ) ) ||
( ! ( entry_ptr->header.is_read_only ) ) ||
( entry_ptr->header.ro_ref_count != 2 ) ) {
pass = FALSE;
failure_mssg = "Unexpected ro protected status 7.\n";
}
}
#if H5C_COLLECT_CACHE_STATS
if ( ( cache_ptr->write_protects[0] != 0 ) ||
( cache_ptr->read_protects[0] != 4 ) ||
( cache_ptr->max_read_protects[0] != 3 ) ) {
pass = FALSE;
failure_mssg = "Unexpected protect stats 7.\n";
}
#endif /* H5C_COLLECT_CACHE_STATS */
if ( pass )
{
unprotect_entry(cache_ptr, 0, 0, FALSE, H5C__NO_FLAGS_SET);
if ( ( ! ( entry_ptr->header.is_protected ) ) ||
( ! ( entry_ptr->header.is_read_only ) ) ||
( entry_ptr->header.ro_ref_count != 1 ) ) {
pass = FALSE;
failure_mssg = "Unexpected ro protected status 8.\n";
}
}
#if H5C_COLLECT_CACHE_STATS
if ( ( cache_ptr->write_protects[0] != 0 ) ||
( cache_ptr->read_protects[0] != 4 ) ||
( cache_ptr->max_read_protects[0] != 3 ) ) {
pass = FALSE;
failure_mssg = "Unexpected protect stats 8.\n";
}
#endif /* H5C_COLLECT_CACHE_STATS */
if ( pass )
{
unprotect_entry(cache_ptr, 0, 0, FALSE, H5C__NO_FLAGS_SET);
if ( ( entry_ptr->header.is_protected ) ||
( entry_ptr->header.is_read_only ) ||
( entry_ptr->header.ro_ref_count != 0 ) ) {
pass = FALSE;
failure_mssg = "Unexpected ro protected status 9.\n";
}
}
#if H5C_COLLECT_CACHE_STATS
if ( ( cache_ptr->write_protects[0] != 0 ) ||
( cache_ptr->read_protects[0] != 4 ) ||
( cache_ptr->max_read_protects[0] != 3 ) ) {
pass = FALSE;
failure_mssg = "Unexpected protect stats 9.\n";
}
#endif /* H5C_COLLECT_CACHE_STATS */
/* If we get this far, do a write protect and unprotect to verify
* that the stats are getting collected properly here as well.
*/
if ( pass )
{
protect_entry(cache_ptr, 0, 0);
if ( ( ! ( entry_ptr->header.is_protected ) ) ||
( entry_ptr->header.is_read_only ) ||
( entry_ptr->header.ro_ref_count != 0 ) ) {
pass = FALSE;
failure_mssg = "Unexpected ro protected status 10.\n";
}
}
#if H5C_COLLECT_CACHE_STATS
if ( ( cache_ptr->write_protects[0] != 1 ) ||
( cache_ptr->read_protects[0] != 4 ) ||
( cache_ptr->max_read_protects[0] != 3 ) ) {
pass = FALSE;
failure_mssg = "Unexpected protect stats 10.\n";
}
#endif /* H5C_COLLECT_CACHE_STATS */
if ( pass )
{
unprotect_entry(cache_ptr, 0, 0, FALSE, H5C__NO_FLAGS_SET);
if ( ( entry_ptr->header.is_protected ) ||
( entry_ptr->header.is_read_only ) ||
( entry_ptr->header.ro_ref_count != 0 ) ) {
pass = FALSE;
failure_mssg = "Unexpected ro protected status 11.\n";
}
}
#if H5C_COLLECT_CACHE_STATS
if ( ( cache_ptr->write_protects[0] != 1 ) ||
( cache_ptr->read_protects[0] != 4 ) ||
( cache_ptr->max_read_protects[0] != 3 ) ) {
pass = FALSE;
failure_mssg = "Unexpected protect stats 11.\n";
}
#endif /* H5C_COLLECT_CACHE_STATS */
/* Finally, mix things up a little, using a mix of reads and
* and writes on different entries. Also include a pin to verify
* that it works as well.
*
* Stats are looking OK, so we will only test them one more time
* at the end to ensure that all is at it should be.
*/
if ( pass ) {
protect_entry(cache_ptr, 0, 2); /* (0,2) write */
protect_entry_ro(cache_ptr, 0, 4); /* (0,4) read only (1) */
protect_entry(cache_ptr, 0, 6); /* (0,6) write */
unprotect_entry(cache_ptr, 0, 2, FALSE, /* (0,2) unprotect */
H5C__NO_FLAGS_SET);
protect_entry_ro(cache_ptr, 0, 2); /* (0,2) read only (1) */
protect_entry(cache_ptr, 0, 1); /* (0,1) write */
protect_entry_ro(cache_ptr, 0, 4); /* (0,4) read only (2) */
protect_entry(cache_ptr, 0, 0); /* (0,0) write */
protect_entry_ro(cache_ptr, 0, 2); /* (0,2) read only (2) */
unprotect_entry(cache_ptr, 0, 2, FALSE, /* (0,2) read only (1) pin */
H5C__PIN_ENTRY_FLAG);
unprotect_entry(cache_ptr, 0, 6, FALSE, /* (0,6) unprotect */
H5C__NO_FLAGS_SET);
protect_entry_ro(cache_ptr, 0, 4); /* (0,4) read only (3) */
unprotect_entry(cache_ptr, 0, 2, FALSE, /* (0,2) unprotect */
H5C__NO_FLAGS_SET);
unprotect_entry(cache_ptr, 0, 1, FALSE, /* (0,1) unprotect */
H5C__NO_FLAGS_SET);
if ( pass ) {
entry_ptr = &((entries[0])[4]);
if ( H5C_pin_protected_entry(cache_ptr, (void *)entry_ptr) < 0 ) {
pass = FALSE;
failure_mssg = "H5C_pin_protected_entry() failed.\n";
} else if ( ! (entry_ptr->header.is_pinned) ) {
pass = FALSE;
failure_mssg = "entry (0,4) not pinned.\n";
} else {
/* keep test bed sanity checks happy */
entry_ptr->is_pinned = TRUE;
}
}
unprotect_entry(cache_ptr, 0, 4, FALSE, /* (0,4) read only (2) */
H5C__NO_FLAGS_SET);
unprotect_entry(cache_ptr, 0, 4, FALSE, /* (0,4) read only (1) */
H5C__UNPIN_ENTRY_FLAG);
if ( ( pass ) && ( entry_ptr->header.is_pinned ) ) {
pass = FALSE;
failure_mssg = "enty (0,4) still pinned.\n";
}
unprotect_entry(cache_ptr, 0, 4, FALSE, /* (0,4) unprotect */
H5C__NO_FLAGS_SET);
unprotect_entry(cache_ptr, 0, 0, FALSE, /* (0,0) unprotect */
H5C__NO_FLAGS_SET);
unpin_entry(cache_ptr, 0, 2);
}
#if H5C_COLLECT_CACHE_STATS
if ( ( cache_ptr->write_protects[0] != 5 ) ||
( cache_ptr->read_protects[0] != 9 ) ||
( cache_ptr->max_read_protects[0] != 3 ) ) {
pass = FALSE;
failure_mssg = "Unexpected protect stats 11.\n";
}
#endif /* H5C_COLLECT_CACHE_STATS */
if ( pass ) {
takedown_cache(cache_ptr, FALSE, FALSE);
}
if ( pass ) { PASSED(); } else { H5_FAILED(); }
if ( ! pass ) {
HDfprintf(stdout, "%s: failure_mssg = \"%s\".\n",
fcn_name, failure_mssg);
}
return;
} /* check_multiple_read_protect() */
/*-------------------------------------------------------------------------
* Function: check_rename_entry()
*
* Purpose: Verify that H5C_rename_entry behaves as expected. In
* particular, verify that it works correctly with pinned
* entries.
*
* Return: void
*
* Programmer: John Mainzer
* 4/26/06
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static void
check_rename_entry(void)
{
const char * fcn_name = "check_rename_entry";
int i;
H5C_t * cache_ptr = NULL;
struct rename_entry_test_spec test_specs[4] =
{
{
/* 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 = */ 20,
/* hbool_t is_dirty = */ TRUE,
/* hbool_t is_pinned = */ 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 = */ 40,
/* hbool_t is_dirty = */ TRUE,
/* hbool_t is_pinned = */ TRUE
}
};
TESTING("H5C_rename_entry() functionality");
pass = TRUE;
/* allocate a cache, load entries into it, and then rename
* them. To the extent possible, verify that the desired
* actions took place.
*
* At present, we should do the following tests:
*
* 1) Rename a clean, unprotected, unpinned entry.
*
* 2) Rename a dirty, unprotected, unpinned entry.
*
* 3) Rename a clean, unprotected, pinned entry.
*
* 4) Rename a dirty, unprotected, pinned entry.
*
* In all cases, the entry should have moved to its
* new location, and have been marked dirty if it wasn't
* already.
*
* Unpinned entries should have been moved to the head
* of the LRU list.
*
* Pinned entries should remain untouched on the pinned entry
* list.
*/
if ( pass ) {
reset_entries();
cache_ptr = setup_cache((size_t)(2 * 1024 * 1024),
(size_t)(1 * 1024 * 1024));
}
i = 0;
while ( ( pass ) && ( i < 4 ) )
{
check_rename_entry__run_test(cache_ptr, i, &(test_specs[i]));
i++;
}
if ( pass ) {
takedown_cache(cache_ptr, FALSE, FALSE);
}
if ( pass ) { PASSED(); } else { H5_FAILED(); }
if ( ! pass ) {
HDfprintf(stdout, "%s(): failure_mssg = \"%s\".\n",
fcn_name, failure_mssg);
}
return;
} /* check_rename_entry() */
/*-------------------------------------------------------------------------
* Function: check_rename_entry__run_test()
*
* Purpose: Run a rename entry test.
*
* Do nothing if pass is FALSE on entry.
*
* Return: void
*
* Programmer: John Mainzer
* 4/27/06
*
* Modifications:
*
* None.
*
*-------------------------------------------------------------------------
*/
static void
check_rename_entry__run_test(H5C_t * cache_ptr,
int test_num,
struct rename_entry_test_spec * spec_ptr)
{
/* const char * fcn_name = "check_rename_entry__run_test"; */
static char msg[128];
unsigned int flags = H5C__NO_FLAGS_SET;
test_entry_t * base_addr;
test_entry_t * entry_ptr = NULL;
H5C_cache_entry_t * test_ptr = NULL;
if ( cache_ptr == NULL ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"cache_ptr NULL on entry to rename test #%d.",
test_num);
failure_mssg = msg;
} else if ( spec_ptr == NULL ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"spec_ptr NULL on entry to rename test #%d.",
test_num);
failure_mssg = msg;
}
if ( pass ) {
base_addr = entries[spec_ptr->entry_type];
entry_ptr = &(base_addr[spec_ptr->entry_index]);
if ( ( entry_ptr->self != entry_ptr ) ||
( ( entry_ptr->cache_ptr != cache_ptr ) &&
( entry_ptr->cache_ptr != NULL ) ) ||
( ! ( entry_ptr->at_main_addr ) ) ||
( entry_ptr->addr != entry_ptr->main_addr ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"bad entry_ptr in rename test #%d.",
test_num);
failure_mssg = msg;
} else if ( spec_ptr->is_pinned ) {
flags |= H5C__PIN_ENTRY_FLAG;
}
}
protect_entry(cache_ptr, spec_ptr->entry_type, spec_ptr->entry_index);
unprotect_entry(cache_ptr, spec_ptr->entry_type, spec_ptr->entry_index,
(int)(spec_ptr->is_dirty), flags);
rename_entry(cache_ptr, spec_ptr->entry_type, spec_ptr->entry_index, FALSE);
if ( pass ) {
/* verify that the rename took place, and that the cache's internal
* structures are as expected. Note that some sanity checking is
* done by rename_entry(), so we don't have to repeat it here.
*/
if ( spec_ptr->is_pinned ) {
if ( ! ( entry_ptr->header.is_pinned ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"Pinned entry not pinned after rename in test #%d.",
test_num);
failure_mssg = msg;
}
if ( pass ) {
test_ptr = cache_ptr->pel_head_ptr;
while ( ( test_ptr != NULL ) &&
( test_ptr != (H5C_cache_entry_t *)entry_ptr ) )
{
test_ptr = test_ptr->next;
}
if ( test_ptr == NULL ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"Pinned entry not in pel after rename in test #%d.",
test_num);
failure_mssg = msg;
}
}
unpin_entry(cache_ptr, spec_ptr->entry_type, spec_ptr->entry_index);
} else {
if ( entry_ptr->header.is_pinned ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"Unpinned entry pinned after rename in test #%d.",
test_num);
failure_mssg = msg;
}
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 rename in test #%d.",
test_num);
failure_mssg = msg;
}
}
}
/* put the entry back where it started from */
rename_entry(cache_ptr, spec_ptr->entry_type, spec_ptr->entry_index, TRUE);
return;
} /* check_rename_entry__run_test() */
/*-------------------------------------------------------------------------
* Function: check_pin_protected_entry()
*
* Purpose: Verify that H5C_pin_protected_entry behaves as expected.
*
* Return: void
*
* Programmer: John Mainzer
* 4/28/06
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static void
check_pin_protected_entry(void)
{
const char * fcn_name = "check_pin_protected_entry";
static char msg[128];
herr_t result;
H5C_t * cache_ptr = NULL;
test_entry_t * base_addr;
test_entry_t * entry_ptr;
TESTING("H5C_pin_protected_entry() functionality");
pass = TRUE;
/* Create a cache, protect an entry, and then use H5C_pin_protected_entry()
* to pin it. Verify that the entry is in fact pined. Unprotect the entry
* to unpin it, and then destroy the cache.
*/
if ( pass ) {
reset_entries();
cache_ptr = setup_cache((size_t)(2 * 1024 * 1024),
(size_t)(1 * 1024 * 1024));
}
protect_entry(cache_ptr, 0, 0);
if ( pass ) {
base_addr = entries[0];
entry_ptr = &(base_addr[0]);
result = H5C_pin_protected_entry(cache_ptr, (void *)entry_ptr);
if ( result < 0 ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"H5C_pin_protected_entry() reports failure.");
failure_mssg = msg;
} else if ( ! ( entry_ptr->header.is_pinned ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "entry not pinned when it should be.");
failure_mssg = msg;
} else {
entry_ptr->is_pinned = TRUE;
}
}
unprotect_entry(cache_ptr, 0, 0, FALSE, H5C__UNPIN_ENTRY_FLAG);
if ( pass ) {
takedown_cache(cache_ptr, FALSE, FALSE);
}
if ( pass ) { PASSED(); } else { H5_FAILED(); }
if ( ! pass ) {
HDfprintf(stdout, "%s(): failure_mssg = \"%s\".\n",
fcn_name, failure_mssg);
}
return;
} /* check_pin_protected_entry() */
/*-------------------------------------------------------------------------
* Function: check_resize_entry()
*
* Purpose: Verify that H5C_resize_entry() and H5C_unprotect() resize
* entries as expected.
*
* Return: void
*
* Programmer: John Mainzer
* 7/7/06
*
* Modifications:
*
* None.
*
*-------------------------------------------------------------------------
*/
static void
check_resize_entry(void)
{
const char * fcn_name = "check_resize_entry";
static char msg[128];
herr_t result;
hbool_t in_cache;
hbool_t is_dirty;
hbool_t is_protected;
hbool_t is_pinned;
size_t entry_size;
size_t reported_entry_size;
H5C_t * cache_ptr = NULL;
test_entry_t * base_addr;
test_entry_t * entry_ptr;
TESTING("entry resize functionality");
/* Setup a cache and verify that it is empty.
*
* Then force the load of an entry by protecting it, and verify that
* the entry and cache have the expected sizes.
*
* Then unprotect the entry with the size changed flag and a reduced
* size. Verify that the entry and cache have the expected expected
* sizes.
*
* Use a second protect/unprotect cycle to restore the entry to
* its original size. Verify that the entry and cache have the
* expected sizes.
*
* Protect and unprotect the entry again to pin it. Use
* H5C_resize_entry to reduce its size. Verify that the entry
* and cache have the expected sizes.
*
* Use H5C_resize_entry again to restore the entry to its original
* size. Verify that the entry and cache have the expected sizes.
*
* Use a protect / unprotect cycle to unpin and destroy the entry.
* Verify that the entry and cache have the expected sizes.
*
*
* Obesrve that all the above tests have been done with only one
* entry in the cache. Repeat the tests with several entries in
* the cache.
*/
pass = TRUE;
/* tests with only one entry in the cache: */
if ( pass ) {
reset_entries();
cache_ptr = setup_cache((size_t)(2 * 1024 * 1024),
(size_t)(1 * 1024 * 1024));
base_addr = entries[LARGE_ENTRY_TYPE];
entry_ptr = &(base_addr[0]);
entry_size = LARGE_ENTRY_SIZE;
}
if ( pass ) {
if ( ( cache_ptr->index_len != 0 ) ||
( cache_ptr->index_size != 0 ) ||
( cache_ptr->slist_len != 0 ) ||
( cache_ptr->slist_size != 0 ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected cache status 1.");
failure_mssg = msg;
}
}
protect_entry(cache_ptr, LARGE_ENTRY_TYPE, 0);
if ( pass ) {
if ( ( cache_ptr->index_len != 1 ) ||
( cache_ptr->index_size != LARGE_ENTRY_SIZE ) ||
( cache_ptr->slist_len != 0 ) ||
( cache_ptr->slist_size != 0 ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected cache status 2.");
failure_mssg = msg;
}
}
if ( pass ) {
result = H5C_get_entry_status(cache_ptr, entry_ptr->addr,
&reported_entry_size, &in_cache,
&is_dirty, &is_protected, &is_pinned);
if ( result < 0 ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"H5AC_get_entry_status() reports failure 1.");
failure_mssg = msg;
} else if ( !in_cache || is_dirty || !is_protected || is_pinned ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected status 1.");
failure_mssg = msg;
} else if ( ( ! entry_ptr->loaded ) ||
( entry_ptr->cleared ) ||
( entry_ptr->flushed ) ||
( entry_ptr->destroyed ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected entry history 1.");
failure_mssg = msg;
}
}
if ( pass ) {
result = H5C_unprotect(NULL, -1, -1, cache_ptr,
&(types[LARGE_ENTRY_TYPE]), entry_ptr->addr,
(void *)entry_ptr,
H5C__SIZE_CHANGED_FLAG | H5C__DIRTIED_FLAG,
(LARGE_ENTRY_SIZE / 2));
if ( result < 0 ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "H5C_unprotect() reports failure 1.");
failure_mssg = msg;
} else {
/* tidy up so we play nice with the standard protect / unprotect
* calls.
*/
entry_ptr->is_protected = FALSE;
entry_ptr->is_dirty = TRUE;
entry_ptr->size = LARGE_ENTRY_SIZE / 2;
}
}
if ( pass ) {
if ( ( cache_ptr->index_len != 1 ) ||
( cache_ptr->index_size != (LARGE_ENTRY_SIZE / 2) ) ||
( cache_ptr->slist_len != 1 ) ||
( cache_ptr->slist_size != (LARGE_ENTRY_SIZE / 2) ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected cache status 3.");
failure_mssg = msg;
}
}
if ( pass ) {
result = H5C_get_entry_status(cache_ptr, entry_ptr->addr,
&reported_entry_size, &in_cache,
&is_dirty, &is_protected, &is_pinned);
if ( result < 0 ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"H5AC_get_entry_status() reports failure 2.");
failure_mssg = msg;
} else if ( !in_cache || !is_dirty || is_protected || is_pinned ||
( reported_entry_size != (LARGE_ENTRY_SIZE / 2) ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected status 2.");
failure_mssg = msg;
} else if ( ( ! entry_ptr->loaded ) ||
( entry_ptr->cleared ) ||
( entry_ptr->flushed ) ||
( entry_ptr->destroyed ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected entry history 2.");
failure_mssg = msg;
}
}
protect_entry(cache_ptr, LARGE_ENTRY_TYPE, 0);
if ( pass ) {
result = H5C_unprotect(NULL, -1, -1, cache_ptr,
&(types[LARGE_ENTRY_TYPE]), entry_ptr->addr,
(void *)entry_ptr,
(H5C__DIRTIED_FLAG | H5C__SIZE_CHANGED_FLAG),
LARGE_ENTRY_SIZE);
if ( result < 0 ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "H5C_unprotect() reports failure 2.");
failure_mssg = msg;
} else {
/* tidy up so we play nice with the standard protect / unprotect
* calls.
*/
entry_ptr->is_protected = FALSE;
entry_ptr->is_dirty = TRUE;
entry_ptr->size = LARGE_ENTRY_SIZE;
}
}
if ( pass ) {
if ( ( cache_ptr->index_len != 1 ) ||
( cache_ptr->index_size != LARGE_ENTRY_SIZE ) ||
( cache_ptr->slist_len != 1 ) ||
( cache_ptr->slist_size != LARGE_ENTRY_SIZE ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected cache status 4.");
failure_mssg = msg;
}
}
if ( pass ) {
result = H5C_get_entry_status(cache_ptr, entry_ptr->addr,
&reported_entry_size, &in_cache,
&is_dirty, &is_protected, &is_pinned);
if ( result < 0 ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"H5AC_get_entry_status() reports failure 3.");
failure_mssg = msg;
} else if ( !in_cache || !is_dirty || is_protected || is_pinned ||
( reported_entry_size != LARGE_ENTRY_SIZE ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected status 3.");
failure_mssg = msg;
} else if ( ( ! entry_ptr->loaded ) ||
( entry_ptr->cleared ) ||
( entry_ptr->flushed ) ||
( entry_ptr->destroyed ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected entry history 3.");
failure_mssg = msg;
}
}
protect_entry(cache_ptr, LARGE_ENTRY_TYPE, 0);
unprotect_entry(cache_ptr, LARGE_ENTRY_TYPE, 0, FALSE, H5C__PIN_ENTRY_FLAG);
if ( pass ) {
result = H5C_resize_pinned_entry(cache_ptr, (void *)entry_ptr,
(LARGE_ENTRY_SIZE / 4));
if ( result < 0 ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"H5C_resize_pinned_entry() reports failure 1.");
failure_mssg = msg;
}
}
if ( pass ) {
if ( ( cache_ptr->index_len != 1 ) ||
( cache_ptr->index_size != (LARGE_ENTRY_SIZE / 4) ) ||
( cache_ptr->slist_len != 1 ) ||
( cache_ptr->slist_size != (LARGE_ENTRY_SIZE / 4) ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected cache status 5.");
failure_mssg = msg;
}
}
if ( pass ) {
result = H5C_get_entry_status(cache_ptr, entry_ptr->addr,
&reported_entry_size, &in_cache,
&is_dirty, &is_protected, &is_pinned);
if ( result < 0 ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"H5AC_get_entry_status() reports failure 4.");
failure_mssg = msg;
} else if ( !in_cache || !is_dirty || is_protected || ! is_pinned ||
( reported_entry_size != (LARGE_ENTRY_SIZE / 4) ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected status 4.");
failure_mssg = msg;
} else if ( ( ! entry_ptr->loaded ) ||
( entry_ptr->cleared ) ||
( entry_ptr->flushed ) ||
( entry_ptr->destroyed ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected entry history 4.");
failure_mssg = msg;
}
}
if ( pass ) {
result = H5C_resize_pinned_entry(cache_ptr, (void *)entry_ptr,
LARGE_ENTRY_SIZE);
if ( result < 0 ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"H5C_resize_pinned_entry() reports failure 2.");
failure_mssg = msg;
}
}
if ( pass ) {
if ( ( cache_ptr->index_len != 1 ) ||
( cache_ptr->index_size != LARGE_ENTRY_SIZE ) ||
( cache_ptr->slist_len != 1 ) ||
( cache_ptr->slist_size != LARGE_ENTRY_SIZE ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected cache status 6.");
failure_mssg = msg;
}
}
if ( pass ) {
result = H5C_get_entry_status(cache_ptr, entry_ptr->addr,
&reported_entry_size, &in_cache,
&is_dirty, &is_protected, &is_pinned);
if ( result < 0 ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"H5AC_get_entry_status() reports failure 5.");
failure_mssg = msg;
} else if ( !in_cache || !is_dirty || is_protected || ! is_pinned ||
( reported_entry_size != LARGE_ENTRY_SIZE ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected status 5.");
failure_mssg = msg;
} else if ( ( ! entry_ptr->loaded ) ||
( entry_ptr->cleared ) ||
( entry_ptr->flushed ) ||
( entry_ptr->destroyed ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected entry history 5.");
failure_mssg = msg;
}
}
protect_entry(cache_ptr, LARGE_ENTRY_TYPE, 0);
unprotect_entry(cache_ptr, LARGE_ENTRY_TYPE, 0, FALSE,
H5C__UNPIN_ENTRY_FLAG | H5C__DELETED_FLAG);
if ( pass ) {
result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, &entry_size,
&in_cache, &is_dirty, &is_protected,
&is_pinned);
if ( result < 0 ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"H5AC_get_entry_status() reports failure 6.");
failure_mssg = msg;
} else if ( in_cache ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected status 6.");
failure_mssg = msg;
} else if ( ( ! entry_ptr->loaded ) ||
( ! entry_ptr->cleared ) ||
( entry_ptr->flushed ) ||
( ! entry_ptr->destroyed ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected entry history 6.");
failure_mssg = msg;
}
}
if ( pass ) {
if ( ( cache_ptr->index_len != 0 ) ||
( cache_ptr->index_size != 0 ) ||
( cache_ptr->slist_len != 0 ) ||
( cache_ptr->slist_size != 0 ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected cache status 7.");
failure_mssg = msg;
}
}
/* now repreat the above tests with several entries in the cache: */
if ( pass ) {
if ( ( cache_ptr->index_len != 0 ) ||
( cache_ptr->index_size != 0 ) ||
( cache_ptr->slist_len != 0 ) ||
( cache_ptr->slist_size != 0 ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected cache status 8.");
failure_mssg = msg;
}
base_addr = entries[LARGE_ENTRY_TYPE];
entry_ptr = &(base_addr[3]);
entry_size = LARGE_ENTRY_SIZE;
}
protect_entry(cache_ptr, LARGE_ENTRY_TYPE, 0);
unprotect_entry(cache_ptr, LARGE_ENTRY_TYPE, 0, FALSE, H5C__NO_FLAGS_SET);
protect_entry(cache_ptr, LARGE_ENTRY_TYPE, 1);
unprotect_entry(cache_ptr, LARGE_ENTRY_TYPE, 1, TRUE, H5C__NO_FLAGS_SET);
protect_entry(cache_ptr, LARGE_ENTRY_TYPE, 2);
unprotect_entry(cache_ptr, LARGE_ENTRY_TYPE, 2, FALSE, H5C__NO_FLAGS_SET);
if ( pass ) {
if ( ( cache_ptr->index_len != 3 ) ||
( cache_ptr->index_size != 3 * LARGE_ENTRY_SIZE ) ||
( cache_ptr->slist_len != 1 ) ||
( cache_ptr->slist_size != LARGE_ENTRY_SIZE ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected cache status 9.");
failure_mssg = msg;
}
}
protect_entry(cache_ptr, LARGE_ENTRY_TYPE, 3);
if ( pass ) {
if ( ( cache_ptr->index_len != 4 ) ||
( cache_ptr->index_size != 4 * LARGE_ENTRY_SIZE ) ||
( cache_ptr->slist_len != 1 ) ||
( cache_ptr->slist_size != LARGE_ENTRY_SIZE ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected cache status 10.");
failure_mssg = msg;
}
}
if ( pass ) {
result = H5C_get_entry_status(cache_ptr, entry_ptr->addr,
&reported_entry_size, &in_cache,
&is_dirty, &is_protected, &is_pinned);
if ( result < 0 ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"H5AC_get_entry_status() reports failure 7.");
failure_mssg = msg;
} else if ( !in_cache || is_dirty || !is_protected || is_pinned ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected status 7.");
failure_mssg = msg;
} else if ( ( ! entry_ptr->loaded ) ||
( entry_ptr->cleared ) ||
( entry_ptr->flushed ) ||
( entry_ptr->destroyed ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected entry history 7.");
failure_mssg = msg;
}
}
if ( pass ) {
result = H5C_unprotect(NULL, -1, -1, cache_ptr,
&(types[LARGE_ENTRY_TYPE]), entry_ptr->addr,
(void *)entry_ptr,
H5C__SIZE_CHANGED_FLAG | H5C__DIRTIED_FLAG,
(LARGE_ENTRY_SIZE / 2));
if ( result < 0 ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "H5C_unprotect() reports failure 3.");
failure_mssg = msg;
} else {
/* tidy up so we play nice with the standard protect / unprotect
* calls.
*/
entry_ptr->is_protected = FALSE;
entry_ptr->is_dirty = TRUE;
entry_ptr->size = LARGE_ENTRY_SIZE / 2;
}
}
if ( pass ) {
if ( ( cache_ptr->index_len != 4 ) ||
( cache_ptr->index_size !=
((3 * LARGE_ENTRY_SIZE) + (LARGE_ENTRY_SIZE / 2)) ) ||
( cache_ptr->slist_len != 2 ) ||
( cache_ptr->slist_size !=
(LARGE_ENTRY_SIZE + (LARGE_ENTRY_SIZE / 2)) ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected cache status 11.");
failure_mssg = msg;
}
}
if ( pass ) {
result = H5C_get_entry_status(cache_ptr, entry_ptr->addr,
&reported_entry_size, &in_cache,
&is_dirty, &is_protected, &is_pinned);
if ( result < 0 ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"H5AC_get_entry_status() reports failure 8.");
failure_mssg = msg;
} else if ( !in_cache || !is_dirty || is_protected || is_pinned ||
( reported_entry_size != (LARGE_ENTRY_SIZE / 2) ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected status 8.");
failure_mssg = msg;
} else if ( ( ! entry_ptr->loaded ) ||
( entry_ptr->cleared ) ||
( entry_ptr->flushed ) ||
( entry_ptr->destroyed ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected entry history 8.");
failure_mssg = msg;
}
}
protect_entry(cache_ptr, LARGE_ENTRY_TYPE, 3);
if ( pass ) {
result = H5C_unprotect(NULL, -1, -1, cache_ptr,
&(types[LARGE_ENTRY_TYPE]), entry_ptr->addr,
(void *)entry_ptr,
(H5C__DIRTIED_FLAG | H5C__SIZE_CHANGED_FLAG),
LARGE_ENTRY_SIZE);
if ( result < 0 ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "H5C_unprotect() reports failure 4.");
failure_mssg = msg;
} else {
/* tidy up so we play nice with the standard protect / unprotect
* calls.
*/
entry_ptr->is_protected = FALSE;
entry_ptr->is_dirty = TRUE;
entry_ptr->size = LARGE_ENTRY_SIZE;
}
}
if ( pass ) {
if ( ( cache_ptr->index_len != 4 ) ||
( cache_ptr->index_size != 4 * LARGE_ENTRY_SIZE ) ||
( cache_ptr->slist_len != 2 ) ||
( cache_ptr->slist_size != 2 * LARGE_ENTRY_SIZE ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected cache status 12.");
failure_mssg = msg;
}
}
if ( pass ) {
result = H5C_get_entry_status(cache_ptr, entry_ptr->addr,
&reported_entry_size, &in_cache,
&is_dirty, &is_protected, &is_pinned);
if ( result < 0 ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"H5AC_get_entry_status() reports failure 9.");
failure_mssg = msg;
} else if ( !in_cache || !is_dirty || is_protected || is_pinned ||
( reported_entry_size != LARGE_ENTRY_SIZE ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected status 9.");
failure_mssg = msg;
} else if ( ( ! entry_ptr->loaded ) ||
( entry_ptr->cleared ) ||
( entry_ptr->flushed ) ||
( entry_ptr->destroyed ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected entry history 9.");
failure_mssg = msg;
}
}
protect_entry(cache_ptr, LARGE_ENTRY_TYPE, 3);
unprotect_entry(cache_ptr, LARGE_ENTRY_TYPE, 3, FALSE, H5C__PIN_ENTRY_FLAG);
if ( pass ) {
result = H5C_resize_pinned_entry(cache_ptr, (void *)entry_ptr,
(LARGE_ENTRY_SIZE / 4));
if ( result < 0 ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"H5C_resize_pinned_entry() reports failure 3.");
failure_mssg = msg;
}
}
if ( pass ) {
if ( ( cache_ptr->index_len != 4 ) ||
( cache_ptr->index_size !=
((3 * LARGE_ENTRY_SIZE) + (LARGE_ENTRY_SIZE / 4)) ) ||
( cache_ptr->slist_len != 2 ) ||
( cache_ptr->slist_size !=
(LARGE_ENTRY_SIZE + (LARGE_ENTRY_SIZE / 4)) ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected cache status 13.");
failure_mssg = msg;
}
}
if ( pass ) {
result = H5C_get_entry_status(cache_ptr, entry_ptr->addr,
&reported_entry_size, &in_cache,
&is_dirty, &is_protected, &is_pinned);
if ( result < 0 ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"H5AC_get_entry_status() reports failure 10.");
failure_mssg = msg;
} else if ( !in_cache || !is_dirty || is_protected || ! is_pinned ||
( reported_entry_size != (LARGE_ENTRY_SIZE / 4) ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected status 10.");
failure_mssg = msg;
} else if ( ( ! entry_ptr->loaded ) ||
( entry_ptr->cleared ) ||
( entry_ptr->flushed ) ||
( entry_ptr->destroyed ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected entry history 10.");
failure_mssg = msg;
}
}
if ( pass ) {
result = H5C_resize_pinned_entry(cache_ptr, (void *)entry_ptr,
LARGE_ENTRY_SIZE);
if ( result < 0 ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"H5C_resize_pinned_entry() reports failure 4.");
failure_mssg = msg;
}
}
if ( pass ) {
if ( ( cache_ptr->index_len != 4 ) ||
( cache_ptr->index_size != (4 * LARGE_ENTRY_SIZE) ) ||
( cache_ptr->slist_len != 2 ) ||
( cache_ptr->slist_size != (2 * LARGE_ENTRY_SIZE) ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected cache status 14.");
failure_mssg = msg;
}
}
if ( pass ) {
result = H5C_get_entry_status(cache_ptr, entry_ptr->addr,
&reported_entry_size, &in_cache,
&is_dirty, &is_protected, &is_pinned);
if ( result < 0 ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"H5AC_get_entry_status() reports failure 11.");
failure_mssg = msg;
} else if ( !in_cache || !is_dirty || is_protected || ! is_pinned ||
( reported_entry_size != LARGE_ENTRY_SIZE ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected status 11.");
failure_mssg = msg;
} else if ( ( ! entry_ptr->loaded ) ||
( entry_ptr->cleared ) ||
( entry_ptr->flushed ) ||
( entry_ptr->destroyed ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected entry history 11.");
failure_mssg = msg;
}
}
protect_entry(cache_ptr, LARGE_ENTRY_TYPE, 3);
unprotect_entry(cache_ptr, LARGE_ENTRY_TYPE, 3, FALSE,
H5C__UNPIN_ENTRY_FLAG | H5C__DELETED_FLAG);
if ( pass ) {
result = H5C_get_entry_status(cache_ptr, entry_ptr->addr, &entry_size,
&in_cache, &is_dirty, &is_protected,
&is_pinned);
if ( result < 0 ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"H5AC_get_entry_status() reports failure 12.");
failure_mssg = msg;
} else if ( in_cache ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected status 12.");
failure_mssg = msg;
} else if ( ( ! entry_ptr->loaded ) ||
( ! entry_ptr->cleared ) ||
( entry_ptr->flushed ) ||
( ! entry_ptr->destroyed ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected entry history 12.");
failure_mssg = msg;
}
}
if ( pass ) {
if ( ( cache_ptr->index_len != 3 ) ||
( cache_ptr->index_size != (3 * LARGE_ENTRY_SIZE) ) ||
( cache_ptr->slist_len != 1 ) ||
( cache_ptr->slist_size != LARGE_ENTRY_SIZE ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected cache status 15.");
failure_mssg = msg;
}
}
protect_entry(cache_ptr, LARGE_ENTRY_TYPE, 2);
unprotect_entry(cache_ptr, LARGE_ENTRY_TYPE, 2, FALSE, H5C__DELETED_FLAG);
protect_entry(cache_ptr, LARGE_ENTRY_TYPE, 1);
unprotect_entry(cache_ptr, LARGE_ENTRY_TYPE, 1, FALSE, H5C__DELETED_FLAG);
protect_entry(cache_ptr, LARGE_ENTRY_TYPE, 0);
unprotect_entry(cache_ptr, LARGE_ENTRY_TYPE, 0, FALSE, H5C__DELETED_FLAG);
if ( pass ) {
if ( ( cache_ptr->index_len != 0 ) ||
( cache_ptr->index_size != 0 ) ||
( cache_ptr->slist_len != 0 ) ||
( cache_ptr->slist_size != 0 ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected cache status 16.");
failure_mssg = msg;
}
}
if ( pass ) {
takedown_cache(cache_ptr, FALSE, FALSE);
}
if ( pass ) { PASSED(); } else { H5_FAILED(); }
if ( ! pass ) {
HDfprintf(stdout, "%s(): failure_mssg = \"%s\".\n",
fcn_name, failure_mssg);
}
return;
} /* check_resize_entry() */
/*-------------------------------------------------------------------------
* Function: check_evictions_enabled()
*
* Purpose: Verify that H5C_get_evictions_enabled() and
* H5C_set_evictions_enabled() functions perform as expected.
*
* Return: void
*
* Programmer: John Mainzer
* 8/2/07
*
* Modifications:
*
* None.
*
*-------------------------------------------------------------------------
*/
static void
check_evictions_enabled(void)
{
const char * fcn_name = "check_evictions_enabled";
static char msg[128];
herr_t result;
hbool_t show_progress = FALSE;
hbool_t evictions_enabled;
hbool_t in_cache;
int i;
int mile_stone = 1;
size_t entry_size;
H5C_t * cache_ptr = NULL;
test_entry_t * base_addr;
test_entry_t * entry_ptr;
TESTING("evictions enabled/disabled functionality");
/* Setup a cache and verify that it is empty.
*
* Use H5C_get_evictions_enabled() to determine if evictions are
* currently enabled -- they should be.
*
* Load entries until the cache is full. Load one more. Verify that
* this caused an entry to be evicted.
*
* Insert an entry. Verify that this cases and entry to be evicted.
*
* Used H5C_set_evictions_enabled() to disable evictions. Verify
* with a call to H5C_get_evictions_enabled().
*
* Load another entry -- verify that this does not cause an entry
* to be evicted.
*
* Insert an entry -- verify that this does not cause an entry to
* be evicted.
*
* Use H5C_set_evictions_enabled() to re-enable evictions. Verify
* with a call to H5C_get_evictions_enabled().
*
* Protect and unprotect some of the entries in the cache. Verify
* that there are no evictions (since we only try to make space
* when we either insert or load a new entry).
*
* Protect an entry not in the cache. Verify that this causes
* two evictions.
*
* Used H5C_set_evictions_enabled() to disable evictions again.
* Verify with a call to H5C_get_evictions_enabled().
*
* Now flush and discard the cache -- should succeed.
*/
pass = TRUE;
if ( show_progress ) /* 1 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
/* create the cache */
if ( pass ) {
reset_entries();
cache_ptr = setup_cache((size_t)(1 * 1024 * 1024),
(size_t)( 512 * 1024));
base_addr = entries[MONSTER_ENTRY_TYPE];
entry_size = MONSTER_ENTRY_SIZE;
}
if ( show_progress ) /* 2 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
/* verivy that it is empty */
if ( pass ) {
if ( ( cache_ptr->index_len != 0 ) ||
( cache_ptr->index_size != 0 ) ||
( cache_ptr->slist_len != 0 ) ||
( cache_ptr->slist_size != 0 ) ||
( cache_ptr->evictions_enabled != TRUE ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected cache status 1.");
failure_mssg = msg;
}
}
if ( show_progress ) /* 3 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
/* verify that H5C_get_evictions_enabled() returns the expected value */
if ( pass ) {
result = H5C_get_evictions_enabled(cache_ptr, &evictions_enabled);
if ( ( result != SUCCEED ) || ( evictions_enabled != TRUE ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected evictions enabled 1.");
failure_mssg = msg;
}
}
if ( show_progress ) /* 4 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
/* fill the cache */
for ( i = 0; i < 16 ; i++ )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i);
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i,
FALSE, H5C__NO_FLAGS_SET);
}
if ( show_progress ) /* 5 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
/* verify that the cache is full */
if ( pass ) {
if ( ( cache_ptr->index_len != 16 ) ||
( cache_ptr->index_size != 16 * MONSTER_ENTRY_SIZE ) ||
( cache_ptr->slist_len != 0 ) ||
( cache_ptr->slist_size != 0 ) ||
( cache_ptr->evictions_enabled != TRUE ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected cache status 2.");
failure_mssg = msg;
}
}
if ( show_progress ) /* 6 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
/* protect and unprotect another entry */
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 16);
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 16,
FALSE, H5C__NO_FLAGS_SET);
if ( show_progress ) /* 7 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
/* verify that the an entry has been evicted */
if ( pass ) {
if ( ( cache_ptr->index_len != 16 ) ||
( cache_ptr->index_size != 16 * MONSTER_ENTRY_SIZE ) ||
( cache_ptr->slist_len != 0 ) ||
( cache_ptr->slist_size != 0 ) ||
( cache_ptr->evictions_enabled != TRUE ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected cache status 3.");
failure_mssg = msg;
}
}
if ( show_progress ) /* 8 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
if ( pass ) {
entry_ptr = &(base_addr[0]);
result = H5C_get_entry_status(cache_ptr, entry_ptr->addr,
NULL, &in_cache, NULL, NULL, NULL);
if ( result < 0 ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"H5AC_get_entry_status() reports failure 1.");
failure_mssg = msg;
} else if ( in_cache ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected status 1.");
failure_mssg = msg;
} else if ( ( ! entry_ptr->loaded ) ||
( entry_ptr->cleared ) ||
( ! entry_ptr->flushed ) ||
( ! entry_ptr->destroyed ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected entry history 1.");
failure_mssg = msg;
}
}
if ( show_progress ) /* 9 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
/* insert an entry */
insert_entry(cache_ptr, MONSTER_ENTRY_TYPE, 17, TRUE, H5C__NO_FLAGS_SET);
if ( show_progress ) /* 10 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
/* verify that another entry has been evicted */
if ( pass ) {
if ( ( cache_ptr->index_len != 16 ) ||
( cache_ptr->index_size != 16 * MONSTER_ENTRY_SIZE ) ||
( cache_ptr->slist_len != 1 ) ||
( cache_ptr->slist_size != MONSTER_ENTRY_SIZE ) ||
( cache_ptr->evictions_enabled != TRUE ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected cache status 4.");
failure_mssg = msg;
}
}
if ( show_progress ) /* 11 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
if ( pass ) {
entry_ptr = &(base_addr[1]);
result = H5C_get_entry_status(cache_ptr, entry_ptr->addr,
NULL, &in_cache, NULL, NULL, NULL);
if ( result < 0 ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"H5AC_get_entry_status() reports failure 2.");
failure_mssg = msg;
} else if ( in_cache ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected status 2.");
failure_mssg = msg;
} else if ( ( ! entry_ptr->loaded ) ||
( entry_ptr->cleared ) ||
( ! entry_ptr->flushed ) ||
( ! entry_ptr->destroyed ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected entry history 2.");
failure_mssg = msg;
}
}
if ( show_progress ) /* 12 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
/* disable evictions */
if ( pass ) {
result = H5C_set_evictions_enabled(cache_ptr, FALSE);
if ( result != SUCCEED ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "can't disable evictions 1.");
failure_mssg = msg;
}
}
if ( show_progress ) /* 13 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
/* verify that evictions are disabled */
if ( pass ) {
if ( ( cache_ptr->index_len != 16 ) ||
( cache_ptr->index_size != 16 * MONSTER_ENTRY_SIZE ) ||
( cache_ptr->slist_len != 1 ) ||
( cache_ptr->slist_size != MONSTER_ENTRY_SIZE ) ||
( cache_ptr->evictions_enabled != FALSE ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected cache status 5.");
failure_mssg = msg;
}
}
if ( show_progress ) /* 14 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
/* protect and unprotect another entry */
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 18);
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 18,
FALSE, H5C__NO_FLAGS_SET);
if ( show_progress ) /* 15 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
/* verify that no entry has been evicted */
if ( pass ) {
if ( ( cache_ptr->index_len != 17 ) ||
( cache_ptr->index_size != 17 * MONSTER_ENTRY_SIZE ) ||
( cache_ptr->slist_len != 1 ) ||
( cache_ptr->slist_size != MONSTER_ENTRY_SIZE ) ||
( cache_ptr->evictions_enabled != FALSE ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected cache status 6.");
failure_mssg = msg;
}
}
if ( show_progress ) /* 16 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
/* insert another entry */
insert_entry(cache_ptr, MONSTER_ENTRY_TYPE, 19, TRUE, H5C__NO_FLAGS_SET);
if ( show_progress ) /* 17 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
/* verify that no entry has been evicted */
if ( pass ) {
if ( ( cache_ptr->index_len != 18 ) ||
( cache_ptr->index_size != 18 * MONSTER_ENTRY_SIZE ) ||
( cache_ptr->slist_len != 2 ) ||
( cache_ptr->slist_size != 2 * MONSTER_ENTRY_SIZE ) ||
( cache_ptr->evictions_enabled != FALSE ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected cache status 7.");
failure_mssg = msg;
}
}
if ( show_progress ) /* 18 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
/* re-enable evictions */
if ( pass ) {
result = H5C_set_evictions_enabled(cache_ptr, TRUE);
if ( result != SUCCEED ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "can't enable evictions 1.");
failure_mssg = msg;
}
}
if ( show_progress ) /* 19 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
/* protect and unprotect an entry that is in the cache */
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 19);
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 19,
FALSE, H5C__NO_FLAGS_SET);
if ( show_progress ) /* 20 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
/* verify that no entries have been evicted */
if ( pass ) {
if ( ( cache_ptr->index_len != 18 ) ||
( cache_ptr->index_size != 18 * MONSTER_ENTRY_SIZE ) ||
( cache_ptr->slist_len != 2 ) ||
( cache_ptr->slist_size != 2 * MONSTER_ENTRY_SIZE ) ||
( cache_ptr->evictions_enabled != TRUE ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected cache status 8.");
failure_mssg = msg;
}
}
if ( show_progress ) /* 21 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
/* protect and unprotect an entry that isn't in the cache */
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 20);
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 20,
FALSE, H5C__NO_FLAGS_SET);
if ( show_progress ) /* 22 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
/* verify that the entries have been evicted to bring the
* cache back down to its normal size.
*/
if ( pass ) {
if ( ( cache_ptr->index_len != 16 ) ||
( cache_ptr->index_size != 16 * MONSTER_ENTRY_SIZE ) ||
( cache_ptr->slist_len != 2 ) ||
( cache_ptr->slist_size != 2 * MONSTER_ENTRY_SIZE ) ||
( cache_ptr->evictions_enabled != TRUE ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected cache status 9.");
failure_mssg = msg;
}
}
if ( show_progress ) /* 23 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
if ( pass ) {
entry_ptr = &(base_addr[2]);
result = H5C_get_entry_status(cache_ptr, entry_ptr->addr,
NULL, &in_cache, NULL, NULL, NULL);
if ( result < 0 ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"H5AC_get_entry_status() reports failure 3.");
failure_mssg = msg;
} else if ( in_cache ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected status 3.");
failure_mssg = msg;
} else if ( ( ! entry_ptr->loaded ) ||
( entry_ptr->cleared ) ||
( ! entry_ptr->flushed ) ||
( ! entry_ptr->destroyed ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected entry history 3.");
failure_mssg = msg;
}
}
if ( show_progress ) /* 24 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
if ( pass ) {
entry_ptr = &(base_addr[3]);
result = H5C_get_entry_status(cache_ptr, entry_ptr->addr,
NULL, &in_cache, NULL, NULL, NULL);
if ( result < 0 ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"H5AC_get_entry_status() reports failure 4.");
failure_mssg = msg;
} else if ( in_cache ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected status 4.");
failure_mssg = msg;
} else if ( ( ! entry_ptr->loaded ) ||
( entry_ptr->cleared ) ||
( ! entry_ptr->flushed ) ||
( ! entry_ptr->destroyed ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected entry history 4.");
failure_mssg = msg;
}
}
if ( show_progress ) /* 25 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
/* disable evictions again */
if ( pass ) {
result = H5C_set_evictions_enabled(cache_ptr, FALSE);
if ( result != SUCCEED ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "can't disable evictions 2.");
failure_mssg = msg;
}
}
if ( show_progress ) /* 26 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
/* protect and unprotect an entry that isn't in the cache, forcing
* the cache to grow.
*/
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 21);
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 21,
FALSE, H5C__NO_FLAGS_SET);
if ( show_progress ) /* 27 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
/* verify that the cache has grown */
if ( pass ) {
if ( ( cache_ptr->index_len != 17 ) ||
( cache_ptr->index_size != 17 * MONSTER_ENTRY_SIZE ) ||
( cache_ptr->slist_len != 2 ) ||
( cache_ptr->slist_size != 2 * MONSTER_ENTRY_SIZE ) ||
( cache_ptr->evictions_enabled != FALSE ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected cache status 10.");
failure_mssg = msg;
}
}
if ( show_progress ) /* 28 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
/* re-enable evictions again */
if ( pass ) {
result = H5C_set_evictions_enabled(cache_ptr, TRUE);
if ( result != SUCCEED ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "can't enable evictions 2.");
failure_mssg = msg;
}
}
if ( show_progress ) /* 29 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
/* insert an entry */
insert_entry(cache_ptr, MONSTER_ENTRY_TYPE, 22, TRUE, H5C__NO_FLAGS_SET);
if ( show_progress ) /* 30 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
/* verify that the cache has returned to its maximum size */
if ( pass ) {
if ( ( cache_ptr->index_len != 16 ) ||
( cache_ptr->index_size != 16 * MONSTER_ENTRY_SIZE ) ||
( cache_ptr->slist_len != 3 ) ||
( cache_ptr->slist_size != 3 * MONSTER_ENTRY_SIZE ) ||
( cache_ptr->evictions_enabled != TRUE ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected cache status 11.");
failure_mssg = msg;
}
}
if ( show_progress ) /* 31 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
if ( pass ) {
entry_ptr = &(base_addr[4]);
result = H5C_get_entry_status(cache_ptr, entry_ptr->addr,
NULL, &in_cache, NULL, NULL, NULL);
if ( result < 0 ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"H5AC_get_entry_status() reports failure 5.");
failure_mssg = msg;
} else if ( in_cache ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected status 5.");
failure_mssg = msg;
} else if ( ( ! entry_ptr->loaded ) ||
( entry_ptr->cleared ) ||
( ! entry_ptr->flushed ) ||
( ! entry_ptr->destroyed ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected entry history 5.");
failure_mssg = msg;
}
}
if ( show_progress ) /* 32 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
/* disable evictions one last time before we shut down */
if ( pass ) {
result = H5C_set_evictions_enabled(cache_ptr, FALSE);
if ( result != SUCCEED ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "can't disable evictions 3.");
failure_mssg = msg;
}
}
if ( show_progress ) /* 33 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
if ( pass ) {
takedown_cache(cache_ptr, FALSE, FALSE);
}
if ( show_progress ) /* 34 */
HDfprintf(stdout, "%s() - %0d -- pass = %d\n",
fcn_name, mile_stone++, (int)pass);
if ( pass ) { PASSED(); } else { H5_FAILED(); }
if ( ! pass ) {
HDfprintf(stdout, "%s(): failure_mssg = \"%s\".\n",
fcn_name, failure_mssg);
}
return;
} /* check_evictions_enabled() */
/*-------------------------------------------------------------------------
* Function: check_flush_protected_err()
*
* Purpose: Verify that an attempt to flush the cache when it contains
* a protected entry will generate an error.
*
* Return: void
*
* Programmer: John Mainzer
* 6/24/04
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static void
check_flush_protected_err(void)
{
const char * fcn_name = "check_flush_protected_err";
H5C_t * cache_ptr = NULL;
TESTING("flush cache with protected entry error");
pass = TRUE;
/* allocate a cache, protect an entry, and try to flush. This
* should fail. Unprotect the entry and flush again -- should
* succeed.
*/
if ( pass ) {
reset_entries();
cache_ptr = setup_cache((size_t)(2 * 1024),
(size_t)(1 * 1024));
protect_entry(cache_ptr, 0, 0);
if ( H5C_flush_cache(NULL, -1, -1, cache_ptr, H5C__NO_FLAGS_SET)
>= 0 ) {
pass = FALSE;
failure_mssg = "flush succeeded on cache with protected entry.\n";
} else {
unprotect_entry(cache_ptr, 0, 0, TRUE, H5C__NO_FLAGS_SET);
if ( H5C_flush_cache(NULL, -1, -1, cache_ptr, H5C__NO_FLAGS_SET)
< 0 ) {
pass = FALSE;
failure_mssg = "flush failed after unprotect.\n";
} else {
takedown_cache(cache_ptr, FALSE, FALSE);
}
}
}
if ( pass ) { PASSED(); } else { H5_FAILED(); }
if ( ! pass ) {
HDfprintf(stdout, "%s(): failure_mssg = \"%s\".\n",
fcn_name, failure_mssg);
}
return;
} /* check_flush_protected_err() */
/*-------------------------------------------------------------------------
* Function: check_destroy_pinned_err()
*
* Purpose: Verify that an attempt to destroy the cache when it contains
* a pinned entry that can't be unpined during the flush destroy
* will generate an error.
*
* Return: void
*
* Programmer: John Mainzer
* 4/7/06
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static void
check_destroy_pinned_err(void)
{
const char * fcn_name = "check_destroy_pinned_err()";
H5C_t * cache_ptr = NULL;
TESTING("destroy cache with permanently pinned entry error");
pass = TRUE;
/* allocate a cache, pin an entry, and try to flush destroy. This
* should fail. Unpin the entry and flush destroy again -- should
* succeed.
*/
if ( pass ) {
reset_entries();
cache_ptr = setup_cache((size_t)(2 * 1024),
(size_t)(1 * 1024));
protect_entry(cache_ptr, 0, 0);
unprotect_entry(cache_ptr, 0, 0, FALSE, H5C__PIN_ENTRY_FLAG);
if ( H5C_dest(NULL, -1, -1, cache_ptr) >= 0 ) {
pass = FALSE;
failure_mssg = "destroy succeeded on cache with pinned entry.\n";
} else {
unpin_entry(cache_ptr, 0, 0);
if ( H5C_dest(NULL, -1, -1, cache_ptr) < 0 ) {
pass = FALSE;
failure_mssg = "destroy failed after unpin.\n";
}
}
}
if ( pass ) { PASSED(); } else { H5_FAILED(); }
if ( ! pass ) {
HDfprintf(stdout, "%s(): failure_mssg = \"%s\".\n",
fcn_name, failure_mssg);
}
return;
} /* check_destroy_pinned_err() */
/*-------------------------------------------------------------------------
* Function: check_destroy_protected_err()
*
* Purpose: Verify that an attempt to destroy the cache when it contains
* a protected entry will generate an error.
*
* Return: void
*
* Programmer: John Mainzer
* 6/24/04
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static void
check_destroy_protected_err(void)
{
const char * fcn_name = "check_destroy_protected_err";
H5C_t * cache_ptr = NULL;
TESTING("destroy cache with protected entry error");
pass = TRUE;
/* allocate a cache, protect an entry, and try to flush. This
* should fail. Unprotect the entry and flush again -- should
* succeed.
*/
if ( pass ) {
reset_entries();
cache_ptr = setup_cache((size_t)(2 * 1024),
(size_t)(1 * 1024));
protect_entry(cache_ptr, 0, 0);
if ( H5C_dest(NULL, -1, -1, cache_ptr) >= 0 ) {
pass = FALSE;
failure_mssg = "destroy succeeded on cache with protected entry.\n";
} else {
unprotect_entry(cache_ptr, 0, 0, TRUE, H5C__NO_FLAGS_SET);
if ( H5C_dest(NULL, -1, -1, cache_ptr) < 0 ) {
pass = FALSE;
failure_mssg = "destroy failed after unprotect.\n";
}
}
}
if ( pass ) { PASSED(); } else { H5_FAILED(); }
if ( ! pass ) {
HDfprintf(stdout, "%s(): failure_mssg = \"%s\".\n",
fcn_name, failure_mssg);
}
return;
} /* check_destroy_protected_err() */
/*-------------------------------------------------------------------------
* Function: check_duplicate_insert_err()
*
* Purpose: Verify that an attempt to insert and entry that is
* alread in the cache will generate an error.
*
* Return: void
*
* Programmer: John Mainzer
* 6/24/04
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static void
check_duplicate_insert_err(void)
{
const char * fcn_name = "check_duplicate_insert_err";
herr_t result;
H5C_t * cache_ptr = NULL;
test_entry_t * base_addr;
test_entry_t * entry_ptr;
TESTING("duplicate entry insertion error");
pass = TRUE;
/* allocate a cache, protect an entry, and then try to insert
* the entry again. This should fail. Unprotect the entry and
* destroy the cache -- should succeed.
*/
if ( pass ) {
reset_entries();
cache_ptr = setup_cache((size_t)(2 * 1024),
(size_t)(1 * 1024));
protect_entry(cache_ptr, 0, 0);
if ( pass ) {
base_addr = entries[0];
entry_ptr = &(base_addr[0]);
result = H5C_insert_entry(NULL, -1, -1, cache_ptr,
&(types[0]), entry_ptr->addr,
(void *)entry_ptr, H5C__NO_FLAGS_SET);
if ( result >= 0 ) {
pass = FALSE;
failure_mssg = "insert of duplicate entry succeeded.\n";
} else {
unprotect_entry(cache_ptr, 0, 0, TRUE, H5C__NO_FLAGS_SET);
takedown_cache(cache_ptr, FALSE, FALSE);
}
}
}
if ( pass ) { PASSED(); } else { H5_FAILED(); }
if ( ! pass ) {
HDfprintf(stdout, "%s(): failure_mssg = \"%s\".\n",
fcn_name, failure_mssg);
}
return;
} /* check_duplicate_insert_err() */
/*-------------------------------------------------------------------------
* Function: check_rename_err()
*
* Purpose: Verify that an attempt to rename an entry to the address
* of an existing entry will generate an error.
*
* Return: void
*
* Programmer: John Mainzer
* 6/24/04
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static void
check_rename_err(void)
{
const char * fcn_name = "check_rename_err()";
herr_t result;
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("rename to existing entry errors");
pass = TRUE;
/* allocate a cache, and insert several entries. Try to rename
* entries to other entries resident in the cache. This should
* fail. Destroy the cache -- should succeed.
*/
if ( pass ) {
reset_entries();
cache_ptr = setup_cache((size_t)(2 * 1024),
(size_t)(1 * 1024));
insert_entry(cache_ptr, 0, 0, TRUE, H5C__NO_FLAGS_SET);
insert_entry(cache_ptr, 0, 1, TRUE, H5C__NO_FLAGS_SET);
insert_entry(cache_ptr, 1, 0, TRUE, 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_rename_entry(cache_ptr, &(types[0]),
entry_0_0_ptr->addr, entry_0_1_ptr->addr);
if ( result >= 0 ) {
pass = FALSE;
failure_mssg = "rename to addr of same type succeeded.\n";
}
}
if ( pass ) {
result = H5C_rename_entry(cache_ptr, &(types[0]),
entry_0_0_ptr->addr, entry_1_0_ptr->addr);
if ( result >= 0 ) {
pass = FALSE;
failure_mssg = "rename to addr of different type succeeded.\n";
}
}
if ( pass ) {
takedown_cache(cache_ptr, FALSE, FALSE);
}
if ( pass ) { PASSED(); } else { H5_FAILED(); }
if ( ! pass ) {
HDfprintf(stdout, "%s: failure_mssg = \"%s\".\n",
fcn_name, failure_mssg);
}
return;
} /* check_rename_err() */
/*-------------------------------------------------------------------------
* Function: check_double_pin_err()
*
* Purpose: Verify that an attempt to pin an entry that is already
* pinned will generate an error.
*
* Return: void
*
* Programmer: John Mainzer
* 4/24/06
*
* Modifications:
*
* None.
*
*-------------------------------------------------------------------------
*/
static void
check_double_pin_err(void)
{
const char * fcn_name = "check_double_pin_err()";
herr_t result;
H5C_t * cache_ptr = NULL;
test_entry_t * entry_ptr;
TESTING("pin a pinned entry error");
pass = TRUE;
/* allocate a cache, protect an entry, unprotect it with the pin flag,
* protect it again, and then try to unprotect it again with the pin
* flag. This should fail. Unpin the entry and destroy the cache
* -- should succeed.
*/
if ( pass ) {
reset_entries();
cache_ptr = setup_cache((size_t)(2 * 1024),
(size_t)(1 * 1024));
protect_entry(cache_ptr, 0, 0);
unprotect_entry(cache_ptr, 0, 0, FALSE, H5C__PIN_ENTRY_FLAG);
protect_entry(cache_ptr, 0, 0);
entry_ptr = &((entries[0])[0]);
}
if ( pass ) {
result = H5C_unprotect(NULL, -1, -1, cache_ptr, &(types[0]),
entry_ptr->addr, (void *)entry_ptr,
H5C__PIN_ENTRY_FLAG, (size_t)0);
if ( result > 0 ) {
pass = FALSE;
failure_mssg =
"attempt to pin a pinned entry succeeded.\n";
} else {
unprotect_entry(cache_ptr, 0, 0, FALSE, H5C__UNPIN_ENTRY_FLAG);
}
}
if ( pass ) {
takedown_cache(cache_ptr, FALSE, FALSE);
}
if ( pass ) { PASSED(); } else { H5_FAILED(); }
if ( ! pass ) {
HDfprintf(stdout, "%s: failure_mssg = \"%s\".\n",
fcn_name, failure_mssg);
}
return;
} /* check_double_pin_err() */
/*-------------------------------------------------------------------------
* Function: check_double_unpin_err()
*
* Purpose: Verify that an attempt to unpin an unpinned entry will
* generate an error.
*
* Return: void
*
* Programmer: John Mainzer
* 4/24/06
*
* Modifications:
*
* None.
*
*-------------------------------------------------------------------------
*/
static void
check_double_unpin_err(void)
{
const char * fcn_name = "check_double_unpin_err()";
herr_t result;
H5C_t * cache_ptr = NULL;
test_entry_t * entry_ptr;
TESTING("unpin an unpinned entry error");
pass = TRUE;
/* allocate a cache, protect an entry, unprotect it with the unpin flag.
* -- This should fail.
*
* Try again with H5C_unpin_entry -- this should also fail.
*
* Destroy the cache -- should succeed.
*/
if ( pass ) {
reset_entries();
cache_ptr = setup_cache((size_t)(2 * 1024),
(size_t)(1 * 1024));
protect_entry(cache_ptr, 0, 0);
entry_ptr = &((entries[0])[0]);
}
if ( pass ) {
result = H5C_unprotect(NULL, -1, -1, cache_ptr, &(types[0]),
entry_ptr->addr, (void *)entry_ptr,
H5C__UNPIN_ENTRY_FLAG, (size_t)0);
if ( result > 0 ) {
pass = FALSE;
failure_mssg =
"attempt to unpin an unpinned entry succeeded 1.\n";
} else {
unprotect_entry(cache_ptr, 0, 0, FALSE, H5C__NO_FLAGS_SET);
}
}
if ( pass ) {
result = H5C_unpin_entry(cache_ptr, (void *)entry_ptr);
if ( result > 0 ) {
pass = FALSE;
failure_mssg =
"attempt to unpin an unpinned entry succeeded 2.\n";
}
}
if ( pass ) {
takedown_cache(cache_ptr, FALSE, FALSE);
}
if ( pass ) { PASSED(); } else { H5_FAILED(); }
if ( ! pass ) {
HDfprintf(stdout, "%s: failure_mssg = \"%s\".\n",
fcn_name, failure_mssg);
}
return;
} /* check_double_unpin_err() */
/*-------------------------------------------------------------------------
* Function: check_pin_entry_errs()
*
* Purpose: Verify that invalid calls to H5C_pin_protected_entry()
* generate errors as expected.
*
* Return: void
*
* Programmer: John Mainzer
* 4/24/06
*
* Modifications:
*
* None.
*
*-------------------------------------------------------------------------
*/
static void
check_pin_entry_errs(void)
{
const char * fcn_name = "check_pin_entry_errs()";
herr_t result;
H5C_t * cache_ptr = NULL;
test_entry_t * entry_ptr;
TESTING("pin entry related errors");
pass = TRUE;
/* Allocate a cache, protect an entry, unprotect it with no flags,
* and then call H5C_pin_protected_entry() to pin it -- This should fail.
*
* Protect the entry again, unprotect it with a pin flag, protect it
* again, and then call H5C_pin_protected_entry() to pin it -- This
* should fail also.
*
* Unprotect the entry with the unpin flag.
*
* Destroy the cache -- should succeed.
*/
if ( pass ) {
reset_entries();
cache_ptr = setup_cache((size_t)(2 * 1024),
(size_t)(1 * 1024));
protect_entry(cache_ptr, 0, 0);
unprotect_entry(cache_ptr, 0, 0, FALSE, H5C__NO_FLAGS_SET);
entry_ptr = &((entries[0])[0]);
}
if ( pass ) {
result = H5C_pin_protected_entry(cache_ptr, (void *)entry_ptr);
if ( result > 0 ) {
pass = FALSE;
failure_mssg =
"attempt to pin an unprotected entry succeeded.\n";
} else {
protect_entry(cache_ptr, 0, 0);
unprotect_entry(cache_ptr, 0, 0, FALSE, H5C__PIN_ENTRY_FLAG);
protect_entry(cache_ptr, 0, 0);
}
}
if ( pass ) {
result = H5C_pin_protected_entry(cache_ptr, (void *)entry_ptr);
if ( result > 0 ) {
pass = FALSE;
failure_mssg =
"attempt to pin a pinned, protected entry succeeded.\n";
} else {
unprotect_entry(cache_ptr, 0, 0, FALSE, H5C__UNPIN_ENTRY_FLAG);
}
}
if ( pass ) {
takedown_cache(cache_ptr, FALSE, FALSE);
}
if ( pass ) { PASSED(); } else { H5_FAILED(); }
if ( ! pass ) {
HDfprintf(stdout, "%s: failure_mssg = \"%s\".\n",
fcn_name, failure_mssg);
}
return;
} /* check_pin_entry_errs() */
/*-------------------------------------------------------------------------
* Function: check_double_protect_err()
*
* Purpose: Verify that an attempt to protect an entry that is already
* protected will generate an error.
*
* Return: void
*
* Programmer: John Mainzer
* 6/24/04
*
* Modifications:
*
* - Modified call to H5C_protect() to pass H5C__NO_FLAGS_SET in the
* the new flags parameter.
*
* JRM -- 3/28/07
*
*-------------------------------------------------------------------------
*/
static void
check_double_protect_err(void)
{
const char * fcn_name = "check_double_protect_err()";
H5C_t * cache_ptr = NULL;
test_entry_t * entry_ptr;
H5C_cache_entry_t * cache_entry_ptr;
TESTING("protect a protected entry error");
pass = TRUE;
/* allocate a cache, protect an entry, and then try to protect
* the entry again. This should fail. Unprotect the entry and
* destroy the cache -- should succeed.
*/
if ( pass ) {
reset_entries();
cache_ptr = setup_cache((size_t)(2 * 1024),
(size_t)(1 * 1024));
protect_entry(cache_ptr, 0, 0);
entry_ptr = &((entries[0])[0]);
}
if ( pass ) {
cache_entry_ptr = H5C_protect(NULL, -1, -1, cache_ptr, &(types[0]),
entry_ptr->addr, NULL, NULL,
H5C__NO_FLAGS_SET);
if ( cache_entry_ptr != NULL ) {
pass = FALSE;
failure_mssg = "attempt to protect a protected entry succeeded.\n";
}
}
if ( pass ) {
unprotect_entry(cache_ptr, 0, 0, FALSE, H5C__NO_FLAGS_SET);
}
if ( pass ) {
takedown_cache(cache_ptr, FALSE, FALSE);
}
if ( pass ) { PASSED(); } else { H5_FAILED(); }
if ( ! pass ) {
HDfprintf(stdout, "%s: failure_mssg = \"%s\".\n",
fcn_name, failure_mssg);
}
return;
} /* check_double_protect_err() */
/*-------------------------------------------------------------------------
* Function: check_double_unprotect_err()
*
* Purpose: Verify that an attempt to unprotect an entry that is already
* unprotected will generate an error.
*
* Return: void
*
* Programmer: John Mainzer
* 6/24/04
*
* Modifications:
*
* JRM -- 6/17/05
* Modified function to use the new dirtied parameter in
* H5C_unprotect().
*
* JRM -- 9/8/05
* Updated function for the new size change parameter in
* H5C_unprotect(). We don't use them for now.
*
*-------------------------------------------------------------------------
*/
static void
check_double_unprotect_err(void)
{
const char * fcn_name = "check_double_unprotect_err()";
herr_t result;
H5C_t * cache_ptr = NULL;
test_entry_t * entry_ptr;
TESTING("unprotect an unprotected entry error");
pass = TRUE;
/* allocate a cache, protect an entry, unprotect it, and then try to
* unprotect the entry again. This should fail. Destroy the cache
* -- should succeed.
*/
if ( pass ) {
reset_entries();
cache_ptr = setup_cache((size_t)(2 * 1024),
(size_t)(1 * 1024));
protect_entry(cache_ptr, 0, 0);
unprotect_entry(cache_ptr, 0, 0, FALSE, H5C__NO_FLAGS_SET);
entry_ptr = &((entries[0])[0]);
}
if ( pass ) {
result = H5C_unprotect(NULL, -1, -1, cache_ptr, &(types[0]),
entry_ptr->addr, (void *)entry_ptr,
H5C__NO_FLAGS_SET, (size_t)0);
if ( result > 0 ) {
pass = FALSE;
failure_mssg =
"attempt to unprotect an unprotected entry succeeded 1.\n";
}
}
if ( pass ) {
takedown_cache(cache_ptr, FALSE, FALSE);
}
if ( pass ) { PASSED(); } else { H5_FAILED(); }
if ( ! pass ) {
HDfprintf(stdout, "%s: failure_mssg = \"%s\".\n",
fcn_name, failure_mssg);
}
return;
} /* check_double_unprotect_err() */
/*-------------------------------------------------------------------------
* Function: check_mark_entry_dirty_errs()
*
* Purpose: Verify that:
*
* 1) a call to H5C_mark_pinned_entry_dirty with an upinned
* entry as the target will generate an error.
*
* 2) a call to H5C_mark_pinned_entry_dirty with a protected
* entry as the target will generate an error.
*
* 3) a call to H5C_mark_pinned_or_protected_entry_dirty with
* and unpinned and unprotected entry will generate an
* error.
*
* Return: void
*
* Programmer: John Mainzer
* 5/17/06
*
* Modifications:
*
* None.
*
*-------------------------------------------------------------------------
*/
static void
check_mark_entry_dirty_errs(void)
{
const char * fcn_name = "check_mark_entry_dirty_errs()";
herr_t result;
H5C_t * cache_ptr = NULL;
test_entry_t * entry_ptr;
TESTING("mark entry dirty related errors");
pass = TRUE;
/* allocate a cache, protect an entry, and then attempt to mark it dirty
* with the H5C_mark_pinned_entry_dirty() call -- This should fail.
*
* Then unprotect the entry without pinning it, and try to mark it dirty
* again -- this should fail too.
*
* Try it again using H5C_mark_pinned_or_protected_entry_dirty -- this
* should fail as well.
*
* Destroy the cache -- should succeed.
*/
if ( pass ) {
reset_entries();
cache_ptr = setup_cache((size_t)(2 * 1024),
(size_t)(1 * 1024));
protect_entry(cache_ptr, 0, 0);
unprotect_entry(cache_ptr, 0, 0, FALSE, H5C__PIN_ENTRY_FLAG);
protect_entry(cache_ptr, 0, 0);
entry_ptr = &((entries[0])[0]);
}
if ( pass ) {
result = H5C_mark_pinned_entry_dirty(cache_ptr, (void *)entry_ptr,
FALSE, (size_t)0);
if ( result > 0 ) {
pass = FALSE;
failure_mssg =
"attempt dirty a pinned and protected entry succeeded.\n";
} else {
unprotect_entry(cache_ptr, 0, 0, FALSE, H5C__UNPIN_ENTRY_FLAG);
}
}
if ( pass ) {
result = H5C_mark_pinned_entry_dirty(cache_ptr, (void *)entry_ptr,
FALSE, (size_t)0);
if ( result > 0 ) {
pass = FALSE;
failure_mssg =
"attempt to dirty a unpinned and unprotected entry succeeded 1.\n";
}
}
if ( pass ) {
result = H5C_mark_pinned_or_protected_entry_dirty(cache_ptr,
(void *)entry_ptr);
if ( result > 0 ) {
pass = FALSE;
failure_mssg =
"attempt to dirty a unpinned and unprotected entry succeeded 2.\n";
}
}
if ( pass ) {
takedown_cache(cache_ptr, FALSE, FALSE);
}
if ( pass ) { PASSED(); } else { H5_FAILED(); }
if ( ! pass ) {
HDfprintf(stdout, "%s: failure_mssg = \"%s\".\n",
fcn_name, failure_mssg);
}
return;
} /* check_mark_entry_dirty_errs() */
/*-------------------------------------------------------------------------
* Function: check_expunge_entry_errs()
*
* Purpose: Verify that invalid calls to H5C_expunge_entry()
* generate errors as expected.
*
* Return: void
*
* Programmer: John Mainzer
* 7/6/06
*
* Modifications:
*
* None.
*
*-------------------------------------------------------------------------
*/
static void
check_expunge_entry_errs(void)
{
const char * fcn_name = "check_expunge_entry_errs()";
herr_t result;
H5C_t * cache_ptr = NULL;
test_entry_t * entry_ptr;
TESTING("expunge entry related errors");
pass = TRUE;
/* 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
* H5C_expunge_entry() again. This should fail too.
*
* Finally, unpin the entry and call H5C_expunge_entry() yet again.
* This should succeed.
*
* Destroy the cache -- should succeed.
*/
if ( pass ) {
reset_entries();
cache_ptr = setup_cache((size_t)(2 * 1024),
(size_t)(1 * 1024));
entry_ptr = &((entries[0])[0]);
protect_entry(cache_ptr, 0, 0);
}
if ( pass ) {
result = H5C_expunge_entry(NULL, -1, -1, cache_ptr,
&(types[0]), entry_ptr->addr, H5AC__NO_FLAGS_SET);
if ( result > 0 ) {
pass = FALSE;
failure_mssg =
"attempt to expunge a protected entry succeeded.\n";
} else {
unprotect_entry(cache_ptr, 0, 0, FALSE, H5C__PIN_ENTRY_FLAG);
}
}
if ( pass ) {
result = H5C_expunge_entry(NULL, -1, -1, cache_ptr,
&(types[0]), entry_ptr->addr, H5AC__NO_FLAGS_SET);
if ( result > 0 ) {
pass = FALSE;
failure_mssg =
"attempt to expunge a pinned entry succeeded.\n";
} else {
unpin_entry(cache_ptr, 0, 0);
}
}
if ( pass ) {
result = H5C_expunge_entry(NULL, -1, -1, cache_ptr,
&(types[0]), entry_ptr->addr, H5AC__NO_FLAGS_SET);
if ( result < 0 ) {
pass = FALSE;
failure_mssg =
"attempt to expunge an unpinned and unprotected entry failed.\n";
}
}
if ( pass ) {
takedown_cache(cache_ptr, FALSE, FALSE);
}
if ( pass ) { PASSED(); } else { H5_FAILED(); }
if ( ! pass ) {
HDfprintf(stdout, "%s: failure_mssg = \"%s\".\n",
fcn_name, failure_mssg);
}
return;
} /* check_expunge_entry_errs() */
/*-------------------------------------------------------------------------
* Function: check_resize_entry_errs()
*
* Purpose: Verify that invalid calls to H5C_resize_pinned_entry()
* generates errors as expected.
*
* Return: void
*
* Programmer: John Mainzer
* 7/7/06
*
* Modifications:
*
* None.
*
*-------------------------------------------------------------------------
*/
static void
check_resize_entry_errs(void)
{
const char * fcn_name = "check_resize_entry_errs()";
herr_t result;
H5C_t * cache_ptr = NULL;
test_entry_t * entry_ptr;
TESTING("resize entry related errors");
pass = TRUE;
/* Allocate a cache, protect an entry, and then call
* H5C_resize_pinned_entry() to resize it -- this should fail.
*
* Unprotect the the entry with the pinned flag, and then call
* H5C_resize_pinned_entry() again with new size of zero.
* This should fail too.
*
* Finally, unpin the entry and destroy the cache.
* This should succeed.
*/
if ( pass ) {
reset_entries();
cache_ptr = setup_cache((size_t)(2 * 1024),
(size_t)(1 * 1024));
entry_ptr = &((entries[0])[0]);
protect_entry(cache_ptr, 0, 0);
}
if ( pass ) {
result = H5C_resize_pinned_entry(cache_ptr, (void *)entry_ptr, (size_t)1);
if ( result > 0 ) {
pass = FALSE;
failure_mssg =
"Call to H5C_resize_pinned_entry on a protected entry succeeded.\n";
} else {
unprotect_entry(cache_ptr, 0, 0, FALSE, H5C__PIN_ENTRY_FLAG);
}
}
if ( pass ) {
result = H5C_resize_pinned_entry(cache_ptr, (void *)entry_ptr, (size_t)0);
if ( result > 0 ) {
pass = FALSE;
failure_mssg =
"Call to H5C_resize_pinned_entry with 0 new size succeeded.\n";
} else {
unpin_entry(cache_ptr, 0, 0);
}
}
if ( pass ) {
takedown_cache(cache_ptr, FALSE, FALSE);
}
if ( pass ) { PASSED(); } else { H5_FAILED(); }
if ( ! pass ) {
HDfprintf(stdout, "%s: failure_mssg = \"%s\".\n",
fcn_name, failure_mssg);
}
return;
} /* check_resize_entry_errs() */
/*-------------------------------------------------------------------------
* Function: check_unprotect_ro_dirty_err()
*
* Purpose: If an entry is protected read only, verify that unprotecting
* it dirty will generate an error.
*
* Return: void
*
* Programmer: John Mainzer
* 4/3/07
*
* Modifications:
*
* None.
*
*-------------------------------------------------------------------------
*/
static void
check_unprotect_ro_dirty_err(void)
{
const char * fcn_name = "check_unprotect_ro_dirty_err()";
herr_t result;
H5C_t * cache_ptr = NULL;
test_entry_t * entry_ptr;
TESTING("unprotect a read only entry dirty error");
pass = TRUE;
/* allocate a cache, protect an entry read only, and then unprotect it
* with the dirtied flag set. This should fail. Destroy the cache
* -- should succeed.
*/
if ( pass ) {
reset_entries();
cache_ptr = setup_cache((size_t)(2 * 1024),
(size_t)(1 * 1024));
protect_entry_ro(cache_ptr, 0, 0);
entry_ptr = &((entries[0])[0]);
}
if ( pass ) {
result = H5C_unprotect(NULL, -1, -1, cache_ptr, &(types[0]),
entry_ptr->addr, (void *)entry_ptr,
H5C__DIRTIED_FLAG, (size_t)0);
if ( result >= 0 ) {
pass = FALSE;
failure_mssg =
"attempt to unprotect a ro entry dirty succeeded 1.\n";
}
}
if ( pass ) {
unprotect_entry(cache_ptr, 0, 0, FALSE, H5C__NO_FLAGS_SET);
}
if ( pass ) {
takedown_cache(cache_ptr, FALSE, FALSE);
}
/* allocate a another cache, protect an entry read only twice, and
* then unprotect it with the dirtied flag set. This should fail.
* Unprotect it with no flags set twice and then destroy the cache.
* This should succeed.
*/
if ( pass ) {
reset_entries();
cache_ptr = setup_cache((size_t)(2 * 1024),
(size_t)(1 * 1024));
protect_entry_ro(cache_ptr, 0, 0);
protect_entry_ro(cache_ptr, 0, 0);
entry_ptr = &((entries[0])[0]);
}
if ( pass ) {
result = H5C_unprotect(NULL, -1, -1, cache_ptr, &(types[0]),
entry_ptr->addr, (void *)entry_ptr,
H5C__DIRTIED_FLAG, (size_t)0);
if ( result > 0 ) {
pass = FALSE;
failure_mssg =
"attempt to unprotect a ro entry dirty succeeded 2.\n";
}
}
if ( pass ) {
unprotect_entry(cache_ptr, 0, 0, FALSE, H5C__NO_FLAGS_SET);
unprotect_entry(cache_ptr, 0, 0, FALSE, H5C__NO_FLAGS_SET);
}
if ( pass ) {
takedown_cache(cache_ptr, FALSE, FALSE);
}
if ( pass ) { PASSED(); } else { H5_FAILED(); }
if ( ! pass ) {
HDfprintf(stdout, "%s: failure_mssg = \"%s\".\n",
fcn_name, failure_mssg);
}
return;
} /* check_unprotect_ro_dirty_err() */
/*-------------------------------------------------------------------------
* Function: check_protect_ro_rw_err()
*
* Purpose: If an entry is protected read only, verify that protecting
* it rw will generate an error.
*
* Return: void
*
* Programmer: John Mainzer
* 4/9/07
*
* Modifications:
*
* None.
*
*-------------------------------------------------------------------------
*/
static void
check_protect_ro_rw_err(void)
{
const char * fcn_name = "check_protect_ro_rw_err()";
H5C_t * cache_ptr = NULL;
test_entry_t * entry_ptr;
void * thing_ptr = NULL;
TESTING("protect a read only entry rw error");
pass = TRUE;
/* allocate a cache, protect an entry read only, and then try to protect
* it again rw. This should fail.
*
* Unprotect the entry and destroy the cache -- should succeed.
*/
if ( pass ) {
reset_entries();
cache_ptr = setup_cache((size_t)(2 * 1024),
(size_t)(1 * 1024));
protect_entry_ro(cache_ptr, 0, 0);
entry_ptr = &((entries[0])[0]);
}
if ( pass ) {
thing_ptr = H5C_protect(NULL, -1, -1, cache_ptr, &(types[0]),
entry_ptr->addr, NULL, NULL, H5C__NO_FLAGS_SET);
if ( thing_ptr != NULL ) {
pass = FALSE;
failure_mssg = "attempt to protect a ro entry rw succeeded.\n";
}
}
if ( pass ) {
unprotect_entry(cache_ptr, 0, 0, FALSE, H5C__NO_FLAGS_SET);
}
if ( pass ) {
takedown_cache(cache_ptr, FALSE, FALSE);
}
if ( pass ) { PASSED(); } else { H5_FAILED(); }
if ( ! pass ) {
HDfprintf(stdout, "%s: failure_mssg = \"%s\".\n",
fcn_name, failure_mssg);
}
return;
} /* check_protect_ro_rw_err() */
/*-------------------------------------------------------------------------
* Function: check_evictions_enabled_err()
*
* Purpose: Verify that H5C_get_evictions_enabled() and
* H5C_set_evictions_enabled() generate errors as expected.
*
* Return: void
*
* Programmer: John Mainzer
* 8/3/07
*
* Modifications:
*
* None.
*
*-------------------------------------------------------------------------
*/
static void
check_check_evictions_enabled_err(void)
{
const char * fcn_name = "check_evictions_enabled_err()";
herr_t result;
hbool_t evictions_enabled;
H5C_t * cache_ptr = NULL;
TESTING("get/set evictions enabled errors");
pass = TRUE;
/* allocate a cache.
*
* Call H5C_get_evictions_enabled(), passing it a NULL cache_ptr,
* should fail.
*
* Repeat with a NULL evictions_enabled_ptr, should fail as well.
*
* Configure the cache to use auto cache resize. Call
* H5C_set_evictions_enabled() to disable evictions. Should fail.
*
* Unprotect the entry and destroy the cache -- should succeed.
*/
if ( pass ) {
reset_entries();
cache_ptr = setup_cache((size_t)(2 * 1024),
(size_t)(1 * 1024));
}
if ( pass ) {
result = H5C_get_evictions_enabled(NULL, &evictions_enabled);
if ( result == SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_get_evictions_enabled succeeded() 1.\n";
}
}
if ( pass ) {
result = H5C_get_evictions_enabled(cache_ptr, NULL);
if ( result == SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_get_evictions_enabled succeeded() 2.\n";
}
}
if ( pass ) {
result = H5C_set_evictions_enabled(cache_ptr, TRUE);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_set_evictions_enabled failed().\n";
}
}
if ( pass ) {
(cache_ptr->resize_ctl).incr_mode = H5C_incr__threshold;
result = H5C_get_evictions_enabled(cache_ptr, FALSE);
if ( result == SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_set_evictions_enabled succeeded() 1.\n";
} else if ( cache_ptr->evictions_enabled == TRUE ) {
}
(cache_ptr->resize_ctl).incr_mode = H5C_incr__off;
}
if ( pass ) {
(cache_ptr->resize_ctl).decr_mode = H5C_decr__threshold;
result = H5C_get_evictions_enabled(cache_ptr, FALSE);
if ( result == SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_set_evictions_enabled succeeded() 2.\n";
}
(cache_ptr->resize_ctl).decr_mode = H5C_decr__off;
}
if ( pass ) {
takedown_cache(cache_ptr, FALSE, FALSE);
}
if ( pass ) { PASSED(); } else { H5_FAILED(); }
if ( ! pass ) {
HDfprintf(stdout, "%s: failure_mssg = \"%s\".\n",
fcn_name, failure_mssg);
}
return;
} /* check_evictions_enabled_err() */
/*-------------------------------------------------------------------------
* Function: check_auto_cache_resize()
*
* Purpose: Exercise the automatic cache resizing functionality.
* The objective is to operate the auto-resize code in
* all possible modes. Unfortunately, there are quite
* a few of them.
*
* Return: void
*
* Programmer: John Mainzer
* 10/29/04
*
* Modifications:
*
* John Mainzer 1/8/08
* Added a basic set of tests for the flash cache size
* increment code.
*
*-------------------------------------------------------------------------
*/
hbool_t rpt_fcn_called = FALSE;
enum H5C_resize_status rpt_status;
static void test_rpt_fcn(UNUSED H5C_t * cache_ptr,
UNUSED int32_t version,
UNUSED double hit_rate,
enum H5C_resize_status status,
UNUSED size_t old_max_cache_size,
UNUSED size_t new_max_cache_size,
UNUSED size_t old_min_clean_size,
UNUSED size_t new_min_clean_size)
{
rpt_fcn_called = TRUE;
rpt_status = status;
}
static void
check_auto_cache_resize(void)
{
const char * fcn_name = "check_auto_cache_resize()";
hbool_t show_progress = FALSE;
herr_t result;
int32_t i;
int32_t checkpoint = 0;
H5C_t * cache_ptr = NULL;
H5C_auto_size_ctl_t auto_size_ctl =
{
/* int32_t version = */ H5C__CURR_AUTO_SIZE_CTL_VER,
/* H5C_auto_resize_report_fcn rpt_fcn = */ test_rpt_fcn,
/* hbool_t set_initial_size = */ TRUE,
/* size_t initial_size = */ (512 * 1024),
/* double min_clean_fraction = */ 0.5,
/* size_t max_size = */ (14 * 1024 * 1024),
/* size_t min_size = */ (512 * 1024),
/* int64_t epoch_length = */ 1000,
/* enum H5C_cache_incr_mode incr_mode = */ H5C_incr__threshold,
/* double lower_hr_threshold = */ 0.75,
/* double increment = */ 2.0,
/* hbool_t apply_max_increment = */ TRUE,
/* size_t max_increment = */ (4 * 1024 * 1024),
/* enum H5C_cache_flash_incr_mode */
/* flash_incr_mode = */ H5C_flash_incr__off,
/* double flash_multiple = */ 2.0,
/* double flash_threshold = */ 0.5,
/* enum H5C_cache_decr_mode decr_mode = */ H5C_decr__threshold,
/* double upper_hr_threshold = */ 0.995,
/* double decrement = */ 0.1,
/* hbool_t apply_max_decrement = */ TRUE,
/* size_t max_decrement = */ (1 * 1024 * 1024),
/* int32_t epochs_before_eviction = */ 3,
/* hbool_t apply_empty_reserve = */ TRUE,
/* double empty_reserve = */ 0.05
};
TESTING("automatic cache resizing");
pass = TRUE;
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* allocate a cache, enable automatic cache resizing, and then force
* the cache through all its operational modes. Verify that all
* performs as expected.
*/
if ( pass ) {
reset_entries();
cache_ptr = setup_cache((size_t)(2 * 1024),
(size_t)(1 * 1024));
}
if ( pass ) {
result = H5C_set_cache_auto_resize_config(cache_ptr, &auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_set_cache_auto_resize_config failed 1.\n";
}
}
if ( pass ) {
if ( ( cache_ptr->max_cache_size != (512 * 1024) ) ||
( cache_ptr->min_clean_size != (256 * 1024) ) ) {
pass = FALSE;
failure_mssg = "bad cache size after initialization.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* force low hit rate with cache not full -- should result in not
* full status.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, PICO_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, PICO_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != not_full ) ||
( cache_ptr->max_cache_size != (512 * 1024) ) ||
( cache_ptr->min_clean_size != (256 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 1.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* force low hit rate with cache full -- should result in increase
* of cache size from .5 to 1 meg.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != increase ) ||
( cache_ptr->max_cache_size != (1 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (512 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 2.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* force low hit rate with cache not full -- should result in not
* full status.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, PICO_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, PICO_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != not_full ) ||
( cache_ptr->max_cache_size != (1 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (512 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 3.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* force low hit rate with cache full again -- should result in increase
* of cache size from 1 to 2 meg.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != increase ) ||
( cache_ptr->max_cache_size != (2 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (1 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 4.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* force low hit rate with cache full again -- should result in increase
* of cache size from 2 to 4 meg.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != increase ) ||
( cache_ptr->max_cache_size != (4 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (2 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 5.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* force low hit rate with cache full again -- should result in increase
* of cache size from 4 to 8 meg.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != increase ) ||
( cache_ptr->max_cache_size != (8 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (4 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 6.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* force low hit rate with cache full again -- should result in increase
* of cache size from 8 to 12 meg. Note that max increase reduced the
* size of the increase.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != increase ) ||
( cache_ptr->max_cache_size != (12 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (6 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 7.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* force low hit rate with cache full again -- should result in increase
* of cache size from 12 to 14 meg.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != increase ) ||
( cache_ptr->max_cache_size != (14 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (7 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 8.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* force low hit rate with cache full and at maximum size -- should
* in no change in size and a result of at_max_size.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != at_max_size ) ||
( cache_ptr->max_cache_size != (14 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (7 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 9.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* force high hit rate with cache full and at maximum size -- should
* result in a decrease from 14 to 13 Meg -- note that max decrease
* reduced the size of the reduction
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != decrease ) ||
( cache_ptr->max_cache_size != (13 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (6 * 1024 * 1024 + 512 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 10.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* the current cache configuration is inconvenient for testing cache
* size reduction, so lets change it some something easier to work
* with.
*/
if ( pass ) {
auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
auto_size_ctl.rpt_fcn = test_rpt_fcn;
auto_size_ctl.set_initial_size = TRUE;
auto_size_ctl.initial_size = 4 * 1000 * 1000 + 10;
auto_size_ctl.min_clean_fraction = 0.1;
auto_size_ctl.max_size = 8 * 1000 * 1000;
auto_size_ctl.min_size = 500 * 1000;
auto_size_ctl.epoch_length = 1000;
auto_size_ctl.incr_mode = H5C_incr__threshold;
auto_size_ctl.lower_hr_threshold = 0.75;
auto_size_ctl.increment = 2.0;
auto_size_ctl.apply_max_increment = TRUE;
auto_size_ctl.max_increment = (4 * 1000 * 1000);
auto_size_ctl.flash_incr_mode = H5C_flash_incr__off;
auto_size_ctl.flash_multiple = 2.0;
auto_size_ctl.flash_threshold = 0.5;
auto_size_ctl.decr_mode = H5C_decr__threshold;
auto_size_ctl.upper_hr_threshold = 0.995;
auto_size_ctl.decrement = 0.5;
auto_size_ctl.apply_max_decrement = TRUE;
auto_size_ctl.max_decrement = (1 * 1000 * 1000);
auto_size_ctl.epochs_before_eviction = 3;
auto_size_ctl.apply_empty_reserve = TRUE;
auto_size_ctl.empty_reserve = 0.05;
result = H5C_set_cache_auto_resize_config(cache_ptr, &auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_set_cache_auto_resize_config failed 2.\n";
}
}
if ( pass ) {
if ( ( cache_ptr->max_cache_size != (4 * 1000 * 1000 + 10) ) ||
( cache_ptr->min_clean_size != (400 * 1000 + 1) ) ) {
pass = FALSE;
failure_mssg = "bad cache size after set resize re-config 1.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* force high hit rate -- should result in a decrease from ~4 to ~3
* M -- note that max decrease reduces the size of the reduction
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != decrease ) ||
( cache_ptr->max_cache_size != (3 * 1000 * 1000 + 10) ) ||
( cache_ptr->min_clean_size != (300 * 1000 + 1) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 11.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* force high hit rate again -- should result in a decrease from ~3
* to ~2 M -- again note that max decrease reduces the size of the
* reduction.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != decrease ) ||
( cache_ptr->max_cache_size != (2 * 1000 * 1000 + 10) ) ||
( cache_ptr->min_clean_size != (200 * 1000 + 1) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 12.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* force high hit rate again -- should result in a decrease from ~2
* to ~1 M -- again note that max decrease reduces the size of the
* reduction, but only by five bites.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != decrease ) ||
( cache_ptr->max_cache_size != (1 * 1000 * 1000 + 10) ) ||
( cache_ptr->min_clean_size != (100 * 1000 + 1) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 13.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* force high hit rate again -- should result in a decrease from ~1
* to ~0.5 M -- max decrease is no longer a factor. New size is five
* bytes above the minimum.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != decrease ) ||
( cache_ptr->max_cache_size != (500 * 1000 + 5) ) ||
( cache_ptr->min_clean_size != (50 * 1000) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 14.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* force high hit rate again -- should result in a decrease of five
* bytes to the minimum cache size.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != decrease ) ||
( cache_ptr->max_cache_size != (500 * 1000) ) ||
( cache_ptr->min_clean_size != (50 * 1000) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 15.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* force high hit rate again -- Already at minimum size so no change in
* cache size and result should be at_min_size.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != at_min_size ) ||
( cache_ptr->max_cache_size != (500 * 1000) ) ||
( cache_ptr->min_clean_size != (50 * 1000) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 16.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* force in range hit rate -- should be no change in cache size,
* and result should be in_spec.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 900 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i + 1000);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i + 1000,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != in_spec ) ||
( cache_ptr->max_cache_size != (500 * 1000) ) ||
( cache_ptr->min_clean_size != (50 * 1000) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 17.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* force low hit rate with cache full -- should
* increase cache size from .5 to 1 M.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != increase ) ||
( cache_ptr->max_cache_size != (1 * 1000 * 1000) ) ||
( cache_ptr->min_clean_size != (100 * 1000) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 18.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* force high hit rate -- should result in a decrease to the
* minimum cache size.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != decrease ) ||
( cache_ptr->max_cache_size != (500 * 1000) ) ||
( cache_ptr->min_clean_size != (50 * 1000) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 19.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/******************************************************************
* now do some tests with the maximum increase and decrease sizes
* disabled.
******************************************************************/
if ( pass ) {
auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
auto_size_ctl.rpt_fcn = test_rpt_fcn;
auto_size_ctl.set_initial_size = TRUE;
auto_size_ctl.initial_size = 4 * 1024 * 1024;
auto_size_ctl.min_clean_fraction = 0.5;
auto_size_ctl.max_size = 16 * 1024 * 1024;
auto_size_ctl.min_size = 1 * 1024 * 1024;
auto_size_ctl.epoch_length = 1000;
auto_size_ctl.incr_mode = H5C_incr__threshold;
auto_size_ctl.lower_hr_threshold = 0.75;
auto_size_ctl.increment = 4.0;
auto_size_ctl.apply_max_increment = FALSE;
auto_size_ctl.max_increment = (4 * 1024 * 1024);
auto_size_ctl.flash_incr_mode = H5C_flash_incr__off;
auto_size_ctl.flash_multiple = 2.0;
auto_size_ctl.flash_threshold = 0.5;
auto_size_ctl.decr_mode = H5C_decr__threshold;
auto_size_ctl.upper_hr_threshold = 0.995;
auto_size_ctl.decrement = 0.25;
auto_size_ctl.apply_max_decrement = FALSE;
auto_size_ctl.max_decrement = (1 * 1024 * 1024);
auto_size_ctl.epochs_before_eviction = 3;
auto_size_ctl.apply_empty_reserve = TRUE;
auto_size_ctl.empty_reserve = 0.05;
result = H5C_set_cache_auto_resize_config(cache_ptr, &auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_set_cache_auto_resize_config failed 3.\n";
}
}
if ( pass ) {
if ( ( cache_ptr->max_cache_size != (4 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (2 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "bad cache size after set resize re-config 2.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* force high hit rate -- should result in a decrease to the
* minimum cache size.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != decrease ) ||
( cache_ptr->max_cache_size != (1 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (512 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 20.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* force low hit rate with cache full -- should increase cache size
* from 1 to 4 Meg.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != increase ) ||
( cache_ptr->max_cache_size != (4 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (2 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 21.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* force low hit rate again with cache full -- should increase cache
* size from 4 to 16 Meg.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != increase ) ||
( cache_ptr->max_cache_size != (16 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != ( 8 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 22.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* force high hit rate -- should result in a decrease cache size from
* 16 to 4 Meg.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != decrease ) ||
( cache_ptr->max_cache_size != (4 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (2 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 23.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/******************************************************************
* We have tested the threshold increment and decrement modes.
* must now test the ageout decrement mode.
*
* Reconfigure the cache for this testing.
******************************************************************/
if ( pass ) {
auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
auto_size_ctl.rpt_fcn = test_rpt_fcn;
auto_size_ctl.set_initial_size = TRUE;
auto_size_ctl.initial_size = 8 * 1024 * 1024;
auto_size_ctl.min_clean_fraction = 0.5;
auto_size_ctl.max_size = 8 * 1024 * 1024;
auto_size_ctl.min_size = 512 * 1024;
auto_size_ctl.epoch_length = 1000;
auto_size_ctl.incr_mode = H5C_incr__threshold;
auto_size_ctl.lower_hr_threshold = 0.75;
auto_size_ctl.increment = 2.0;
auto_size_ctl.apply_max_increment = TRUE;
auto_size_ctl.max_increment = (4 * 1024 * 1024);
auto_size_ctl.flash_incr_mode = H5C_flash_incr__off;
auto_size_ctl.flash_multiple = 2.0;
auto_size_ctl.flash_threshold = 0.5;
auto_size_ctl.decr_mode = H5C_decr__age_out;
auto_size_ctl.upper_hr_threshold = 0.995;
auto_size_ctl.decrement = 0.5;
auto_size_ctl.apply_max_decrement = FALSE;
auto_size_ctl.max_decrement = (1 * 1024 * 1024);
auto_size_ctl.epochs_before_eviction = 3;
auto_size_ctl.apply_empty_reserve = FALSE;
auto_size_ctl.empty_reserve = 0.05;
result = H5C_set_cache_auto_resize_config(cache_ptr, &auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_set_cache_auto_resize_config failed 4.\n";
}
}
if ( pass ) {
if ( ( cache_ptr->max_cache_size != (8 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (4 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "bad cache size after set resize re-config 3.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* fill the cache with 1024 byte entries -- nothing should happen
* for three epochs while the markers are inserted into the cache
*
* Note that hit rate will be zero, so the cache will attempt to
* increase its size. Since we are already at max size, it will
* not be able to.
*/
if ( pass ) { /* first epoch */
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != at_max_size ) ||
( cache_ptr->max_cache_size != (8 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (4 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 24.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
if ( pass ) { /* second epoch */
rpt_fcn_called = FALSE;
i = 1000;
while ( ( pass ) && ( i < 2000 ) )
{
protect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != at_max_size ) ||
( cache_ptr->max_cache_size != (8 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (4 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 25.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
if ( pass ) { /* third epoch */
rpt_fcn_called = FALSE;
i = 2000;
while ( ( pass ) && ( i < 3000 ) )
{
protect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != at_max_size ) ||
( cache_ptr->max_cache_size != (8 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (4 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 26.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* fourth epoch -- If the hit rate were above the lower threshold,
* we would see cache size reduction now. However, nothing will
* happen until we get the hit rate above the lower threshold.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 3000;
while ( ( pass ) && ( i < 4000 ) )
{
protect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != at_max_size ) ||
( cache_ptr->max_cache_size != (8 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (4 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 27.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* fifth epoch -- force the hit rate to 100%. We should see cache size
* reduction now.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 3000;
while ( ( pass ) && ( i < 4000 ) )
{
protect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != decrease ) ||
( cache_ptr->max_cache_size != (2001 * 1024) ) ||
( cache_ptr->min_clean_size != (int)(2001 * 512) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 28.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* sixth epoch -- force the hit rate to 100% again.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 3000;
while ( ( pass ) && ( i < 4000 ) )
{
protect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != decrease ) ||
( cache_ptr->max_cache_size != (1001 * 1024) ) ||
( cache_ptr->min_clean_size != (int)(1001 * 512) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 29.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* seventh epoch -- force the hit rate to 100% again.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 3000;
while ( ( pass ) && ( i < 4000 ) )
{
protect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != decrease ) ||
( cache_ptr->max_cache_size != (1000 * 1024) ) ||
( cache_ptr->min_clean_size != (int)(1000 * 512) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 30.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* eigth epoch -- force the hit rate to 100% again -- should be steady
* state.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 3000;
while ( ( pass ) && ( i < 4000 ) )
{
protect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != in_spec ) ||
( cache_ptr->max_cache_size != (1000 * 1024) ) ||
( cache_ptr->min_clean_size != (int)(1000 * 512) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 31.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "*check point %d\n", checkpoint++);
/* now just bang on one entry -- after three epochs, this should
* get all entries other than the one evicted, and the cache size
* should be decreased to the minimum.
*/
if ( pass ) { /* ninth epoch */
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != in_spec ) ||
( cache_ptr->max_cache_size != (1000 * 1024) ) ||
( cache_ptr->min_clean_size != (int)(1000 * 512) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 32.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
if ( pass ) { /* tenth epoch */
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != in_spec ) ||
( cache_ptr->max_cache_size != (1000 * 1024) ) ||
( cache_ptr->min_clean_size != (int)(1000 * 512) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 33.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
if ( pass ) { /* eleventh epoch -- cache size reduction */
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != decrease ) ||
( cache_ptr->max_cache_size != (512 * 1024) ) ||
( cache_ptr->min_clean_size != (256 * 1024) ) ||
( cache_ptr->index_len != 2 ) ||
( cache_ptr->index_size !=
MONSTER_ENTRY_SIZE + MEDIUM_ENTRY_SIZE ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 34.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
if ( pass ) { /* twelth epoch -- at minimum size so no more ageouts */
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != at_min_size ) ||
( cache_ptr->max_cache_size != (512 * 1024) ) ||
( cache_ptr->min_clean_size != (256 * 1024) ) ||
( cache_ptr->index_len != 2 ) ||
( cache_ptr->index_size !=
MONSTER_ENTRY_SIZE + MEDIUM_ENTRY_SIZE ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 35.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* repeat the above test, but with max_decrement enabled to see
* if that features works as it should. Note that this will change
* the structure of the test a bit.
*/
if ( pass ) {
auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
auto_size_ctl.rpt_fcn = test_rpt_fcn;
auto_size_ctl.set_initial_size = TRUE;
auto_size_ctl.initial_size = 8 * 1024 * 1024;
auto_size_ctl.min_clean_fraction = 0.5;
auto_size_ctl.max_size = 8 * 1024 * 1024;
auto_size_ctl.min_size = 512 * 1024;
auto_size_ctl.epoch_length = 1000;
auto_size_ctl.incr_mode = H5C_incr__threshold;
auto_size_ctl.lower_hr_threshold = 0.75;
auto_size_ctl.increment = 2.0;
auto_size_ctl.apply_max_increment = TRUE;
auto_size_ctl.max_increment = (4 * 1024 * 1024);
auto_size_ctl.flash_incr_mode = H5C_flash_incr__off;
auto_size_ctl.flash_multiple = 2.0;
auto_size_ctl.flash_threshold = 0.5;
auto_size_ctl.decr_mode = H5C_decr__age_out;
auto_size_ctl.upper_hr_threshold = 0.995;
auto_size_ctl.decrement = 0.5;
auto_size_ctl.apply_max_decrement = TRUE;
auto_size_ctl.max_decrement = (1 * 1024 * 1024);
auto_size_ctl.epochs_before_eviction = 3;
auto_size_ctl.apply_empty_reserve = FALSE;
auto_size_ctl.empty_reserve = 0.05;
result = H5C_set_cache_auto_resize_config(cache_ptr, &auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_set_cache_auto_resize_config failed 5.\n";
}
}
if ( pass ) {
if ( ( cache_ptr->max_cache_size != (8 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (4 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "bad cache size after set resize re-config 4.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* fill the cache with 1024 byte entries -- nothing should happen
* for three epochs while the markers are inserted into the cache
*
* Note that hit rate will be zero, so the cache will attempt to
* increase its size. Since we are already at max size, it will
* not be able to.
*/
if ( pass ) { /* first epoch */
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != at_max_size ) ||
( cache_ptr->max_cache_size != (8 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (4 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 36.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
if ( pass ) { /* second epoch */
rpt_fcn_called = FALSE;
i = 1000;
while ( ( pass ) && ( i < 2000 ) )
{
protect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != at_max_size ) ||
( cache_ptr->max_cache_size != (8 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (4 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 37.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
if ( pass ) { /* third epoch */
rpt_fcn_called = FALSE;
i = 2000;
while ( ( pass ) && ( i < 3000 ) )
{
protect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != at_max_size ) ||
( cache_ptr->max_cache_size != (8 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (4 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 38.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* fourth epoch -- If the hit rate were above the lower threshold,
* we would see cache size reduction now. However, nothing will
* happen until we get the hit rate above the lower threshold.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 3000;
while ( ( pass ) && ( i < 4000 ) )
{
protect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != at_max_size ) ||
( cache_ptr->max_cache_size != (8 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (4 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 39.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* fifth epoch -- force the hit rate to 100%. We should see cache size
* reduction now.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 3000;
while ( ( pass ) && ( i < 4000 ) )
{
protect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != decrease ) ||
( cache_ptr->max_cache_size != (7 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (7 * 512 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 40.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* sixth epoch -- force the hit rate to 100% again.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 2000;
while ( ( pass ) && ( i < 3000 ) )
{
protect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != decrease ) ||
( cache_ptr->max_cache_size != (6 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (6 * 512 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 41.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* seventh epoch -- keep hit rate at 100%, and keep 2K entries active.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 3000;
while ( ( pass ) && ( i < 4000 ) )
{
protect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != decrease ) ||
( cache_ptr->max_cache_size != (5 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (5 * 512 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 42.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* eigth epoch -- still 100% hit rate
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 2000;
while ( ( pass ) && ( i < 3000 ) )
{
protect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != decrease ) ||
( cache_ptr->max_cache_size != (4 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (4 * 512 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 43.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* ninth epoch --hit rate at 100%.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 3000;
while ( ( pass ) && ( i < 4000 ) )
{
protect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != decrease ) ||
( cache_ptr->max_cache_size != (3 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (3 * 512 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 44.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* tenth epoch -- still 100% hit rate
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 2000;
while ( ( pass ) && ( i < 3000 ) )
{
protect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != decrease ) ||
( cache_ptr->max_cache_size != (2 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (2 * 512 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 45.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* eleventh epoch -- hit rate at 100% -- starting to stableize
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 3000;
while ( ( pass ) && ( i < 4000 ) )
{
protect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != decrease ) ||
( cache_ptr->max_cache_size != (2000 * 1024) ) ||
( cache_ptr->min_clean_size != (int)(2000 * 512) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 46.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* twelth epoch -- force the hit rate to 100% again -- should be steady
* state.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 2000;
while ( ( pass ) && ( i < 3000 ) )
{
protect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != in_spec ) ||
( cache_ptr->max_cache_size != (2000 * 1024) ) ||
( cache_ptr->min_clean_size != (int)(2000 * 512) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 47.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* now just bang on one entry -- after three epochs, this should
* get all entries other than the one evicted, and the cache size
* should be decreased to the minimum.
*/
if ( pass ) { /* thirteenth epoch */
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != in_spec ) ||
( cache_ptr->max_cache_size != (2000 * 1024) ) ||
( cache_ptr->min_clean_size != (int)(2000 * 512) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 48.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
if ( pass ) { /* fourteenth epoch */
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != decrease ) ||
( cache_ptr->max_cache_size !=
(1001 * 1024 + MONSTER_ENTRY_SIZE) ) ||
( cache_ptr->min_clean_size !=
(1001 * 512 + MONSTER_ENTRY_SIZE / 2) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 49.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
if ( pass ) { /* fifteenth epoch -- cache size reduction */
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != decrease ) ||
( cache_ptr->max_cache_size != (512 * 1024) ) ||
( cache_ptr->min_clean_size != (256 * 1024) ) ||
( cache_ptr->index_len != 2 ) ||
( cache_ptr->index_size !=
MONSTER_ENTRY_SIZE + MEDIUM_ENTRY_SIZE ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 50.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
if ( pass ) { /* sixteenth epoch -- at minimum size so no more ageouts */
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != at_min_size ) ||
( cache_ptr->max_cache_size != (512 * 1024) ) ||
( cache_ptr->min_clean_size != (256 * 1024) ) ||
( cache_ptr->index_len != 2 ) ||
( cache_ptr->index_size !=
MONSTER_ENTRY_SIZE + MEDIUM_ENTRY_SIZE ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 51.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* repeat the test yet again, this time with empty reserve enabled.
* Again, some structural changes in the test are necessary.
*/
if ( pass ) {
auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
auto_size_ctl.rpt_fcn = test_rpt_fcn;
auto_size_ctl.set_initial_size = TRUE;
auto_size_ctl.initial_size = 8 * 1024 * 1024;
auto_size_ctl.min_clean_fraction = 0.5;
auto_size_ctl.max_size = 8 * 1024 * 1024;
auto_size_ctl.min_size = 512 * 1024;
auto_size_ctl.epoch_length = 1000;
auto_size_ctl.incr_mode = H5C_incr__threshold;
auto_size_ctl.lower_hr_threshold = 0.75;
auto_size_ctl.increment = 2.0;
auto_size_ctl.apply_max_increment = TRUE;
auto_size_ctl.max_increment = (4 * 1024 * 1024);
auto_size_ctl.flash_incr_mode = H5C_flash_incr__off;
auto_size_ctl.flash_multiple = 2.0;
auto_size_ctl.flash_threshold = 0.5;
auto_size_ctl.decr_mode = H5C_decr__age_out;
auto_size_ctl.upper_hr_threshold = 0.995;
auto_size_ctl.decrement = 0.5;
auto_size_ctl.apply_max_decrement = FALSE;
auto_size_ctl.max_decrement = (1 * 1024 * 1024);
auto_size_ctl.epochs_before_eviction = 3;
auto_size_ctl.apply_empty_reserve = TRUE;
auto_size_ctl.empty_reserve = 0.5; /* for ease of testing */
result = H5C_set_cache_auto_resize_config(cache_ptr, &auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_set_cache_auto_resize_config failed 6.\n";
}
}
if ( pass ) {
if ( ( cache_ptr->max_cache_size != (8 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (4 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "bad cache size after set resize re-config 5.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* fill the cache with 1024 byte entries -- nothing should happen
* for three epochs while the markers are inserted into the cache
*
* Note that hit rate will be zero, so the cache will attempt to
* increase its size. Since we are already at max size, it will
* not be able to.
*/
if ( pass ) { /* first epoch */
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != at_max_size ) ||
( cache_ptr->max_cache_size != (8 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (4 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 52.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
if ( pass ) { /* second epoch */
rpt_fcn_called = FALSE;
i = 1000;
while ( ( pass ) && ( i < 2000 ) )
{
protect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != at_max_size ) ||
( cache_ptr->max_cache_size != (8 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (4 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 53.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
if ( pass ) { /* third epoch */
rpt_fcn_called = FALSE;
i = 2000;
while ( ( pass ) && ( i < 3000 ) )
{
protect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != at_max_size ) ||
( cache_ptr->max_cache_size != (8 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (4 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 54.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* fourth epoch -- If the hit rate were above the lower threshold,
* we would see cache size reduction now. However, nothing will
* happen until we get the hit rate above the lower threshold.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 3000;
while ( ( pass ) && ( i < 4000 ) )
{
protect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != at_max_size ) ||
( cache_ptr->max_cache_size != (8 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (4 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 55.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* fifth epoch -- force the hit rate to 100%. We should see cache size
* reduction now.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 3000;
while ( ( pass ) && ( i < 4000 ) )
{
protect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != decrease ) ||
( cache_ptr->max_cache_size != (4002 * 1024) ) ||
( cache_ptr->min_clean_size != (int)(4002 * 512) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 56.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* sixth epoch -- force the hit rate to 100% again.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 3000;
while ( ( pass ) && ( i < 4000 ) )
{
protect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != decrease ) ||
( cache_ptr->max_cache_size != (2002 * 1024) ) ||
( cache_ptr->min_clean_size != (int)(2002 * 512) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 57.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* seventh epoch -- force the hit rate to 100% again.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 3000;
while ( ( pass ) && ( i < 4000 ) )
{
protect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != decrease ) ||
( cache_ptr->max_cache_size != (2000 * 1024) ) ||
( cache_ptr->min_clean_size != (int)(2000 * 512) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 58.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* eigth epoch -- force the hit rate to 100% again -- should be steady
* state.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 3000;
while ( ( pass ) && ( i < 4000 ) )
{
protect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != in_spec ) ||
( cache_ptr->max_cache_size != (2000 * 1024) ) ||
( cache_ptr->min_clean_size != (int)(2000 * 512) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 59.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* now just bang on one entry -- after three epochs, this should
* get all entries other than the one evicted, and the cache size
* should be decreased to the minimum.
*/
if ( pass ) { /* ninth epoch */
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != in_spec ) ||
( cache_ptr->max_cache_size != (2000 * 1024) ) ||
( cache_ptr->min_clean_size != (int)(2000 * 512) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 60.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
if ( pass ) { /* tenth epoch */
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != in_spec ) ||
( cache_ptr->max_cache_size != (2000 * 1024) ) ||
( cache_ptr->min_clean_size != (2000 * 512) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 61.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
if ( pass ) { /* eleventh epoch -- cache size reduction */
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != decrease ) ||
( cache_ptr->max_cache_size != (512 * 1024) ) ||
( cache_ptr->min_clean_size != (256 * 1024) ) ||
( cache_ptr->index_len != 2 ) ||
( cache_ptr->index_size !=
MONSTER_ENTRY_SIZE + MEDIUM_ENTRY_SIZE ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 62.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
if ( pass ) { /* twelth epoch -- at minimum size so no more ageouts */
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != at_min_size ) ||
( cache_ptr->max_cache_size != (512 * 1024) ) ||
( cache_ptr->min_clean_size != (256 * 1024) ) ||
( cache_ptr->index_len != 2 ) ||
( cache_ptr->index_size !=
MONSTER_ENTRY_SIZE + MEDIUM_ENTRY_SIZE ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 63.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* Repeat the test again, this time using the age out with threshold
* mode. To simplify the testing, set epochs to eviction to 1.
*
* Again, there are some minor structural changes in the test.
*/
if ( pass ) {
auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
auto_size_ctl.rpt_fcn = test_rpt_fcn;
auto_size_ctl.set_initial_size = TRUE;
auto_size_ctl.initial_size = 8 * 1024 * 1024;
auto_size_ctl.min_clean_fraction = 0.5;
auto_size_ctl.max_size = 8 * 1024 * 1024;
auto_size_ctl.min_size = 512 * 1024;
auto_size_ctl.epoch_length = 1000;
auto_size_ctl.incr_mode = H5C_incr__off;
auto_size_ctl.lower_hr_threshold = 0.75;
auto_size_ctl.increment = 2.0;
auto_size_ctl.apply_max_increment = TRUE;
auto_size_ctl.max_increment = (4 * 1024 * 1024);
auto_size_ctl.flash_incr_mode = H5C_flash_incr__off;
auto_size_ctl.flash_multiple = 2.0;
auto_size_ctl.flash_threshold = 0.5;
auto_size_ctl.decr_mode = H5C_decr__age_out_with_threshold;
auto_size_ctl.upper_hr_threshold = 0.999; /* for ease of testing */
auto_size_ctl.decrement = 0.5;
auto_size_ctl.apply_max_decrement = FALSE;
auto_size_ctl.max_decrement = (1 * 1024 * 1024);
auto_size_ctl.epochs_before_eviction = 1; /* for ease of testing */
auto_size_ctl.apply_empty_reserve = FALSE;
auto_size_ctl.empty_reserve = 0.05;
result = H5C_set_cache_auto_resize_config(cache_ptr, &auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_set_cache_auto_resize_config failed 7.\n";
}
}
if ( pass ) {
if ( ( cache_ptr->max_cache_size != (8 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (4 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "bad cache size after set resize re-config 6.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* fill the cache with 4K byte entries -- increment mode is off,
* so cache size reduction should kick in as soon as we get the
* hit rate above .999.
*/
if ( pass ) { /* first epoch -- hit rate 0 */
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, LARGE_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, LARGE_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != in_spec ) ||
( cache_ptr->max_cache_size != (8 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (4 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 64.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
if ( pass ) { /* second epoch -- hit rate 0 */
rpt_fcn_called = FALSE;
i = 1000;
while ( ( pass ) && ( i < 2000 ) )
{
protect_entry(cache_ptr, LARGE_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, LARGE_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != in_spec ) ||
( cache_ptr->max_cache_size != (8 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (4 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 65.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
if ( pass ) { /* third epoch -- hit rate 1.0 -- should see decrease */
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, LARGE_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, LARGE_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != decrease ) ||
( cache_ptr->max_cache_size != (1001 * LARGE_ENTRY_SIZE) ) ||
( cache_ptr->min_clean_size != (1001 * LARGE_ENTRY_SIZE / 2) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 66.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* fourth epoch -- load up the cache again -- hit rate 0 */
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != in_spec ) ||
( cache_ptr->max_cache_size != (1001 * LARGE_ENTRY_SIZE) ) ||
( cache_ptr->min_clean_size != (1001 * LARGE_ENTRY_SIZE / 2) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 67.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* fifth epoch -- still loading up the cache -- hit rate 0 */
if ( pass ) {
rpt_fcn_called = FALSE;
i = 1000;
while ( ( pass ) && ( i < 2000 ) )
{
protect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != in_spec ) ||
( cache_ptr->max_cache_size != (1001 * LARGE_ENTRY_SIZE) ) ||
( cache_ptr->min_clean_size != (1001 * LARGE_ENTRY_SIZE / 2) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 68.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* sixth epoch -- force hit rate to .998 -- should be no reduction */
if ( pass ) {
rpt_fcn_called = FALSE;
i = 1002;
while ( ( pass ) && ( i < 2002 ) )
{
protect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != in_spec ) ||
( cache_ptr->max_cache_size != (1001 * LARGE_ENTRY_SIZE) ) ||
( cache_ptr->min_clean_size != (1001 * LARGE_ENTRY_SIZE / 2) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 69.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* seventh epoch -- force hit rate to .999 -- should see reduction
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 1003;
while ( ( pass ) && ( i < 2003 ) )
{
protect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != decrease ) ||
( cache_ptr->max_cache_size != (1000 * MEDIUM_ENTRY_SIZE) ) ||
( cache_ptr->min_clean_size != (1000 * MEDIUM_ENTRY_SIZE / 2) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 70.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* We have now tested all the major ageout modes individually.
* Lets try them all together to look for unexpected interactions
* and/or bugs.
*/
if ( pass ) {
auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
auto_size_ctl.rpt_fcn = test_rpt_fcn;
auto_size_ctl.set_initial_size = TRUE;
auto_size_ctl.initial_size = 8 * 1000 * 1024;
auto_size_ctl.min_clean_fraction = 0.5;
auto_size_ctl.max_size = 8 * 1000 * 1024;
auto_size_ctl.min_size = 512 * 1024;
auto_size_ctl.epoch_length = 1000;
auto_size_ctl.incr_mode = H5C_incr__threshold;
auto_size_ctl.lower_hr_threshold = 0.75;
auto_size_ctl.increment = 2.0;
auto_size_ctl.apply_max_increment = TRUE;
auto_size_ctl.max_increment = (4 * 1024 * 1024);
auto_size_ctl.flash_incr_mode = H5C_flash_incr__off;
auto_size_ctl.flash_multiple = 2.0;
auto_size_ctl.flash_threshold = 0.5;
auto_size_ctl.decr_mode = H5C_decr__age_out_with_threshold;
auto_size_ctl.upper_hr_threshold = 0.999; /* for ease of testing */
auto_size_ctl.decrement = 0.5;
auto_size_ctl.apply_max_decrement = TRUE;
auto_size_ctl.max_decrement = (1 * 1000 * 1024);
auto_size_ctl.epochs_before_eviction = 1; /* for ease of testing */
auto_size_ctl.apply_empty_reserve = TRUE;
auto_size_ctl.empty_reserve = 0.5; /* for ease of testing */
result = H5C_set_cache_auto_resize_config(cache_ptr, &auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_set_cache_auto_resize_config failed 8.\n";
}
}
if ( pass ) {
if ( ( cache_ptr->max_cache_size != (8 * 1000 * 1024) ) ||
( cache_ptr->min_clean_size != (4 * 1000 * 1024) ) ) {
pass = FALSE;
failure_mssg = "bad cache size after set resize re-config 7.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* fill the cache with 4K byte entries -- increment mode is threshold,
* so the decrease code will not be executed until the hit rate exceeds
* .75.
*/
if ( pass ) { /* first epoch -- hit rate 0 */
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, LARGE_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, LARGE_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != at_max_size ) ||
( cache_ptr->max_cache_size != (8 * 1000 * 1024) ) ||
( cache_ptr->min_clean_size != (4 * 1000 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 71.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
if ( pass ) { /* second epoch -- hit rate 0 */
rpt_fcn_called = FALSE;
i = 1000;
while ( ( pass ) && ( i < 2000 ) )
{
protect_entry(cache_ptr, LARGE_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, LARGE_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != at_max_size ) ||
( cache_ptr->max_cache_size != (8 * 1000 * 1024) ) ||
( cache_ptr->min_clean_size != (4 * 1000 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 72.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* third epoch -- force the hit rate to 1.0. Should be no change
* in the cache size due to the combination of the empty reserve
* and the max decrease. Max decrease will limit the evictions
* in any one epoch, and the empty reserve will not permit cache
* size reduction unless the specified empty reserve is maintained.
*
* In this epoch, all we should see is a reduction in the index size.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, LARGE_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, LARGE_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != in_spec ) ||
( cache_ptr->max_cache_size != (8 * 1000 * 1024) ) ||
( cache_ptr->min_clean_size != (4 * 1000 * 1024) ) ||
( cache_ptr->index_size != (7 * 1000 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 73.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* fourth epoch -- hit rate still 1.0. Index size should decrease,
* but otherwise no change expected.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, LARGE_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, LARGE_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != in_spec ) ||
( cache_ptr->max_cache_size != (8 * 1000 * 1024) ) ||
( cache_ptr->min_clean_size != (4 * 1000 * 1024) ) ||
( cache_ptr->index_size != (6 * 1000 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 74.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* fifth epoch -- hit rate still 1.0. Index size should decrease,
* but otherwise no change expected.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, LARGE_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, LARGE_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != in_spec ) ||
( cache_ptr->max_cache_size != (8 * 1000 * 1024) ) ||
( cache_ptr->min_clean_size != (4 * 1000 * 1024) ) ||
( cache_ptr->index_size != (5 * 1000 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 75.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* sixth epoch -- hit rate still 1.0. Index size should decrease,
* but otherwise no change expected. Note that the cache size is
* now just on the edge of meeting the clean reserve.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, LARGE_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, LARGE_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != in_spec ) ||
( cache_ptr->max_cache_size != (8 * 1000 * 1024) ) ||
( cache_ptr->min_clean_size != (4 * 1000 * 1024) ) ||
( cache_ptr->index_size != (4 * 1000 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 76.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* seventh epoch -- hit rate still 1.0. No change in index size expected.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, LARGE_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, LARGE_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != in_spec ) ||
( cache_ptr->max_cache_size != (8 * 1000 * 1024) ) ||
( cache_ptr->min_clean_size != (4 * 1000 * 1024) ) ||
( cache_ptr->index_size != (4 * 1000 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 77.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* eighth epoch -- start loading 1 KB entries. Hit rate 0 so
* decrease code shouldn't be called.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != at_max_size ) ||
( cache_ptr->max_cache_size != (8 * 1000 * 1024) ) ||
( cache_ptr->min_clean_size != (4 * 1000 * 1024) ) ||
( cache_ptr->index_size != (5 * 1000 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 78.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* ninth epoch -- access the 1 KB entries again, driving the hit rate
* to 1.0. Decrease code should be triggered, but the max decrease
* should prevent the empty reserve from being met in this epoch.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != in_spec ) ||
( cache_ptr->max_cache_size != (8 * 1000 * 1024) ) ||
( cache_ptr->min_clean_size != (4 * 1000 * 1024) ) ||
( cache_ptr->index_size != (4 * 1000 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 79.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* tenth epoch -- access the 1 KB entries yet again, forcing hit rate
* to 1.0. Decrease code should be triggered, and the empty reserve
* should finally be met.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != decrease ) ||
( cache_ptr->max_cache_size != (7 * 1000 * 1024) ) ||
( cache_ptr->min_clean_size != (7 * 1000 * 1024 / 2) ) ||
( cache_ptr->index_size != (3 * 1000 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 80.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* eleventh epoch -- access the 1 KB entries yet again, forcing hit rate
* to 1.0. Decrease code should be triggered, and the empty reserve
* should be met again.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != decrease ) ||
( cache_ptr->max_cache_size != (6 * 1000 * 1024) ) ||
( cache_ptr->min_clean_size != (3 * 1000 * 1024) ) ||
( cache_ptr->index_size != (2 * 1000 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 81.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* twelth epoch -- hit rate 1.0 -- decrease as before.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != decrease ) ||
( cache_ptr->max_cache_size != (5 * 1000 * 1024) ) ||
( cache_ptr->min_clean_size != (5 * 1000 * 1024 / 2) ) ||
( cache_ptr->index_size != (1 * 1000 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 82.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* thirteenth epoch -- hit rate 1.0 -- decrease as before.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != decrease ) ||
( cache_ptr->max_cache_size != (4 * 1000 * 1024) ) ||
( cache_ptr->min_clean_size != (2 * 1000 * 1024) ) ||
( cache_ptr->index_size != (1 * 1000 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 83.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* fourteenth epoch -- hit rate 1.0 -- decrease as before.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != decrease ) ||
( cache_ptr->max_cache_size != (3 * 1000 * 1024) ) ||
( cache_ptr->min_clean_size != (3 * 1000 * 1024 / 2) ) ||
( cache_ptr->index_size != (1 * 1000 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 84.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* fifteenth epoch -- hit rate 1.0 -- decrease as before.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != decrease ) ||
( cache_ptr->max_cache_size != (2 * 1000 * 1024) ) ||
( cache_ptr->min_clean_size != (1 * 1000 * 1024) ) ||
( cache_ptr->index_size != (1 * 1000 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 85.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* sixteenth epoch -- hit rate 1.0 -- should be stable now
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != in_spec ) ||
( cache_ptr->max_cache_size != (2 * 1000 * 1024) ) ||
( cache_ptr->min_clean_size != (1 * 1000 * 1024) ) ||
( cache_ptr->index_size != (1 * 1000 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 86.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
if ( pass ) {
takedown_cache(cache_ptr, FALSE, FALSE);
}
/* now test the flash cache size increment code. At least at present,
* there should be no interaction between the regular auto-resize
* code and the flash cache size increment code other than a reset
* of the counter and stats collection used by the regular auto-resize
* code. Thus we do only limited tests of the two pieces of code
* operating together.
*
* Start with simple test to verify that the flash cache increment
* code increases the cache size when and as expected.
*/
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* allocate a cache, enable the flash cache size increase code, and
* then force the flash size increase code through all its operational
* modes. Verify that all performs as expected.
*/
if ( pass ) {
reset_entries();
cache_ptr = setup_cache((size_t)(2 * 1024),
(size_t)(1 * 1024));
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* now repeat the above tests using the add space flash cache size
* increment algorithm.
*/
if ( pass ) {
auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
auto_size_ctl.rpt_fcn = test_rpt_fcn;
auto_size_ctl.set_initial_size = TRUE;
auto_size_ctl.initial_size = 64 * 1024;
auto_size_ctl.min_clean_fraction = 0.5;
auto_size_ctl.max_size = 1024 * 1024;
auto_size_ctl.min_size = 5 * 1024;
auto_size_ctl.epoch_length = 100;
auto_size_ctl.incr_mode = H5C_incr__threshold;
auto_size_ctl.lower_hr_threshold = 0.75;
auto_size_ctl.increment = 2.0;
auto_size_ctl.apply_max_increment = TRUE;
auto_size_ctl.max_increment = (32 * 1024);
auto_size_ctl.flash_incr_mode = H5C_flash_incr__add_space;
auto_size_ctl.flash_multiple = 1.0;
auto_size_ctl.flash_threshold = 0.5;
auto_size_ctl.decr_mode = H5C_decr__age_out_with_threshold;
auto_size_ctl.upper_hr_threshold = 0.999; /* for ease of testing */
auto_size_ctl.decrement = 0.5;
auto_size_ctl.apply_max_decrement = TRUE;
auto_size_ctl.max_decrement = (1 * 1000 * 1024);
auto_size_ctl.epochs_before_eviction = 1; /* for ease of testing */
auto_size_ctl.apply_empty_reserve = TRUE;
auto_size_ctl.empty_reserve = 0.5; /* for ease of testing */
result = H5C_set_cache_auto_resize_config(cache_ptr, &auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_set_cache_auto_resize_config failed 12.\n";
}
}
if ( pass ) {
if ( ( cache_ptr->max_cache_size != (64 * 1024) ) ||
( cache_ptr->min_clean_size != (32 * 1024) ) ||
( cache_ptr->index_len != 0 ) ||
( cache_ptr->index_size != 0 ) ||
( cache_ptr->cache_accesses != 0 ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache config (0).\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* Load a huge entry into the cache */
if ( pass ) {
protect_entry(cache_ptr, HUGE_ENTRY_TYPE, 0);
if ( pass ) {
unprotect_entry(cache_ptr, HUGE_ENTRY_TYPE, 0,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
if ( ( pass ) &&
( ( ( cache_ptr->max_cache_size != (64 * 1024) ) ||
( cache_ptr->min_clean_size != (32 * 1024) ) ||
( cache_ptr->index_len != 1 ) ||
( cache_ptr->index_size != HUGE_ENTRY_SIZE ) ||
( cache_ptr->cache_accesses != 1 ) ) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache config (1).\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* Now load a monster entry. Since a monster entry is larger than
* half the size of the cache, and there is not sufficient space
* for a monster entry in the cache, we will add space to the
* cache to make room for the entry.
*/
if ( pass ) {
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
if ( ( pass ) &&
( ( ( cache_ptr->max_cache_size != (80 * 1024) ) ||
( cache_ptr->min_clean_size != (40 * 1024) ) ||
( cache_ptr->index_len != 2 ) ||
( cache_ptr->index_size != (HUGE_ENTRY_SIZE +
MONSTER_ENTRY_SIZE) ) ||
( cache_ptr->cache_accesses != 1 ) ) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache config (2).\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* Load a second moster entry. Since the monster entry is larger
* than half the size of the cache yet again, and there is not
* sufficient space for the monster entry in the cache, we again
* add space to the cache to make space for the entry.
*/
if ( pass ) {
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 1);
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 1,
NO_CHANGE, H5C__NO_FLAGS_SET);
if ( ( pass ) &&
( ( ( cache_ptr->max_cache_size != (144 * 1024) ) ||
( cache_ptr->min_clean_size != ( 72 * 1024) ) ||
( cache_ptr->index_len != 3 ) ||
( cache_ptr->index_size != ((2 * MONSTER_ENTRY_SIZE) +
HUGE_ENTRY_SIZE) ) ||
( cache_ptr->cache_accesses != 1 ) ) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache config (3).\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* Load a third moster entry. Should be no cache size increase this
* time.
*/
if ( pass ) {
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 2);
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 2,
NO_CHANGE, H5C__NO_FLAGS_SET);
if ( ( pass ) &&
( ( ( cache_ptr->max_cache_size != (144 * 1024) ) ||
( cache_ptr->min_clean_size != ( 72 * 1024) ) ||
( cache_ptr->index_len != 2 ) ||
( cache_ptr->index_size != (2 * MONSTER_ENTRY_SIZE) ) ||
( cache_ptr->cache_accesses != 2 ) ) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache config (4).\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* delete existing entries to prepare for next test, and reset
* the size of the cache.
*/
if ( pass ) {
expunge_entry(cache_ptr, MONSTER_ENTRY_TYPE, 1);
expunge_entry(cache_ptr, MONSTER_ENTRY_TYPE, 2);
if ( pass ) {
result = H5C_set_cache_auto_resize_config(cache_ptr,
&auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_set_cache_auto_resize_config failed 13.\n";
}
}
if ( ( pass ) &&
( ( ( cache_ptr->max_cache_size != (64 * 1024) ) ||
( cache_ptr->min_clean_size != (32 * 1024) ) ||
( cache_ptr->index_len != 0 ) ||
( cache_ptr->index_size != 0 ) ||
( cache_ptr->cache_accesses != 0 ) ) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache config (5).\n";
}
}
/* repeat the above basic test, only this time, use inserts to add
* entries to the cache, not protects.
*/
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* insert a huge entry into the cache */
if ( pass ) {
insert_entry(cache_ptr, HUGE_ENTRY_TYPE, 1, TRUE,
H5C__NO_FLAGS_SET);
/* protect and unprotect a couple times to increment cache_accesses */
protect_entry(cache_ptr, HUGE_ENTRY_TYPE, 1);
unprotect_entry(cache_ptr, HUGE_ENTRY_TYPE, 1,
NO_CHANGE, H5C__NO_FLAGS_SET);
protect_entry(cache_ptr, HUGE_ENTRY_TYPE, 1);
unprotect_entry(cache_ptr, HUGE_ENTRY_TYPE, 1,
NO_CHANGE, H5C__NO_FLAGS_SET);
if ( ( pass ) &&
( ( ( cache_ptr->max_cache_size != (64 * 1024) ) ||
( cache_ptr->min_clean_size != (32 * 1024) ) ||
( cache_ptr->index_len != 1 ) ||
( cache_ptr->index_size != HUGE_ENTRY_SIZE ) ||
( cache_ptr->cache_accesses != 2 ) ) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache config (6).\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* Now insert a monster entry. Since a monster entry is larger than
* half the size of the cache, and there is not sufficient space
* for a monster entry in the cache, we will add space to the
* cache to make room for the entry.
*/
if ( pass ) {
insert_entry(cache_ptr, MONSTER_ENTRY_TYPE, 4, TRUE,
H5C__NO_FLAGS_SET);
if ( ( pass ) &&
( ( ( cache_ptr->max_cache_size != (80 * 1024) ) ||
( cache_ptr->min_clean_size != (40 * 1024) ) ||
( cache_ptr->index_len != 2 ) ||
( cache_ptr->index_size !=
HUGE_ENTRY_SIZE + MONSTER_ENTRY_SIZE ) ||
( cache_ptr->cache_accesses != 0 ) ) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache config (7).\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* Insert a second monster entry. Cache size should increase again.
*/
if ( pass ) {
insert_entry(cache_ptr, MONSTER_ENTRY_TYPE, 5, TRUE,
H5C__NO_FLAGS_SET);
if ( ( pass ) &&
( ( ( cache_ptr->max_cache_size != (144 * 1024) ) ||
( cache_ptr->min_clean_size != ( 72 * 1024) ) ||
( cache_ptr->index_len != 3 ) ||
( cache_ptr->index_size !=
2 * MONSTER_ENTRY_SIZE + HUGE_ENTRY_SIZE ) ||
( cache_ptr->cache_accesses != 0 ) ) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache config (8).\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* Insert a third monster entry. Should be no cache size increase this
* time.
*/
if ( pass ) {
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 6);
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 6,
NO_CHANGE, H5C__NO_FLAGS_SET);
if ( ( pass ) &&
( ( ( cache_ptr->max_cache_size != (144 * 1024) ) ||
( cache_ptr->min_clean_size != ( 72 * 1024) ) ||
( cache_ptr->index_len != 2 ) ||
( cache_ptr->index_size != (2 * MONSTER_ENTRY_SIZE) ) ||
( cache_ptr->cache_accesses != 1 ) ) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache config (9).\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* delete existing entries to prepare for next test, and reset
* the size of the cache. We must also change the size of the needed
* variable entries before we run the test, so will protect and
* unprotect them now so as to get the correct initial size.
*/
if ( pass ) {
expunge_entry(cache_ptr, MONSTER_ENTRY_TYPE, 5);
expunge_entry(cache_ptr, MONSTER_ENTRY_TYPE, 6);
protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 10);
unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 10,
H5C__DIRTIED_FLAG|H5C__SIZE_CHANGED_FLAG, 1024);
protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 11);
unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 11,
H5C__DIRTIED_FLAG|H5C__SIZE_CHANGED_FLAG, 1024);
protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 12);
unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 12,
H5C__DIRTIED_FLAG|H5C__SIZE_CHANGED_FLAG, 1024);
protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 13);
unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 13,
H5C__DIRTIED_FLAG|H5C__SIZE_CHANGED_FLAG, 1024);
flush_cache(cache_ptr, TRUE, FALSE, FALSE);
if ( pass ) {
auto_size_ctl.initial_size = 6 * 1024;
result = H5C_set_cache_auto_resize_config(cache_ptr,
&auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_set_cache_auto_resize_config failed 13.\n";
}
}
if ( ( pass ) &&
( ( ( cache_ptr->max_cache_size != (6 * 1024) ) ||
( cache_ptr->min_clean_size != (3 * 1024) ) ||
( cache_ptr->index_len != 0 ) ||
( cache_ptr->index_size != 0 ) ||
( cache_ptr->cache_accesses != 0 ) ) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache config (10).\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* Now load the variable entries into the cache */
if ( pass ) {
protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 10);
unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 10, NO_CHANGE,
H5C__NO_FLAGS_SET);
protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 11);
unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 11, NO_CHANGE,
H5C__NO_FLAGS_SET);
protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 12);
unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 12, NO_CHANGE,
H5C__NO_FLAGS_SET);
protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 13);
unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 13, NO_CHANGE,
H5C__NO_FLAGS_SET);
if ( ( pass ) &&
( ( ( cache_ptr->max_cache_size != (6 * 1024) ) ||
( cache_ptr->min_clean_size != (3 * 1024) ) ||
( cache_ptr->index_len != 4 ) ||
( cache_ptr->index_size != 4 * 1024 ) ||
( cache_ptr->cache_accesses != 4 ) ) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache config (11).\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* protect a variable entry, and re-size it to 3K. Should be
* no effect on the size of the cache.
*/
if ( pass ) {
protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 10);
unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 10,
H5C__DIRTIED_FLAG|H5C__SIZE_CHANGED_FLAG, 3 * 1024);
if ( ( pass ) &&
( ( ( cache_ptr->max_cache_size != (6 * 1024) ) ||
( cache_ptr->min_clean_size != (3 * 1024) ) ||
( cache_ptr->index_len != 4 ) ||
( cache_ptr->index_size != 6 * 1024 ) ||
( cache_ptr->cache_accesses != 5 ) ) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache config (12).\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* protect the variable entry again, and re-size it to 10K. Should
* resize the cache to 13 KB. Note that cache_accesses will be 0
* in this case, since cache_accesses is incremented on the protect.
*/
if ( pass ) {
protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 10);
unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 10,
H5C__DIRTIED_FLAG|H5C__SIZE_CHANGED_FLAG, 10 * 1024);
if ( ( pass ) &&
( ( ( cache_ptr->max_cache_size != (13 * 1024) ) ||
( cache_ptr->min_clean_size != (13 * 512) ) ||
( cache_ptr->index_len != 4 ) ||
( cache_ptr->index_size != 13 * 1024 ) ||
( cache_ptr->cache_accesses != 0 ) ) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache config (13).\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* protect a second variable entry, and re-size it to 10K. Should
* resize to 22 KB.
*/
if ( pass ) {
protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 11);
unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 11,
H5C__DIRTIED_FLAG|H5C__SIZE_CHANGED_FLAG, 10 * 1024);
if ( ( pass ) &&
( ( ( cache_ptr->max_cache_size != (22 * 1024) ) ||
( cache_ptr->min_clean_size != (11 * 1024) ) ||
( cache_ptr->index_len != 4 ) ||
( cache_ptr->index_size != 22 * 1024 ) ||
( cache_ptr->cache_accesses != 0 ) ) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache config (14).\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* protect a third variable entry, and re-size it to 10K. Should
* be no change in cache size.
*/
if ( pass ) {
protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 12);
unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 12,
H5C__DIRTIED_FLAG|H5C__SIZE_CHANGED_FLAG, 10 * 1024);
if ( ( pass ) &&
( ( ( cache_ptr->max_cache_size != (22 * 1024) ) ||
( cache_ptr->min_clean_size != (11 * 1024) ) ||
( cache_ptr->index_len != 4 ) ||
( cache_ptr->index_size != 31 * 1024 ) ||
( cache_ptr->cache_accesses != 1 ) ) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache config (15).\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* re-size the variable entries back down to their initial size, and
* restore the cache to its initial size as well, in preparation
* for the next test.
*/
if ( pass ) {
protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 10);
unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 10,
H5C__DIRTIED_FLAG|H5C__SIZE_CHANGED_FLAG, 1 * 1024);
protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 11);
unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 11,
H5C__DIRTIED_FLAG|H5C__SIZE_CHANGED_FLAG, 1 * 1024);
protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 12);
unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 12,
H5C__DIRTIED_FLAG|H5C__SIZE_CHANGED_FLAG, 1 * 1024);
if ( pass ) {
auto_size_ctl.initial_size = 6 * 1024;
result = H5C_set_cache_auto_resize_config(cache_ptr,
&auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_set_cache_auto_resize_config failed 14.\n";
}
}
if ( ( pass ) &&
( ( ( cache_ptr->max_cache_size != (6 * 1024) ) ||
( cache_ptr->min_clean_size != (3 * 1024) ) ||
( cache_ptr->index_len != 4 ) ||
( cache_ptr->index_size != 4 * 1024 ) ||
( cache_ptr->cache_accesses != 0 ) ) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache config (16).\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* Now test flash cache resizes with pinned entries...
*/
if ( pass ) {
protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 10);
unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 10, NO_CHANGE,
H5C__PIN_ENTRY_FLAG);
resize_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 10, 2 * 1024, TRUE);
if ( ( pass ) &&
( ( ( cache_ptr->max_cache_size != (6 * 1024) ) ||
( cache_ptr->min_clean_size != (6 * 512) ) ||
( cache_ptr->index_len != 4 ) ||
( cache_ptr->index_size != 5 * 1024 ) ||
( cache_ptr->cache_accesses != 1 ) ) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache config (17).\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
if ( pass ) {
resize_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 10, 10 * 1024, TRUE);
if ( ( pass ) &&
( ( ( cache_ptr->max_cache_size != (13 * 1024) ) ||
( cache_ptr->min_clean_size != (13 * 512) ) ||
( cache_ptr->index_len != 4 ) ||
( cache_ptr->index_size != 13 * 1024 ) ||
( cache_ptr->cache_accesses != 0 ) ) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache config (18).\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
if ( pass ) {
protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 11);
unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 11, NO_CHANGE,
H5C__PIN_ENTRY_FLAG);
resize_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 11, 10 * 1024, TRUE);
if ( ( pass ) &&
( ( ( cache_ptr->max_cache_size != (22 * 1024) ) ||
( cache_ptr->min_clean_size != (11 * 1024) ) ||
( cache_ptr->index_len != 4 ) ||
( cache_ptr->index_size != 22 * 1024 ) ||
( cache_ptr->cache_accesses != 0 ) ) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache config (19).\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
if ( pass ) {
protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 12);
unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 12, NO_CHANGE,
H5C__PIN_ENTRY_FLAG);
resize_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 12, 10 * 1024, TRUE);
if ( ( pass ) &&
( ( ( cache_ptr->max_cache_size != (22 * 1024) ) ||
( cache_ptr->min_clean_size != (11 * 1024) ) ||
( cache_ptr->index_len != 4 ) ||
( cache_ptr->index_size != 31 * 1024 ) ||
( cache_ptr->cache_accesses != 1 ) ) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache config (20).\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* Unpin the entries. Note that no entries are evicted as we don't
* load any entries.
*/
if ( pass ) {
protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 10);
unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 10, NO_CHANGE,
H5C__UNPIN_ENTRY_FLAG);
protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 11);
unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 11, NO_CHANGE,
H5C__UNPIN_ENTRY_FLAG);
protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 12);
unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 12, NO_CHANGE,
H5C__UNPIN_ENTRY_FLAG);
if ( ( pass ) &&
( ( ( cache_ptr->max_cache_size != (22 * 1024) ) ||
( cache_ptr->min_clean_size != (11 * 1024) ) ||
( cache_ptr->index_len != 4 ) ||
( cache_ptr->index_size != 31 * 1024 ) ||
( cache_ptr->cache_accesses != 4 ) ) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache config (21).\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* re-size the variable entries back down to their initial size, and
* restore the cache to its initial size as well, in preparation
* for the next test.
*/
if ( pass ) {
protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 10);
unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 10,
H5C__DIRTIED_FLAG|H5C__SIZE_CHANGED_FLAG, 1 * 1024);
protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 11);
unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 11,
H5C__DIRTIED_FLAG|H5C__SIZE_CHANGED_FLAG, 1 * 1024);
protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 12);
unprotect_entry_with_size_change(cache_ptr, VARIABLE_ENTRY_TYPE, 12,
H5C__DIRTIED_FLAG|H5C__SIZE_CHANGED_FLAG, 1 * 1024);
if ( pass ) {
auto_size_ctl.initial_size = 6 * 1024;
result = H5C_set_cache_auto_resize_config(cache_ptr,
&auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_set_cache_auto_resize_config failed 15.\n";
}
}
if ( ( pass ) &&
( ( ( cache_ptr->max_cache_size != (6 * 1024) ) ||
( cache_ptr->min_clean_size != (3 * 1024) ) ||
( cache_ptr->index_len != 4 ) ||
( cache_ptr->index_size != 4 * 1024 ) ||
( cache_ptr->cache_accesses != 0 ) ) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache config (22).\n";
}
}
if ( pass ) {
protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 10);
unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 10, NO_CHANGE,
H5C__PIN_ENTRY_FLAG);
resize_pinned_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 10, 2 * 1024);
if ( ( pass ) &&
( ( ( cache_ptr->max_cache_size != (6 * 1024) ) ||
( cache_ptr->min_clean_size != (6 * 512) ) ||
( cache_ptr->index_len != 4 ) ||
( cache_ptr->index_size != 5 * 1024 ) ||
( cache_ptr->cache_accesses != 1 ) ) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache config (23).\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
if ( pass ) {
resize_pinned_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 10, 10 * 1024);
if ( ( pass ) &&
( ( ( cache_ptr->max_cache_size != (13 * 1024) ) ||
( cache_ptr->min_clean_size != (13 * 512) ) ||
( cache_ptr->index_len != 4 ) ||
( cache_ptr->index_size != 13 * 1024 ) ||
( cache_ptr->cache_accesses != 0 ) ) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache config (24).\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
if ( pass ) {
protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 11);
unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 11, NO_CHANGE,
H5C__PIN_ENTRY_FLAG);
resize_pinned_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 11, 10 * 1024);
if ( ( pass ) &&
( ( ( cache_ptr->max_cache_size != (22 * 1024) ) ||
( cache_ptr->min_clean_size != (11 * 1024) ) ||
( cache_ptr->index_len != 4 ) ||
( cache_ptr->index_size != 22 * 1024 ) ||
( cache_ptr->cache_accesses != 0 ) ) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache config (25).\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
if ( pass ) {
protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 12);
unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 12, NO_CHANGE,
H5C__PIN_ENTRY_FLAG);
resize_pinned_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 12, 10 * 1024);
if ( ( pass ) &&
( ( ( cache_ptr->max_cache_size != (22 * 1024) ) ||
( cache_ptr->min_clean_size != (11 * 1024) ) ||
( cache_ptr->index_len != 4 ) ||
( cache_ptr->index_size != 31 * 1024 ) ||
( cache_ptr->cache_accesses != 1 ) ) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache config (26).\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* Unpin the entries. Note that no entries are evicted as we don't
* load any entries.
*/
if ( pass ) {
protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 10);
unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 10, NO_CHANGE,
H5C__UNPIN_ENTRY_FLAG);
protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 11);
unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 11, NO_CHANGE,
H5C__UNPIN_ENTRY_FLAG);
protect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 12);
unprotect_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 12, NO_CHANGE,
H5C__UNPIN_ENTRY_FLAG);
if ( ( pass ) &&
( ( ( cache_ptr->max_cache_size != (22 * 1024) ) ||
( cache_ptr->min_clean_size != (11 * 1024) ) ||
( cache_ptr->index_len != 4 ) ||
( cache_ptr->index_size != 31 * 1024 ) ||
( cache_ptr->cache_accesses != 4 ) ) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache config (27).\n";
}
}
/* We have finished a basic check of the flash cache size increment
* code. Tidy up for a more extensive test...
*/
if ( pass ) {
expunge_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 10);
expunge_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 11);
expunge_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 12);
expunge_entry(cache_ptr, VARIABLE_ENTRY_TYPE, 13);
if ( ( pass ) &&
( ( ( cache_ptr->max_cache_size != (22 * 1024) ) ||
( cache_ptr->min_clean_size != (11 * 1024) ) ||
( cache_ptr->index_len != 0 ) ||
( cache_ptr->index_size != 0 ) ||
( cache_ptr->cache_accesses != 4 ) ) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache config (28).\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* ...and then reconfigure. Note that we change the flash_multiple
* and flash_threshold just to make sure that such changed perform
* as expected.
*/
if ( pass ) {
auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
auto_size_ctl.rpt_fcn = test_rpt_fcn;
auto_size_ctl.set_initial_size = TRUE;
auto_size_ctl.initial_size = 4 * 1024;
auto_size_ctl.min_clean_fraction = 0.5;
auto_size_ctl.max_size = 20 * 1024;
auto_size_ctl.min_size = 4 * 1024;
auto_size_ctl.epoch_length = 100;
auto_size_ctl.incr_mode = H5C_incr__threshold;
auto_size_ctl.lower_hr_threshold = 0.75;
auto_size_ctl.increment = 2.0;
auto_size_ctl.apply_max_increment = TRUE;
auto_size_ctl.max_increment = (4 * 1024);
auto_size_ctl.flash_incr_mode = H5C_flash_incr__add_space;
auto_size_ctl.flash_multiple = 2.0;
auto_size_ctl.flash_threshold = 0.4;
auto_size_ctl.decr_mode = H5C_decr__age_out_with_threshold;
auto_size_ctl.upper_hr_threshold = 0.999; /* for ease of testing */
auto_size_ctl.decrement = 0.5;
auto_size_ctl.apply_max_decrement = TRUE;
auto_size_ctl.max_decrement = (2 * 1024);
auto_size_ctl.epochs_before_eviction = 1; /* for ease of testing */
auto_size_ctl.apply_empty_reserve = TRUE;
auto_size_ctl.empty_reserve = 0.5; /* for ease of testing */
result = H5C_set_cache_auto_resize_config(cache_ptr, &auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_set_cache_auto_resize_config failed 15.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
if ( pass ) {
if ( ( cache_ptr->max_cache_size != (4 * 1024) ) ||
( cache_ptr->min_clean_size != (4 * 512) ) ||
( cache_ptr->index_len != 0 ) ||
( cache_ptr->index_size != 0 ) ||
( cache_ptr->cache_accesses != 0 ) ) {
pass = FALSE;
failure_mssg = "bad cache after initialization 15.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* protect and unprotect a large entry -- no change in cache size since
* a large entry will just fill the available space in the cache.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
protect_entry(cache_ptr, LARGE_ENTRY_TYPE, 0);
unprotect_entry(cache_ptr, LARGE_ENTRY_TYPE, 0, NO_CHANGE,
H5C__NO_FLAGS_SET);
if ( ( pass ) &&
( ( ( cache_ptr->max_cache_size != (4 * 1024) ) ||
( cache_ptr->min_clean_size != (4 * 512) ) ||
( cache_ptr->index_len != 1 ) ||
( cache_ptr->index_size != LARGE_ENTRY_SIZE ) ||
( cache_ptr->cache_accesses != 1 ) ||
( rpt_fcn_called == TRUE ) ) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache config (29).\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* protect and unprotect another a large entry -- should trigger a
* flash cache size increase to 12 KB (remember that flash_multiple is
* set to 2.0).
*/
if ( pass ) {
rpt_fcn_called = FALSE;
protect_entry(cache_ptr, LARGE_ENTRY_TYPE, 1);
unprotect_entry(cache_ptr, LARGE_ENTRY_TYPE, 1, NO_CHANGE,
H5C__NO_FLAGS_SET);
if ( ( pass ) &&
( ( ( cache_ptr->max_cache_size != (12 * 1024) ) ||
( cache_ptr->min_clean_size != (12 * 512) ) ||
( cache_ptr->index_len != 2 ) ||
( cache_ptr->index_size != 2 * LARGE_ENTRY_SIZE ) ||
( cache_ptr->cache_accesses != 1 ) ||
( rpt_fcn_called != TRUE ) ) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache config (30).\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* protect and unprotect two more large entries -- shouldnt trigger a
* flash cache size increase.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
protect_entry(cache_ptr, LARGE_ENTRY_TYPE, 2);
unprotect_entry(cache_ptr, LARGE_ENTRY_TYPE, 2, NO_CHANGE,
H5C__NO_FLAGS_SET);
protect_entry(cache_ptr, LARGE_ENTRY_TYPE, 3);
unprotect_entry(cache_ptr, LARGE_ENTRY_TYPE, 3, NO_CHANGE,
H5C__NO_FLAGS_SET);
if ( ( pass ) &&
( ( ( cache_ptr->max_cache_size != (12 * 1024) ) ||
( cache_ptr->min_clean_size != (12 * 512) ) ||
( cache_ptr->index_len != 3 ) ||
( cache_ptr->index_size != 3 * LARGE_ENTRY_SIZE ) ||
( cache_ptr->cache_accesses != 3 ) ||
( rpt_fcn_called != FALSE ) ) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache config (31).\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* do many accesses of a single entry to talk the cache into reducing
* its size to the minimum.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, TINY_ENTRY_TYPE, 0);
if ( pass ) {
unprotect_entry(cache_ptr, TINY_ENTRY_TYPE, 0,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( cache_ptr->max_cache_size != (4 * 1024) ) ||
( cache_ptr->min_clean_size != (2 * 1024) ) ||
( cache_ptr->index_size != (1 * TINY_ENTRY_SIZE) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache config (32).\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* Force another flash increase */
if ( pass ) {
rpt_fcn_called = FALSE;
protect_entry(cache_ptr, LARGE_ENTRY_TYPE, 0);
unprotect_entry(cache_ptr, LARGE_ENTRY_TYPE, 0, NO_CHANGE,
H5C__NO_FLAGS_SET);
if ( ( pass ) &&
( ( ( cache_ptr->max_cache_size != (4 * 1024 + 128) ) ||
( cache_ptr->min_clean_size != (2 * 1024 + 64) ) ||
( cache_ptr->index_len != 2 ) ||
( cache_ptr->index_size !=
LARGE_ENTRY_SIZE + TINY_ENTRY_SIZE ) ||
( cache_ptr->cache_accesses != 1 ) ||
( rpt_fcn_called == FALSE ) ||
( rpt_status != flash_increase ) ) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache config (33).\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* force regular size increase up to maximum */
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 500 ) )
{
protect_entry(cache_ptr, TINY_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, TINY_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( cache_ptr->max_cache_size != (20 * 1024) ) ||
( cache_ptr->min_clean_size != (10 * 1024) ) ||
( rpt_fcn_called == FALSE ) ||
( rpt_status != at_max_size ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache config (34).\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
if ( pass ) {
takedown_cache(cache_ptr, FALSE, FALSE);
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
if ( pass ) { PASSED(); } else { H5_FAILED(); }
if ( ! pass ) {
HDfprintf(stdout, "%s: failure_mssg = \"%s\".\n",
fcn_name, failure_mssg);
}
return;
} /* check_auto_cache_resize() */
/*-------------------------------------------------------------------------
* Function: check_auto_cache_resize_disable()
*
* Purpose: Test the various ways in which the resize code can
* be disabled. Unfortunately, there are quite a few of them.
*
* Return: void
*
* Programmer: John Mainzer
* 12/16/04
*
* Modifications:
*
* Added code to include the flash cache size increment
* code in this test.
* JRM -- 1/10/08
*
*-------------------------------------------------------------------------
*/
static void
check_auto_cache_resize_disable(void)
{
const char * fcn_name = "check_auto_cache_resize_disable()";
hbool_t show_progress = FALSE;
herr_t result;
int32_t i;
int32_t checkpoint = 0;
H5C_t * cache_ptr = NULL;
H5C_auto_size_ctl_t auto_size_ctl =
{
/* int32_t version = */ H5C__CURR_AUTO_SIZE_CTL_VER,
/* H5C_auto_resize_report_fcn rpt_fcn = */ test_rpt_fcn,
/* hbool_t set_initial_size = */ TRUE,
/* size_t initial_size = */ (512 * 1024),
/* double min_clean_fraction = */ 0.5,
/* size_t max_size = */ (14 * 1024 * 1024),
/* size_t min_size = */ (512 * 1024),
/* int64_t epoch_length = */ 1000,
/* enum H5C_cache_incr_mode incr_mode = */ H5C_incr__threshold,
/* double lower_hr_threshold = */ 0.75,
/* double increment = */ 2.0,
/* hbool_t apply_max_increment = */ TRUE,
/* size_t max_increment = */ (4 * 1024 * 1024),
/* enum H5C_cache_flash_incr_mode */
/* flash_incr_mode = */ H5C_flash_incr__off,
/* double flash_multiple = */ 1.0,
/* double flash_threshold = */ 0.25,
/* enum H5C_cache_decr_mode decr_mode = */ H5C_decr__threshold,
/* double upper_hr_threshold = */ 0.995,
/* double decrement = */ 0.1,
/* hbool_t apply_max_decrement = */ TRUE,
/* size_t max_decrement = */ (1 * 1024 * 1024),
/* int32_t epochs_before_eviction = */ 3,
/* hbool_t apply_empty_reserve = */ TRUE,
/* double empty_reserve = */ 0.05
};
TESTING("automatic cache resize disable");
pass = TRUE;
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* allocate a cache, enable automatic cache resizing, and then force
* the cache through all its operational modes. Verify that all
* performs as expected.
*/
if ( pass ) {
reset_entries();
cache_ptr = setup_cache((size_t)(2 * 1024),
(size_t)(1 * 1024));
}
if ( pass ) {
result = H5C_set_cache_auto_resize_config(cache_ptr, &auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_set_cache_auto_resize_config failed 1.\n";
}
}
if ( pass ) {
if ( ( cache_ptr->max_cache_size != (512 * 1024) ) ||
( cache_ptr->min_clean_size != (256 * 1024) ) ) {
pass = FALSE;
failure_mssg = "bad cache size after initialization.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/******************************************************************
* So far, we have forced the auto cache resize through all modes
* other than increase_disabled and decrease_disabled. Force these
* modes now. Note that there are several ways we can reach these
* modes.
******************************************************************/
if ( pass ) {
auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
auto_size_ctl.rpt_fcn = test_rpt_fcn;
auto_size_ctl.set_initial_size = TRUE;
auto_size_ctl.initial_size = 4 * 1024 * 1024;
auto_size_ctl.min_clean_fraction = 0.5;
auto_size_ctl.max_size = 16 * 1024 * 1024;
auto_size_ctl.min_size = 1 * 1024 * 1024;
auto_size_ctl.epoch_length = 1000;
auto_size_ctl.incr_mode = H5C_incr__threshold;
auto_size_ctl.lower_hr_threshold = 0.75;
auto_size_ctl.increment = 1.0; /* disable size increases */
auto_size_ctl.apply_max_increment = FALSE;
auto_size_ctl.max_increment = (4 * 1024 * 1024);
auto_size_ctl.flash_incr_mode = H5C_flash_incr__off;
auto_size_ctl.flash_multiple = 2.0;
auto_size_ctl.flash_threshold = 0.5;
auto_size_ctl.decr_mode = H5C_decr__threshold;
auto_size_ctl.upper_hr_threshold = 0.995;
auto_size_ctl.decrement = 0.5;
auto_size_ctl.apply_max_decrement = FALSE;
auto_size_ctl.max_decrement = (1 * 1024 * 1024);
auto_size_ctl.epochs_before_eviction = 3;
auto_size_ctl.apply_empty_reserve = TRUE;
auto_size_ctl.empty_reserve = 0.05;
result = H5C_set_cache_auto_resize_config(cache_ptr, &auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_set_cache_auto_resize_config failed 2.\n";
}
}
if ( pass ) {
if ( ( cache_ptr->max_cache_size != (4 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (2 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "bad cache size after set resize re-config 1.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* force low hit rate with cache full -- increase disabled so should
* be no change in cache size, and result should be increase_disabled.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( cache_ptr->size_increase_possible ) ||
( rpt_status != increase_disabled ) ||
( cache_ptr->max_cache_size != (4 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (2 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 1.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* force high hit rate -- make sure that we haven't disabled decreases.
* should result in a decrease cache size from 4 to 2 Meg.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != decrease ) ||
( cache_ptr->max_cache_size != (2 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (1 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 2.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* force low hit rate again -- increase disabled so should
* be no change in cache size, and result should be increase_disabled.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( cache_ptr->size_increase_possible ) ||
( rpt_status != increase_disabled ) ||
( cache_ptr->max_cache_size != (2 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (1 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 3.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* Repeat the above tests, disabling increase through the lower
* threshold instead of the increment.
*/
if ( pass ) {
auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
auto_size_ctl.rpt_fcn = test_rpt_fcn;
auto_size_ctl.set_initial_size = TRUE;
auto_size_ctl.initial_size = 4 * 1024 * 1024;
auto_size_ctl.min_clean_fraction = 0.5;
auto_size_ctl.max_size = 16 * 1024 * 1024;
auto_size_ctl.min_size = 1 * 1024 * 1024;
auto_size_ctl.epoch_length = 1000;
auto_size_ctl.incr_mode = H5C_incr__threshold;
auto_size_ctl.lower_hr_threshold = 0.0; /* disable size increases */
auto_size_ctl.increment = 2.0;
auto_size_ctl.apply_max_increment = FALSE;
auto_size_ctl.max_increment = (4 * 1024 * 1024);
auto_size_ctl.flash_incr_mode = H5C_flash_incr__off;
auto_size_ctl.flash_multiple = 2.0;
auto_size_ctl.flash_threshold = 0.5;
auto_size_ctl.decr_mode = H5C_decr__threshold;
auto_size_ctl.upper_hr_threshold = 0.995;
auto_size_ctl.decrement = 0.5;
auto_size_ctl.apply_max_decrement = FALSE;
auto_size_ctl.max_decrement = (1 * 1024 * 1024);
auto_size_ctl.epochs_before_eviction = 3;
auto_size_ctl.apply_empty_reserve = TRUE;
auto_size_ctl.empty_reserve = 0.05;
result = H5C_set_cache_auto_resize_config(cache_ptr, &auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_set_cache_auto_resize_config failed 3.\n";
}
}
if ( pass ) {
if ( ( cache_ptr->max_cache_size != (4 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (2 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "bad cache size after set resize re-config 2.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* force low hit rate with cache full -- increase disabled so should
* be no change in cache size, and result should be in_spec.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( cache_ptr->size_increase_possible ) ||
( rpt_status != in_spec ) ||
( cache_ptr->max_cache_size != (4 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (2 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 4.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* force high hit rate -- make sure that we haven't disabled decreases.
* should result in a decrease cache size from 4 to 2 Meg.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != decrease ) ||
( cache_ptr->max_cache_size != (2 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (1 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 5.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* force low hit rate again -- increase disabled so should
* be no change in cache size, and result should be increase_disabled.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( cache_ptr->size_increase_possible ) ||
( rpt_status != in_spec ) ||
( cache_ptr->max_cache_size != (2 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (1 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 6.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* Repeat the above tests yet again, disabling increase through the
* incr_mode.
*/
if ( pass ) {
auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
auto_size_ctl.rpt_fcn = test_rpt_fcn;
auto_size_ctl.set_initial_size = TRUE;
auto_size_ctl.initial_size = 4 * 1024 * 1024;
auto_size_ctl.min_clean_fraction = 0.5;
auto_size_ctl.max_size = 16 * 1024 * 1024;
auto_size_ctl.min_size = 1 * 1024 * 1024;
auto_size_ctl.epoch_length = 1000;
auto_size_ctl.incr_mode = H5C_incr__off;
auto_size_ctl.lower_hr_threshold = 0.75;
auto_size_ctl.increment = 2.0;
auto_size_ctl.apply_max_increment = FALSE;
auto_size_ctl.max_increment = (4 * 1024 * 1024);
auto_size_ctl.flash_incr_mode = H5C_flash_incr__off;
auto_size_ctl.flash_multiple = 2.0;
auto_size_ctl.flash_threshold = 0.5;
auto_size_ctl.decr_mode = H5C_decr__threshold;
auto_size_ctl.upper_hr_threshold = 0.995;
auto_size_ctl.decrement = 0.5;
auto_size_ctl.apply_max_decrement = FALSE;
auto_size_ctl.max_decrement = (1 * 1024 * 1024);
auto_size_ctl.epochs_before_eviction = 3;
auto_size_ctl.apply_empty_reserve = TRUE;
auto_size_ctl.empty_reserve = 0.05;
result = H5C_set_cache_auto_resize_config(cache_ptr, &auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_set_cache_auto_resize_config failed 4.\n";
}
}
if ( pass ) {
if ( ( cache_ptr->max_cache_size != (4 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (2 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "bad cache size after set resize re-config 3.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* force low hit rate with cache full -- increase disabled so should
* be no change in cache size, and result should be in_spec.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( cache_ptr->size_increase_possible ) ||
( rpt_status != in_spec ) ||
( cache_ptr->max_cache_size != (4 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (2 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 7.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* force high hit rate -- make sure that we haven't disabled decreases.
* should result in a decrease cache size from 4 to 2 Meg.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != decrease ) ||
( cache_ptr->max_cache_size != (2 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (1 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 8.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* force low hit rate again -- increase disabled so should
* be no change in cache size, and result should be increase_disabled.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( cache_ptr->size_increase_possible ) ||
( rpt_status != in_spec ) ||
( cache_ptr->max_cache_size != (2 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (1 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 9.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* Now, disable size decreases, and repeat the above tests.
*/
if ( pass ) {
auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
auto_size_ctl.rpt_fcn = test_rpt_fcn;
auto_size_ctl.set_initial_size = TRUE;
auto_size_ctl.initial_size = 4 * 1024 * 1024;
auto_size_ctl.min_clean_fraction = 0.5;
auto_size_ctl.max_size = 16 * 1024 * 1024;
auto_size_ctl.min_size = 1 * 1024 * 1024;
auto_size_ctl.epoch_length = 1000;
auto_size_ctl.incr_mode = H5C_incr__threshold;
auto_size_ctl.lower_hr_threshold = 0.75;
auto_size_ctl.increment = 2.0;
auto_size_ctl.apply_max_increment = TRUE;
auto_size_ctl.max_increment = (2 * 1024 * 1024);
auto_size_ctl.flash_incr_mode = H5C_flash_incr__off;
auto_size_ctl.flash_multiple = 2.0;
auto_size_ctl.flash_threshold = 0.5;
auto_size_ctl.decr_mode = H5C_decr__threshold;
auto_size_ctl.upper_hr_threshold = 0.995;
auto_size_ctl.decrement = 1.0; /* disable size decreases */
auto_size_ctl.apply_max_decrement = TRUE;
auto_size_ctl.max_decrement = (1 * 1024 * 1024);
auto_size_ctl.epochs_before_eviction = 3;
auto_size_ctl.apply_empty_reserve = TRUE;
auto_size_ctl.empty_reserve = 0.05;
result = H5C_set_cache_auto_resize_config(cache_ptr, &auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_set_cache_auto_resize_config failed 5.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
if ( pass ) {
if ( ( cache_ptr->max_cache_size != (4 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (2 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "bad cache size after set resize re-config 4.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* force high hit rate -- should be no change in cache size,
* and result should be decrease_disabled.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != decrease_disabled ) ||
( cache_ptr->max_cache_size != (4 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (2 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 10.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* force low hit rate -- cache size should increase from 4 to 6 Meg.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != increase ) ||
( cache_ptr->max_cache_size != (6 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (3 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 11.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* force high hit rate again -- should be no change in cache size,
* and result should be decrease_disabled.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != decrease_disabled ) ||
( cache_ptr->max_cache_size != (6 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (3 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 12.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* Repeat the above tests, disabling decrease through the upper
* threshold instead of the decrement.
*/
if ( pass ) {
auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
auto_size_ctl.rpt_fcn = test_rpt_fcn;
auto_size_ctl.set_initial_size = TRUE;
auto_size_ctl.initial_size = 4 * 1024 * 1024;
auto_size_ctl.min_clean_fraction = 0.5;
auto_size_ctl.max_size = 16 * 1024 * 1024;
auto_size_ctl.min_size = 1 * 1024 * 1024;
auto_size_ctl.epoch_length = 1000;
auto_size_ctl.incr_mode = H5C_incr__threshold;
auto_size_ctl.lower_hr_threshold = 0.75;
auto_size_ctl.increment = 2.0;
auto_size_ctl.apply_max_increment = TRUE;
auto_size_ctl.max_increment = (2 * 1024 * 1024);
auto_size_ctl.flash_incr_mode = H5C_flash_incr__off;
auto_size_ctl.flash_multiple = 2.0;
auto_size_ctl.flash_threshold = 0.5;
auto_size_ctl.decr_mode = H5C_decr__threshold;
auto_size_ctl.upper_hr_threshold = 1.0; /* disable size decreases */
auto_size_ctl.decrement = 0.5;
auto_size_ctl.apply_max_decrement = TRUE;
auto_size_ctl.max_decrement = (1 * 1024 * 1024);
auto_size_ctl.epochs_before_eviction = 3;
auto_size_ctl.apply_empty_reserve = TRUE;
auto_size_ctl.empty_reserve = 0.05;
result = H5C_set_cache_auto_resize_config(cache_ptr, &auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_set_cache_auto_resize_config failed 6.\n";
}
}
if ( pass ) {
if ( ( cache_ptr->max_cache_size != (4 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (2 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "bad cache size after set resize re-config 5.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* force high hit rate -- should be no change in cache size,
* and result should be in_spec.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( cache_ptr->size_decrease_possible ) ||
( rpt_status != in_spec ) ||
( cache_ptr->max_cache_size != (4 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (2 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 13.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* force low hit rate -- cache size should increase from 4 to 6 Meg.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != increase ) ||
( cache_ptr->max_cache_size != (6 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (3 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 14.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* force high hit rate again -- should be no change in cache size,
* and result should be in_spec.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( cache_ptr->size_decrease_possible ) ||
( rpt_status != in_spec ) ||
( cache_ptr->max_cache_size != (6 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (3 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 15.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* Repeat the above tests, disabling decrease through the decr_mode.
*/
if ( pass ) {
auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
auto_size_ctl.rpt_fcn = test_rpt_fcn;
auto_size_ctl.set_initial_size = TRUE;
auto_size_ctl.initial_size = 4 * 1024 * 1024;
auto_size_ctl.min_clean_fraction = 0.5;
auto_size_ctl.max_size = 16 * 1024 * 1024;
auto_size_ctl.min_size = 1 * 1024 * 1024;
auto_size_ctl.epoch_length = 1000;
auto_size_ctl.incr_mode = H5C_incr__threshold;
auto_size_ctl.lower_hr_threshold = 0.75;
auto_size_ctl.increment = 2.0;
auto_size_ctl.apply_max_increment = TRUE;
auto_size_ctl.max_increment = (2 * 1024 * 1024);
auto_size_ctl.flash_incr_mode = H5C_flash_incr__off;
auto_size_ctl.flash_multiple = 2.0;
auto_size_ctl.flash_threshold = 0.5;
auto_size_ctl.decr_mode = H5C_decr__off;
auto_size_ctl.upper_hr_threshold = 0.995;
auto_size_ctl.decrement = 0.5;
auto_size_ctl.apply_max_decrement = TRUE;
auto_size_ctl.max_decrement = (1 * 1024 * 1024);
auto_size_ctl.epochs_before_eviction = 3;
auto_size_ctl.apply_empty_reserve = TRUE;
auto_size_ctl.empty_reserve = 0.05;
result = H5C_set_cache_auto_resize_config(cache_ptr, &auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_set_cache_auto_resize_config failed 7.\n";
}
}
if ( pass ) {
if ( ( cache_ptr->max_cache_size != (4 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (2 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "bad cache size after set resize re-config 6.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* force high hit rate -- should be no change in cache size,
* and result should be in_spec.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( cache_ptr->size_decrease_possible ) ||
( rpt_status != in_spec ) ||
( cache_ptr->max_cache_size != (4 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (2 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 16.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* force low hit rate -- cache size should increase from 4 to 6 Meg.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != increase ) ||
( cache_ptr->max_cache_size != (6 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (3 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 17.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* force high hit rate again -- should be no change in cache size,
* and result should be in_spec.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( cache_ptr->size_decrease_possible ) ||
( rpt_status != in_spec ) ||
( cache_ptr->max_cache_size != (6 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (3 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 18.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* Now do tests disabling size decrement in age out mode.
*
* Start by disabling size decrement by setting max_decrement to zero.
*/
if ( pass ) {
auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
auto_size_ctl.rpt_fcn = test_rpt_fcn;
auto_size_ctl.set_initial_size = TRUE;
auto_size_ctl.initial_size = 4 * 1024 * 1024;
auto_size_ctl.min_clean_fraction = 0.5;
auto_size_ctl.max_size = 16 * 1024 * 1024;
auto_size_ctl.min_size = 1 * 1024 * 1024;
auto_size_ctl.epoch_length = 1000;
auto_size_ctl.incr_mode = H5C_incr__threshold;
auto_size_ctl.lower_hr_threshold = 0.75;
auto_size_ctl.increment = 2.0;
auto_size_ctl.apply_max_increment = TRUE;
auto_size_ctl.max_increment = (2 * 1024 * 1024);
auto_size_ctl.flash_incr_mode = H5C_flash_incr__off;
auto_size_ctl.flash_multiple = 2.0;
auto_size_ctl.flash_threshold = 0.5;
auto_size_ctl.decr_mode = H5C_decr__age_out;
auto_size_ctl.upper_hr_threshold = 0.995;
auto_size_ctl.decrement = 0.5;
auto_size_ctl.apply_max_decrement = TRUE;
auto_size_ctl.max_decrement = 0; /* disable decrement */
auto_size_ctl.epochs_before_eviction = 1;
auto_size_ctl.apply_empty_reserve = TRUE;
auto_size_ctl.empty_reserve = 0.05;
result = H5C_set_cache_auto_resize_config(cache_ptr, &auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_set_cache_auto_resize_config failed 8.\n";
}
}
if ( pass ) {
if ( ( cache_ptr->max_cache_size != (4 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (2 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "bad cache size after set resize re-config 7.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* flush the cache and destroy all entries so we start from a known point */
flush_cache(cache_ptr, TRUE, FALSE, FALSE);
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* load up the cache with small entries. Note that it will take an
* epoch for the ageout code to initialize itself if it is enabled.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, SMALL_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, SMALL_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( cache_ptr->size_decrease_possible ) ||
( rpt_status != not_full ) ||
( cache_ptr->max_cache_size != (4 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (2 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 19.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* Load up some more small entries.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 1000;
while ( ( pass ) && ( i < 2000 ) )
{
protect_entry(cache_ptr, SMALL_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, SMALL_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( cache_ptr->size_decrease_possible ) ||
( rpt_status != not_full ) ||
( cache_ptr->max_cache_size != (4 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (2 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 20.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* Now force a high hit rate so that the size increase code is
* is satisfied. We would see a decrease here if decrease were
* possible.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, SMALL_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, SMALL_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( cache_ptr->size_decrease_possible ) ||
( rpt_status != decrease_disabled ) ||
( cache_ptr->max_cache_size != (4 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (2 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 21.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* force low hit rate -- cache size should increase from 4 to 6 Meg.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != increase ) ||
( cache_ptr->max_cache_size != (6 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (3 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 22.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* just bang on a single entry. This will see to it that there are
* many entries that could be aged out were decreases enabled.
* Should be no change in cache size, and result should be
* decrease_disabled.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( cache_ptr->size_decrease_possible ) ||
( rpt_status != decrease_disabled ) ||
( cache_ptr->max_cache_size != (6 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (3 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 23.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* Now disable size decrement in age out mode via the empty reserve.
*/
if ( pass ) {
auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
auto_size_ctl.rpt_fcn = test_rpt_fcn;
auto_size_ctl.set_initial_size = TRUE;
auto_size_ctl.initial_size = 4 * 1024 * 1024;
auto_size_ctl.min_clean_fraction = 0.5;
auto_size_ctl.max_size = 16 * 1024 * 1024;
auto_size_ctl.min_size = 1 * 1024 * 1024;
auto_size_ctl.epoch_length = 1000;
auto_size_ctl.incr_mode = H5C_incr__threshold;
auto_size_ctl.lower_hr_threshold = 0.75;
auto_size_ctl.increment = 2.0;
auto_size_ctl.apply_max_increment = TRUE;
auto_size_ctl.max_increment = (2 * 1024 * 1024);
auto_size_ctl.flash_incr_mode = H5C_flash_incr__off;
auto_size_ctl.flash_multiple = 2.0;
auto_size_ctl.flash_threshold = 0.5;
auto_size_ctl.decr_mode = H5C_decr__age_out;
auto_size_ctl.upper_hr_threshold = 0.995;
auto_size_ctl.decrement = 0.5;
auto_size_ctl.apply_max_decrement = TRUE;
auto_size_ctl.max_decrement = (1 * 1024 * 1024);
auto_size_ctl.epochs_before_eviction = 1;
auto_size_ctl.apply_empty_reserve = TRUE;
auto_size_ctl.empty_reserve = 1.0; /* disable decrement */
result = H5C_set_cache_auto_resize_config(cache_ptr, &auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_set_cache_auto_resize_config failed 9.\n";
}
}
if ( pass ) {
if ( ( cache_ptr->max_cache_size != (4 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (2 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "bad cache size after set resize re-config 8.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* flush the cache and destroy all entries so we start from a known point */
flush_cache(cache_ptr, TRUE, FALSE, FALSE);
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* load up the cache with small entries. Note that it will take an
* epoch for the ageout code to initialize itself if it is enabled.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, SMALL_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, SMALL_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( cache_ptr->size_decrease_possible ) ||
( rpt_status != not_full ) ||
( cache_ptr->max_cache_size != (4 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (2 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 24.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* Load up some more small entries.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 1000;
while ( ( pass ) && ( i < 2000 ) )
{
protect_entry(cache_ptr, SMALL_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, SMALL_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( cache_ptr->size_decrease_possible ) ||
( rpt_status != not_full ) ||
( cache_ptr->max_cache_size != (4 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (2 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 25.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* Now force a high hit rate so that the size increase code is
* is satisfied. We would see a decrease here if decrease were
* possible.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, SMALL_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, SMALL_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( cache_ptr->size_decrease_possible ) ||
( rpt_status != decrease_disabled ) ||
( cache_ptr->max_cache_size != (4 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (2 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 26.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* force low hit rate -- cache size should increase from 4 to 6 Meg.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != increase ) ||
( cache_ptr->max_cache_size != (6 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (3 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 27.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* just bang on a single entry. This will see to it that there are
* many entries that could be aged out were decreases enabled.
* Should be no change in cache size, and result should be
* decrease_disabled.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( cache_ptr->size_decrease_possible ) ||
( rpt_status != decrease_disabled ) ||
( cache_ptr->max_cache_size != (6 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (3 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 28.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* Now work with age out with threshold. One can argue that we should
* repeat the above age out tests with age out with threshold, but the
* same code is executed in both cases so I don't see the point. If
* that ever changes, this test should be updated.
*
* There is only one way of disabling decrements that is peculiar
* to age out with threshold, which is to set the upper threshold
* to 1.0. Test this now.
*/
if ( pass ) {
auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
auto_size_ctl.rpt_fcn = test_rpt_fcn;
auto_size_ctl.set_initial_size = TRUE;
auto_size_ctl.initial_size = 4 * 1024 * 1024;
auto_size_ctl.min_clean_fraction = 0.5;
auto_size_ctl.max_size = 16 * 1024 * 1024;
auto_size_ctl.min_size = 1 * 1024 * 1024;
auto_size_ctl.epoch_length = 1000;
auto_size_ctl.incr_mode = H5C_incr__threshold;
auto_size_ctl.lower_hr_threshold = 0.75;
auto_size_ctl.increment = 2.0;
auto_size_ctl.apply_max_increment = TRUE;
auto_size_ctl.max_increment = (2 * 1024 * 1024);
auto_size_ctl.flash_incr_mode = H5C_flash_incr__off;
auto_size_ctl.flash_multiple = 2.0;
auto_size_ctl.flash_threshold = 0.5;
auto_size_ctl.decr_mode = H5C_decr__age_out_with_threshold;
auto_size_ctl.upper_hr_threshold = 1.0;
auto_size_ctl.decrement = 0.5;
auto_size_ctl.apply_max_decrement = TRUE;
auto_size_ctl.max_decrement = (1 * 1024 * 1024);
auto_size_ctl.epochs_before_eviction = 1;
auto_size_ctl.apply_empty_reserve = TRUE;
auto_size_ctl.empty_reserve = 0.05;
result = H5C_set_cache_auto_resize_config(cache_ptr, &auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_set_cache_auto_resize_config failed 10.\n";
}
}
if ( pass ) {
if ( ( cache_ptr->max_cache_size != (4 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (2 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "bad cache size after set resize re-config 9.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* flush the cache and destroy all entries so we start from a known point */
flush_cache(cache_ptr, TRUE, FALSE, FALSE);
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* load up the cache with small entries. Note that it will take an
* epoch for the ageout code to initialize itself if it is enabled.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, SMALL_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, SMALL_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( cache_ptr->size_decrease_possible ) ||
( rpt_status != not_full ) ||
( cache_ptr->max_cache_size != (4 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (2 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 29.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* Load up some more small entries.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 1000;
while ( ( pass ) && ( i < 2000 ) )
{
protect_entry(cache_ptr, SMALL_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, SMALL_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( cache_ptr->size_decrease_possible ) ||
( rpt_status != not_full ) ||
( cache_ptr->max_cache_size != (4 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (2 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 30.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* Now force a high hit rate so that the size increase code is
* is satisfied. We would see a decrease here if decrease were
* possible, but the upper threshold cannot be met, so no decrease.
*
* rpt_status should be decrease_disabled.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, SMALL_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, SMALL_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( cache_ptr->size_decrease_possible ) ||
( rpt_status != decrease_disabled ) ||
( cache_ptr->max_cache_size != (4 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (2 * 1024 * 1024) ) ||
( cache_ptr->index_len != 2000 ) ||
( cache_ptr->index_size != 2000 * SMALL_ENTRY_SIZE ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 31.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* force low hit rate -- cache size should increase from 4 to 6 Meg.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != increase ) ||
( cache_ptr->max_cache_size != (6 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (3 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 32.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* just bang on a single entry. This keeps the hit rate high, and sees
* to it that there are many entries that could be aged out were
* decreases enabled.
*
* Should be no change in cache size, and result should be
* decrease_disabled.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 999);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 999,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( cache_ptr->size_decrease_possible ) ||
( rpt_status != decrease_disabled ) ||
( cache_ptr->max_cache_size != (6 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (3 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 33.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/*********************************************************************
* Finally, use the auto cache resize code to set the size of the
* cache and keep it there. Again, due to the complexity of the
* interface, there are lots of ways of doing this. We have to
* check them all.
*********************************************************************/
if ( pass ) {
auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
auto_size_ctl.rpt_fcn = test_rpt_fcn;
auto_size_ctl.set_initial_size = TRUE;
auto_size_ctl.initial_size = 2 * 1024 * 1024;
auto_size_ctl.min_clean_fraction = 0.5;
auto_size_ctl.max_size = 16 * 1024 * 1024;
auto_size_ctl.min_size = 1 * 1024 * 1024;
auto_size_ctl.epoch_length = 1000;
auto_size_ctl.incr_mode = H5C_incr__threshold;
auto_size_ctl.lower_hr_threshold = 0.0; /* disable size increases */
auto_size_ctl.increment = 2.0;
auto_size_ctl.apply_max_increment = TRUE;
auto_size_ctl.max_increment = (2 * 1024 * 1024);
auto_size_ctl.flash_incr_mode = H5C_flash_incr__off;
auto_size_ctl.flash_multiple = 2.0;
auto_size_ctl.flash_threshold = 0.5;
auto_size_ctl.decr_mode = H5C_decr__threshold;
auto_size_ctl.upper_hr_threshold = 1.0; /* disable size decreases */
auto_size_ctl.decrement = 0.5;
auto_size_ctl.apply_max_decrement = TRUE;
auto_size_ctl.max_decrement = (1 * 1024 * 1024);
auto_size_ctl.epochs_before_eviction = 3;
auto_size_ctl.apply_empty_reserve = TRUE;
auto_size_ctl.empty_reserve = 0.05;
result = H5C_set_cache_auto_resize_config(cache_ptr, &auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_set_cache_auto_resize_config failed 11.\n";
}
}
if ( pass ) {
if ( ( cache_ptr->max_cache_size != (2 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (1 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "bad cache size after set resize re-config 10.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* force low hit rate -- should be no response as the auto-resize
* code should be disabled.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( rpt_fcn_called ) ||
( cache_ptr->resize_enabled ) ||
( cache_ptr->size_increase_possible ) ||
( cache_ptr->size_decrease_possible ) ||
( cache_ptr->max_cache_size != (2 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (1 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 34.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* force high hit rate -- should be no response as the auto-resize
* code should be disabled.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( rpt_fcn_called ) ||
( cache_ptr->resize_enabled ) ||
( cache_ptr->size_increase_possible ) ||
( cache_ptr->size_decrease_possible ) ||
( cache_ptr->max_cache_size != (2 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (1 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 35.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
if ( pass ) {
auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
auto_size_ctl.rpt_fcn = test_rpt_fcn;
auto_size_ctl.set_initial_size = TRUE;
auto_size_ctl.initial_size = 4 * 1024 * 1024;
auto_size_ctl.min_clean_fraction = 0.25;
auto_size_ctl.max_size = 16 * 1024 * 1024;
auto_size_ctl.min_size = 1 * 1024 * 1024;
auto_size_ctl.epoch_length = 1000;
auto_size_ctl.incr_mode = H5C_incr__threshold;
auto_size_ctl.lower_hr_threshold = 0.75;
auto_size_ctl.increment = 1.0; /* disable size increment */
auto_size_ctl.apply_max_increment = TRUE;
auto_size_ctl.max_increment = (2 * 1024 * 1024);
auto_size_ctl.flash_incr_mode = H5C_flash_incr__off;
auto_size_ctl.flash_multiple = 2.0;
auto_size_ctl.flash_threshold = 0.5;
auto_size_ctl.decr_mode = H5C_decr__threshold;
auto_size_ctl.upper_hr_threshold = 0.995;
auto_size_ctl.decrement = 1.0; /* disable size decrement */
auto_size_ctl.apply_max_decrement = TRUE;
auto_size_ctl.max_decrement = (1 * 1024 * 1024);
auto_size_ctl.epochs_before_eviction = 3;
auto_size_ctl.apply_empty_reserve = TRUE;
auto_size_ctl.empty_reserve = 0.05;
result = H5C_set_cache_auto_resize_config(cache_ptr, &auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_set_cache_auto_resize_config failed 12.\n";
}
}
if ( pass ) {
if ( ( cache_ptr->max_cache_size != (4 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (1 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "bad cache size after set resize re-config 11.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* force low hit rate -- should be no response as the auto-resize
* code should be disabled.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( rpt_fcn_called ) ||
( cache_ptr->resize_enabled ) ||
( cache_ptr->size_increase_possible ) ||
( cache_ptr->size_decrease_possible ) ||
( cache_ptr->max_cache_size != (4 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (1 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 36.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* force high hit rate -- should be no response as the auto-resize
* code should be disabled.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( rpt_fcn_called ) ||
( cache_ptr->resize_enabled ) ||
( cache_ptr->size_increase_possible ) ||
( cache_ptr->size_decrease_possible ) ||
( cache_ptr->max_cache_size != (4 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (1 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 37.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
if ( pass ) {
auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
auto_size_ctl.rpt_fcn = test_rpt_fcn;
auto_size_ctl.set_initial_size = FALSE;
auto_size_ctl.initial_size = 2 * 1024 * 1024;
auto_size_ctl.min_clean_fraction = 0.5;
auto_size_ctl.max_size = 6 * 1024 * 1024; /* no resize */
auto_size_ctl.min_size = 6 * 1024 * 1024; /* no resize */
auto_size_ctl.epoch_length = 1000;
auto_size_ctl.incr_mode = H5C_incr__threshold;
auto_size_ctl.lower_hr_threshold = 0.75;
auto_size_ctl.increment = 2.0;
auto_size_ctl.apply_max_increment = TRUE;
auto_size_ctl.max_increment = (2 * 1024 * 1024);
auto_size_ctl.flash_incr_mode = H5C_flash_incr__off;
auto_size_ctl.flash_multiple = 2.0;
auto_size_ctl.flash_threshold = 0.5;
auto_size_ctl.decr_mode = H5C_decr__threshold;
auto_size_ctl.upper_hr_threshold = 0.995;
auto_size_ctl.decrement = 0.5;
auto_size_ctl.apply_max_decrement = TRUE;
auto_size_ctl.max_decrement = (1 * 1024 * 1024);
auto_size_ctl.epochs_before_eviction = 3;
auto_size_ctl.apply_empty_reserve = TRUE;
auto_size_ctl.empty_reserve = 0.05;
result = H5C_set_cache_auto_resize_config(cache_ptr, &auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_set_cache_auto_resize_config failed 13.\n";
}
}
if ( pass ) {
if ( ( cache_ptr->max_cache_size != (6 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (3 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "bad cache size after set resize re-config 12.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* force low hit rate -- should be no response as the auto-resize
* code should be disabled.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( rpt_fcn_called ) ||
( cache_ptr->resize_enabled ) ||
( cache_ptr->size_increase_possible ) ||
( cache_ptr->size_decrease_possible ) ||
( cache_ptr->max_cache_size != (6 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (3 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 38.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* force high hit rate -- should be no response as the auto-resize
* code should be disabled.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( rpt_fcn_called ) ||
( cache_ptr->resize_enabled ) ||
( cache_ptr->size_increase_possible ) ||
( cache_ptr->size_decrease_possible ) ||
( cache_ptr->max_cache_size != (6 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (3 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 39.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
if ( pass ) {
auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
auto_size_ctl.rpt_fcn = test_rpt_fcn;
auto_size_ctl.set_initial_size = TRUE;
auto_size_ctl.initial_size = 4 * 1024 * 1024;
auto_size_ctl.min_clean_fraction = 0.25;
auto_size_ctl.max_size = 16 * 1024 * 1024;
auto_size_ctl.min_size = 1 * 1024 * 1024;
auto_size_ctl.epoch_length = 1000;
auto_size_ctl.incr_mode = H5C_incr__threshold;
auto_size_ctl.lower_hr_threshold = 0.75;
auto_size_ctl.increment = 1.0; /* disable size increment */
auto_size_ctl.apply_max_increment = TRUE;
auto_size_ctl.max_increment = (2 * 1024 * 1024);
auto_size_ctl.flash_incr_mode = H5C_flash_incr__off;
auto_size_ctl.flash_multiple = 2.0;
auto_size_ctl.flash_threshold = 0.5;
auto_size_ctl.decr_mode = H5C_decr__threshold;
auto_size_ctl.upper_hr_threshold = 1.0; /* disable size decrement */
auto_size_ctl.decrement = 0.5;
auto_size_ctl.apply_max_decrement = TRUE;
auto_size_ctl.max_decrement = (1 * 1024 * 1024);
auto_size_ctl.epochs_before_eviction = 3;
auto_size_ctl.apply_empty_reserve = TRUE;
auto_size_ctl.empty_reserve = 0.05;
result = H5C_set_cache_auto_resize_config(cache_ptr, &auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_set_cache_auto_resize_config failed 14.\n";
}
}
if ( pass ) {
if ( ( cache_ptr->max_cache_size != (4 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (1 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "bad cache size after set resize re-config 13.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* force low hit rate -- should be no response as the auto-resize
* code should be disabled.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( rpt_fcn_called ) ||
( cache_ptr->resize_enabled ) ||
( cache_ptr->size_increase_possible ) ||
( cache_ptr->size_decrease_possible ) ||
( cache_ptr->max_cache_size != (4 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (1 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 40.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* force high hit rate -- should be no response as the auto-resize
* code should be disabled.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( rpt_fcn_called ) ||
( cache_ptr->resize_enabled ) ||
( cache_ptr->size_increase_possible ) ||
( cache_ptr->size_decrease_possible ) ||
( cache_ptr->max_cache_size != (4 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (1 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 41.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
if ( pass ) {
auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
auto_size_ctl.rpt_fcn = test_rpt_fcn;
auto_size_ctl.set_initial_size = TRUE;
auto_size_ctl.initial_size = 4 * 1024 * 1024;
auto_size_ctl.min_clean_fraction = 0.5;
auto_size_ctl.max_size = 16 * 1024 * 1024;
auto_size_ctl.min_size = 1 * 1024 * 1024;
auto_size_ctl.epoch_length = 1000;
auto_size_ctl.incr_mode = H5C_incr__threshold;
auto_size_ctl.lower_hr_threshold = 0.0; /* disable size increment */
auto_size_ctl.increment = 2.0;
auto_size_ctl.apply_max_increment = TRUE;
auto_size_ctl.max_increment = (2 * 1024 * 1024);
auto_size_ctl.flash_incr_mode = H5C_flash_incr__off;
auto_size_ctl.flash_multiple = 2.0;
auto_size_ctl.flash_threshold = 0.5;
auto_size_ctl.decr_mode = H5C_decr__threshold;
auto_size_ctl.upper_hr_threshold = 0.995;
auto_size_ctl.decrement = 1.0; /* disable size decrement */
auto_size_ctl.apply_max_decrement = TRUE;
auto_size_ctl.max_decrement = (1 * 1024 * 1024);
auto_size_ctl.epochs_before_eviction = 3;
auto_size_ctl.apply_empty_reserve = TRUE;
auto_size_ctl.empty_reserve = 0.05;
result = H5C_set_cache_auto_resize_config(cache_ptr, &auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_set_cache_auto_resize_config failed 15.\n";
}
}
if ( pass ) {
if ( ( cache_ptr->max_cache_size != (4 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (2 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "bad cache size after set resize re-config 14.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* force low hit rate -- should be no response as the auto-resize
* code should be disabled.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( rpt_fcn_called ) ||
( cache_ptr->resize_enabled ) ||
( cache_ptr->size_increase_possible ) ||
( cache_ptr->size_decrease_possible ) ||
( cache_ptr->max_cache_size != (4 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (2 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 42.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* force high hit rate -- should be no response as the auto-resize
* code should be disabled.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( rpt_fcn_called ) ||
( cache_ptr->resize_enabled ) ||
( cache_ptr->size_increase_possible ) ||
( cache_ptr->size_decrease_possible ) ||
( cache_ptr->max_cache_size != (4 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (2 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 43.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
if ( pass ) {
auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
auto_size_ctl.rpt_fcn = test_rpt_fcn;
auto_size_ctl.set_initial_size = TRUE;
auto_size_ctl.initial_size = 4 * 1024 * 1024;
auto_size_ctl.min_clean_fraction = 0.5;
auto_size_ctl.max_size = 16 * 1024 * 1024;
auto_size_ctl.min_size = 1 * 1024 * 1024;
auto_size_ctl.epoch_length = 1000;
auto_size_ctl.incr_mode = H5C_incr__off;
auto_size_ctl.lower_hr_threshold = 0.75;
auto_size_ctl.increment = 2.0;
auto_size_ctl.apply_max_increment = TRUE;
auto_size_ctl.max_increment = (2 * 1024 * 1024);
auto_size_ctl.flash_incr_mode = H5C_flash_incr__off;
auto_size_ctl.flash_multiple = 2.0;
auto_size_ctl.flash_threshold = 0.5;
auto_size_ctl.decr_mode = H5C_decr__off;
auto_size_ctl.upper_hr_threshold = 0.995;
auto_size_ctl.decrement = 0.5;
auto_size_ctl.apply_max_decrement = TRUE;
auto_size_ctl.max_decrement = (1 * 1024 * 1024);
auto_size_ctl.epochs_before_eviction = 3;
auto_size_ctl.apply_empty_reserve = TRUE;
auto_size_ctl.empty_reserve = 0.05;
result = H5C_set_cache_auto_resize_config(cache_ptr, &auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_set_cache_auto_resize_config failed 16.\n";
}
}
if ( pass ) {
if ( ( cache_ptr->max_cache_size != (4 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (2 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "bad cache size after set resize re-config 15.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* force low hit rate -- should be no response as the auto-resize
* code should be disabled.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( rpt_fcn_called ) ||
( cache_ptr->resize_enabled ) ||
( cache_ptr->size_increase_possible ) ||
( cache_ptr->size_decrease_possible ) ||
( cache_ptr->max_cache_size != (4 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (2 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 44.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* force high hit rate -- should be no response as the auto-resize
* code should be disabled.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0);
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( rpt_fcn_called ) ||
( cache_ptr->resize_enabled ) ||
( cache_ptr->size_increase_possible ) ||
( cache_ptr->size_decrease_possible ) ||
( cache_ptr->max_cache_size != (4 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (2 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 45.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* Now test the flash cache size increment code to verify that it
* is disabled when it should be.
*
* Since the flash size increase code doesn't look at hit rate, or
* use epochs (other than to start a new epoch if a flash cache size
* increase is triggered), we go about these tests somewhat differently
* than the rest of the tests in this function.
*
* As of this writing, there is only one flash cache size increment
* mode (add space), which is triggered whenever the size of a newly
* loaded or inserted entry, or the delta between old and new entry
* sizes exceeds some fraction of the current maximum cache size, and
* the cache doesn't have enough free space to accomodate the new/
* resize entry without performing evictions. The range of permissible
* values for the flash_threshold (0.1 to 1.0 as of this writing), and
* for the flash_multiple (0.1 to 10.0) do not permit the facility to
* be turned off by configuration. Thus, flash cache size increases
* can be disabled only via the flash_incr_mode, and by setting the
* current max_cache_size equal to max_size.
*
* We have already tested the latter in check_auto_cache_resize(), so
* we need only thest the former here. Do this by disabling flash
* cache size increments via the flash_incr_mode, and then creating
* situations that would trigger flash cache size increases were that
* code enabled.
*/
if ( pass ) {
auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
auto_size_ctl.rpt_fcn = test_rpt_fcn;
auto_size_ctl.set_initial_size = TRUE;
auto_size_ctl.initial_size = 64 * 1024;
auto_size_ctl.min_clean_fraction = 0.5;
auto_size_ctl.max_size = 256 * 1024;
auto_size_ctl.min_size = 32 * 1024;
auto_size_ctl.epoch_length = 1000;
auto_size_ctl.incr_mode = H5C_incr__threshold;
auto_size_ctl.lower_hr_threshold = 0.75;
auto_size_ctl.increment = 2.0;
auto_size_ctl.apply_max_increment = TRUE;
auto_size_ctl.max_increment = (2 * 1024);
auto_size_ctl.flash_incr_mode = H5C_flash_incr__off;
auto_size_ctl.flash_multiple = 1.0;
auto_size_ctl.flash_threshold = 0.25;
auto_size_ctl.decr_mode = H5C_decr__age_out_with_threshold;
auto_size_ctl.upper_hr_threshold = 0.995;
auto_size_ctl.decrement = 0.5;
auto_size_ctl.apply_max_decrement = TRUE;
auto_size_ctl.max_decrement = (1 * 1024);
auto_size_ctl.epochs_before_eviction = 3;
auto_size_ctl.apply_empty_reserve = TRUE;
auto_size_ctl.empty_reserve = 0.05;
result = H5C_set_cache_auto_resize_config(cache_ptr, &auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_set_cache_auto_resize_config failed 17.\n";
}
}
if ( pass ) {
if ( ( cache_ptr->max_cache_size != (64 * 1024) ) ||
( cache_ptr->min_clean_size != (32 * 1024) ) ) {
pass = FALSE;
failure_mssg = "bad cache size after set resize re-config 16.\n";
}
}
/* We have reduced the max cache size to well below the current index
* size. Protect and unprotect an entry to allow the cache to evict
* entries and get within bounds
*/
if ( pass ) {
rpt_fcn_called = FALSE;
protect_entry(cache_ptr, LARGE_ENTRY_TYPE, 0);
unprotect_entry(cache_ptr, LARGE_ENTRY_TYPE, 0,
NO_CHANGE, H5C__NO_FLAGS_SET);
if ( ( pass ) &&
( ( ( cache_ptr->max_cache_size != (64 * 1024) ) ||
( cache_ptr->min_clean_size != (32 * 1024) ) ||
( cache_ptr->index_len != 1 ) ||
( cache_ptr->index_size != LARGE_ENTRY_SIZE ) ||
( rpt_fcn_called != FALSE ) ) ) ) {
HDfprintf(stdout, "\nmax_cache_size = %ld.\n",
(long)(cache_ptr->max_cache_size));
HDfprintf(stdout, "min_clean_size = %ld.\n",
(long)(cache_ptr->min_clean_size));
HDfprintf(stdout, "index_len = %ld.\n",
(long)(cache_ptr->index_len));
HDfprintf(stdout, "index_size = %ld.\n",
(long)(cache_ptr->index_size));
HDfprintf(stdout, "rpt_fcn_called = %ld.\n",
(long)(rpt_fcn_called));
pass = FALSE;
failure_mssg = "Unexpected cache size change results 46.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* Now protect and unprotect a monster entry. If the flash cache
* size increment code was active, this would trigger an increase.
* Verify that it doesn't.
*
* This finishes the additional tests needed for the flash cache
* size increase code.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0);
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0,
NO_CHANGE, H5C__NO_FLAGS_SET);
if ( ( pass ) &&
( ( ( cache_ptr->max_cache_size != (64 * 1024) ) ||
( cache_ptr->min_clean_size != (32 * 1024) ) ||
( cache_ptr->index_len != 1 ) ||
( cache_ptr->index_size != MONSTER_ENTRY_SIZE ) ||
( rpt_fcn_called != FALSE ) ) ) ) {
HDfprintf(stdout, "\nmax_cache_size = %ld.\n",
(long)(cache_ptr->max_cache_size));
HDfprintf(stdout, "min_clean_size = %ld.\n",
(long)(cache_ptr->min_clean_size));
HDfprintf(stdout, "index_len = %ld.\n",
(long)(cache_ptr->index_len));
HDfprintf(stdout, "index_size = %ld.\n",
(long)(cache_ptr->index_size));
HDfprintf(stdout, "rpt_fcn_called = %ld.\n",
(long)(rpt_fcn_called));
pass = FALSE;
failure_mssg = "Unexpected cache size change results 47.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
if ( pass ) {
takedown_cache(cache_ptr, FALSE, FALSE);
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
if ( pass ) { PASSED(); } else { H5_FAILED(); }
if ( ! pass ) {
HDfprintf(stdout, "%s: failure_mssg = \"%s\".\n",
fcn_name, failure_mssg);
}
return;
} /* check_auto_cache_resize_disable() */
/*-------------------------------------------------------------------------
* Function: check_auto_cache_resize_epoch_markers()
*
* Purpose: Verify that the auto-resize code manages epoch markers
* correctly.
*
* Return: void
*
* Programmer: John Mainzer
* 12/16/04
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static void
check_auto_cache_resize_epoch_markers(void)
{
const char * fcn_name = "check_auto_cache_resize_epoch_markers()";
hbool_t show_progress = FALSE;
herr_t result;
int32_t i;
int32_t j;
int32_t checkpoint = 0;
H5C_t * cache_ptr = NULL;
H5C_auto_size_ctl_t auto_size_ctl =
{
/* int32_t version = */ H5C__CURR_AUTO_SIZE_CTL_VER,
/* H5C_auto_resize_report_fcn rpt_fcn = */ test_rpt_fcn,
/* hbool_t set_initial_size = */ TRUE,
/* size_t initial_size = */ (512 * 1024),
/* double min_clean_fraction = */ 0.5,
/* size_t max_size = */ (14 * 1024 * 1024),
/* size_t min_size = */ (512 * 1024),
/* int64_t epoch_length = */ 1000,
/* enum H5C_cache_incr_mode incr_mode = */ H5C_incr__threshold,
/* double lower_hr_threshold = */ 0.75,
/* double increment = */ 2.0,
/* hbool_t apply_max_increment = */ TRUE,
/* size_t max_increment = */ (4 * 1024 * 1024),
/* enum H5C_cache_flash_incr_mode */
/* flash_incr_mode = */ H5C_flash_incr__off,
/* double flash_multiple = */ 2.0,
/* double flash_threshold = */ 0.5,
/* enum H5C_cache_decr_mode decr_mode = */ H5C_decr__threshold,
/* double upper_hr_threshold = */ 0.995,
/* double decrement = */ 0.1,
/* hbool_t apply_max_decrement = */ TRUE,
/* size_t max_decrement = */ (1 * 1024 * 1024),
/* int32_t epochs_before_eviction = */ 3,
/* hbool_t apply_empty_reserve = */ TRUE,
/* double empty_reserve = */ 0.05
};
TESTING("automatic cache resize epoch marker management");
pass = TRUE;
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
if ( pass ) {
reset_entries();
cache_ptr = setup_cache((size_t)(2 * 1024),
(size_t)(1 * 1024));
}
if ( pass ) {
result = H5C_set_cache_auto_resize_config(cache_ptr, &auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_set_cache_auto_resize_config failed 1.\n";
}
}
if ( pass ) {
if ( ( cache_ptr->max_cache_size != (512 * 1024) ) ||
( cache_ptr->min_clean_size != (256 * 1024) ) ) {
pass = FALSE;
failure_mssg = "bad cache size after initialization.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* Now make sure that we are managing the epoch markers correctly.
*/
if ( pass ) {
auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
auto_size_ctl.rpt_fcn = test_rpt_fcn;
auto_size_ctl.set_initial_size = TRUE;
auto_size_ctl.initial_size = 8 * 1024 * 1024;
auto_size_ctl.min_clean_fraction = 0.5;
auto_size_ctl.max_size = 8 * 1024 * 1024;
auto_size_ctl.min_size = 512 * 1024;
auto_size_ctl.epoch_length = 1000;
auto_size_ctl.incr_mode = H5C_incr__off;
auto_size_ctl.lower_hr_threshold = 0.75;
auto_size_ctl.increment = 2.0;
auto_size_ctl.apply_max_increment = TRUE;
auto_size_ctl.max_increment = (4 * 1024 * 1024);
auto_size_ctl.flash_incr_mode = H5C_flash_incr__off;
auto_size_ctl.flash_multiple = 2.0;
auto_size_ctl.flash_threshold = 0.5;
auto_size_ctl.decr_mode = H5C_decr__age_out;
auto_size_ctl.upper_hr_threshold = 0.995;
auto_size_ctl.decrement = 0.5;
auto_size_ctl.apply_max_decrement = FALSE;
auto_size_ctl.max_decrement = (1 * 1024 * 1024);
auto_size_ctl.epochs_before_eviction = 10;
auto_size_ctl.apply_empty_reserve = FALSE;
auto_size_ctl.empty_reserve = 0.05;
result = H5C_set_cache_auto_resize_config(cache_ptr, &auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_set_cache_auto_resize_config failed 2.\n";
}
}
if ( pass ) {
if ( ( cache_ptr->max_cache_size != (8 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (4 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "bad cache size after set resize re-config 1.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* Since we just created the cache, there should be no epoch markers
* active. Verify that this is true.
*/
if ( pass ) {
if ( cache_ptr->epoch_markers_active != 0 ) {
pass = FALSE;
failure_mssg = "Unexpected # of epoch markers 1.\n";
}
}
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, MEDIUM_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != in_spec ) ||
( cache_ptr->max_cache_size != (8 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (4 * 1024 * 1024) ) ||
( cache_ptr->index_size != (1 * 1000 * MEDIUM_ENTRY_SIZE) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 0.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
if ( pass ) {
j = 2;
while ( ( pass ) && ( j <= 10 ) )
{
rpt_fcn_called = FALSE;
i = (j - 2) * 1000;
while ( ( pass ) && ( i < (j - 1) * 1000 ) )
{
protect_entry(cache_ptr, SMALL_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, SMALL_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != in_spec ) ||
( cache_ptr->epoch_markers_active != j ) ) {
pass = FALSE;
failure_mssg = "Unexpected # of epoch markers 2.\n";
}
j++;
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* we now have a full complement of epoch markers -- see if
* we get the expected reduction.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 9000;
while ( ( pass ) && ( i < 10000 ) )
{
protect_entry(cache_ptr, SMALL_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, SMALL_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != decrease ) ||
( cache_ptr->max_cache_size !=
(10 * 1000 * SMALL_ENTRY_SIZE + MEDIUM_ENTRY_SIZE) ) ||
( cache_ptr->min_clean_size !=
((10 * 1000 * SMALL_ENTRY_SIZE + MEDIUM_ENTRY_SIZE) / 2) ) ||
( cache_ptr->index_size !=
(10 * 1000 * SMALL_ENTRY_SIZE + MEDIUM_ENTRY_SIZE) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 1.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* now reduce the epochs before eviction, and see if the cache
* deletes the extra markers
*/
if ( pass ) {
auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
auto_size_ctl.rpt_fcn = test_rpt_fcn;
auto_size_ctl.set_initial_size = TRUE;
auto_size_ctl.initial_size = 8 * 1024 * 1024;
auto_size_ctl.min_clean_fraction = 0.5;
auto_size_ctl.max_size = 8 * 1024 * 1024;
auto_size_ctl.min_size = 512 * 1024;
auto_size_ctl.epoch_length = 1000;
auto_size_ctl.incr_mode = H5C_incr__off;
auto_size_ctl.lower_hr_threshold = 0.75;
auto_size_ctl.increment = 2.0;
auto_size_ctl.apply_max_increment = TRUE;
auto_size_ctl.max_increment = (4 * 1024 * 1024);
auto_size_ctl.flash_incr_mode = H5C_flash_incr__off;
auto_size_ctl.flash_multiple = 2.0;
auto_size_ctl.flash_threshold = 0.5;
auto_size_ctl.decr_mode = H5C_decr__age_out;
auto_size_ctl.upper_hr_threshold = 0.995;
auto_size_ctl.decrement = 0.5;
auto_size_ctl.apply_max_decrement = FALSE;
auto_size_ctl.max_decrement = (1 * 1024 * 1024);
auto_size_ctl.epochs_before_eviction = 1;
auto_size_ctl.apply_empty_reserve = FALSE;
auto_size_ctl.empty_reserve = 0.05;
result = H5C_set_cache_auto_resize_config(cache_ptr, &auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_set_cache_auto_resize_config failed 3.\n";
}
}
if ( pass ) {
if ( ( cache_ptr->max_cache_size != (8 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (4 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "bad cache size after set resize re-config 2.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* There should be exactly one active epoch marker at present.
*/
if ( pass ) {
if ( cache_ptr->epoch_markers_active != 1 ) {
pass = FALSE;
failure_mssg = "Unexpected # of epoch markers 3.\n";
}
}
/* Now do an epochs worth of accesses, and verify that everything
* not accessed in this epoch gets evicted, and the cache size
* is reduced.
*/
if ( pass ) {
rpt_fcn_called = FALSE;
i = 9000;
while ( ( pass ) && ( i < 10000 ) )
{
protect_entry(cache_ptr, SMALL_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, SMALL_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != decrease ) ||
( cache_ptr->max_cache_size != (512 * 1024) ) ||
( cache_ptr->min_clean_size != (256 * 1024) ) ||
( cache_ptr->index_size != (1 * 1000 * SMALL_ENTRY_SIZE) ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 2.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* There should be exactly one active epoch marker at present...
*/
if ( pass ) {
if ( cache_ptr->epoch_markers_active != 1 ) {
pass = FALSE;
failure_mssg = "Unexpected # of epoch markers 4.\n";
}
}
/* shift the decrement mode to threshold, and verify that we remove
* all epoch markers.
*/
if ( pass ) {
auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
auto_size_ctl.rpt_fcn = test_rpt_fcn;
auto_size_ctl.set_initial_size = TRUE;
auto_size_ctl.initial_size = 8 * 1024 * 1024;
auto_size_ctl.min_clean_fraction = 0.5;
auto_size_ctl.max_size = 8 * 1024 * 1024;
auto_size_ctl.min_size = 512 * 1024;
auto_size_ctl.epoch_length = 1000;
auto_size_ctl.incr_mode = H5C_incr__off;
auto_size_ctl.lower_hr_threshold = 0.75;
auto_size_ctl.increment = 2.0;
auto_size_ctl.apply_max_increment = TRUE;
auto_size_ctl.max_increment = (4 * 1024 * 1024);
auto_size_ctl.flash_incr_mode = H5C_flash_incr__off;
auto_size_ctl.flash_multiple = 2.0;
auto_size_ctl.flash_threshold = 0.5;
auto_size_ctl.decr_mode = H5C_decr__threshold;
auto_size_ctl.upper_hr_threshold = 0.995;
auto_size_ctl.decrement = 0.5;
auto_size_ctl.apply_max_decrement = FALSE;
auto_size_ctl.max_decrement = (1 * 1024 * 1024);
auto_size_ctl.epochs_before_eviction = 1;
auto_size_ctl.apply_empty_reserve = FALSE;
auto_size_ctl.empty_reserve = 0.05;
result = H5C_set_cache_auto_resize_config(cache_ptr, &auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_set_cache_auto_resize_config failed 4.\n";
}
}
if ( pass ) {
if ( ( cache_ptr->max_cache_size != (8 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (4 * 1024 * 1024) ) ) {
pass = FALSE;
failure_mssg = "bad cache size after set resize re-config 3.\n";
}
}
/* ... and now there should be none.
*/
if ( pass ) {
if ( cache_ptr->epoch_markers_active != 0 ) {
pass = FALSE;
failure_mssg = "Unexpected # of epoch markers 5.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* shift the decrement mode to age out with threshold. Set epochs
* before eviction to 10 again.
*/
if ( pass ) {
auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
auto_size_ctl.rpt_fcn = test_rpt_fcn;
auto_size_ctl.set_initial_size = TRUE;
auto_size_ctl.initial_size = 8 * 1024 * 1024;
auto_size_ctl.min_clean_fraction = 0.5;
auto_size_ctl.max_size = 8 * 1024 * 1024;
auto_size_ctl.min_size = 512 * 1024;
auto_size_ctl.epoch_length = 1000;
auto_size_ctl.incr_mode = H5C_incr__off;
auto_size_ctl.lower_hr_threshold = 0.75;
auto_size_ctl.increment = 2.0;
auto_size_ctl.apply_max_increment = TRUE;
auto_size_ctl.max_increment = (4 * 1024 * 1024);
auto_size_ctl.flash_incr_mode = H5C_flash_incr__off;
auto_size_ctl.flash_multiple = 2.0;
auto_size_ctl.flash_threshold = 0.5;
auto_size_ctl.decr_mode = H5C_decr__age_out_with_threshold;
auto_size_ctl.upper_hr_threshold = 0.995;
auto_size_ctl.decrement = 0.5;
auto_size_ctl.apply_max_decrement = FALSE;
auto_size_ctl.max_decrement = (1 * 1024 * 1024);
auto_size_ctl.epochs_before_eviction = 10;
auto_size_ctl.apply_empty_reserve = FALSE;
auto_size_ctl.empty_reserve = 0.05;
result = H5C_set_cache_auto_resize_config(cache_ptr, &auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_set_cache_auto_resize_config failed 5.\n";
}
}
/* Verify that there are no active epoch markers.
*/
if ( pass ) {
if ( cache_ptr->epoch_markers_active != 0 ) {
pass = FALSE;
failure_mssg = "Unexpected # of epoch markers 6.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* build up a full set of epoch markers. */
if ( pass ) {
j = 1;
while ( ( pass ) && ( j <= 10 ) )
{
rpt_fcn_called = FALSE;
i = (j - 1) * 1000;
while ( ( pass ) && ( i < j * 1000 ) )
{
protect_entry(cache_ptr, SMALL_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, SMALL_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
if ( ( ! rpt_fcn_called ) ||
( rpt_status != in_spec ) ||
( cache_ptr->epoch_markers_active != j ) ) {
pass = FALSE;
failure_mssg = "Unexpected # of epoch markers 7.\n";
}
j++;
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* Verify that there are now 10 active epoch markers.
*/
if ( pass ) {
if ( cache_ptr->epoch_markers_active != 10 ) {
pass = FALSE;
failure_mssg = "Unexpected # of epoch markers 8.\n";
}
}
/* shift the decrement mode to off. This should cause all epoch
* markers to be removed.
*/
if ( pass ) {
auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
auto_size_ctl.rpt_fcn = test_rpt_fcn;
auto_size_ctl.set_initial_size = TRUE;
auto_size_ctl.initial_size = 8 * 1024 * 1024;
auto_size_ctl.min_clean_fraction = 0.5;
auto_size_ctl.max_size = 8 * 1024 * 1024;
auto_size_ctl.min_size = 512 * 1024;
auto_size_ctl.epoch_length = 1000;
auto_size_ctl.incr_mode = H5C_incr__off;
auto_size_ctl.lower_hr_threshold = 0.75;
auto_size_ctl.increment = 2.0;
auto_size_ctl.apply_max_increment = TRUE;
auto_size_ctl.max_increment = (4 * 1024 * 1024);
auto_size_ctl.flash_incr_mode = H5C_flash_incr__off;
auto_size_ctl.flash_multiple = 2.0;
auto_size_ctl.flash_threshold = 0.5;
auto_size_ctl.decr_mode = H5C_decr__off;
auto_size_ctl.upper_hr_threshold = 0.995;
auto_size_ctl.decrement = 0.5;
auto_size_ctl.apply_max_decrement = FALSE;
auto_size_ctl.max_decrement = (1 * 1024 * 1024);
auto_size_ctl.epochs_before_eviction = 10;
auto_size_ctl.apply_empty_reserve = FALSE;
auto_size_ctl.empty_reserve = 0.05;
result = H5C_set_cache_auto_resize_config(cache_ptr, &auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_set_cache_auto_resize_config failed 6.\n";
}
}
/* Verify that there are now no active epoch markers.
*/
if ( pass ) {
if ( cache_ptr->epoch_markers_active != 0 ) {
pass = FALSE;
failure_mssg = "Unexpected # of epoch markers 9.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
/* verify that we still have the expected number of entries in the cache,
* and that the cache is of the expected size.
*/
if ( pass ) {
if ( ( cache_ptr->max_cache_size != (8 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (4 * 1024 * 1024) )||
( cache_ptr->index_size != (10 * 1000 * SMALL_ENTRY_SIZE) ) ||
( cache_ptr->index_len != 10000 ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache size change results 3.\n";
}
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
if ( pass ) {
takedown_cache(cache_ptr, FALSE, FALSE);
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
if ( pass ) { PASSED(); } else { H5_FAILED(); }
if ( ! pass ) {
HDfprintf(stdout, "%s: failure_mssg = \"%s\".\n",
fcn_name, failure_mssg);
}
return;
} /* check_auto_cache_resize_epoch_markers() */
/*-------------------------------------------------------------------------
* Function: check_auto_cache_resize_input_errs()
*
* Purpose: Verify that H5C_set_cache_auto_resize_config() detects
* and rejects invalid input.
*
* Return: void
*
* Programmer: John Mainzer
* 10/29/04
*
* Modifications:
*
* Added code to verify that errors in the flash cache size
* increment related fields are caught as well.
*
* JRM -- 1/17/08
*
*-------------------------------------------------------------------------
*/
#define RESIZE_CONFIGS_ARE_EQUAL(a, b, compare_init) \
( ( (a).version == (b).version ) && \
( (a).rpt_fcn == (b).rpt_fcn ) && \
( ( ! compare_init ) || \
( (a).set_initial_size == (b).set_initial_size ) ) && \
( ( ! compare_init ) || \
( (a).initial_size == (b).initial_size ) ) && \
( (a).min_clean_fraction == (b).min_clean_fraction ) && \
( (a).max_size == (b).max_size ) && \
( (a).min_size == (b).min_size ) && \
( (a).epoch_length == (b).epoch_length ) && \
( (a).incr_mode == (b).incr_mode ) && \
( (a).lower_hr_threshold == (b).lower_hr_threshold ) && \
( (a).increment == (b).increment ) && \
( (a).apply_max_increment == (b).apply_max_increment ) && \
( (a).max_increment == (b).max_increment ) && \
( (a).flash_incr_mode == (b).flash_incr_mode ) && \
( (a).flash_multiple == (b).flash_multiple ) && \
( (a).flash_threshold == (b).flash_threshold ) && \
( (a).decr_mode == (b).decr_mode ) && \
( (a).upper_hr_threshold == (b).upper_hr_threshold ) && \
( (a).flash_incr_mode == (b).flash_incr_mode ) && \
( (a).flash_multiple == (b).flash_multiple ) && \
( (a).flash_threshold == (b).flash_threshold ) && \
( (a).decrement == (b).decrement ) && \
( (a).apply_max_decrement == (b).apply_max_decrement ) && \
( (a).max_decrement == (b).max_decrement ) && \
( (a).epochs_before_eviction == (b).epochs_before_eviction ) && \
( (a).apply_empty_reserve == (b).apply_empty_reserve ) && \
( (a).empty_reserve == (b).empty_reserve ) )
static void
check_auto_cache_resize_input_errs(void)
{
const char * fcn_name = "check_auto_cache_resize_input_errs()";
herr_t result;
H5C_t * cache_ptr = NULL;
H5C_auto_size_ctl_t ref_auto_size_ctl =
{
/* int32_t version = */ H5C__CURR_AUTO_SIZE_CTL_VER,
/* H5C_auto_resize_report_fcn rpt_fcn = */ test_rpt_fcn,
/* hbool_t set_initial_size = */ TRUE,
/* size_t initial_size = */ (512 * 1024),
/* double min_clean_fraction = */ 0.5,
/* size_t max_size = */ (16 * 1024 * 1024),
/* size_t min_size = */ (512 * 1024),
/* int64_t epoch_length = */ 1000,
/* enum H5C_cache_incr_mode incr_mode = */ H5C_incr__threshold,
/* double lower_hr_threshold = */ 0.75,
/* double increment = */ 2.0,
/* hbool_t apply_max_increment = */ TRUE,
/* size_t max_increment = */ (4 * 1024 * 1024),
/* enum H5C_cache_flash_incr_mode */
/* flash_incr_mode = */ H5C_flash_incr__off,
/* double flash_multiple = */ 2.0,
/* double flash_threshold = */ 0.5,
/* enum H5C_cache_decr_mode decr_mode = */ H5C_decr__threshold,
/* double upper_hr_threshold = */ 0.995,
/* double decrement = */ 0.1,
/* hbool_t apply_max_decrement = */ TRUE,
/* size_t max_decrement = */ (1 * 1024 * 1024),
/* int32_t epochs_before_eviction = */ 3,
/* hbool_t apply_empty_reserve = */ TRUE,
/* double empty_reserve = */ 0.05
};
H5C_auto_size_ctl_t invalid_auto_size_ctl;
H5C_auto_size_ctl_t test_auto_size_ctl;
TESTING("automatic cache resize input errors");
pass = TRUE;
/* allocate a cache, and set a reference automatic cache control
* configuration. Then feed H5C_set_cache_auto_resize_config()
* invalid input, and verify that the correct error is returned,
* and that the configuration is not modified.
*/
if ( pass ) {
reset_entries();
cache_ptr = setup_cache((size_t)(2 * 1024),
(size_t)(1 * 1024));
}
if ( pass ) {
result = H5C_set_cache_auto_resize_config(cache_ptr,
&ref_auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_set_cache_auto_resize_config failed 1.\n";
}
}
if ( pass ) {
if ( ( cache_ptr->max_cache_size != (512 * 1024) ) ||
( cache_ptr->min_clean_size != (256 * 1024) ) ) {
pass = FALSE;
failure_mssg = "bad cache size after initialization.\n";
}
}
if ( pass ) {
result = H5C_get_cache_auto_resize_config(cache_ptr,
&test_auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_get_cache_auto_resize_config failed 1.";
} else if ( ! RESIZE_CONFIGS_ARE_EQUAL(test_auto_size_ctl, \
ref_auto_size_ctl, FALSE) ) {
pass = FALSE;
failure_mssg = "Unexpected auto resize config 1.";
}
}
if ( pass ) {
invalid_auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
invalid_auto_size_ctl.rpt_fcn = NULL;
invalid_auto_size_ctl.set_initial_size = TRUE;
invalid_auto_size_ctl.initial_size = 4 * 1024 * 1024;
invalid_auto_size_ctl.min_clean_fraction = 0.5;
invalid_auto_size_ctl.max_size = 16 * 1024 * 1024;
invalid_auto_size_ctl.min_size = 1 * 1024 * 1024;
invalid_auto_size_ctl.epoch_length = 5000;
invalid_auto_size_ctl.incr_mode = H5C_incr__threshold;
invalid_auto_size_ctl.lower_hr_threshold = 0.7;
invalid_auto_size_ctl.increment = 2.0;
invalid_auto_size_ctl.apply_max_increment = TRUE;
invalid_auto_size_ctl.max_increment = (2 * 1024 * 1024);
invalid_auto_size_ctl.flash_incr_mode = H5C_flash_incr__off;
invalid_auto_size_ctl.flash_multiple = 2.0;
invalid_auto_size_ctl.flash_threshold = 0.5;
invalid_auto_size_ctl.decr_mode = H5C_decr__threshold;
invalid_auto_size_ctl.upper_hr_threshold = 0.999;
invalid_auto_size_ctl.decrement = 0.5;
invalid_auto_size_ctl.apply_max_decrement = TRUE;
invalid_auto_size_ctl.max_decrement = (1 * 1024 * 1024);
invalid_auto_size_ctl.epochs_before_eviction = 3;
invalid_auto_size_ctl.apply_empty_reserve = TRUE;
invalid_auto_size_ctl.empty_reserve = 0.05;
result = H5C_set_cache_auto_resize_config(NULL,
&invalid_auto_size_ctl);
if ( result != FAIL ) {
pass = FALSE;
failure_mssg =
"H5C_set_cache_auto_resize_config accepted NULL cache_ptr.\n";
}
}
if ( pass ) {
result = H5C_get_cache_auto_resize_config(cache_ptr,
&test_auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_get_cache_auto_resize_config failed 2.";
} else if ( ! RESIZE_CONFIGS_ARE_EQUAL(test_auto_size_ctl, \
ref_auto_size_ctl, FALSE) ) {
pass = FALSE;
failure_mssg = "Unexpected auto resize config 2.";
}
}
/* check bad version rejection. */
if ( pass ) {
invalid_auto_size_ctl.version = -1; /* INVALID */
invalid_auto_size_ctl.rpt_fcn = NULL;
invalid_auto_size_ctl.set_initial_size = TRUE;
invalid_auto_size_ctl.initial_size = 4 * 1024 * 1024;
invalid_auto_size_ctl.min_clean_fraction = 0.5;
invalid_auto_size_ctl.max_size = 16 * 1024 * 1024;
invalid_auto_size_ctl.min_size = 1 * 1024 * 1024;
invalid_auto_size_ctl.epoch_length = 5000;
invalid_auto_size_ctl.incr_mode = H5C_incr__threshold;
invalid_auto_size_ctl.lower_hr_threshold = 0.7;
invalid_auto_size_ctl.increment = 2.0;
invalid_auto_size_ctl.apply_max_increment = TRUE;
invalid_auto_size_ctl.max_increment = (2 * 1024 * 1024);
invalid_auto_size_ctl.flash_incr_mode = H5C_flash_incr__off;
invalid_auto_size_ctl.flash_multiple = 2.0;
invalid_auto_size_ctl.flash_threshold = 0.5;
invalid_auto_size_ctl.decr_mode = H5C_decr__threshold;
invalid_auto_size_ctl.upper_hr_threshold = 0.999;
invalid_auto_size_ctl.decrement = 0.5;
invalid_auto_size_ctl.apply_max_decrement = TRUE;
invalid_auto_size_ctl.max_decrement = (1 * 1024 * 1024);
invalid_auto_size_ctl.epochs_before_eviction = 3;
invalid_auto_size_ctl.apply_empty_reserve = TRUE;
invalid_auto_size_ctl.empty_reserve = 0.05;
result = H5C_set_cache_auto_resize_config(cache_ptr,
&invalid_auto_size_ctl);
if ( result != FAIL ) {
pass = FALSE;
failure_mssg =
"H5C_set_cache_auto_resize_config accepted bad version.\n";
}
}
if ( pass ) {
result = H5C_get_cache_auto_resize_config(cache_ptr,
&test_auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_get_cache_auto_resize_config failed 3.";
} else if ( ! RESIZE_CONFIGS_ARE_EQUAL(test_auto_size_ctl, \
ref_auto_size_ctl, FALSE) ) {
pass = FALSE;
failure_mssg = "Unexpected auto resize config 3.";
}
}
/* check bad initial size rejection */
if ( pass ) {
invalid_auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
invalid_auto_size_ctl.rpt_fcn = NULL;
invalid_auto_size_ctl.set_initial_size = TRUE;
invalid_auto_size_ctl.initial_size = 16 * 1024 * 1024 + 1;
/* INVALID */
invalid_auto_size_ctl.min_clean_fraction = 0.5;
invalid_auto_size_ctl.max_size = 16 * 1024 * 1024;
invalid_auto_size_ctl.min_size = 1 * 1024 * 1024;
invalid_auto_size_ctl.epoch_length = 5000;
invalid_auto_size_ctl.incr_mode = H5C_incr__threshold;
invalid_auto_size_ctl.lower_hr_threshold = 0.75;
invalid_auto_size_ctl.increment = 2.0;
invalid_auto_size_ctl.apply_max_increment = TRUE;
invalid_auto_size_ctl.max_increment = (2 * 1024 * 1024);
invalid_auto_size_ctl.flash_incr_mode = H5C_flash_incr__off;
invalid_auto_size_ctl.flash_multiple = 2.0;
invalid_auto_size_ctl.flash_threshold = 0.5;
invalid_auto_size_ctl.decr_mode = H5C_decr__threshold;
invalid_auto_size_ctl.upper_hr_threshold = 0.999;
invalid_auto_size_ctl.decrement = 0.5;
invalid_auto_size_ctl.apply_max_decrement = TRUE;
invalid_auto_size_ctl.max_decrement = (1 * 1024 * 1024);
invalid_auto_size_ctl.epochs_before_eviction = 3;
invalid_auto_size_ctl.apply_empty_reserve = TRUE;
invalid_auto_size_ctl.empty_reserve = 0.05;
result = H5C_set_cache_auto_resize_config(cache_ptr,
&invalid_auto_size_ctl);
if ( result != FAIL ) {
pass = FALSE;
failure_mssg =
"H5C_set_cache_auto_resize_config accepted bad init size 1.\n";
}
}
if ( pass ) {
result = H5C_get_cache_auto_resize_config(cache_ptr,
&test_auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_get_cache_auto_resize_config failed 4.";
} else if ( ! RESIZE_CONFIGS_ARE_EQUAL(test_auto_size_ctl, \
ref_auto_size_ctl, FALSE) ) {
pass = FALSE;
failure_mssg = "Unexpected auto resize config 4.";
}
}
if ( pass ) {
invalid_auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
invalid_auto_size_ctl.rpt_fcn = NULL;
invalid_auto_size_ctl.set_initial_size = TRUE;
invalid_auto_size_ctl.initial_size = 1 * 1024 * 1024 - 1;
/* INVALID */
invalid_auto_size_ctl.min_clean_fraction = 0.5;
invalid_auto_size_ctl.max_size = 16 * 1024 * 1024;
invalid_auto_size_ctl.min_size = 1 * 1024 * 1024;
invalid_auto_size_ctl.epoch_length = 5000;
invalid_auto_size_ctl.incr_mode = H5C_incr__threshold;
invalid_auto_size_ctl.lower_hr_threshold = 0.75;
invalid_auto_size_ctl.increment = 2.0;
invalid_auto_size_ctl.apply_max_increment = TRUE;
invalid_auto_size_ctl.max_increment = (2 * 1024 * 1024);
invalid_auto_size_ctl.flash_incr_mode = H5C_flash_incr__off;
invalid_auto_size_ctl.flash_multiple = 2.0;
invalid_auto_size_ctl.flash_threshold = 0.5;
invalid_auto_size_ctl.decr_mode = H5C_decr__threshold;
invalid_auto_size_ctl.upper_hr_threshold = 0.999;
invalid_auto_size_ctl.decrement = 0.5;
invalid_auto_size_ctl.apply_max_decrement = TRUE;
invalid_auto_size_ctl.max_decrement = (1 * 1024 * 1024);
invalid_auto_size_ctl.epochs_before_eviction = 3;
invalid_auto_size_ctl.apply_empty_reserve = TRUE;
invalid_auto_size_ctl.empty_reserve = 0.05;
result = H5C_set_cache_auto_resize_config(cache_ptr,
&invalid_auto_size_ctl);
if ( result != FAIL ) {
pass = FALSE;
failure_mssg =
"H5C_set_cache_auto_resize_config accepted bad init size 2.\n";
}
}
if ( pass ) {
result = H5C_get_cache_auto_resize_config(cache_ptr,
&test_auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_get_cache_auto_resize_config failed 5.";
} else if ( ! RESIZE_CONFIGS_ARE_EQUAL(test_auto_size_ctl, \
ref_auto_size_ctl, FALSE) ) {
pass = FALSE;
failure_mssg = "Unexpected auto resize config 5.";
}
}
/* test for invalid min clean fraction rejection. */
if ( pass ) {
invalid_auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
invalid_auto_size_ctl.rpt_fcn = NULL;
invalid_auto_size_ctl.set_initial_size = TRUE;
invalid_auto_size_ctl.initial_size = 4 * 1024 * 1024;
invalid_auto_size_ctl.min_clean_fraction = 1.00001; /* INVALID */
invalid_auto_size_ctl.max_size = 16 * 1024 * 1024;
invalid_auto_size_ctl.min_size = 1 * 1024 * 1024;
invalid_auto_size_ctl.epoch_length = 5000;
invalid_auto_size_ctl.incr_mode = H5C_incr__threshold;
invalid_auto_size_ctl.lower_hr_threshold = 0.75;
invalid_auto_size_ctl.increment = 2.0;
invalid_auto_size_ctl.apply_max_increment = TRUE;
invalid_auto_size_ctl.max_increment = (2 * 1024 * 1024);
invalid_auto_size_ctl.flash_incr_mode = H5C_flash_incr__off;
invalid_auto_size_ctl.flash_multiple = 2.0;
invalid_auto_size_ctl.flash_threshold = 0.5;
invalid_auto_size_ctl.decr_mode = H5C_decr__threshold;
invalid_auto_size_ctl.upper_hr_threshold = 0.999;
invalid_auto_size_ctl.decrement = 0.5;
invalid_auto_size_ctl.apply_max_decrement = TRUE;
invalid_auto_size_ctl.max_decrement = (1 * 1024 * 1024);
invalid_auto_size_ctl.epochs_before_eviction = 3;
invalid_auto_size_ctl.apply_empty_reserve = TRUE;
invalid_auto_size_ctl.empty_reserve = 0.05;
result = H5C_set_cache_auto_resize_config(cache_ptr,
&invalid_auto_size_ctl);
if ( result != FAIL ) {
pass = FALSE;
failure_mssg =
"H5C_set_cache_auto_resize_config accepted bad min clean frac 1.\n";
}
}
if ( pass ) {
result = H5C_get_cache_auto_resize_config(cache_ptr,
&test_auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_get_cache_auto_resize_config failed 6.";
} else if ( ! RESIZE_CONFIGS_ARE_EQUAL(test_auto_size_ctl, \
ref_auto_size_ctl, FALSE) ) {
pass = FALSE;
failure_mssg = "Unexpected auto resize config 6.";
}
}
if ( pass ) {
invalid_auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
invalid_auto_size_ctl.rpt_fcn = NULL;
invalid_auto_size_ctl.set_initial_size = TRUE;
invalid_auto_size_ctl.initial_size = 4 * 1024 * 1024;
invalid_auto_size_ctl.min_clean_fraction = -0.00001; /* INVALID */
invalid_auto_size_ctl.max_size = 16 * 1024 * 1024;
invalid_auto_size_ctl.min_size = 1 * 1024 * 1024;
invalid_auto_size_ctl.epoch_length = 5000;
invalid_auto_size_ctl.incr_mode = H5C_incr__threshold;
invalid_auto_size_ctl.lower_hr_threshold = 0.75;
invalid_auto_size_ctl.increment = 2.0;
invalid_auto_size_ctl.apply_max_increment = TRUE;
invalid_auto_size_ctl.max_increment = (2 * 1024 * 1024);
invalid_auto_size_ctl.flash_incr_mode = H5C_flash_incr__off;
invalid_auto_size_ctl.flash_multiple = 2.0;
invalid_auto_size_ctl.flash_threshold = 0.5;
invalid_auto_size_ctl.decr_mode = H5C_decr__threshold;
invalid_auto_size_ctl.upper_hr_threshold = 0.999;
invalid_auto_size_ctl.decrement = 0.5;
invalid_auto_size_ctl.apply_max_decrement = TRUE;
invalid_auto_size_ctl.max_decrement = (1 * 1024 * 1024);
invalid_auto_size_ctl.epochs_before_eviction = 3;
invalid_auto_size_ctl.apply_empty_reserve = TRUE;
invalid_auto_size_ctl.empty_reserve = 0.05;
result = H5C_set_cache_auto_resize_config(cache_ptr,
&invalid_auto_size_ctl);
if ( result != FAIL ) {
pass = FALSE;
failure_mssg =
"H5C_set_cache_auto_resize_config accepted bad min clean frac 2.\n";
}
}
if ( pass ) {
result = H5C_get_cache_auto_resize_config(cache_ptr,
&test_auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_get_cache_auto_resize_config failed 7.";
} else if ( ! RESIZE_CONFIGS_ARE_EQUAL(test_auto_size_ctl, \
ref_auto_size_ctl, FALSE) ) {
pass = FALSE;
failure_mssg = "Unexpected auto resize config 7.";
}
}
/* test for invalid max_size and/or min_size rejection */
if ( pass ) {
invalid_auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
invalid_auto_size_ctl.rpt_fcn = NULL;
invalid_auto_size_ctl.set_initial_size = TRUE;
invalid_auto_size_ctl.initial_size = 4 * 1024 * 1024;
invalid_auto_size_ctl.min_clean_fraction = 0.5;
invalid_auto_size_ctl.max_size = H5C__MAX_MAX_CACHE_SIZE + 1;
/* INVALID */
invalid_auto_size_ctl.min_size = 1 * 1024 * 1024;
invalid_auto_size_ctl.epoch_length = 5000;
invalid_auto_size_ctl.incr_mode = H5C_incr__threshold;
invalid_auto_size_ctl.lower_hr_threshold = 0.75;
invalid_auto_size_ctl.increment = 2.0;
invalid_auto_size_ctl.apply_max_increment = TRUE;
invalid_auto_size_ctl.max_increment = (2 * 1024 * 1024);
invalid_auto_size_ctl.flash_incr_mode = H5C_flash_incr__off;
invalid_auto_size_ctl.flash_multiple = 2.0;
invalid_auto_size_ctl.flash_threshold = 0.5;
invalid_auto_size_ctl.decr_mode = H5C_decr__threshold;
invalid_auto_size_ctl.upper_hr_threshold = 0.999;
invalid_auto_size_ctl.decrement = 0.5;
invalid_auto_size_ctl.apply_max_decrement = TRUE;
invalid_auto_size_ctl.max_decrement = (1 * 1024 * 1024);
invalid_auto_size_ctl.epochs_before_eviction = 3;
invalid_auto_size_ctl.apply_empty_reserve = TRUE;
invalid_auto_size_ctl.empty_reserve = 0.05;
result = H5C_set_cache_auto_resize_config(cache_ptr,
&invalid_auto_size_ctl);
if ( result != FAIL ) {
pass = FALSE;
failure_mssg =
"H5C_set_cache_auto_resize_config accepted bad max_size.\n";
}
}
if ( pass ) {
result = H5C_get_cache_auto_resize_config(cache_ptr,
&test_auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_get_cache_auto_resize_config failed 8.";
} else if ( ! RESIZE_CONFIGS_ARE_EQUAL(test_auto_size_ctl, \
ref_auto_size_ctl, FALSE) ) {
pass = FALSE;
failure_mssg = "Unexpected auto resize config 8.";
}
}
if ( pass ) {
invalid_auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
invalid_auto_size_ctl.rpt_fcn = NULL;
invalid_auto_size_ctl.set_initial_size = TRUE;
invalid_auto_size_ctl.initial_size = 4 * 1024 * 1024;
invalid_auto_size_ctl.min_clean_fraction = 0.5;
invalid_auto_size_ctl.max_size = 1 * 1024 * 1024;/* INVALID */
invalid_auto_size_ctl.min_size = 1 * 1024 * 1024 + 1;/*PAIR */
invalid_auto_size_ctl.epoch_length = 5000;
invalid_auto_size_ctl.incr_mode = H5C_incr__threshold;
invalid_auto_size_ctl.lower_hr_threshold = 0.75;
invalid_auto_size_ctl.increment = 2.0;
invalid_auto_size_ctl.apply_max_increment = TRUE;
invalid_auto_size_ctl.max_increment = (2 * 1024 * 1024);
invalid_auto_size_ctl.flash_incr_mode = H5C_flash_incr__off;
invalid_auto_size_ctl.flash_multiple = 2.0;
invalid_auto_size_ctl.flash_threshold = 0.5;
invalid_auto_size_ctl.decr_mode = H5C_decr__threshold;
invalid_auto_size_ctl.upper_hr_threshold = 0.999;
invalid_auto_size_ctl.decrement = 0.5;
invalid_auto_size_ctl.apply_max_decrement = TRUE;
invalid_auto_size_ctl.max_decrement = (1 * 1024 * 1024);
invalid_auto_size_ctl.epochs_before_eviction = 3;
invalid_auto_size_ctl.apply_empty_reserve = TRUE;
invalid_auto_size_ctl.empty_reserve = 0.05;
result = H5C_set_cache_auto_resize_config(cache_ptr,
&invalid_auto_size_ctl);
if ( result != FAIL ) {
pass = FALSE;
failure_mssg =
"H5C_set_cache_auto_resize_config accepted bad size pair.\n";
}
}
if ( pass ) {
result = H5C_get_cache_auto_resize_config(cache_ptr,
&test_auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_get_cache_auto_resize_config failed 9.";
} else if ( ! RESIZE_CONFIGS_ARE_EQUAL(test_auto_size_ctl, \
ref_auto_size_ctl, FALSE) ) {
pass = FALSE;
failure_mssg = "Unexpected auto resize config 9.";
}
}
if ( pass ) {
invalid_auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
invalid_auto_size_ctl.rpt_fcn = NULL;
invalid_auto_size_ctl.set_initial_size = TRUE;
invalid_auto_size_ctl.initial_size = 4 * 1024 * 1024;
invalid_auto_size_ctl.min_clean_fraction = 0.5;
invalid_auto_size_ctl.max_size = 16 * 1024 * 1024;
invalid_auto_size_ctl.min_size = H5C__MIN_MAX_CACHE_SIZE - 1;
/* INVALID */
invalid_auto_size_ctl.epoch_length = 5000;
invalid_auto_size_ctl.incr_mode = H5C_incr__threshold;
invalid_auto_size_ctl.lower_hr_threshold = 0.75;
invalid_auto_size_ctl.increment = 2.0;
invalid_auto_size_ctl.apply_max_increment = TRUE;
invalid_auto_size_ctl.max_increment = (2 * 1024 * 1024);
invalid_auto_size_ctl.flash_incr_mode = H5C_flash_incr__off;
invalid_auto_size_ctl.flash_multiple = 2.0;
invalid_auto_size_ctl.flash_threshold = 0.5;
invalid_auto_size_ctl.decr_mode = H5C_decr__threshold;
invalid_auto_size_ctl.upper_hr_threshold = 0.999;
invalid_auto_size_ctl.decrement = 0.5;
invalid_auto_size_ctl.apply_max_decrement = TRUE;
invalid_auto_size_ctl.max_decrement = (1 * 1024 * 1024);
invalid_auto_size_ctl.epochs_before_eviction = 3;
invalid_auto_size_ctl.apply_empty_reserve = TRUE;
invalid_auto_size_ctl.empty_reserve = 0.05;
result = H5C_set_cache_auto_resize_config(cache_ptr,
&invalid_auto_size_ctl);
if ( result != FAIL ) {
pass = FALSE;
failure_mssg =
"H5C_set_cache_auto_resize_config accepted bad min_size.\n";
}
}
if ( pass ) {
result = H5C_get_cache_auto_resize_config(cache_ptr,
&test_auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_get_cache_auto_resize_config failed 10.";
} else if ( ! RESIZE_CONFIGS_ARE_EQUAL(test_auto_size_ctl, \
ref_auto_size_ctl, FALSE) ) {
pass = FALSE;
failure_mssg = "Unexpected auto resize config 10.";
}
}
/* test for invalid epoch_length rejection */
if ( pass ) {
invalid_auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
invalid_auto_size_ctl.rpt_fcn = NULL;
invalid_auto_size_ctl.set_initial_size = TRUE;
invalid_auto_size_ctl.initial_size = 4 * 1024 * 1024;
invalid_auto_size_ctl.min_clean_fraction = 0.1;
invalid_auto_size_ctl.max_size = 16 * 1024 * 1024;
invalid_auto_size_ctl.min_size = 1 * 1024 * 1024;
invalid_auto_size_ctl.epoch_length = H5C__MAX_AR_EPOCH_LENGTH + 1;
/* INVALID */
invalid_auto_size_ctl.incr_mode = H5C_incr__threshold;
invalid_auto_size_ctl.lower_hr_threshold = 0.75;
invalid_auto_size_ctl.increment = 2.0;
invalid_auto_size_ctl.apply_max_increment = TRUE;
invalid_auto_size_ctl.max_increment = (2 * 1024 * 1024);
invalid_auto_size_ctl.flash_incr_mode = H5C_flash_incr__off;
invalid_auto_size_ctl.flash_multiple = 2.0;
invalid_auto_size_ctl.flash_threshold = 0.5;
invalid_auto_size_ctl.decr_mode = H5C_decr__threshold;
invalid_auto_size_ctl.upper_hr_threshold = 0.999;
invalid_auto_size_ctl.decrement = 0.9;
invalid_auto_size_ctl.apply_max_decrement = TRUE;
invalid_auto_size_ctl.max_decrement = (1 * 1024 * 1024);
invalid_auto_size_ctl.epochs_before_eviction = 3;
invalid_auto_size_ctl.apply_empty_reserve = TRUE;
invalid_auto_size_ctl.empty_reserve = 0.05;
result = H5C_set_cache_auto_resize_config(cache_ptr,
&invalid_auto_size_ctl);
if ( result != FAIL ) {
pass = FALSE;
failure_mssg =
"H5C_set_cache_auto_resize_config accepted bad epoch len 1.\n";
}
}
if ( pass ) {
result = H5C_get_cache_auto_resize_config(cache_ptr,
&test_auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_get_cache_auto_resize_config failed 11.";
} else if ( ! RESIZE_CONFIGS_ARE_EQUAL(test_auto_size_ctl, \
ref_auto_size_ctl, FALSE) ) {
pass = FALSE;
failure_mssg = "Unexpected auto resize config 11.";
}
}
if ( pass ) {
invalid_auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
invalid_auto_size_ctl.rpt_fcn = NULL;
invalid_auto_size_ctl.set_initial_size = TRUE;
invalid_auto_size_ctl.initial_size = 4 * 1024 * 1024;
invalid_auto_size_ctl.min_clean_fraction = 0.1;
invalid_auto_size_ctl.max_size = 16 * 1024 * 1024;
invalid_auto_size_ctl.min_size = 1 * 1024 * 1024;
invalid_auto_size_ctl.epoch_length = H5C__MIN_AR_EPOCH_LENGTH - 1;
/* INVALID */
invalid_auto_size_ctl.incr_mode = H5C_incr__threshold;
invalid_auto_size_ctl.lower_hr_threshold = 0.75;
invalid_auto_size_ctl.increment = 2.0;
invalid_auto_size_ctl.apply_max_increment = TRUE;
invalid_auto_size_ctl.max_increment = (2 * 1024 * 1024);
invalid_auto_size_ctl.flash_incr_mode = H5C_flash_incr__off;
invalid_auto_size_ctl.flash_multiple = 2.0;
invalid_auto_size_ctl.flash_threshold = 0.5;
invalid_auto_size_ctl.decr_mode = H5C_decr__threshold;
invalid_auto_size_ctl.upper_hr_threshold = 0.999;
invalid_auto_size_ctl.decrement = 0.9;
invalid_auto_size_ctl.apply_max_decrement = TRUE;
invalid_auto_size_ctl.max_decrement = (1 * 1024 * 1024);
invalid_auto_size_ctl.epochs_before_eviction = 3;
invalid_auto_size_ctl.apply_empty_reserve = TRUE;
invalid_auto_size_ctl.empty_reserve = 0.05;
result = H5C_set_cache_auto_resize_config(cache_ptr,
&invalid_auto_size_ctl);
if ( result != FAIL ) {
pass = FALSE;
failure_mssg =
"H5C_set_cache_auto_resize_config accepted bad epoch len 2.\n";
}
}
if ( pass ) {
result = H5C_get_cache_auto_resize_config(cache_ptr,
&test_auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_get_cache_auto_resize_config failed 12.";
} else if ( ! RESIZE_CONFIGS_ARE_EQUAL(test_auto_size_ctl, \
ref_auto_size_ctl, FALSE) ) {
pass = FALSE;
failure_mssg = "Unexpected auto resize config 12.";
}
}
/* test for bad incr_mode rejection */
if ( pass ) {
invalid_auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
invalid_auto_size_ctl.rpt_fcn = NULL;
invalid_auto_size_ctl.set_initial_size = TRUE;
invalid_auto_size_ctl.initial_size = 4 * 1024 * 1024;
invalid_auto_size_ctl.min_clean_fraction = 0.1;
invalid_auto_size_ctl.max_size = 16 * 1024 * 1024;
invalid_auto_size_ctl.min_size = 1 * 1024 * 1024;
invalid_auto_size_ctl.epoch_length = 5000;
invalid_auto_size_ctl.incr_mode =
(enum H5C_cache_incr_mode) -1; /* INVALID */
invalid_auto_size_ctl.lower_hr_threshold = 0.75;
invalid_auto_size_ctl.increment = 2.0;
invalid_auto_size_ctl.apply_max_increment = TRUE;
invalid_auto_size_ctl.max_increment = (2 * 1024 * 1024);
invalid_auto_size_ctl.flash_incr_mode = H5C_flash_incr__off;
invalid_auto_size_ctl.flash_multiple = 2.0;
invalid_auto_size_ctl.flash_threshold = 0.5;
invalid_auto_size_ctl.decr_mode = H5C_decr__threshold;
invalid_auto_size_ctl.upper_hr_threshold = 0.999;
invalid_auto_size_ctl.decrement = 0.9;
invalid_auto_size_ctl.apply_max_decrement = TRUE;
invalid_auto_size_ctl.max_decrement = (1 * 1024 * 1024);
invalid_auto_size_ctl.epochs_before_eviction = 3;
invalid_auto_size_ctl.apply_empty_reserve = TRUE;
invalid_auto_size_ctl.empty_reserve = 0.05;
result = H5C_set_cache_auto_resize_config(cache_ptr,
&invalid_auto_size_ctl);
if ( result != FAIL ) {
pass = FALSE;
failure_mssg =
"H5C_set_cache_auto_resize_config accepted bad incr_mode 1.\n";
}
}
if ( pass ) {
result = H5C_get_cache_auto_resize_config(cache_ptr,
&test_auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_get_cache_auto_resize_config failed 13.";
} else if ( ! RESIZE_CONFIGS_ARE_EQUAL(test_auto_size_ctl, \
ref_auto_size_ctl, FALSE) ) {
pass = FALSE;
failure_mssg = "Unexpected auto resize config 13.";
}
}
if ( pass ) {
invalid_auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
invalid_auto_size_ctl.rpt_fcn = NULL;
invalid_auto_size_ctl.set_initial_size = TRUE;
invalid_auto_size_ctl.initial_size = 4 * 1024 * 1024;
invalid_auto_size_ctl.min_clean_fraction = 0.1;
invalid_auto_size_ctl.max_size = 16 * 1024 * 1024;
invalid_auto_size_ctl.min_size = 1 * 1024 * 1024;
invalid_auto_size_ctl.epoch_length = 5000;
invalid_auto_size_ctl.incr_mode =
(enum H5C_cache_incr_mode) 2; /* INVALID */
invalid_auto_size_ctl.lower_hr_threshold = 0.75;
invalid_auto_size_ctl.increment = 2.0;
invalid_auto_size_ctl.apply_max_increment = TRUE;
invalid_auto_size_ctl.max_increment = (2 * 1024 * 1024);
invalid_auto_size_ctl.flash_incr_mode = H5C_flash_incr__off;
invalid_auto_size_ctl.flash_multiple = 2.0;
invalid_auto_size_ctl.flash_threshold = 0.5;
invalid_auto_size_ctl.decr_mode = H5C_decr__threshold;
invalid_auto_size_ctl.upper_hr_threshold = 0.999;
invalid_auto_size_ctl.decrement = 0.9;
invalid_auto_size_ctl.apply_max_decrement = TRUE;
invalid_auto_size_ctl.max_decrement = (1 * 1024 * 1024);
invalid_auto_size_ctl.epochs_before_eviction = 3;
invalid_auto_size_ctl.apply_empty_reserve = TRUE;
invalid_auto_size_ctl.empty_reserve = 0.05;
result = H5C_set_cache_auto_resize_config(cache_ptr,
&invalid_auto_size_ctl);
if ( result != FAIL ) {
pass = FALSE;
failure_mssg =
"H5C_set_cache_auto_resize_config accepted bad incr_mode 2.\n";
}
}
if ( pass ) {
result = H5C_get_cache_auto_resize_config(cache_ptr,
&test_auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_get_cache_auto_resize_config failed 14.";
} else if ( ! RESIZE_CONFIGS_ARE_EQUAL(test_auto_size_ctl, \
ref_auto_size_ctl, FALSE) ) {
pass = FALSE;
failure_mssg = "Unexpected auto resize config 14.";
}
}
/* check for bad upper and/or lower threshold rejection */
if ( pass ) {
invalid_auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
invalid_auto_size_ctl.rpt_fcn = NULL;
invalid_auto_size_ctl.set_initial_size = TRUE;
invalid_auto_size_ctl.initial_size = 4 * 1024 * 1024;
invalid_auto_size_ctl.min_clean_fraction = 0.5;
invalid_auto_size_ctl.max_size = 16 * 1024 * 1024;
invalid_auto_size_ctl.min_size = 1 * 1024 * 1024;
invalid_auto_size_ctl.epoch_length = 5000;
invalid_auto_size_ctl.incr_mode = H5C_incr__threshold;
invalid_auto_size_ctl.lower_hr_threshold = 0.7;
invalid_auto_size_ctl.increment = 2.0;
invalid_auto_size_ctl.apply_max_increment = TRUE;
invalid_auto_size_ctl.max_increment = (2 * 1024 * 1024);
invalid_auto_size_ctl.flash_incr_mode = H5C_flash_incr__off;
invalid_auto_size_ctl.flash_multiple = 2.0;
invalid_auto_size_ctl.flash_threshold = 0.5;
invalid_auto_size_ctl.decr_mode = H5C_decr__threshold;
invalid_auto_size_ctl.upper_hr_threshold = 1.01; /* INVALID */
invalid_auto_size_ctl.decrement = 0.5;
invalid_auto_size_ctl.apply_max_decrement = TRUE;
invalid_auto_size_ctl.max_decrement = (1 * 1024 * 1024);
invalid_auto_size_ctl.epochs_before_eviction = 3;
invalid_auto_size_ctl.apply_empty_reserve = TRUE;
invalid_auto_size_ctl.empty_reserve = 0.05;
result = H5C_set_cache_auto_resize_config(cache_ptr,
&invalid_auto_size_ctl);
if ( result != FAIL ) {
pass = FALSE;
failure_mssg =
"H5C_set_cache_auto_resize_config accepted bad upper threshold.\n";
}
}
if ( pass ) {
result = H5C_get_cache_auto_resize_config(cache_ptr,
&test_auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_get_cache_auto_resize_config failed 15.";
} else if ( ! RESIZE_CONFIGS_ARE_EQUAL(test_auto_size_ctl, \
ref_auto_size_ctl, FALSE) ) {
pass = FALSE;
failure_mssg = "Unexpected auto resize config 15.";
}
}
if ( pass ) {
invalid_auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
invalid_auto_size_ctl.rpt_fcn = NULL;
invalid_auto_size_ctl.set_initial_size = TRUE;
invalid_auto_size_ctl.initial_size = 4 * 1024 * 1024;
invalid_auto_size_ctl.min_clean_fraction = 0.5;
invalid_auto_size_ctl.max_size = 16 * 1024 * 1024;
invalid_auto_size_ctl.min_size = 1 * 1024 * 1024;
invalid_auto_size_ctl.epoch_length = 5000;
invalid_auto_size_ctl.incr_mode = H5C_incr__threshold;
invalid_auto_size_ctl.lower_hr_threshold = 0.8; /* INVALID */
invalid_auto_size_ctl.increment = 2.0;
invalid_auto_size_ctl.apply_max_increment = TRUE;
invalid_auto_size_ctl.max_increment = (2 * 1024 * 1024);
invalid_auto_size_ctl.flash_incr_mode = H5C_flash_incr__off;
invalid_auto_size_ctl.flash_multiple = 2.0;
invalid_auto_size_ctl.flash_threshold = 0.5;
invalid_auto_size_ctl.decr_mode = H5C_decr__threshold;
invalid_auto_size_ctl.upper_hr_threshold = 0.7; /* INVALID */
invalid_auto_size_ctl.decrement = 0.5;
invalid_auto_size_ctl.apply_max_decrement = TRUE;
invalid_auto_size_ctl.max_decrement = (1 * 1024 * 1024);
invalid_auto_size_ctl.epochs_before_eviction = 3;
invalid_auto_size_ctl.apply_empty_reserve = TRUE;
invalid_auto_size_ctl.empty_reserve = 0.05;
result = H5C_set_cache_auto_resize_config(cache_ptr,
&invalid_auto_size_ctl);
if ( result != FAIL ) {
pass = FALSE;
failure_mssg =
"H5C_set_cache_auto_resize_config accepted bad threshold pair.\n";
}
}
if ( pass ) {
result = H5C_get_cache_auto_resize_config(cache_ptr,
&test_auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_get_cache_auto_resize_config failed 16.";
} else if ( ! RESIZE_CONFIGS_ARE_EQUAL(test_auto_size_ctl, \
ref_auto_size_ctl, FALSE) ) {
pass = FALSE;
failure_mssg = "Unexpected auto resize config 16.";
}
}
if ( pass ) {
invalid_auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
invalid_auto_size_ctl.rpt_fcn = NULL;
invalid_auto_size_ctl.set_initial_size = TRUE;
invalid_auto_size_ctl.initial_size = 4 * 1024 * 1024;
invalid_auto_size_ctl.min_clean_fraction = 0.5;
invalid_auto_size_ctl.max_size = 16 * 1024 * 1024;
invalid_auto_size_ctl.min_size = 1 * 1024 * 1024;
invalid_auto_size_ctl.epoch_length = 5000;
invalid_auto_size_ctl.incr_mode = H5C_incr__threshold;
invalid_auto_size_ctl.lower_hr_threshold = -0.0001; /* INVALID */
invalid_auto_size_ctl.increment = 2.0;
invalid_auto_size_ctl.apply_max_increment = TRUE;
invalid_auto_size_ctl.max_increment = (2 * 1024 * 1024);
invalid_auto_size_ctl.flash_incr_mode = H5C_flash_incr__off;
invalid_auto_size_ctl.flash_multiple = 2.0;
invalid_auto_size_ctl.flash_threshold = 0.5;
invalid_auto_size_ctl.decr_mode = H5C_decr__threshold;
invalid_auto_size_ctl.upper_hr_threshold = 0.999;
invalid_auto_size_ctl.decrement = 0.5;
invalid_auto_size_ctl.apply_max_decrement = TRUE;
invalid_auto_size_ctl.max_decrement = (1 * 1024 * 1024);
invalid_auto_size_ctl.epochs_before_eviction = 3;
invalid_auto_size_ctl.apply_empty_reserve = TRUE;
invalid_auto_size_ctl.empty_reserve = 0.05;
result = H5C_set_cache_auto_resize_config(cache_ptr,
&invalid_auto_size_ctl);
if ( result != FAIL ) {
pass = FALSE;
failure_mssg =
"H5C_set_cache_auto_resize_config accepted bad lower threshold.\n";
}
}
if ( pass ) {
result = H5C_get_cache_auto_resize_config(cache_ptr,
&test_auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_get_cache_auto_resize_config failed 17.";
} else if ( ! RESIZE_CONFIGS_ARE_EQUAL(test_auto_size_ctl, \
ref_auto_size_ctl, FALSE) ) {
pass = FALSE;
failure_mssg = "Unexpected auto resize config 17.";
}
}
/* test for bad increment rejection */
if ( pass ) {
invalid_auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
invalid_auto_size_ctl.rpt_fcn = NULL;
invalid_auto_size_ctl.set_initial_size = TRUE;
invalid_auto_size_ctl.initial_size = 4 * 1024 * 1024;
invalid_auto_size_ctl.min_clean_fraction = 0.1;
invalid_auto_size_ctl.max_size = 16 * 1024 * 1024;
invalid_auto_size_ctl.min_size = 1 * 1024 * 1024;
invalid_auto_size_ctl.epoch_length = 5000;
invalid_auto_size_ctl.incr_mode = H5C_incr__threshold;
invalid_auto_size_ctl.lower_hr_threshold = 0.75;
invalid_auto_size_ctl.increment = 0.99999; /* INVALID */
invalid_auto_size_ctl.apply_max_increment = TRUE;
invalid_auto_size_ctl.max_increment = (2 * 1024 * 1024);
invalid_auto_size_ctl.flash_incr_mode = H5C_flash_incr__off;
invalid_auto_size_ctl.flash_multiple = 2.0;
invalid_auto_size_ctl.flash_threshold = 0.5;
invalid_auto_size_ctl.decr_mode = H5C_decr__threshold;
invalid_auto_size_ctl.upper_hr_threshold = 0.999;
invalid_auto_size_ctl.decrement = 0.5;
invalid_auto_size_ctl.apply_max_decrement = TRUE;
invalid_auto_size_ctl.max_decrement = (1 * 1024 * 1024);
invalid_auto_size_ctl.epochs_before_eviction = 3;
invalid_auto_size_ctl.apply_empty_reserve = TRUE;
invalid_auto_size_ctl.empty_reserve = 0.05;
result = H5C_set_cache_auto_resize_config(cache_ptr,
&invalid_auto_size_ctl);
if ( result != FAIL ) {
pass = FALSE;
failure_mssg =
"H5C_set_cache_auto_resize_config accepted bad increment.\n";
}
}
if ( pass ) {
result = H5C_get_cache_auto_resize_config(cache_ptr,
&test_auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_get_cache_auto_resize_config failed 18.";
} else if ( ! RESIZE_CONFIGS_ARE_EQUAL(test_auto_size_ctl, \
ref_auto_size_ctl, FALSE) ) {
pass = FALSE;
failure_mssg = "Unexpected auto resize config 18.";
}
}
/* test for bad flash_incr_mode rejection */
if ( pass ) {
invalid_auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
invalid_auto_size_ctl.rpt_fcn = NULL;
invalid_auto_size_ctl.set_initial_size = TRUE;
invalid_auto_size_ctl.initial_size = 4 * 1024 * 1024;
invalid_auto_size_ctl.min_clean_fraction = 0.1;
invalid_auto_size_ctl.max_size = 16 * 1024 * 1024;
invalid_auto_size_ctl.min_size = 1 * 1024 * 1024;
invalid_auto_size_ctl.epoch_length = 5000;
invalid_auto_size_ctl.incr_mode = H5C_incr__threshold;
invalid_auto_size_ctl.lower_hr_threshold = 0.75;
invalid_auto_size_ctl.increment = 2.0;
invalid_auto_size_ctl.apply_max_increment = TRUE;
invalid_auto_size_ctl.max_increment = (2 * 1024 * 1024);
invalid_auto_size_ctl.flash_incr_mode =
(enum H5C_cache_flash_incr_mode) -1; /* INVALID */
invalid_auto_size_ctl.flash_multiple = 2.0;
invalid_auto_size_ctl.flash_threshold = 0.5;
invalid_auto_size_ctl.decr_mode = H5C_decr__threshold;
invalid_auto_size_ctl.upper_hr_threshold = 0.999;
invalid_auto_size_ctl.decrement = 0.9;
invalid_auto_size_ctl.apply_max_decrement = TRUE;
invalid_auto_size_ctl.max_decrement = (1 * 1024 * 1024);
invalid_auto_size_ctl.epochs_before_eviction = 3;
invalid_auto_size_ctl.apply_empty_reserve = TRUE;
invalid_auto_size_ctl.empty_reserve = 0.05;
result = H5C_set_cache_auto_resize_config(cache_ptr,
&invalid_auto_size_ctl);
if ( result != FAIL ) {
pass = FALSE;
failure_mssg =
"H5C_set_cache_auto_resize_config accepted bad flash_incr_mode.\n";
}
}
if ( pass ) {
result = H5C_get_cache_auto_resize_config(cache_ptr,
&test_auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_get_cache_auto_resize_config failed 19.";
} else if ( ! RESIZE_CONFIGS_ARE_EQUAL(test_auto_size_ctl, \
ref_auto_size_ctl, FALSE) ) {
pass = FALSE;
failure_mssg = "Unexpected auto resize config 19.";
}
}
/* test for bad flash_multiple rejection */
if ( pass ) {
invalid_auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
invalid_auto_size_ctl.rpt_fcn = NULL;
invalid_auto_size_ctl.set_initial_size = TRUE;
invalid_auto_size_ctl.initial_size = 4 * 1024 * 1024;
invalid_auto_size_ctl.min_clean_fraction = 0.1;
invalid_auto_size_ctl.max_size = 16 * 1024 * 1024;
invalid_auto_size_ctl.min_size = 1 * 1024 * 1024;
invalid_auto_size_ctl.epoch_length = 5000;
invalid_auto_size_ctl.incr_mode = H5C_incr__threshold;
invalid_auto_size_ctl.lower_hr_threshold = 0.75;
invalid_auto_size_ctl.increment = 2.0;
invalid_auto_size_ctl.apply_max_increment = TRUE;
invalid_auto_size_ctl.max_increment = (2 * 1024 * 1024);
invalid_auto_size_ctl.flash_incr_mode =
H5C_flash_incr__add_space;
invalid_auto_size_ctl.flash_multiple = 0.09; /* INVALID */
invalid_auto_size_ctl.flash_threshold = 0.5;
invalid_auto_size_ctl.decr_mode = H5C_decr__threshold;
invalid_auto_size_ctl.upper_hr_threshold = 0.999;
invalid_auto_size_ctl.decrement = 0.9;
invalid_auto_size_ctl.apply_max_decrement = TRUE;
invalid_auto_size_ctl.max_decrement = (1 * 1024 * 1024);
invalid_auto_size_ctl.epochs_before_eviction = 3;
invalid_auto_size_ctl.apply_empty_reserve = TRUE;
invalid_auto_size_ctl.empty_reserve = 0.05;
result = H5C_set_cache_auto_resize_config(cache_ptr,
&invalid_auto_size_ctl);
if ( result != FAIL ) {
pass = FALSE;
failure_mssg =
"H5C_set_cache_auto_resize_config accepted bad flash_multiple(1).\n";
}
}
if ( pass ) {
result = H5C_get_cache_auto_resize_config(cache_ptr,
&test_auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_get_cache_auto_resize_config failed 20.";
} else if ( ! RESIZE_CONFIGS_ARE_EQUAL(test_auto_size_ctl, \
ref_auto_size_ctl, FALSE) ) {
pass = FALSE;
failure_mssg = "Unexpected auto resize config 20.";
}
}
if ( pass ) {
invalid_auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
invalid_auto_size_ctl.rpt_fcn = NULL;
invalid_auto_size_ctl.set_initial_size = TRUE;
invalid_auto_size_ctl.initial_size = 4 * 1024 * 1024;
invalid_auto_size_ctl.min_clean_fraction = 0.1;
invalid_auto_size_ctl.max_size = 16 * 1024 * 1024;
invalid_auto_size_ctl.min_size = 1 * 1024 * 1024;
invalid_auto_size_ctl.epoch_length = 5000;
invalid_auto_size_ctl.incr_mode = H5C_incr__threshold;
invalid_auto_size_ctl.lower_hr_threshold = 0.75;
invalid_auto_size_ctl.increment = 2.0;
invalid_auto_size_ctl.apply_max_increment = TRUE;
invalid_auto_size_ctl.max_increment = (2 * 1024 * 1024);
invalid_auto_size_ctl.flash_incr_mode =
H5C_flash_incr__add_space;
invalid_auto_size_ctl.flash_multiple = 10.01; /* INVALID */
invalid_auto_size_ctl.flash_threshold = 0.5;
invalid_auto_size_ctl.decr_mode = H5C_decr__threshold;
invalid_auto_size_ctl.upper_hr_threshold = 0.999;
invalid_auto_size_ctl.decrement = 0.9;
invalid_auto_size_ctl.apply_max_decrement = TRUE;
invalid_auto_size_ctl.max_decrement = (1 * 1024 * 1024);
invalid_auto_size_ctl.epochs_before_eviction = 3;
invalid_auto_size_ctl.apply_empty_reserve = TRUE;
invalid_auto_size_ctl.empty_reserve = 0.05;
result = H5C_set_cache_auto_resize_config(cache_ptr,
&invalid_auto_size_ctl);
if ( result != FAIL ) {
pass = FALSE;
failure_mssg =
"H5C_set_cache_auto_resize_config accepted bad flash_multiple(2).\n";
}
}
if ( pass ) {
result = H5C_get_cache_auto_resize_config(cache_ptr,
&test_auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_get_cache_auto_resize_config failed 21.";
} else if ( ! RESIZE_CONFIGS_ARE_EQUAL(test_auto_size_ctl, \
ref_auto_size_ctl, FALSE) ) {
pass = FALSE;
failure_mssg = "Unexpected auto resize config 21.";
}
}
/* test for bad flash_threshold rejection */
if ( pass ) {
invalid_auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
invalid_auto_size_ctl.rpt_fcn = NULL;
invalid_auto_size_ctl.set_initial_size = TRUE;
invalid_auto_size_ctl.initial_size = 4 * 1024 * 1024;
invalid_auto_size_ctl.min_clean_fraction = 0.1;
invalid_auto_size_ctl.max_size = 16 * 1024 * 1024;
invalid_auto_size_ctl.min_size = 1 * 1024 * 1024;
invalid_auto_size_ctl.epoch_length = 5000;
invalid_auto_size_ctl.incr_mode = H5C_incr__threshold;
invalid_auto_size_ctl.lower_hr_threshold = 0.75;
invalid_auto_size_ctl.increment = 2.0;
invalid_auto_size_ctl.apply_max_increment = TRUE;
invalid_auto_size_ctl.max_increment = (2 * 1024 * 1024);
invalid_auto_size_ctl.flash_incr_mode =
H5C_flash_incr__add_space;
invalid_auto_size_ctl.flash_multiple = 1.0;
invalid_auto_size_ctl.flash_threshold = 0.09; /* INVALID */
invalid_auto_size_ctl.decr_mode = H5C_decr__threshold;
invalid_auto_size_ctl.upper_hr_threshold = 0.999;
invalid_auto_size_ctl.decrement = 0.9;
invalid_auto_size_ctl.apply_max_decrement = TRUE;
invalid_auto_size_ctl.max_decrement = (1 * 1024 * 1024);
invalid_auto_size_ctl.epochs_before_eviction = 3;
invalid_auto_size_ctl.apply_empty_reserve = TRUE;
invalid_auto_size_ctl.empty_reserve = 0.05;
result = H5C_set_cache_auto_resize_config(cache_ptr,
&invalid_auto_size_ctl);
if ( result != FAIL ) {
pass = FALSE;
failure_mssg =
"H5C_set_cache_auto_resize_config accepted bad flash_threshold(1).\n";
}
}
if ( pass ) {
result = H5C_get_cache_auto_resize_config(cache_ptr,
&test_auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_get_cache_auto_resize_config failed 22.";
} else if ( ! RESIZE_CONFIGS_ARE_EQUAL(test_auto_size_ctl, \
ref_auto_size_ctl, FALSE) ) {
pass = FALSE;
failure_mssg = "Unexpected auto resize config 22.";
}
}
if ( pass ) {
invalid_auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
invalid_auto_size_ctl.rpt_fcn = NULL;
invalid_auto_size_ctl.set_initial_size = TRUE;
invalid_auto_size_ctl.initial_size = 4 * 1024 * 1024;
invalid_auto_size_ctl.min_clean_fraction = 0.1;
invalid_auto_size_ctl.max_size = 16 * 1024 * 1024;
invalid_auto_size_ctl.min_size = 1 * 1024 * 1024;
invalid_auto_size_ctl.epoch_length = 5000;
invalid_auto_size_ctl.incr_mode = H5C_incr__threshold;
invalid_auto_size_ctl.lower_hr_threshold = 0.75;
invalid_auto_size_ctl.increment = 2.0;
invalid_auto_size_ctl.apply_max_increment = TRUE;
invalid_auto_size_ctl.max_increment = (2 * 1024 * 1024);
invalid_auto_size_ctl.flash_incr_mode =
H5C_flash_incr__add_space;
invalid_auto_size_ctl.flash_multiple = 1.0;
invalid_auto_size_ctl.flash_threshold = 1.001; /* INVALID */
invalid_auto_size_ctl.decr_mode = H5C_decr__threshold;
invalid_auto_size_ctl.upper_hr_threshold = 0.999;
invalid_auto_size_ctl.decrement = 0.9;
invalid_auto_size_ctl.apply_max_decrement = TRUE;
invalid_auto_size_ctl.max_decrement = (1 * 1024 * 1024);
invalid_auto_size_ctl.epochs_before_eviction = 3;
invalid_auto_size_ctl.apply_empty_reserve = TRUE;
invalid_auto_size_ctl.empty_reserve = 0.05;
result = H5C_set_cache_auto_resize_config(cache_ptr,
&invalid_auto_size_ctl);
if ( result != FAIL ) {
pass = FALSE;
failure_mssg =
"H5C_set_cache_auto_resize_config accepted bad flash_threshold(2).\n";
}
}
if ( pass ) {
result = H5C_get_cache_auto_resize_config(cache_ptr,
&test_auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_get_cache_auto_resize_config failed 23.";
} else if ( ! RESIZE_CONFIGS_ARE_EQUAL(test_auto_size_ctl, \
ref_auto_size_ctl, FALSE) ) {
pass = FALSE;
failure_mssg = "Unexpected auto resize config 23.";
}
}
/* test for bad decr_mode rejection */
if ( pass ) {
invalid_auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
invalid_auto_size_ctl.rpt_fcn = NULL;
invalid_auto_size_ctl.set_initial_size = TRUE;
invalid_auto_size_ctl.initial_size = 4 * 1024 * 1024;
invalid_auto_size_ctl.min_clean_fraction = 0.1;
invalid_auto_size_ctl.max_size = 16 * 1024 * 1024;
invalid_auto_size_ctl.min_size = 1 * 1024 * 1024;
invalid_auto_size_ctl.epoch_length = 5000;
invalid_auto_size_ctl.incr_mode = H5C_incr__threshold;
invalid_auto_size_ctl.lower_hr_threshold = 0.75;
invalid_auto_size_ctl.increment = 2.0;
invalid_auto_size_ctl.apply_max_increment = TRUE;
invalid_auto_size_ctl.max_increment = (2 * 1024 * 1024);
invalid_auto_size_ctl.flash_incr_mode = H5C_flash_incr__off;
invalid_auto_size_ctl.flash_multiple = 2.0;
invalid_auto_size_ctl.flash_threshold = 0.5;
invalid_auto_size_ctl.decr_mode =
(enum H5C_cache_decr_mode) -1; /* INVALID */
invalid_auto_size_ctl.upper_hr_threshold = 0.999;
invalid_auto_size_ctl.decrement = 0.9;
invalid_auto_size_ctl.apply_max_decrement = TRUE;
invalid_auto_size_ctl.max_decrement = (1 * 1024 * 1024);
invalid_auto_size_ctl.epochs_before_eviction = 3;
invalid_auto_size_ctl.apply_empty_reserve = TRUE;
invalid_auto_size_ctl.empty_reserve = 0.05;
result = H5C_set_cache_auto_resize_config(cache_ptr,
&invalid_auto_size_ctl);
if ( result != FAIL ) {
pass = FALSE;
failure_mssg =
"H5C_set_cache_auto_resize_config accepted bad decr_mode 1.\n";
}
}
if ( pass ) {
result = H5C_get_cache_auto_resize_config(cache_ptr,
&test_auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_get_cache_auto_resize_config failed 24.";
} else if ( ! RESIZE_CONFIGS_ARE_EQUAL(test_auto_size_ctl, \
ref_auto_size_ctl, FALSE) ) {
pass = FALSE;
failure_mssg = "Unexpected auto resize config 24.";
}
}
if ( pass ) {
invalid_auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
invalid_auto_size_ctl.rpt_fcn = NULL;
invalid_auto_size_ctl.set_initial_size = TRUE;
invalid_auto_size_ctl.initial_size = 4 * 1024 * 1024;
invalid_auto_size_ctl.min_clean_fraction = 0.1;
invalid_auto_size_ctl.max_size = 16 * 1024 * 1024;
invalid_auto_size_ctl.min_size = 1 * 1024 * 1024;
invalid_auto_size_ctl.epoch_length = 5000;
invalid_auto_size_ctl.incr_mode = H5C_incr__threshold;
invalid_auto_size_ctl.lower_hr_threshold = 0.75;
invalid_auto_size_ctl.increment = 2.0;
invalid_auto_size_ctl.apply_max_increment = TRUE;
invalid_auto_size_ctl.max_increment = (2 * 1024 * 1024);
invalid_auto_size_ctl.flash_incr_mode = H5C_flash_incr__off;
invalid_auto_size_ctl.flash_multiple = 2.0;
invalid_auto_size_ctl.flash_threshold = 0.5;
invalid_auto_size_ctl.decr_mode =
(enum H5C_cache_decr_mode) 4; /* INVALID */
invalid_auto_size_ctl.upper_hr_threshold = 0.999;
invalid_auto_size_ctl.decrement = 0.9;
invalid_auto_size_ctl.apply_max_decrement = TRUE;
invalid_auto_size_ctl.max_decrement = (1 * 1024 * 1024);
invalid_auto_size_ctl.epochs_before_eviction = 3;
invalid_auto_size_ctl.apply_empty_reserve = TRUE;
invalid_auto_size_ctl.empty_reserve = 0.05;
result = H5C_set_cache_auto_resize_config(cache_ptr,
&invalid_auto_size_ctl);
if ( result != FAIL ) {
pass = FALSE;
failure_mssg =
"H5C_set_cache_auto_resize_config accepted bad decr_mode 2.\n";
}
}
if ( pass ) {
result = H5C_get_cache_auto_resize_config(cache_ptr,
&test_auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_get_cache_auto_resize_config failed 25.";
} else if ( ! RESIZE_CONFIGS_ARE_EQUAL(test_auto_size_ctl, \
ref_auto_size_ctl, FALSE) ) {
pass = FALSE;
failure_mssg = "Unexpected auto resize config 25.";
}
}
/* check for bad decrement rejection */
if ( pass ) {
invalid_auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
invalid_auto_size_ctl.rpt_fcn = NULL;
invalid_auto_size_ctl.set_initial_size = TRUE;
invalid_auto_size_ctl.initial_size = 4 * 1024 * 1024;
invalid_auto_size_ctl.min_clean_fraction = 0.1;
invalid_auto_size_ctl.max_size = 16 * 1024 * 1024;
invalid_auto_size_ctl.min_size = 1 * 1024 * 1024;
invalid_auto_size_ctl.epoch_length = 5000;
invalid_auto_size_ctl.incr_mode = H5C_incr__threshold;
invalid_auto_size_ctl.lower_hr_threshold = 0.75;
invalid_auto_size_ctl.increment = 2.0;
invalid_auto_size_ctl.apply_max_increment = TRUE;
invalid_auto_size_ctl.max_increment = (2 * 1024 * 1024);
invalid_auto_size_ctl.flash_incr_mode = H5C_flash_incr__off;
invalid_auto_size_ctl.flash_multiple = 2.0;
invalid_auto_size_ctl.flash_threshold = 0.5;
invalid_auto_size_ctl.decr_mode = H5C_decr__threshold;
invalid_auto_size_ctl.upper_hr_threshold = 0.999;
invalid_auto_size_ctl.decrement = 1.000001; /* INVALID */
invalid_auto_size_ctl.apply_max_decrement = TRUE;
invalid_auto_size_ctl.max_decrement = (1 * 1024 * 1024);
invalid_auto_size_ctl.epochs_before_eviction = 3;
invalid_auto_size_ctl.apply_empty_reserve = TRUE;
invalid_auto_size_ctl.empty_reserve = 0.05;
result = H5C_set_cache_auto_resize_config(cache_ptr,
&invalid_auto_size_ctl);
if ( result != FAIL ) {
pass = FALSE;
failure_mssg =
"H5C_set_cache_auto_resize_config accepted bad decrement 1.\n";
}
}
if ( pass ) {
result = H5C_get_cache_auto_resize_config(cache_ptr,
&test_auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_get_cache_auto_resize_config failed 26.";
} else if ( ! RESIZE_CONFIGS_ARE_EQUAL(test_auto_size_ctl, \
ref_auto_size_ctl, FALSE) ) {
pass = FALSE;
failure_mssg = "Unexpected auto resize config 26.";
}
}
if ( pass ) {
invalid_auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
invalid_auto_size_ctl.rpt_fcn = NULL;
invalid_auto_size_ctl.set_initial_size = TRUE;
invalid_auto_size_ctl.initial_size = 4 * 1024 * 1024;
invalid_auto_size_ctl.min_clean_fraction = 0.1;
invalid_auto_size_ctl.max_size = 16 * 1024 * 1024;
invalid_auto_size_ctl.min_size = 1 * 1024 * 1024;
invalid_auto_size_ctl.epoch_length = 5000;
invalid_auto_size_ctl.incr_mode = H5C_incr__threshold;
invalid_auto_size_ctl.lower_hr_threshold = 0.75;
invalid_auto_size_ctl.increment = 2.0;
invalid_auto_size_ctl.apply_max_increment = TRUE;
invalid_auto_size_ctl.max_increment = (2 * 1024 * 1024);
invalid_auto_size_ctl.flash_incr_mode = H5C_flash_incr__off;
invalid_auto_size_ctl.flash_multiple = 2.0;
invalid_auto_size_ctl.flash_threshold = 0.5;
invalid_auto_size_ctl.decr_mode = H5C_decr__threshold;
invalid_auto_size_ctl.upper_hr_threshold = 0.999;
invalid_auto_size_ctl.decrement = -0.000001; /* INVALID */
invalid_auto_size_ctl.apply_max_decrement = TRUE;
invalid_auto_size_ctl.max_decrement = (1 * 1024 * 1024);
invalid_auto_size_ctl.epochs_before_eviction = 3;
invalid_auto_size_ctl.apply_empty_reserve = TRUE;
invalid_auto_size_ctl.empty_reserve = 0.05;
result = H5C_set_cache_auto_resize_config(cache_ptr,
&invalid_auto_size_ctl);
if ( result != FAIL ) {
pass = FALSE;
failure_mssg =
"H5C_set_cache_auto_resize_config accepted bad decrement 2.\n";
}
}
if ( pass ) {
result = H5C_get_cache_auto_resize_config(cache_ptr,
&test_auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_get_cache_auto_resize_config failed 27.";
} else if ( ! RESIZE_CONFIGS_ARE_EQUAL(test_auto_size_ctl, \
ref_auto_size_ctl, FALSE) ) {
pass = FALSE;
failure_mssg = "Unexpected auto resize config 27.";
}
}
/* check for rejection of bad epochs_before_eviction */
if ( pass ) {
invalid_auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
invalid_auto_size_ctl.rpt_fcn = NULL;
invalid_auto_size_ctl.set_initial_size = TRUE;
invalid_auto_size_ctl.initial_size = 4 * 1024 * 1024;
invalid_auto_size_ctl.min_clean_fraction = 0.1;
invalid_auto_size_ctl.max_size = 16 * 1024 * 1024;
invalid_auto_size_ctl.min_size = 1 * 1024 * 1024;
invalid_auto_size_ctl.epoch_length = 5000;
invalid_auto_size_ctl.incr_mode = H5C_incr__threshold;
invalid_auto_size_ctl.lower_hr_threshold = 0.75;
invalid_auto_size_ctl.increment = 2.0;
invalid_auto_size_ctl.apply_max_increment = TRUE;
invalid_auto_size_ctl.max_increment = (2 * 1024 * 1024);
invalid_auto_size_ctl.flash_incr_mode = H5C_flash_incr__off;
invalid_auto_size_ctl.flash_multiple = 2.0;
invalid_auto_size_ctl.flash_threshold = 0.5;
invalid_auto_size_ctl.decr_mode = H5C_decr__age_out;
invalid_auto_size_ctl.upper_hr_threshold = 0.999;
invalid_auto_size_ctl.decrement = 0.9;
invalid_auto_size_ctl.apply_max_decrement = TRUE;
invalid_auto_size_ctl.max_decrement = (1 * 1024 * 1024);
invalid_auto_size_ctl.epochs_before_eviction = 0; /* INVALID */
invalid_auto_size_ctl.apply_empty_reserve = TRUE;
invalid_auto_size_ctl.empty_reserve = 0.05;
result = H5C_set_cache_auto_resize_config(cache_ptr,
&invalid_auto_size_ctl);
if ( result != FAIL ) {
pass = FALSE;
failure_mssg = "H5C_set_cache_auto_resize_config accepted bad epochs_before_eviction 1.\n";
}
}
if ( pass ) {
result = H5C_get_cache_auto_resize_config(cache_ptr,
&test_auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_get_cache_auto_resize_config failed 28.";
} else if ( ! RESIZE_CONFIGS_ARE_EQUAL(test_auto_size_ctl, \
ref_auto_size_ctl, FALSE) ) {
pass = FALSE;
failure_mssg = "Unexpected auto resize config 28.";
}
}
if ( pass ) {
invalid_auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
invalid_auto_size_ctl.rpt_fcn = NULL;
invalid_auto_size_ctl.set_initial_size = TRUE;
invalid_auto_size_ctl.initial_size = 4 * 1024 * 1024;
invalid_auto_size_ctl.min_clean_fraction = 0.1;
invalid_auto_size_ctl.max_size = 16 * 1024 * 1024;
invalid_auto_size_ctl.min_size = 1 * 1024 * 1024;
invalid_auto_size_ctl.epoch_length = 5000;
invalid_auto_size_ctl.incr_mode = H5C_incr__threshold;
invalid_auto_size_ctl.lower_hr_threshold = 0.75;
invalid_auto_size_ctl.increment = 2.0;
invalid_auto_size_ctl.apply_max_increment = TRUE;
invalid_auto_size_ctl.max_increment = (2 * 1024 * 1024);
invalid_auto_size_ctl.flash_incr_mode = H5C_flash_incr__off;
invalid_auto_size_ctl.flash_multiple = 2.0;
invalid_auto_size_ctl.flash_threshold = 0.5;
invalid_auto_size_ctl.decr_mode = H5C_decr__age_out_with_threshold;
invalid_auto_size_ctl.upper_hr_threshold = 0.999;
invalid_auto_size_ctl.decrement = 0.9;
invalid_auto_size_ctl.apply_max_decrement = TRUE;
invalid_auto_size_ctl.max_decrement = (1 * 1024 * 1024);
invalid_auto_size_ctl.epochs_before_eviction =
H5C__MAX_EPOCH_MARKERS + 1; /* INVALID */
invalid_auto_size_ctl.apply_empty_reserve = TRUE;
invalid_auto_size_ctl.empty_reserve = 0.05;
result = H5C_set_cache_auto_resize_config(cache_ptr,
&invalid_auto_size_ctl);
if ( result != FAIL ) {
pass = FALSE;
failure_mssg = "H5C_set_cache_auto_resize_config accepted bad epochs_before_eviction 2.\n";
}
}
if ( pass ) {
result = H5C_get_cache_auto_resize_config(cache_ptr,
&test_auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_get_cache_auto_resize_config failed 29.";
} else if ( ! RESIZE_CONFIGS_ARE_EQUAL(test_auto_size_ctl, \
ref_auto_size_ctl, FALSE) ) {
pass = FALSE;
failure_mssg = "Unexpected auto resize config 29.";
}
}
/* Check for bad apply_empty_reserve rejection */
if ( pass ) {
invalid_auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
invalid_auto_size_ctl.rpt_fcn = NULL;
invalid_auto_size_ctl.set_initial_size = TRUE;
invalid_auto_size_ctl.initial_size = 4 * 1024 * 1024;
invalid_auto_size_ctl.min_clean_fraction = 0.1;
invalid_auto_size_ctl.max_size = 16 * 1024 * 1024;
invalid_auto_size_ctl.min_size = 1 * 1024 * 1024;
invalid_auto_size_ctl.epoch_length = 5000;
invalid_auto_size_ctl.incr_mode = H5C_incr__threshold;
invalid_auto_size_ctl.lower_hr_threshold = 0.75;
invalid_auto_size_ctl.increment = 2.0;
invalid_auto_size_ctl.apply_max_increment = TRUE;
invalid_auto_size_ctl.max_increment = (2 * 1024 * 1024);
invalid_auto_size_ctl.flash_incr_mode = H5C_flash_incr__off;
invalid_auto_size_ctl.flash_multiple = 2.0;
invalid_auto_size_ctl.flash_threshold = 0.5;
invalid_auto_size_ctl.decr_mode = H5C_decr__age_out;
invalid_auto_size_ctl.upper_hr_threshold = 0.999;
invalid_auto_size_ctl.decrement = 0.9;
invalid_auto_size_ctl.apply_max_decrement = TRUE;
invalid_auto_size_ctl.max_decrement = (1 * 1024 * 1024);
invalid_auto_size_ctl.epochs_before_eviction = 3;
invalid_auto_size_ctl.apply_empty_reserve = TRUE;
invalid_auto_size_ctl.empty_reserve = -0.0000001; /* INVALID */
result = H5C_set_cache_auto_resize_config(cache_ptr,
&invalid_auto_size_ctl);
if ( result != FAIL ) {
pass = FALSE;
failure_mssg = "H5C_set_cache_auto_resize_config accepted bad empty_reserve 1.\n";
}
}
if ( pass ) {
result = H5C_get_cache_auto_resize_config(cache_ptr,
&test_auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_get_cache_auto_resize_config failed 30.";
} else if ( ! RESIZE_CONFIGS_ARE_EQUAL(test_auto_size_ctl, \
ref_auto_size_ctl, FALSE) ) {
pass = FALSE;
failure_mssg = "Unexpected auto resize config 30.";
}
}
if ( pass ) {
invalid_auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
invalid_auto_size_ctl.rpt_fcn = NULL;
invalid_auto_size_ctl.set_initial_size = TRUE;
invalid_auto_size_ctl.initial_size = 4 * 1024 * 1024;
invalid_auto_size_ctl.min_clean_fraction = 0.1;
invalid_auto_size_ctl.max_size = 16 * 1024 * 1024;
invalid_auto_size_ctl.min_size = 1 * 1024 * 1024;
invalid_auto_size_ctl.epoch_length = 5000;
invalid_auto_size_ctl.incr_mode = H5C_incr__threshold;
invalid_auto_size_ctl.lower_hr_threshold = 0.75;
invalid_auto_size_ctl.increment = 2.0;
invalid_auto_size_ctl.apply_max_increment = TRUE;
invalid_auto_size_ctl.max_increment = (2 * 1024 * 1024);
invalid_auto_size_ctl.flash_incr_mode = H5C_flash_incr__off;
invalid_auto_size_ctl.flash_multiple = 2.0;
invalid_auto_size_ctl.flash_threshold = 0.5;
invalid_auto_size_ctl.decr_mode = H5C_decr__age_out_with_threshold;
invalid_auto_size_ctl.upper_hr_threshold = 0.999;
invalid_auto_size_ctl.decrement = 0.9;
invalid_auto_size_ctl.apply_max_decrement = TRUE;
invalid_auto_size_ctl.max_decrement = (1 * 1024 * 1024);
invalid_auto_size_ctl.epochs_before_eviction =
H5C__MAX_EPOCH_MARKERS + 1; /* INVALID */
invalid_auto_size_ctl.apply_empty_reserve = TRUE;
invalid_auto_size_ctl.empty_reserve = 0.05;
result = H5C_set_cache_auto_resize_config(cache_ptr,
&invalid_auto_size_ctl);
if ( result != FAIL ) {
pass = FALSE;
failure_mssg = "H5C_set_cache_auto_resize_config accepted bad empty_reserve 2.\n";
}
}
if ( pass ) {
result = H5C_get_cache_auto_resize_config(cache_ptr,
&test_auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_get_cache_auto_resize_config failed 31.";
} else if ( ! RESIZE_CONFIGS_ARE_EQUAL(test_auto_size_ctl, \
ref_auto_size_ctl, FALSE) ) {
pass = FALSE;
failure_mssg = "Unexpected auto resize config 31.";
}
}
/* finally, before we finish, try feeding
* H5C_get_cache_auto_resize_config invalid data.
*/
if ( pass ) {
result = H5C_get_cache_auto_resize_config(NULL, &test_auto_size_ctl);
if ( result != FAIL ) {
pass = FALSE;
failure_mssg =
"H5C_get_cache_auto_resize_config accepted NULL cache_ptr.\n";
}
}
if ( pass ) {
result = H5C_get_cache_auto_resize_config((H5C_t *)&test_auto_size_ctl,
&test_auto_size_ctl);
if ( result != FAIL ) {
pass = FALSE;
failure_mssg =
"H5C_get_cache_auto_resize_config accepted bad cache_ptr.\n";
}
}
if ( pass ) {
result = H5C_get_cache_auto_resize_config(cache_ptr, NULL);
if ( result != FAIL ) {
pass = FALSE;
failure_mssg =
"H5C_get_cache_auto_resize_config accepted NULL config ptr.\n";
}
}
if ( pass ) {
takedown_cache(cache_ptr, FALSE, FALSE);
}
if ( pass ) { PASSED(); } else { H5_FAILED(); }
if ( ! pass ) {
HDfprintf(stdout, "%s: failure_mssg = \"%s\".\n",
fcn_name, failure_mssg);
}
return;
} /* check_auto_cache_resize_input_errs() */
/*-------------------------------------------------------------------------
* Function: check_auto_cache_resize_aux_fcns()
*
* Purpose: Verify that the auxilary functions associated with
* the automatic cache resize capability are operating
* correctly. These functions are:
*
* H5C_get_cache_size()
* H5C_get_cache_hit_rate()
* H5C_reset_cache_hit_rate_stats()
*
* Return: void
*
* Programmer: John Mainzer
* 11/4/04
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static void
check_auto_cache_resize_aux_fcns(void)
{
const char * fcn_name = "check_auto_cache_resize_aux_fcns()";
herr_t result;
int32_t i;
H5C_t * cache_ptr = NULL;
double hit_rate;
size_t max_size;
size_t min_clean_size;
size_t cur_size;
int32_t cur_num_entries;
H5C_auto_size_ctl_t auto_size_ctl =
{
/* int32_t version = */ H5C__CURR_AUTO_SIZE_CTL_VER,
#if 1
/* H5C_auto_resize_report_fcn rpt_fcn = */ NULL,
#else
/* H5C_auto_resize_report_fcn rpt_fcn = */ H5C_def_auto_resize_rpt_fcn,
#endif
/* hbool_t set_initial_size = */ TRUE,
/* size_t initial_size = */ (1 * 1024 * 1024),
/* double min_clean_fraction = */ 0.5,
/* size_t max_size = */ (16 * 1024 * 1025),
/* size_t min_size = */ (512 * 1024),
/* int64_t epoch_length = */ 50000,
/* enum H5C_cache_incr_mode incr_mode = */ H5C_incr__off,
/* double lower_hr_threshold = */ 0.75,
/* double increment = */ 2.0,
/* hbool_t apply_max_increment = */ TRUE,
/* size_t max_increment = */ (4 * 1024 * 1024),
/* enum H5C_cache_flash_incr_mode */
/* flash_incr_mode = */ H5C_flash_incr__off,
/* double flash_multiple = */ 2.0,
/* double flash_threshold = */ 0.5,
/* enum H5C_cache_decr_mode decr_mode = */ H5C_decr__off,
/* double upper_hr_threshold = */ 0.995,
/* double decrement = */ 0.9,
/* hbool_t apply_max_decrement = */ TRUE,
/* size_t max_decrement = */ (1 * 1024 * 1024),
/* int32_t epochs_before_eviction = */ 3,
/* hbool_t apply_empty_reserve = */ TRUE,
/* double empty_reserve = */ 0.5
};
TESTING("automatic cache resize auxilary functions");
pass = TRUE;
/* allocate a cache, and then test the various auxilary functions.
*/
if ( pass ) {
reset_entries();
cache_ptr = setup_cache((size_t)(2 * 1024),
(size_t)(1 * 1024));
}
if ( pass ) {
result = H5C_set_cache_auto_resize_config(cache_ptr,
&auto_size_ctl);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_set_cache_auto_resize_config failed 1.\n";
}
}
if ( pass ) {
if ( ( cache_ptr->max_cache_size != (1 * 1024 * 1024) ) ||
( cache_ptr->min_clean_size != (512 * 1024) ) ) {
pass = FALSE;
failure_mssg = "bad cache size after initialization.\n";
}
}
/* lets start with the H5C_get_cache_hit_rate(),
* H5C_reset_cache_hit_rate_stats() pair.
*/
if ( pass ) {
if ( ( H5C_get_cache_hit_rate(NULL, &hit_rate) != FAIL ) ||
( H5C_get_cache_hit_rate(cache_ptr, NULL) != FAIL ) ) {
pass = FALSE;
failure_mssg = "H5C_get_cache_hit_rate accepts bad params.\n";
}
}
if ( pass ) {
result = H5C_get_cache_hit_rate(cache_ptr, &hit_rate);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_get_cache_hit_rate failed.\n";
} else if ( hit_rate != 0.0 ) {
pass = FALSE;
failure_mssg =
"H5C_get_cache_hit_rate returned unexpected hit rate 1.\n";
}
}
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, PICO_ENTRY_TYPE, i);
if ( pass ) {
unprotect_entry(cache_ptr, PICO_ENTRY_TYPE, i,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
}
if ( pass ) {
result = H5C_get_cache_hit_rate(cache_ptr, &hit_rate);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_get_cache_hit_rate failed.\n";
} else if ( hit_rate != 0.0 ) {
pass = FALSE;
failure_mssg =
"H5C_get_cache_hit_rate returned unexpected hit rate 2.\n";
} else if ( ( cache_ptr->cache_accesses != 1000 ) ||
( cache_ptr->cache_hits != 0 ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache hit rate stats.\n";
} else if ( rpt_fcn_called ) {
pass = FALSE;
failure_mssg = "Report function called?.\n";
}
}
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, PICO_ENTRY_TYPE, 0);
if ( pass ) {
unprotect_entry(cache_ptr, PICO_ENTRY_TYPE, 0,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
}
if ( pass ) {
result = H5C_get_cache_hit_rate(cache_ptr, &hit_rate);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_get_cache_hit_rate failed.\n";
} else if ( hit_rate != 0.5 ) {
pass = FALSE;
failure_mssg =
"H5C_get_cache_hit_rate returned unexpected hit rate 3.\n";
} else if ( ( cache_ptr->cache_accesses != 2000 ) ||
( cache_ptr->cache_hits != 1000 ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache hit rate stats.\n";
} else if ( rpt_fcn_called ) {
pass = FALSE;
failure_mssg = "Report function called?.\n";
}
}
if ( pass ) {
result = H5C_reset_cache_hit_rate_stats(NULL);
if ( result != FAIL ) {
pass = FALSE;
failure_mssg =
"H5C_reset_cache_hit_rate_stats accepted NULL cache_ptr.\n";
} else if ( ( cache_ptr->cache_accesses != 2000 ) ||
( cache_ptr->cache_hits != 1000 ) ) {
pass = FALSE;
failure_mssg =
"Failed call to H5C_reset_cache_hit_rate_stats altered stats?\n";
}
}
if ( pass ) {
result = H5C_reset_cache_hit_rate_stats(cache_ptr);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_reset_cache_hit_rate_stats failed.\n";
} else if ( ( cache_ptr->cache_accesses != 0 ) ||
( cache_ptr->cache_hits != 0 ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache hit rate stats.\n";
}
}
if ( pass ) {
rpt_fcn_called = FALSE;
i = 0;
while ( ( pass ) && ( i < 1000 ) )
{
protect_entry(cache_ptr, PICO_ENTRY_TYPE, i + 500);
if ( pass ) {
unprotect_entry(cache_ptr, PICO_ENTRY_TYPE, i + 500,
NO_CHANGE, H5C__NO_FLAGS_SET);
}
i++;
}
}
if ( pass ) {
result = H5C_get_cache_hit_rate(cache_ptr, &hit_rate);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_get_cache_hit_rate failed.\n";
} else if ( hit_rate != 0.5 ) {
pass = FALSE;
failure_mssg =
"H5C_get_cache_hit_rate returned unexpected hit rate 4.\n";
} else if ( ( cache_ptr->cache_accesses != 1000 ) ||
( cache_ptr->cache_hits != 500 ) ) {
pass = FALSE;
failure_mssg = "Unexpected cache hit rate stats.\n";
} else if ( rpt_fcn_called ) {
pass = FALSE;
failure_mssg = "Report function called?.\n";
}
}
/***************************************************
* So much for testing H5C_get_cache_hit_rate() and
* H5C_reset_cache_hit_rate_stats(). Now on to
* H5C_get_cache_size().
***************************************************/
if ( pass ) {
result = H5C_get_cache_size(NULL, &max_size, &min_clean_size,
&cur_size, &cur_num_entries);
if ( result != FAIL ) {
pass = FALSE;
failure_mssg = "H5C_get_cache_size accepted NULL cache_ptr.\n";
}
}
if ( pass ) {
max_size = 0;
min_clean_size = 0;
cur_size = 0;
cur_num_entries = 0;
result = H5C_get_cache_size(cache_ptr, &max_size, &min_clean_size,
&cur_size, &cur_num_entries);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_get_cache_size failed 1.\n";
} else if ( max_size != (1 * 1024 * 1024) ) {
pass = FALSE;
failure_mssg =
"H5C_get_cache_size reports unexpected max_size 1.\n";
} else if ( min_clean_size != (512 * 1024) ) {
pass = FALSE;
failure_mssg =
"H5C_get_cache_size reports unexpected min_clean_size 1.\n";
} else if ( cur_size != (1500 * PICO_ENTRY_SIZE) ) {
pass = FALSE;
failure_mssg =
"H5C_get_cache_size reports unexpected cur_size 1.\n";
} else if ( cur_num_entries != 1500 ) {
pass = FALSE;
failure_mssg =
"H5C_get_cache_size reports unexpected cur_num_entries 1.\n";
}
}
/* read a larger entry so that cur_size and cur_num_entries will be
* different.
*/
if ( pass ) {
protect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0);
}
if ( pass ) {
unprotect_entry(cache_ptr, MONSTER_ENTRY_TYPE, 0, NO_CHANGE,
H5C__NO_FLAGS_SET);
}
if ( pass ) {
max_size = 0;
min_clean_size = 0;
cur_size = 0;
cur_num_entries = 0;
result = H5C_get_cache_size(cache_ptr, &max_size, &min_clean_size,
&cur_size, &cur_num_entries);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_get_cache_size failed 2.\n";
} else if ( max_size != (1 * 1024 * 1024) ) {
pass = FALSE;
failure_mssg =
"H5C_get_cache_size reports unexpected max_size 2.\n";
} else if ( min_clean_size != (512 * 1024) ) {
pass = FALSE;
failure_mssg =
"H5C_get_cache_size reports unexpected min_clean_size 2.\n";
} else if ( cur_size !=
((1500 * PICO_ENTRY_SIZE) + MONSTER_ENTRY_SIZE) ) {
pass = FALSE;
failure_mssg =
"H5C_get_cache_size reports unexpected cur_size 2.\n";
} else if ( cur_num_entries != 1501 ) {
pass = FALSE;
failure_mssg =
"H5C_get_cache_size reports unexpected cur_num_entries 2.\n";
}
}
if ( pass ) {
max_size = 0;
min_clean_size = 0;
cur_size = 0;
cur_num_entries = 0;
result = H5C_get_cache_size(cache_ptr, &max_size, NULL, NULL, NULL);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_get_cache_size failed 3.\n";
} else if ( max_size != (1 * 1024 * 1024) ) {
pass = FALSE;
failure_mssg =
"H5C_get_cache_size reports unexpected max_size 3.\n";
} else if ( ( min_clean_size != 0 ) ||
( cur_size != 0 ) ||
( cur_num_entries != 0 ) ) {
pass = FALSE;
failure_mssg = "Phantom returns from H5C_get_cache_size?\n";
}
}
if ( pass ) {
max_size = 0;
min_clean_size = 0;
cur_size = 0;
cur_num_entries = 0;
result = H5C_get_cache_size(cache_ptr, NULL, &min_clean_size,
NULL, NULL);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_get_cache_size failed 4.\n";
} else if ( min_clean_size != (512 * 1024) ) {
pass = FALSE;
failure_mssg =
"H5C_get_cache_size reports unexpected min_clean_size 4.\n";
} else if ( ( max_size != 0 ) ||
( cur_size != 0 ) ||
( cur_num_entries != 0 ) ) {
pass = FALSE;
failure_mssg = "Phantom returns from H5C_get_cache_size?\n";
}
}
if ( pass ) {
max_size = 0;
min_clean_size = 0;
cur_size = 0;
cur_num_entries = 0;
result = H5C_get_cache_size(cache_ptr, NULL, NULL, &cur_size, NULL);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_get_cache_size failed 5.\n";
} else if ( cur_size !=
((1500 * PICO_ENTRY_SIZE) + MONSTER_ENTRY_SIZE) ) {
pass = FALSE;
failure_mssg =
"H5C_get_cache_size reports unexpected cur_size 5.\n";
} else if ( ( max_size != 0 ) ||
( min_clean_size != 0 ) ||
( cur_num_entries != 0 ) ) {
pass = FALSE;
failure_mssg = "Phantom returns from H5C_get_cache_size?\n";
}
}
if ( pass ) {
max_size = 0;
min_clean_size = 0;
cur_size = 0;
cur_num_entries = 0;
result = H5C_get_cache_size(cache_ptr, NULL, NULL, NULL,
&cur_num_entries);
if ( result != SUCCEED ) {
pass = FALSE;
failure_mssg = "H5C_get_cache_size failed 6.\n";
} else if ( cur_num_entries != 1501 ) {
pass = FALSE;
failure_mssg =
"H5C_get_cache_size reports unexpected cur_num_entries 2.\n";
} else if ( ( max_size != 0 ) ||
( min_clean_size != 0 ) ||
( cur_size != 0 ) ) {
pass = FALSE;
failure_mssg = "Phantom returns from H5C_get_cache_size?\n";
}
}
if ( pass ) {
takedown_cache(cache_ptr, FALSE, FALSE);
}
if ( pass ) { PASSED(); } else { H5_FAILED(); }
if ( ! pass ) {
HDfprintf(stdout, "%s: failure_mssg = \"%s\".\n",
fcn_name, failure_mssg);
}
return;
} /* check_auto_cache_resize_aux_fcns() */
/*-------------------------------------------------------------------------
* Function: main
*
* Purpose: Run tests on the cache code contained in H5C.c
*
* Return: Success:
*
* Failure:
*
* Programmer: John Mainzer
* 6/24/04
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
int
main(void)
{
H5open();
skip_long_tests = FALSE;
#ifdef NDEBUG
run_full_test = TRUE;
#else /* NDEBUG */
run_full_test = FALSE;
#endif /* NDEBUG */
#if 0
run_full_test = TRUE;
#endif
#if 1
smoke_check_1();
smoke_check_2();
smoke_check_3();
smoke_check_4();
smoke_check_5();
smoke_check_6();
smoke_check_7();
smoke_check_8();
smoke_check_9();
smoke_check_10();
#endif
write_permitted_check();
check_insert_entry();
check_flush_cache();
check_get_entry_status();
check_expunge_entry();
check_multiple_read_protect();
check_rename_entry();
check_pin_protected_entry();
check_resize_entry();
check_evictions_enabled();
check_flush_protected_err();
check_destroy_pinned_err();
check_destroy_protected_err();
check_duplicate_insert_err();
check_rename_err();
check_double_pin_err();
check_double_unpin_err();
check_pin_entry_errs();
check_double_protect_err();
check_double_unprotect_err();
check_mark_entry_dirty_errs();
check_expunge_entry_errs();
check_resize_entry_errs();
check_unprotect_ro_dirty_err();
check_protect_ro_rw_err();
check_check_evictions_enabled_err();
check_auto_cache_resize();
check_auto_cache_resize_disable();
check_auto_cache_resize_epoch_markers();
check_auto_cache_resize_input_errs();
check_auto_cache_resize_aux_fcns();
return(0);
} /* main() */
Reference in New Issue View Git Blame Copy Permalink