/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 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 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_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_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_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_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_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_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: 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_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); 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); 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); 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_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: * *------------------------------------------------------------------------- */ 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, UNUSED 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_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 unconvenient 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.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.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.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.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.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.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.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); } 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: * *------------------------------------------------------------------------- */ 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_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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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++); 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_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.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.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.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.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.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: * *------------------------------------------------------------------------- */ #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).decr_mode == (b).decr_mode ) && \ ( (a).upper_hr_threshold == (b).upper_hr_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_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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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 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.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 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."; } } 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.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 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."; } } /* 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.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 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."; } } 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.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 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."; } } /* 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.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 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."; } } 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.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 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."; } } /* 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.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 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."; } } 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.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 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."; } } /* 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_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(); #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_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_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() */