mirrors/hdf5
2
0
Fork 0
mirror of https://github.com/HDFGroup/hdf5.git synced 2026-09-25 04:09:44 +03:00
Code Issues Packages Projects Releases Wiki Activity
Files
e3d9211fa94de3e43908368e5e313930c8cea18c
hdf5/test/cache.c
T
John Mainzer c100b0bf26 [svn-r11470] Purpose: 
Repair synchronization bug in the metadata cache in PHDF5

Also repair numerous other bugs that surfaced in testing the
bug fix.


Description:

While operations modifying metadata must be collective, we allow
independant reads.  This allows metadata caches on different processes
to adjust to different sizes, and to place the entries on their dirty
lists in different orders.  Since only process 0 actually writes
metadata to disk (all other processes thought they did, but the writes
were discarded on the theory that they had to be collective), this made
it possible for another process to modify metadata, flush it, and then
read it back in in its original form (pre-modification) form.  The
possibilities for file corruption should be obvious.


Solution:

Make the policy that only process 0 can write to file explicit, and
visible to the metadata caches.  Thus only process 0 may flush dirty
entries -- all other caches must retain dirty entries until they are
informed by process 0 that the entries are clean.

Synchronization is handled by counting the bytes of dirty cache entries
created, and then synching up between the caches whenever the sum
exceeds an (eventually user specified) limit.  Dirty metadata creation
is consistent across all processes because all operations modifying
metadata must be collective.

This change uncovered may bugs which are repaired in this checkin.
It also required modification of H5HL and H5O to allocate file space
on insertion rather than on flush from cache.


Platforms tested:

H5committest, heping(parallel & serial)

Misc. update:
2005-09-27 00:20:11 -05:00

20572 lines
658 KiB
C
Raw Blame History

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* 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://hdf.ncsa.uiuc.edu/HDF5/doc/Copyright.html. If you do not have *
* access to either file, you may request a copy from hdfhelp@ncsa.uiuc.edu. *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* 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"
const char *FILENAME[] = {
"cache",
NULL
};
#define H5C_PACKAGE /*suppress error about including H5Cpkg */
#include "H5Cpkg.h"
#define H5F_PACKAGE /*suppress error about including H5Fpkg */
#include "H5Fpkg.h"
/* with apologies for the abuse of terminology... */
#define PICO_ENTRY_TYPE 0
#define NANO_ENTRY_TYPE 1
#define MICRO_ENTRY_TYPE 2
#define TINY_ENTRY_TYPE 3
#define SMALL_ENTRY_TYPE 4
#define MEDIUM_ENTRY_TYPE 5
#define LARGE_ENTRY_TYPE 6
#define HUGE_ENTRY_TYPE 7
#define MONSTER_ENTRY_TYPE 8
#define NUMBER_OF_ENTRY_TYPES 9
#define PICO_ENTRY_SIZE (size_t)1
#define NANO_ENTRY_SIZE (size_t)4
#define MICRO_ENTRY_SIZE (size_t)16
#define TINY_ENTRY_SIZE (size_t)64
#define SMALL_ENTRY_SIZE (size_t)256
#define MEDIUM_ENTRY_SIZE (size_t)1024
#define LARGE_ENTRY_SIZE (size_t)(4 * 1024)
#define HUGE_ENTRY_SIZE (size_t)(16 * 1024)
#define MONSTER_ENTRY_SIZE (size_t)(64 * 1024)
#define NUM_PICO_ENTRIES (10 * 1024)
#define NUM_NANO_ENTRIES (10 * 1024)
#define NUM_MICRO_ENTRIES (10 * 1024)
#define NUM_TINY_ENTRIES (10 * 1024)
#define NUM_SMALL_ENTRIES (10 * 1024)
#define NUM_MEDIUM_ENTRIES (10 * 1024)
#define NUM_LARGE_ENTRIES (10 * 1024)
#define NUM_HUGE_ENTRIES (10 * 1024)
#define NUM_MONSTER_ENTRIES (10 * 1024)
#define MAX_ENTRIES (10 * 1024)
#define PICO_BASE_ADDR (haddr_t)0
#define NANO_BASE_ADDR (haddr_t)(PICO_BASE_ADDR + \
(PICO_ENTRY_SIZE * NUM_PICO_ENTRIES))
#define MICRO_BASE_ADDR (haddr_t)(NANO_BASE_ADDR + \
(NANO_ENTRY_SIZE * NUM_NANO_ENTRIES))
#define TINY_BASE_ADDR (haddr_t)(MICRO_BASE_ADDR + \
(MICRO_ENTRY_SIZE * NUM_MICRO_ENTRIES))
#define SMALL_BASE_ADDR (haddr_t)(TINY_BASE_ADDR + \
(TINY_ENTRY_SIZE * NUM_TINY_ENTRIES))
#define MEDIUM_BASE_ADDR (haddr_t)(SMALL_BASE_ADDR + \
(SMALL_ENTRY_SIZE * NUM_SMALL_ENTRIES))
#define LARGE_BASE_ADDR (haddr_t)(MEDIUM_BASE_ADDR + \
(MEDIUM_ENTRY_SIZE * NUM_MEDIUM_ENTRIES))
#define HUGE_BASE_ADDR (haddr_t)(LARGE_BASE_ADDR + \
(LARGE_ENTRY_SIZE * NUM_LARGE_ENTRIES))
#define MONSTER_BASE_ADDR (haddr_t)(HUGE_BASE_ADDR + \
(HUGE_ENTRY_SIZE * NUM_HUGE_ENTRIES))
#define PICO_ALT_BASE_ADDR (haddr_t)(MONSTER_BASE_ADDR + \
(MONSTER_ENTRY_SIZE * NUM_MONSTER_ENTRIES))
#define NANO_ALT_BASE_ADDR (haddr_t)(PICO_ALT_BASE_ADDR + \
(PICO_ENTRY_SIZE * NUM_PICO_ENTRIES))
#define MICRO_ALT_BASE_ADDR (haddr_t)(NANO_ALT_BASE_ADDR + \
(NANO_ENTRY_SIZE * NUM_NANO_ENTRIES))
#define TINY_ALT_BASE_ADDR (haddr_t)(MICRO_ALT_BASE_ADDR + \
(MICRO_ENTRY_SIZE * NUM_MICRO_ENTRIES))
#define SMALL_ALT_BASE_ADDR (haddr_t)(TINY_ALT_BASE_ADDR + \
(TINY_ENTRY_SIZE * NUM_TINY_ENTRIES))
#define MEDIUM_ALT_BASE_ADDR (haddr_t)(SMALL_ALT_BASE_ADDR + \
(SMALL_ENTRY_SIZE * NUM_SMALL_ENTRIES))
#define LARGE_ALT_BASE_ADDR (haddr_t)(MEDIUM_ALT_BASE_ADDR + \
(MEDIUM_ENTRY_SIZE * NUM_MEDIUM_ENTRIES))
#define HUGE_ALT_BASE_ADDR (haddr_t)(LARGE_ALT_BASE_ADDR + \
(LARGE_ENTRY_SIZE * NUM_LARGE_ENTRIES))
#define MONSTER_ALT_BASE_ADDR (haddr_t)(HUGE_ALT_BASE_ADDR + \
(HUGE_ENTRY_SIZE * NUM_HUGE_ENTRIES))
typedef struct test_entry_t
{
H5C_cache_entry_t header; /* entry data used by the cache
* -- must be first
*/
struct test_entry_t * self; /* pointer to this entry -- used for
* sanity checking.
*/
haddr_t addr; /* where the cache thinks this entry
* is located
*/
hbool_t at_main_addr; /* boolean flag indicating whether
* the entry is supposed to be at
* either its main or alternate
* address.
*/
haddr_t main_addr; /* initial location of the entry
*/
haddr_t alt_addr; /* location to which the entry
* can be relocated or "renamed"
*/
size_t size; /* how big the cache thinks this
* entry is
*/
int32_t type; /* indicates which entry array this
* entry is in
*/
int32_t index; /* index in its entry array
*/
int32_t reads; /* number of times this entry has
* been loaded.
*/
int32_t writes; /* number of times this entry has
* been written
*/
hbool_t is_dirty; /* entry has been modified since
* last write
*/
hbool_t is_protected; /* entry should currently be on
* the cache's protected list.
*/
hbool_t loaded; /* entry has been loaded since the
* last time it was reset.
*/
hbool_t cleared; /* entry has been cleared since the
* last time it was reset.
*/
hbool_t flushed; /* entry has been flushed since the
* last time it was reset.
*/
hbool_t destroyed; /* entry has been destroyed since the
* last time it was reset.
*/
} test_entry_t;
/* The following is a cut down copy of the hash table manipulation
* macros from H5C.c, which have been further modified to avoid references
* to the error reporting macros. Needless to say, these macros must be
* updated as necessary.
*/
#define H5C__HASH_MASK ((size_t)(H5C__HASH_TABLE_LEN - 1) << 3)
#define H5C__HASH_FCN(x) (int)(((x) & H5C__HASH_MASK) >> 3)
#define H5C__PRE_HT_SEARCH_SC(cache_ptr, Addr) \
if ( ( (cache_ptr) == NULL ) || \
( (cache_ptr)->magic != H5C__H5C_T_MAGIC ) || \
( ! H5F_addr_defined(Addr) ) || \
( H5C__HASH_FCN(Addr) < 0 ) || \
( H5C__HASH_FCN(Addr) >= H5C__HASH_TABLE_LEN ) ) { \
HDfprintf(stdout, "Pre HT search SC failed.\n"); \
}
#define H5C__POST_SUC_HT_SEARCH_SC(cache_ptr, entry_ptr, Addr, k) \
if ( ( (cache_ptr) == NULL ) || \
( (cache_ptr)->magic != H5C__H5C_T_MAGIC ) || \
( (cache_ptr)->index_len < 1 ) || \
( (entry_ptr) == NULL ) || \
( (cache_ptr)->index_size < (entry_ptr)->size ) || \
( H5F_addr_ne((entry_ptr)->addr, (Addr)) ) || \
( (entry_ptr)->size <= 0 ) || \
( ((cache_ptr)->index)[k] == NULL ) || \
( ( ((cache_ptr)->index)[k] != (entry_ptr) ) && \
( (entry_ptr)->ht_prev == NULL ) ) || \
( ( ((cache_ptr)->index)[k] == (entry_ptr) ) && \
( (entry_ptr)->ht_prev != NULL ) ) || \
( ( (entry_ptr)->ht_prev != NULL ) && \
( (entry_ptr)->ht_prev->ht_next != (entry_ptr) ) ) || \
( ( (entry_ptr)->ht_next != NULL ) && \
( (entry_ptr)->ht_next->ht_prev != (entry_ptr) ) ) ) { \
HDfprintf(stdout, "Post successful HT search SC failed.\n"); \
}
#define H5C__SEARCH_INDEX(cache_ptr, Addr, entry_ptr) \
{ \
int k; \
int depth = 0; \
H5C__PRE_HT_SEARCH_SC(cache_ptr, Addr) \
k = H5C__HASH_FCN(Addr); \
entry_ptr = ((cache_ptr)->index)[k]; \
while ( ( entry_ptr ) && ( H5F_addr_ne(Addr, (entry_ptr)->addr) ) ) \
{ \
(entry_ptr) = (entry_ptr)->ht_next; \
(depth)++; \
} \
if ( entry_ptr ) \
{ \
H5C__POST_SUC_HT_SEARCH_SC(cache_ptr, entry_ptr, Addr, k) \
if ( entry_ptr != ((cache_ptr)->index)[k] ) \
{ \
if ( (entry_ptr)->ht_next ) \
{ \
(entry_ptr)->ht_next->ht_prev = (entry_ptr)->ht_prev; \
} \
HDassert( (entry_ptr)->ht_prev != NULL ); \
(entry_ptr)->ht_prev->ht_next = (entry_ptr)->ht_next; \
((cache_ptr)->index)[k]->ht_prev = (entry_ptr); \
(entry_ptr)->ht_next = ((cache_ptr)->index)[k]; \
(entry_ptr)->ht_prev = NULL; \
((cache_ptr)->index)[k] = (entry_ptr); \
} \
} \
}
/* misc type definitions */
struct flush_cache_test_spec
{
int entry_num;
int entry_type;
int entry_index;
hbool_t insert_flag;
hbool_t dirty_flag;
unsigned int flags;
hbool_t expected_loaded;
hbool_t expected_cleared;
hbool_t expected_flushed;
hbool_t expected_destroyed;
};
/* global variable declarations: */
static hbool_t write_permitted = TRUE;
static hbool_t pass = TRUE; /* set to false on error */
static hbool_t skip_long_tests = TRUE;
static hbool_t run_full_test = TRUE;
const char *failure_mssg = NULL;
test_entry_t pico_entries[NUM_PICO_ENTRIES];
test_entry_t nano_entries[NUM_NANO_ENTRIES];
test_entry_t micro_entries[NUM_MICRO_ENTRIES];
test_entry_t tiny_entries[NUM_TINY_ENTRIES];
test_entry_t small_entries[NUM_SMALL_ENTRIES];
test_entry_t medium_entries[NUM_MEDIUM_ENTRIES];
test_entry_t large_entries[NUM_LARGE_ENTRIES];
test_entry_t huge_entries[NUM_HUGE_ENTRIES];
test_entry_t monster_entries[NUM_MONSTER_ENTRIES];
test_entry_t * entries[NUMBER_OF_ENTRY_TYPES] =
{
pico_entries,
nano_entries,
micro_entries,
tiny_entries,
small_entries,
medium_entries,
large_entries,
huge_entries,
monster_entries
};
const int32_t max_indices[NUMBER_OF_ENTRY_TYPES] =
{
NUM_PICO_ENTRIES - 1,
NUM_NANO_ENTRIES - 1,
NUM_MICRO_ENTRIES - 1,
NUM_TINY_ENTRIES - 1,
NUM_SMALL_ENTRIES - 1,
NUM_MEDIUM_ENTRIES - 1,
NUM_LARGE_ENTRIES - 1,
NUM_HUGE_ENTRIES - 1,
NUM_MONSTER_ENTRIES - 1
};
const size_t entry_sizes[NUMBER_OF_ENTRY_TYPES] =
{
PICO_ENTRY_SIZE,
NANO_ENTRY_SIZE,
MICRO_ENTRY_SIZE,
TINY_ENTRY_SIZE,
SMALL_ENTRY_SIZE,
MEDIUM_ENTRY_SIZE,
LARGE_ENTRY_SIZE,
HUGE_ENTRY_SIZE,
MONSTER_ENTRY_SIZE
};
const haddr_t base_addrs[NUMBER_OF_ENTRY_TYPES] =
{
PICO_BASE_ADDR,
NANO_BASE_ADDR,
MICRO_BASE_ADDR,
TINY_BASE_ADDR,
SMALL_BASE_ADDR,
MEDIUM_BASE_ADDR,
LARGE_BASE_ADDR,
HUGE_BASE_ADDR,
MONSTER_BASE_ADDR
};
const haddr_t alt_base_addrs[NUMBER_OF_ENTRY_TYPES] =
{
PICO_ALT_BASE_ADDR,
NANO_ALT_BASE_ADDR,
MICRO_ALT_BASE_ADDR,
TINY_ALT_BASE_ADDR,
SMALL_ALT_BASE_ADDR,
MEDIUM_ALT_BASE_ADDR,
LARGE_ALT_BASE_ADDR,
HUGE_ALT_BASE_ADDR,
MONSTER_ALT_BASE_ADDR
};
const char * entry_type_names[NUMBER_OF_ENTRY_TYPES] =
{
"pico entries -- 1 B",
"nano entries -- 4 B",
"micro entries -- 16 B",
"tiny entries -- 64 B",
"small entries -- 256 B",
"medium entries -- 1 KB",
"large entries -- 4 KB",
"huge entries -- 16 KB",
"monster entries -- 64 KB"
};
/* call back function declarations: */
static herr_t check_write_permitted(const H5F_t UNUSED * f,
hid_t UNUSED dxpl_id,
hbool_t * write_permitted_ptr);
static herr_t clear(H5F_t * f, void * thing, hbool_t dest);
herr_t pico_clear(H5F_t * f, void * thing, hbool_t dest);
herr_t nano_clear(H5F_t * f, void * thing, hbool_t dest);
herr_t micro_clear(H5F_t * f, void * thing, hbool_t dest);
herr_t tiny_clear(H5F_t * f, void * thing, hbool_t dest);
herr_t small_clear(H5F_t * f, void * thing, hbool_t dest);
herr_t medium_clear(H5F_t * f, void * thing, hbool_t dest);
herr_t large_clear(H5F_t * f, void * thing, hbool_t dest);
herr_t huge_clear(H5F_t * f, void * thing, hbool_t dest);
herr_t monster_clear(H5F_t * f, void * thing, hbool_t dest);
static herr_t destroy(H5F_t UNUSED * f, void * thing);
herr_t pico_dest(H5F_t * f, void * thing);
herr_t nano_dest(H5F_t * f, void * thing);
herr_t micro_dest(H5F_t * f, void * thing);
herr_t tiny_dest(H5F_t * f, void * thing);
herr_t small_dest(H5F_t * f, void * thing);
herr_t medium_dest(H5F_t * f, void * thing);
herr_t large_dest(H5F_t * f, void * thing);
herr_t huge_dest(H5F_t * f, void * thing);
herr_t monster_dest(H5F_t * f, void * thing);
static herr_t flush(H5F_t *f, hid_t UNUSED dxpl_id, hbool_t dest,
haddr_t addr, void *thing);
herr_t pico_flush(H5F_t *f, hid_t dxpl_id, hbool_t dest,
haddr_t addr, void *thing);
herr_t nano_flush(H5F_t *f, hid_t dxpl_id, hbool_t dest,
haddr_t addr, void *thing);
herr_t micro_flush(H5F_t *f, hid_t dxpl_id, hbool_t dest,
haddr_t addr, void *thing);
herr_t tiny_flush(H5F_t *f, hid_t dxpl_id, hbool_t dest,
haddr_t addr, void *thing);
herr_t small_flush(H5F_t *f, hid_t dxpl_id, hbool_t dest,
haddr_t addr, void *thing);
herr_t medium_flush(H5F_t *f, hid_t dxpl_id, hbool_t dest,
haddr_t addr, void *thing);
herr_t large_flush(H5F_t *f, hid_t dxpl_id, hbool_t dest,
haddr_t addr, void *thing);
herr_t huge_flush(H5F_t *f, hid_t dxpl_id, hbool_t dest,
haddr_t addr, void *thing);
herr_t monster_flush(H5F_t *f, hid_t dxpl_id, hbool_t dest,
haddr_t addr, void *thing);
static void * load(H5F_t UNUSED *f, hid_t UNUSED dxpl_id, haddr_t addr,
const void UNUSED *udata1, void UNUSED *udata2);
void * pico_load(H5F_t *f, hid_t dxpl_id, haddr_t addr,
const void *udata1, void *udata2);
void * nano_load(H5F_t *f, hid_t dxpl_id, haddr_t addr,
const void *udata1, void *udata2);
void * micro_load(H5F_t *f, hid_t dxpl_id, haddr_t addr,
const void *udata1, void *udata2);
void * tiny_load(H5F_t *f, hid_t dxpl_id, haddr_t addr,
const void *udata1, void *udata2);
void * small_load(H5F_t *f, hid_t dxpl_id, haddr_t addr,
const void *udata1, void *udata2);
void * medium_load(H5F_t *f, hid_t dxpl_id, haddr_t addr,
const void *udata1, void *udata2);
void * large_load(H5F_t *f, hid_t dxpl_id, haddr_t addr,
const void *udata1, void *udata2);
void * huge_load(H5F_t *f, hid_t dxpl_id, haddr_t addr,
const void *udata1, void *udata2);
void * monster_load(H5F_t *f, hid_t dxpl_id, haddr_t addr,
const void *udata1, void *udata2);
static herr_t size(H5F_t UNUSED * f, void * thing, size_t * size_ptr);
herr_t pico_size(H5F_t * f, void * thing, size_t * size_ptr);
herr_t nano_size(H5F_t * f, void * thing, size_t * size_ptr);
herr_t micro_size(H5F_t * f, void * thing, size_t * size_ptr);
herr_t tiny_size(H5F_t * f, void * thing, size_t * size_ptr);
herr_t small_size(H5F_t * f, void * thing, size_t * size_ptr);
herr_t medium_size(H5F_t * f, void * thing, size_t * size_ptr);
herr_t large_size(H5F_t * f, void * thing, size_t * size_ptr);
herr_t huge_size(H5F_t * f, void * thing, size_t * size_ptr);
herr_t monster_size(H5F_t * f, void * thing, size_t * size_ptr);
/* callback table declaration */
static const H5C_class_t types[NUMBER_OF_ENTRY_TYPES] =
{
{
PICO_ENTRY_TYPE,
(H5C_load_func_t)pico_load,
(H5C_flush_func_t)pico_flush,
(H5C_dest_func_t)pico_dest,
(H5C_clear_func_t)pico_clear,
(H5C_size_func_t)pico_size
},
{
NANO_ENTRY_TYPE,
(H5C_load_func_t)nano_load,
(H5C_flush_func_t)nano_flush,
(H5C_dest_func_t)nano_dest,
(H5C_clear_func_t)nano_clear,
(H5C_size_func_t)nano_size
},
{
MICRO_ENTRY_TYPE,
(H5C_load_func_t)micro_load,
(H5C_flush_func_t)micro_flush,
(H5C_dest_func_t)micro_dest,
(H5C_clear_func_t)micro_clear,
(H5C_size_func_t)micro_size
},
{
TINY_ENTRY_TYPE,
(H5C_load_func_t)tiny_load,
(H5C_flush_func_t)tiny_flush,
(H5C_dest_func_t)tiny_dest,
(H5C_clear_func_t)tiny_clear,
(H5C_size_func_t)tiny_size
},
{
SMALL_ENTRY_TYPE,
(H5C_load_func_t)small_load,
(H5C_flush_func_t)small_flush,
(H5C_dest_func_t)small_dest,
(H5C_clear_func_t)small_clear,
(H5C_size_func_t)small_size
},
{
MEDIUM_ENTRY_TYPE,
(H5C_load_func_t)medium_load,
(H5C_flush_func_t)medium_flush,
(H5C_dest_func_t)medium_dest,
(H5C_clear_func_t)medium_clear,
(H5C_size_func_t)medium_size
},
{
LARGE_ENTRY_TYPE,
(H5C_load_func_t)large_load,
(H5C_flush_func_t)large_flush,
(H5C_dest_func_t)large_dest,
(H5C_clear_func_t)large_clear,
(H5C_size_func_t)large_size
},
{
HUGE_ENTRY_TYPE,
(H5C_load_func_t)huge_load,
(H5C_flush_func_t)huge_flush,
(H5C_dest_func_t)huge_dest,
(H5C_clear_func_t)huge_clear,
(H5C_size_func_t)huge_size
},
{
MONSTER_ENTRY_TYPE,
(H5C_load_func_t)monster_load,
(H5C_flush_func_t)monster_flush,
(H5C_dest_func_t)monster_dest,
(H5C_clear_func_t)monster_clear,
(H5C_size_func_t)monster_size
}
};
/* private function declarations: */
static void addr_to_type_and_index(haddr_t addr,
int32_t * type_ptr,
int32_t * index_ptr);
#if 0 /* keep this for a while -- it may be useful */
static haddr_t type_and_index_to_addr(int32_t type,
int32_t idx);
#endif
static void insert_entry(H5C_t * cache_ptr,
int32_t type,
int32_t idx,
hbool_t dirty,
unsigned int flags);
static void rename_entry(H5C_t * cache_ptr,
int32_t type,
int32_t idx,
hbool_t main_addr);
static void protect_entry(H5C_t * cache_ptr,
int32_t type,
int32_t idx);
hbool_t entry_in_cache(H5C_t * cache_ptr,
int32_t type,
int32_t idx);
static void reset_entries(void);
static H5C_t * setup_cache(size_t max_cache_size, size_t min_clean_size);
static void row_major_scan_forward(H5C_t * cache_ptr,
int32_t lag,
hbool_t verbose,
hbool_t reset_stats,
hbool_t display_stats,
hbool_t display_detailed_stats,
hbool_t do_inserts,
hbool_t dirty_inserts,
hbool_t do_renames,
hbool_t rename_to_main_addr,
hbool_t do_destroys,
int dirty_destroys,
int dirty_unprotects);
static void hl_row_major_scan_forward(H5C_t * cache_ptr,
int32_t max_index,
hbool_t verbose,
hbool_t reset_stats,
hbool_t display_stats,
hbool_t display_detailed_stats,
hbool_t do_inserts,
hbool_t dirty_inserts);
static void row_major_scan_backward(H5C_t * cache_ptr,
int32_t lag,
hbool_t verbose,
hbool_t reset_stats,
hbool_t display_stats,
hbool_t display_detailed_stats,
hbool_t do_inserts,
hbool_t dirty_inserts,
hbool_t do_renames,
hbool_t rename_to_main_addr,
hbool_t do_destroys,
int dirty_destroys,
int dirty_unprotects);
static void hl_row_major_scan_backward(H5C_t * cache_ptr,
int32_t max_index,
hbool_t verbose,
hbool_t reset_stats,
hbool_t display_stats,
hbool_t display_detailed_stats,
hbool_t do_inserts,
hbool_t dirty_inserts);
static void col_major_scan_forward(H5C_t * cache_ptr,
int32_t lag,
hbool_t verbose,
hbool_t reset_stats,
hbool_t display_stats,
hbool_t display_detailed_stats,
hbool_t do_inserts,
hbool_t dirty_inserts,
int dirty_unprotects);
static void hl_col_major_scan_forward(H5C_t * cache_ptr,
int32_t max_index,
hbool_t verbose,
hbool_t reset_stats,
hbool_t display_stats,
hbool_t display_detailed_stats,
hbool_t do_inserts,
hbool_t dirty_inserts,
int dirty_unprotects);
static void col_major_scan_backward(H5C_t * cache_ptr,
int32_t lag,
hbool_t verbose,
hbool_t reset_stats,
hbool_t display_stats,
hbool_t display_detailed_stats,
hbool_t do_inserts,
hbool_t dirty_inserts,
int dirty_unprotects);
static void hl_col_major_scan_backward(H5C_t * cache_ptr,
int32_t max_index,
hbool_t verbose,
hbool_t reset_stats,
hbool_t display_stats,
hbool_t display_detailed_stats,
hbool_t do_inserts,
hbool_t dirty_inserts,
int dirty_unprotects);
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_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__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_protected_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_protect_err(void);
static void check_double_unprotect_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);
static void takedown_cache(H5C_t * cache_ptr,
hbool_t dump_stats,
hbool_t dump_detailed_stats);
static void flush_cache(H5C_t * cache_ptr,
hbool_t destroy_entries,
hbool_t dump_stats,
hbool_t dump_detailed_stats);
static void unprotect_entry(H5C_t * cache_ptr,
int32_t type,
int32_t idx,
int dirty,
unsigned int flags);
static void verify_clean(void);
static void verify_unprotected(void);
static void check_fapl_mdc_api_calls(void);
static void validate_mdc_config(hid_t file_id,
H5AC_cache_config_t * ext_config_ptr,
hbool_t compare_init,
int test_num);
static void check_file_mdc_api_calls(void);
static void check_and_validate_cache_hit_rate(hid_t file_id,
double * hit_rate_ptr,
hbool_t dump_data,
int64_t min_accesses,
double min_hit_rate);
static void check_and_validate_cache_size(hid_t file_id,
size_t * max_size_ptr,
size_t * min_clean_size_ptr,
size_t * cur_size_ptr,
int32_t * cur_num_entries_ptr,
hbool_t dump_data);
static void mdc_api_call_smoke_check(void);
static void check_fapl_mdc_api_errs(void);
static void check_file_mdc_api_errs(void);
/* address translation funtions: */
/*-------------------------------------------------------------------------
* Function: addr_to_type_and_index
*
* Purpose: Given an address, compute the type and index of the
* associated entry.
*
* Return: void
*
* Programmer: John Mainzer
* 6/10/04
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static void
addr_to_type_and_index(haddr_t addr,
int32_t * type_ptr,
int32_t * index_ptr)
{
int i;
int32_t type;
int32_t idx;
HDassert( type_ptr );
HDassert( index_ptr );
/* we only have a small number of entry types, so just do a
* linear search. If NUMBER_OF_ENTRY_TYPES grows, we may want
* to do a binary search instead.
*/
i = 1;
if ( addr >= PICO_ALT_BASE_ADDR ) {
while ( ( i < NUMBER_OF_ENTRY_TYPES ) &&
( addr >= alt_base_addrs[i] ) )
{
i++;
}
} else {
while ( ( i < NUMBER_OF_ENTRY_TYPES ) &&
( addr >= base_addrs[i] ) )
{
i++;
}
}
type = i - 1;
HDassert( ( type >= 0 ) && ( type < NUMBER_OF_ENTRY_TYPES ) );
if ( addr >= PICO_ALT_BASE_ADDR ) {
idx = (addr - alt_base_addrs[type]) / entry_sizes[type];
HDassert( !((entries[type])[idx].at_main_addr) );
HDassert( addr == (entries[type])[idx].alt_addr );
} else {
idx = (addr - base_addrs[type]) / entry_sizes[type];
HDassert( (entries[type])[idx].at_main_addr );
HDassert( addr == (entries[type])[idx].main_addr );
}
HDassert( ( idx >= 0 ) && ( idx <= max_indices[type] ) );
HDassert( addr == (entries[type])[idx].addr );
*type_ptr = type;
*index_ptr = idx;
return;
} /* addr_to_type_and_index() */
#if 0 /* This function has never been used, but we may want it
* some time. Lets keep it for now.
*/
/*-------------------------------------------------------------------------
* Function: type_and_index_to_addr
*
* Purpose: Given a type and index of an entry, compute the associated
* addr and return that value.
*
* Return: computed addr
*
* Programmer: John Mainzer
* 6/10/04
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static haddr_t
type_and_index_to_addr(int32_t type,
int32_t idx)
{
haddr_t addr;
HDassert( ( type >= 0 ) && ( type < NUMBER_OF_ENTRY_TYPES ) );
HDassert( ( idx >= 0 ) && ( idx <= max_indices[type] ) );
addr = base_addrs[type] + (((haddr_t)idx) * entry_sizes[type]);
HDassert( addr == (entries[type])[idx].addr );
if ( (entries[type])[idx].at_main_addr ) {
HDassert( addr == (entries[type])[idx].main_addr );
} else {
HDassert( addr == (entries[type])[idx].alt_addr );
}
return(addr);
} /* type_and_index_to_addr() */
#endif
/* Call back functions: */
/*-------------------------------------------------------------------------
*
* Function: H5AC_check_if_write_permitted
*
* Purpose: Determine if a write is permitted under the current
* circumstances, and set *write_permitted_ptr accordingly.
* As a general rule it is, but when we are running in parallel
* mode with collective I/O, we must ensure that a read cannot
* cause a write.
*
* In the event of failure, the value of *write_permitted_ptr
* is undefined.
*
* Return: Non-negative on success/Negative on failure.
*
* Programmer: John Mainzer, 5/15/04
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static herr_t
check_write_permitted(const H5F_t UNUSED * f,
hid_t UNUSED dxpl_id,
hbool_t * write_permitted_ptr)
{
HDassert( write_permitted_ptr );
*write_permitted_ptr = write_permitted;
return(SUCCEED);
} /* check_write_permitted() */
/*-------------------------------------------------------------------------
* Function: clear & friends
*
* Purpose: clear the entry. The helper functions verify that the
* correct version of clear is being called, and then call
* clear proper.
*
* Return: SUCCEED
*
* Programmer: John Mainzer
* 6/10/04
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static herr_t
clear(H5F_t * f,
void * thing,
hbool_t dest)
{
test_entry_t * entry_ptr;
test_entry_t * base_addr;
HDassert( thing );
entry_ptr = (test_entry_t *)thing;
base_addr = entries[entry_ptr->type];
HDassert( entry_ptr->index >= 0 );
HDassert( entry_ptr->index <= max_indices[entry_ptr->type] );
HDassert( entry_ptr == &(base_addr[entry_ptr->index]) );
HDassert( entry_ptr == entry_ptr->self );
HDassert( entry_ptr->header.addr == entry_ptr->addr );
HDassert( entry_ptr->header.size == entry_ptr->size );
HDassert( entry_ptr->size == entry_sizes[entry_ptr->type] );
entry_ptr->header.is_dirty = FALSE;
entry_ptr->is_dirty = FALSE;
entry_ptr->cleared = TRUE;
if ( dest ) {
destroy(f, thing);
}
return(SUCCEED);
} /* clear() */
herr_t
pico_clear(H5F_t * f, void * thing, hbool_t dest)
{
HDassert ( ((test_entry_t *)thing)->type == PICO_ENTRY_TYPE );
return(clear(f, thing, dest));
}
herr_t
nano_clear(H5F_t * f, void * thing, hbool_t dest)
{
HDassert ( ((test_entry_t *)thing)->type == NANO_ENTRY_TYPE );
return(clear(f, thing, dest));
}
herr_t
micro_clear(H5F_t * f, void * thing, hbool_t dest)
{
HDassert ( ((test_entry_t *)thing)->type == MICRO_ENTRY_TYPE );
return(clear(f, thing, dest));
}
herr_t
tiny_clear(H5F_t * f, void * thing, hbool_t dest)
{
HDassert ( ((test_entry_t *)thing)->type == TINY_ENTRY_TYPE );
return(clear(f, thing, dest));
}
herr_t
small_clear(H5F_t * f, void * thing, hbool_t dest)
{
HDassert ( ((test_entry_t *)thing)->type == SMALL_ENTRY_TYPE );
return(clear(f, thing, dest));
}
herr_t
medium_clear(H5F_t * f, void * thing, hbool_t dest)
{
HDassert ( ((test_entry_t *)thing)->type == MEDIUM_ENTRY_TYPE );
return(clear(f, thing, dest));
}
herr_t
large_clear(H5F_t * f, void * thing, hbool_t dest)
{
HDassert ( ((test_entry_t *)thing)->type == LARGE_ENTRY_TYPE );
return(clear(f, thing, dest));
}
herr_t
huge_clear(H5F_t * f, void * thing, hbool_t dest)
{
HDassert ( ((test_entry_t *)thing)->type == HUGE_ENTRY_TYPE );
return(clear(f, thing, dest));
}
herr_t
monster_clear(H5F_t * f, void * thing, hbool_t dest)
{
HDassert ( ((test_entry_t *)thing)->type == MONSTER_ENTRY_TYPE );
return(clear(f, thing, dest));
}
/*-------------------------------------------------------------------------
* Function: dest & friends
*
* Purpose: Destroy the entry. The helper functions verify that the
* correct version of dest is being called, and then call
* dest proper.
*
* Return: SUCCEED
*
* Programmer: John Mainzer
* 6/10/04
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static herr_t
destroy(H5F_t UNUSED * f,
void * thing)
{
test_entry_t * entry_ptr;
test_entry_t * base_addr;
HDassert( thing );
entry_ptr = (test_entry_t *)thing;
base_addr = entries[entry_ptr->type];
HDassert ( entry_ptr->index >= 0 );
HDassert ( entry_ptr->index <= max_indices[entry_ptr->type] );
HDassert( entry_ptr == &(base_addr[entry_ptr->index]) );
HDassert( entry_ptr == entry_ptr->self );
HDassert( entry_ptr->header.addr == entry_ptr->addr );
HDassert( entry_ptr->header.size == entry_ptr->size );
HDassert( entry_ptr->size == entry_sizes[entry_ptr->type] );
HDassert( !(entry_ptr->is_dirty) );
HDassert( !(entry_ptr->header.is_dirty) );
entry_ptr->destroyed = TRUE;
return(SUCCEED);
} /* dest() */
herr_t
pico_dest(H5F_t * f, void * thing)
{
HDassert ( ((test_entry_t *)thing)->type == PICO_ENTRY_TYPE );
return(destroy(f, thing));
}
herr_t
nano_dest(H5F_t * f, void * thing)
{
HDassert ( ((test_entry_t *)thing)->type == NANO_ENTRY_TYPE );
return(destroy(f, thing));
}
herr_t
micro_dest(H5F_t * f, void * thing)
{
HDassert ( ((test_entry_t *)thing)->type == MICRO_ENTRY_TYPE );
return(destroy(f, thing));
}
herr_t
tiny_dest(H5F_t * f, void * thing)
{
HDassert ( ((test_entry_t *)thing)->type == TINY_ENTRY_TYPE );
return(destroy(f, thing));
}
herr_t
small_dest(H5F_t * f, void * thing)
{
HDassert ( ((test_entry_t *)thing)->type == SMALL_ENTRY_TYPE );
return(destroy(f, thing));
}
herr_t
medium_dest(H5F_t * f, void * thing)
{
HDassert ( ((test_entry_t *)thing)->type == MEDIUM_ENTRY_TYPE );
return(destroy(f, thing));
}
herr_t
large_dest(H5F_t * f, void * thing)
{
HDassert ( ((test_entry_t *)thing)->type == LARGE_ENTRY_TYPE );
return(destroy(f, thing));
}
herr_t
huge_dest(H5F_t * f, void * thing)
{
HDassert ( ((test_entry_t *)thing)->type == HUGE_ENTRY_TYPE );
return(destroy(f, thing));
}
herr_t
monster_dest(H5F_t * f, void * thing)
{
HDassert ( ((test_entry_t *)thing)->type == MONSTER_ENTRY_TYPE );
return(destroy(f, thing));
}
/*-------------------------------------------------------------------------
* Function: flush & friends
*
* Purpose: flush the entry and mark it as clean. The helper functions
* verify that the correct version of flush is being called,
* and then call flush proper.
*
* Return: SUCCEED
*
* Programmer: John Mainzer
* 6/10/04
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static herr_t
flush(H5F_t *f,
hid_t UNUSED dxpl_id,
hbool_t dest,
haddr_t addr,
void *thing)
{
test_entry_t * entry_ptr;
test_entry_t * base_addr;
HDassert( thing );
entry_ptr = (test_entry_t *)thing;
base_addr = entries[entry_ptr->type];
HDassert( entry_ptr->index >= 0 );
HDassert( entry_ptr->index <= max_indices[entry_ptr->type] );
HDassert( entry_ptr == &(base_addr[entry_ptr->index]) );
HDassert( entry_ptr == entry_ptr->self );
HDassert( entry_ptr->header.addr == entry_ptr->addr );
HDassert( entry_ptr->addr == addr );
HDassert( entry_ptr->header.size == entry_ptr->size );
HDassert( entry_ptr->size == entry_sizes[entry_ptr->type] );
HDassert( entry_ptr->header.is_dirty == entry_ptr->is_dirty );
entry_ptr->flushed = TRUE;
if ( ( ! write_permitted ) && ( entry_ptr->is_dirty ) ) {
pass = FALSE;
failure_mssg = "called flush when write_permitted is FALSE.";
}
if ( entry_ptr->is_dirty ) {
(entry_ptr->writes)++;
entry_ptr->is_dirty = FALSE;
entry_ptr->header.is_dirty = FALSE;
}
if ( dest ) {
destroy(f, thing);
}
return(SUCCEED);
} /* flush() */
herr_t
pico_flush(H5F_t *f, hid_t dxpl_id, hbool_t dest, haddr_t addr, void *thing)
{
HDassert ( ((test_entry_t *)thing)->type == PICO_ENTRY_TYPE );
return(flush(f, dxpl_id, dest, addr, thing));
}
herr_t
nano_flush(H5F_t *f, hid_t dxpl_id, hbool_t dest, haddr_t addr, void *thing)
{
HDassert ( ((test_entry_t *)thing)->type == NANO_ENTRY_TYPE );
return(flush(f, dxpl_id, dest, addr, thing));
}
herr_t
micro_flush(H5F_t *f, hid_t dxpl_id, hbool_t dest, haddr_t addr, void *thing)
{
HDassert ( ((test_entry_t *)thing)->type == MICRO_ENTRY_TYPE );
return(flush(f, dxpl_id, dest, addr, thing));
}
herr_t
tiny_flush(H5F_t *f, hid_t dxpl_id, hbool_t dest, haddr_t addr, void *thing)
{
HDassert ( ((test_entry_t *)thing)->type == TINY_ENTRY_TYPE );
return(flush(f, dxpl_id, dest, addr, thing));
}
herr_t
small_flush(H5F_t *f, hid_t dxpl_id, hbool_t dest, haddr_t addr, void *thing)
{
HDassert ( ((test_entry_t *)thing)->type == SMALL_ENTRY_TYPE );
return(flush(f, dxpl_id, dest, addr, thing));
}
herr_t
medium_flush(H5F_t *f, hid_t dxpl_id, hbool_t dest, haddr_t addr, void *thing)
{
HDassert ( ((test_entry_t *)thing)->type == MEDIUM_ENTRY_TYPE );
return(flush(f, dxpl_id, dest, addr, thing));
}
herr_t
large_flush(H5F_t *f, hid_t dxpl_id, hbool_t dest, haddr_t addr, void *thing)
{
HDassert ( ((test_entry_t *)thing)->type == LARGE_ENTRY_TYPE );
return(flush(f, dxpl_id, dest, addr, thing));
}
herr_t
huge_flush(H5F_t *f, hid_t dxpl_id, hbool_t dest, haddr_t addr, void *thing)
{
HDassert ( ((test_entry_t *)thing)->type == HUGE_ENTRY_TYPE );
return(flush(f, dxpl_id, dest, addr, thing));
}
herr_t
monster_flush(H5F_t *f, hid_t dxpl_id, hbool_t dest, haddr_t addr, void *thing)
{
HDassert ( ((test_entry_t *)thing)->type == MONSTER_ENTRY_TYPE );
return(flush(f, dxpl_id, dest, addr, thing));
}
/*-------------------------------------------------------------------------
* Function: load & friends
*
* Purpose: "load" the requested entry and mark it as clean. The
* helper functions verify that the correct version of load
* is being called, and then call load proper.
*
* Return: SUCCEED
*
* Programmer: John Mainzer
* 6/10/04
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static void *
load(H5F_t UNUSED *f,
hid_t UNUSED dxpl_id,
haddr_t addr,
const void UNUSED *udata1,
void UNUSED *udata2)
{
int32_t type;
int32_t idx;
test_entry_t * entry_ptr;
test_entry_t * base_addr;
addr_to_type_and_index(addr, &type, &idx);
base_addr = entries[type];
entry_ptr = &(base_addr[idx]);
HDassert( entry_ptr->type == type );
HDassert( entry_ptr->type >= 0 );
HDassert( entry_ptr->type < NUMBER_OF_ENTRY_TYPES );
HDassert( entry_ptr->index == idx );
HDassert( entry_ptr->index >= 0 );
HDassert( entry_ptr->index <= max_indices[type] );
HDassert( entry_ptr == entry_ptr->self );
HDassert( entry_ptr->addr == addr );
HDassert( entry_ptr->size == entry_sizes[type] );
entry_ptr->loaded = TRUE;
entry_ptr->header.is_dirty = FALSE;
entry_ptr->is_dirty = FALSE;
(entry_ptr->reads)++;
return(entry_ptr);
} /* load() */
void *
pico_load(H5F_t *f, hid_t dxpl_id, haddr_t addr,
const void *udata1, void *udata2)
{
return(load(f, dxpl_id, addr, udata1, udata2));
}
void *
nano_load(H5F_t *f, hid_t dxpl_id, haddr_t addr,
const void *udata1, void *udata2)
{
return(load(f, dxpl_id, addr, udata1, udata2));
}
void *
micro_load(H5F_t *f, hid_t dxpl_id, haddr_t addr,
const void *udata1, void *udata2)
{
return(load(f, dxpl_id, addr, udata1, udata2));
}
void *
tiny_load(H5F_t *f, hid_t dxpl_id, haddr_t addr,
const void *udata1, void *udata2)
{
return(load(f, dxpl_id, addr, udata1, udata2));
}
void *
small_load(H5F_t *f, hid_t dxpl_id, haddr_t addr,
const void *udata1, void *udata2)
{
return(load(f, dxpl_id, addr, udata1, udata2));
}
void *
medium_load(H5F_t *f, hid_t dxpl_id, haddr_t addr,
const void *udata1, void *udata2)
{
return(load(f, dxpl_id, addr, udata1, udata2));
}
void *
large_load(H5F_t *f, hid_t dxpl_id, haddr_t addr,
const void *udata1, void *udata2)
{
return(load(f, dxpl_id, addr, udata1, udata2));
}
void *
huge_load(H5F_t *f, hid_t dxpl_id, haddr_t addr,
const void *udata1, void *udata2)
{
return(load(f, dxpl_id, addr, udata1, udata2));
}
void *
monster_load(H5F_t *f, hid_t dxpl_id, haddr_t addr,
const void *udata1, void *udata2)
{
return(load(f, dxpl_id, addr, udata1, udata2));
}
/*-------------------------------------------------------------------------
* Function: size & friends
*
* Purpose: Get the size of the specified entry. The helper functions
* verify that the correct version of size is being called,
* and then call size proper.
*
* Return: SUCCEED
*
* Programmer: John Mainzer
* 6/10/04
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static herr_t
size(H5F_t UNUSED * f,
void * thing,
size_t * size_ptr)
{
test_entry_t * entry_ptr;
test_entry_t * base_addr;
HDassert( size_ptr );
HDassert( thing );
entry_ptr = (test_entry_t *)thing;
base_addr = entries[entry_ptr->type];
HDassert( entry_ptr->index >= 0 );
HDassert( entry_ptr->index <= max_indices[entry_ptr->type] );
HDassert( entry_ptr == &(base_addr[entry_ptr->index]) );
HDassert( entry_ptr == entry_ptr->self );
HDassert( entry_ptr->header.addr == entry_ptr->addr );
HDassert( entry_ptr->size == entry_sizes[entry_ptr->type] );
*size_ptr = entry_ptr->size;
return(SUCCEED);
} /* size() */
herr_t
pico_size(H5F_t * f, void * thing, size_t * size_ptr)
{
HDassert ( ((test_entry_t *)thing)->type == PICO_ENTRY_TYPE );
return(size(f, thing, size_ptr));
}
herr_t
nano_size(H5F_t * f, void * thing, size_t * size_ptr)
{
HDassert ( ((test_entry_t *)thing)->type == NANO_ENTRY_TYPE );
return(size(f, thing, size_ptr));
}
herr_t
micro_size(H5F_t * f, void * thing, size_t * size_ptr)
{
HDassert ( ((test_entry_t *)thing)->type == MICRO_ENTRY_TYPE );
return(size(f, thing, size_ptr));
}
herr_t
tiny_size(H5F_t * f, void * thing, size_t * size_ptr)
{
HDassert ( ((test_entry_t *)thing)->type == TINY_ENTRY_TYPE );
return(size(f, thing, size_ptr));
}
herr_t
small_size(H5F_t * f, void * thing, size_t * size_ptr)
{
HDassert ( ((test_entry_t *)thing)->type == SMALL_ENTRY_TYPE );
return(size(f, thing, size_ptr));
}
herr_t
medium_size(H5F_t * f, void * thing, size_t * size_ptr)
{
HDassert ( ((test_entry_t *)thing)->type == MEDIUM_ENTRY_TYPE );
return(size(f, thing, size_ptr));
}
herr_t
large_size(H5F_t * f, void * thing, size_t * size_ptr)
{
HDassert ( ((test_entry_t *)thing)->type == LARGE_ENTRY_TYPE );
return(size(f, thing, size_ptr));
}
herr_t
huge_size(H5F_t * f, void * thing, size_t * size_ptr)
{
HDassert ( ((test_entry_t *)thing)->type == HUGE_ENTRY_TYPE );
return(size(f, thing, size_ptr));
}
herr_t
monster_size(H5F_t * f, void * thing, size_t * size_ptr)
{
HDassert ( ((test_entry_t *)thing)->type == MONSTER_ENTRY_TYPE );
return(size(f, thing, size_ptr));
}
/**************************************************************************/
/**************************************************************************/
/************************** test utility functions: ***********************/
/**************************************************************************/
/**************************************************************************/
/*-------------------------------------------------------------------------
* Function: entry_in_cache
*
* Purpose: Given a pointer to a cache, an entry type, and an index,
* determine if the entry is currently in the cache.
*
* Return: TRUE if the entry is in the cache, and FALSE otherwise.
*
* Programmer: John Mainzer
* 6/10/04
*
* Modifications:
*
* JRM - 10/12/04
* Removed references to local_H5C_t, as we now get direct
* access to the definition of H5C_t via H5Cpkg.h.
*
*-------------------------------------------------------------------------
*/
hbool_t
entry_in_cache(H5C_t * cache_ptr,
int32_t type,
int32_t idx)
{
hbool_t in_cache = FALSE; /* will set to TRUE if necessary */
test_entry_t * base_addr;
test_entry_t * entry_ptr;
H5C_cache_entry_t * test_ptr = NULL;
HDassert( cache_ptr );
HDassert( ( 0 <= type ) && ( type < NUMBER_OF_ENTRY_TYPES ) );
HDassert( ( 0 <= idx ) && ( idx <= max_indices[type] ) );
base_addr = entries[type];
entry_ptr = &(base_addr[idx]);
HDassert( entry_ptr->index == idx );
HDassert( entry_ptr->type == type );
HDassert( entry_ptr == entry_ptr->self );
H5C__SEARCH_INDEX(cache_ptr, entry_ptr->addr, test_ptr)
if ( test_ptr != NULL ) {
in_cache = TRUE;
HDassert( test_ptr == (H5C_cache_entry_t *)entry_ptr );
HDassert( entry_ptr->addr == entry_ptr->header.addr );
}
return(in_cache);
} /* entry_in_cache() */
/*-------------------------------------------------------------------------
* Function: reset_entries
*
* Purpose: reset the contents of the entries arrays to know values.
*
* Return: void
*
* Programmer: John Mainzer
* 6/10/04
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static void
reset_entries(void)
{
int i;
int j;
int32_t max_index;
haddr_t addr = 0;
haddr_t alt_addr = PICO_ALT_BASE_ADDR;
size_t entry_size;
test_entry_t * base_addr;
for ( i = 0; i < NUMBER_OF_ENTRY_TYPES; i++ )
{
entry_size = entry_sizes[i];
max_index = max_indices[i];
base_addr = entries[i];
HDassert( base_addr );
for ( j = 0; j <= max_index; j++ )
{
/* one can argue that we should fill the header with garbage.
* If this is desired, we can simply comment out the header
* initialization - the headers will be full of garbage soon
* enough.
*/
base_addr[j].header.addr = (haddr_t)0;
base_addr[j].header.size = (size_t)0;
base_addr[j].header.type = NULL;
base_addr[j].header.is_dirty = FALSE;
base_addr[j].header.is_protected = FALSE;
base_addr[j].header.next = NULL;
base_addr[j].header.prev = NULL;
base_addr[j].header.aux_next = NULL;
base_addr[j].header.aux_prev = NULL;
base_addr[j].self = &(base_addr[j]);
base_addr[j].addr = addr;
base_addr[j].at_main_addr = TRUE;
base_addr[j].main_addr = addr;
base_addr[j].alt_addr = alt_addr;
base_addr[j].size = entry_size;
base_addr[j].type = i;
base_addr[j].index = j;
base_addr[j].reads = 0;
base_addr[j].writes = 0;
base_addr[j].is_dirty = FALSE;
base_addr[j].is_protected = FALSE;
base_addr[j].loaded = FALSE;
base_addr[j].cleared = FALSE;
base_addr[j].flushed = FALSE;
base_addr[j].destroyed = FALSE;
addr += (haddr_t)entry_size;
alt_addr += (haddr_t)entry_size;
}
}
return;
} /* reset_entries() */
/*-------------------------------------------------------------------------
* Function: verify_clean
*
* Purpose: Verify that all cache entries are marked as clean. If any
* are not, set pass to FALSE.
*
* Do nothing if pass is FALSE on entry.
*
* Return: void
*
* Programmer: John Mainzer
* 6/10/04
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static void
verify_clean(void)
{
int i;
int j;
int dirty_count = 0;
int32_t max_index;
test_entry_t * base_addr;
if ( pass ) {
for ( i = 0; i < NUMBER_OF_ENTRY_TYPES; i++ )
{
max_index = max_indices[i];
base_addr = entries[i];
HDassert( base_addr );
for ( j = 0; j <= max_index; j++ )
{
if ( ( base_addr[j].header.is_dirty ) || ( base_addr[j].is_dirty ) ) {
dirty_count++;
}
}
}
if ( dirty_count > 0 ) {
pass = FALSE;
failure_mssg = "verify_clean() found dirty entry(s).";
}
}
return;
} /* verify_clean() */
/*-------------------------------------------------------------------------
* Function: verify_unprotected
*
* Purpose: Verify that no cache entries are marked as protected. If
* any are, set pass to FALSE.
*
* Do nothing if pass is FALSE on entry.
*
* Return: void
*
* Programmer: John Mainzer
* 6/10/04
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static void
verify_unprotected(void)
{
int i;
int j;
int protected_count = 0;
int32_t max_index;
test_entry_t * base_addr;
if ( pass ) {
for ( i = 0; i < NUMBER_OF_ENTRY_TYPES; i++ )
{
max_index = max_indices[i];
base_addr = entries[i];
HDassert( base_addr );
for ( j = 0; j <= max_index; j++ )
{
HDassert( base_addr[j].header.is_protected ==
base_addr[j].is_protected );
if ( ( base_addr[j].header.is_protected ) ||
( base_addr[j].is_protected ) ) {
protected_count++;
}
}
}
if ( protected_count > 0 ) {
pass = FALSE;
failure_mssg = "verify_unprotected() found protected entry(s).";
}
}
return;
} /* verify_unprotected() */
/*-------------------------------------------------------------------------
* Function: setup_cache()
*
* Purpose: Allocate a cache of the desired size and configure it for
* use in the test bed. Return a pointer to the new cache
* structure.
*
* Return: Pointer to new cache, or NULL on failure.
*
* Programmer: John Mainzer
* 6/11/04
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static H5C_t *
setup_cache(size_t max_cache_size,
size_t min_clean_size)
{
H5C_t * cache_ptr = NULL;
cache_ptr = H5C_create(max_cache_size,
min_clean_size,
(NUMBER_OF_ENTRY_TYPES - 1),
(const char **)entry_type_names,
check_write_permitted,
TRUE,
NULL,
NULL);
if ( cache_ptr == NULL ) {
pass = FALSE;
failure_mssg = "H5C_create() returned NULL.";
} else {
H5C_set_skip_flags(cache_ptr, TRUE, TRUE);
}
return(cache_ptr);
} /* setup_cache() */
/*-------------------------------------------------------------------------
* Function: takedown_cache()
*
* Purpose: Flush the specified cache and disable it. If requested,
* dump stats first. If pass is FALSE, do nothing.
*
* Return: void
*
* Programmer: John Mainzer
* 6/11/04
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static void
takedown_cache(H5C_t * cache_ptr,
hbool_t dump_stats,
hbool_t dump_detailed_stats)
{
HDassert(cache_ptr);
if ( pass ) {
if ( dump_stats ) {
H5C_stats(cache_ptr, "test cache", dump_detailed_stats);
}
H5C_dest(NULL, -1, -1, cache_ptr);
}
return;
} /* takedown_cache() */
/*-------------------------------------------------------------------------
* Function: flush_cache()
*
* Purpose: Flush the specified cache, destroying all entries if
requested. If requested, dump stats first.
*
* Return: void
*
* Programmer: John Mainzer
* 6/23/04
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static void
flush_cache(H5C_t * cache_ptr,
hbool_t destroy_entries,
hbool_t dump_stats,
hbool_t dump_detailed_stats)
{
herr_t result = 0;
HDassert(cache_ptr);
verify_unprotected();
if ( pass ) {
if ( destroy_entries ) {
result = H5C_flush_cache(NULL, -1, -1, cache_ptr,
H5C__FLUSH_INVALIDATE_FLAG);
} else {
result = H5C_flush_cache(NULL, -1, -1, cache_ptr,
H5C__NO_FLAGS_SET);
}
}
if ( dump_stats ) {
H5C_stats(cache_ptr, "test cache", dump_detailed_stats);
}
if ( result < 0 ) {
pass = FALSE;
failure_mssg = "error in H5C_flush_cache().";
}
return;
} /* flush_cache() */
/*-------------------------------------------------------------------------
* Function: insert_entry()
*
* Purpose: Insert the entry indicated by the type and index. Mark
* it clean or dirty as indicated.
*
* Note that I don't see much practical use for inserting
* a clean entry, but the interface permits it so we should
* test it.
*
* Do nothing if pass is false.
*
* Return: void
*
* Programmer: John Mainzer
* 6/16/04
*
* Modifications:
*
* JRM -- 1/13/05
* Updated function for the flags parameter in
* H5C_insert_entry(), and to allow access to this parameter.
*
* JRM -- 6/17/05
* The interface no longer permits clean inserts.
* Accordingly, the dirty parameter is no longer meaningfull.
*
*-------------------------------------------------------------------------
*/
static void
insert_entry(H5C_t * cache_ptr,
int32_t type,
int32_t idx,
hbool_t dirty,
unsigned int flags)
{
herr_t result;
test_entry_t * base_addr;
test_entry_t * entry_ptr;
if ( pass ) {
HDassert( cache_ptr );
HDassert( ( 0 <= type ) && ( type < NUMBER_OF_ENTRY_TYPES ) );
HDassert( ( 0 <= idx ) && ( idx <= max_indices[type] ) );
base_addr = entries[type];
entry_ptr = &(base_addr[idx]);
HDassert( entry_ptr->index == idx );
HDassert( entry_ptr->type == type );
HDassert( entry_ptr == entry_ptr->self );
HDassert( !(entry_ptr->is_protected) );
entry_ptr->is_dirty = TRUE;
result = H5C_insert_entry(NULL, -1, -1, cache_ptr, &(types[type]),
entry_ptr->addr, (void *)entry_ptr, flags);
if ( ( result < 0 ) ||
( entry_ptr->header.is_protected ) ||
( entry_ptr->header.type != &(types[type]) ) ||
( entry_ptr->size != entry_ptr->header.size ) ||
( entry_ptr->addr != entry_ptr->header.addr ) ) {
pass = FALSE;
failure_mssg = "error in H5C_insert().";
#if 0
/* This is useful debugging code. Lets keep it around. */
HDfprintf(stdout, "result = %d\n", (int)result);
HDfprintf(stdout, "entry_ptr->header.is_protected = %d\n",
(int)(entry_ptr->header.is_protected));
HDfprintf(stdout, "entry_ptr->header.type != &(types[type]) = %d\n",
(int)(entry_ptr->header.type != &(types[type])));
HDfprintf(stdout,
"entry_ptr->size != entry_ptr->header.size = %d\n",
(int)(entry_ptr->size != entry_ptr->header.size));
HDfprintf(stdout,
"entry_ptr->addr != entry_ptr->header.addr = %d\n",
(int)(entry_ptr->addr != entry_ptr->header.addr));
#endif
}
HDassert( entry_ptr->header.is_dirty );
HDassert( ((entry_ptr->header).type)->id == type );
}
return;
} /* insert_entry() */
/*-------------------------------------------------------------------------
* Function: rename_entry()
*
* Purpose: Rename the entry indicated by the type and index to its
* main or alternate address as indicated. If the entry is
* already at the desired entry, do nothing.
*
* Return: void
*
* Programmer: John Mainzer
* 6/21/04
*
* Modifications:
*
* JRM -- 6/17/05
* Updated code to reflect the fact that renames automatically
* dirty entries.
*
*-------------------------------------------------------------------------
*/
static void
rename_entry(H5C_t * cache_ptr,
int32_t type,
int32_t idx,
hbool_t main_addr)
{
herr_t result;
hbool_t done = TRUE; /* will set to FALSE if we have work to do */
haddr_t old_addr = HADDR_UNDEF;
haddr_t new_addr = HADDR_UNDEF;
test_entry_t * base_addr;
test_entry_t * entry_ptr;
HDassert( cache_ptr );
HDassert( ( 0 <= type ) && ( type < NUMBER_OF_ENTRY_TYPES ) );
HDassert( ( 0 <= idx ) && ( idx <= max_indices[type] ) );
base_addr = entries[type];
entry_ptr = &(base_addr[idx]);
HDassert( entry_ptr->index == idx );
HDassert( entry_ptr->type == type );
HDassert( entry_ptr == entry_ptr->self );
HDassert( !(entry_ptr->is_protected) );
HDassert( !(entry_ptr->header.is_protected) );
if ( entry_ptr->at_main_addr && !main_addr ) {
/* rename to alt addr */
HDassert( entry_ptr->addr == entry_ptr->main_addr );
done = FALSE;
old_addr = entry_ptr->addr;
new_addr = entry_ptr->alt_addr;
} else if ( !(entry_ptr->at_main_addr) && main_addr ) {
/* rename to main addr */
HDassert( entry_ptr->addr == entry_ptr->alt_addr );
done = FALSE;
old_addr = entry_ptr->addr;
new_addr = entry_ptr->main_addr;
}
if ( ! done ) {
entry_ptr->is_dirty = TRUE;
result = H5C_rename_entry(cache_ptr, &(types[type]),
old_addr, new_addr);
}
if ( ! done ) {
if ( ( result < 0 ) || ( entry_ptr->header.addr != new_addr ) ) {
pass = FALSE;
failure_mssg = "error in H5C_rename_entry().";
} else {
entry_ptr->addr = new_addr;
entry_ptr->at_main_addr = main_addr;
}
}
HDassert( ((entry_ptr->header).type)->id == type );
HDassert( entry_ptr->header.is_dirty );
HDassert( entry_ptr->is_dirty );
return;
} /* rename_entry() */
/*-------------------------------------------------------------------------
* Function: protect_entry()
*
* Purpose: Protect the entry indicated by the type and index.
*
* Do nothing if pass is FALSE on entry.
*
* Return: void
*
* Programmer: John Mainzer
* 6/11/04
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static void
protect_entry(H5C_t * cache_ptr,
int32_t type,
int32_t idx)
{
/* const char * fcn_name = "protect_entry()"; */
test_entry_t * base_addr;
test_entry_t * entry_ptr;
H5C_cache_entry_t * cache_entry_ptr;
if ( pass ) {
HDassert( cache_ptr );
HDassert( ( 0 <= type ) && ( type < NUMBER_OF_ENTRY_TYPES ) );
HDassert( ( 0 <= idx ) && ( idx <= max_indices[type] ) );
base_addr = entries[type];
entry_ptr = &(base_addr[idx]);
HDassert( entry_ptr->index == idx );
HDassert( entry_ptr->type == type );
HDassert( entry_ptr == entry_ptr->self );
HDassert( !(entry_ptr->is_protected) );
cache_entry_ptr = H5C_protect(NULL, -1, -1, cache_ptr, &(types[type]),
entry_ptr->addr, NULL, NULL);
if ( ( cache_entry_ptr != (void *)entry_ptr ) ||
( !(entry_ptr->header.is_protected) ) ||
( entry_ptr->header.type != &(types[type]) ) ||
( entry_ptr->size != entry_ptr->header.size ) ||
( entry_ptr->addr != entry_ptr->header.addr ) ) {
#if 0
/* I've written the following debugging code several times
* now. Lets keep it around so I don't have to write it
* again.
* - JRM
*/
HDfprintf(stdout, "( cache_entry_ptr != (void *)entry_ptr ) = %d\n",
(int)( cache_entry_ptr != (void *)entry_ptr ));
HDfprintf(stdout, "cache_entry_ptr = 0x%lx, entry_ptr = 0x%lx\n",
(long)cache_entry_ptr, (long)entry_ptr);
HDfprintf(stdout, "entry_ptr->header.is_protected = %d\n",
(int)(entry_ptr->header.is_protected));
HDfprintf(stdout,
"( entry_ptr->header.type != &(types[type]) ) = %d\n",
(int)( entry_ptr->header.type != &(types[type]) ));
HDfprintf(stdout,
"entry_ptr->size = %d, entry_ptr->header.size = %d\n",
(int)(entry_ptr->size), (int)(entry_ptr->header.size));
HDfprintf(stdout,
"entry_ptr->addr = %d, entry_ptr->header.addr = %d\n",
(int)(entry_ptr->addr), (int)(entry_ptr->header.addr));
#endif
pass = FALSE;
failure_mssg = "error in H5C_protect().";
} else {
entry_ptr->is_protected = TRUE;
}
HDassert( ((entry_ptr->header).type)->id == type );
}
return;
} /* protect_entry() */
/*-------------------------------------------------------------------------
* Function: unprotect_entry()
*
* Purpose: Unprotect the entry indicated by the type and index.
*
* Do nothing if pass is FALSE on entry.
*
* Return: void
*
* Programmer: John Mainzer
* 6/12/04
*
* Modifications:
*
* JRM -- 1/7/05
* Updated for the replacement of the deleted parameter in
* H5C_unprotect() with the new flags parameter.
*
* JRM - 6/17/05
* Modified function to use the new dirtied parameter of
* H5C_unprotect().
*
* JRM -- 9/8/05
* Update for new entry size parameter in H5C_unprotect().
* We don't use them here for now.
*
*-------------------------------------------------------------------------
*/
#define NO_CHANGE -1
static void
unprotect_entry(H5C_t * cache_ptr,
int32_t type,
int32_t idx,
int dirty,
unsigned int flags)
{
/* const char * fcn_name = "unprotect_entry()"; */
herr_t result;
test_entry_t * base_addr;
test_entry_t * entry_ptr;
if ( pass ) {
HDassert( cache_ptr );
HDassert( ( 0 <= type ) && ( type < NUMBER_OF_ENTRY_TYPES ) );
HDassert( ( 0 <= idx ) && ( idx <= max_indices[type] ) );
base_addr = entries[type];
entry_ptr = &(base_addr[idx]);
HDassert( entry_ptr->index == idx );
HDassert( entry_ptr->type == type );
HDassert( entry_ptr == entry_ptr->self );
HDassert( entry_ptr->header.is_protected );
HDassert( entry_ptr->is_protected );
if ( ( dirty == TRUE ) || ( dirty == FALSE ) ) {
flags |= (dirty ? H5AC__DIRTIED_FLAG : H5AC__NO_FLAGS_SET);
entry_ptr->is_dirty = (entry_ptr->is_dirty || dirty);
}
result = H5C_unprotect(NULL, -1, -1, cache_ptr, &(types[type]),
entry_ptr->addr, (void *)entry_ptr,
flags, 0);
if ( ( result < 0 ) ||
( entry_ptr->header.is_protected ) ||
( entry_ptr->header.type != &(types[type]) ) ||
( entry_ptr->size != entry_ptr->header.size ) ||
( entry_ptr->addr != entry_ptr->header.addr ) ) {
pass = FALSE;
failure_mssg = "error in H5C_unprotect().";
}
else
{
entry_ptr->is_protected = FALSE;
}
HDassert( ((entry_ptr->header).type)->id == type );
if ( ( flags & H5AC__DIRTIED_FLAG ) != 0
&& ( (flags & H5C__DELETED_FLAG) == 0 ) ) {
HDassert( entry_ptr->header.is_dirty );
HDassert( entry_ptr->is_dirty );
}
}
return;
} /* unprotect_entry() */
/*-------------------------------------------------------------------------
* Function: row_major_scan_forward()
*
* Purpose: Do a sequence of inserts, protects, unprotects, renames,
* destroys while scanning through the set of entries. If
* pass is false on entry, do nothing.
*
* Return: void
*
* Programmer: John Mainzer
* 6/12/04
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static void
row_major_scan_forward(H5C_t * cache_ptr,
int32_t lag,
hbool_t verbose,
hbool_t reset_stats,
hbool_t display_stats,
hbool_t display_detailed_stats,
hbool_t do_inserts,
hbool_t dirty_inserts,
hbool_t do_renames,
hbool_t rename_to_main_addr,
hbool_t do_destroys,
int dirty_destroys,
int dirty_unprotects)
{
const char * fcn_name = "row_major_scan_forward";
int32_t type;
int32_t idx;
if ( verbose )
HDfprintf(stdout, "%s(): entering.\n", fcn_name);
HDassert( lag > 5 );
type = 0;
if ( ( pass ) && ( reset_stats ) ) {
H5C_stats__reset(cache_ptr);
}
while ( ( pass ) && ( type < NUMBER_OF_ENTRY_TYPES ) )
{
idx = -lag;
while ( ( pass ) && ( idx <= (max_indices[type] + lag) ) )
{
if ( ( pass ) && ( do_inserts ) && ( (idx + lag) >= 0 ) &&
( (idx + lag) <= max_indices[type] ) &&
( ((idx + lag) % 2) == 0 ) &&
( ! entry_in_cache(cache_ptr, type, (idx + lag)) ) ) {
if ( verbose )
HDfprintf(stdout, "(i, %d, %d) ", type, (idx + lag));
insert_entry(cache_ptr, type, (idx + lag), dirty_inserts,
H5C__NO_FLAGS_SET);
}
if ( ( pass ) && ( (idx + lag - 1) >= 0 ) &&
( (idx + lag - 1) <= max_indices[type] ) &&
( ( (idx + lag - 1) % 3 ) == 0 ) ) {
if ( verbose )
HDfprintf(stdout, "(p, %d, %d) ", type, (idx + lag - 1));
protect_entry(cache_ptr, type, (idx + lag - 1));
}
if ( ( pass ) && ( (idx + lag - 2) >= 0 ) &&
( (idx + lag - 2) <= max_indices[type] ) &&
( ( (idx + lag - 2) % 3 ) == 0 ) ) {
if ( verbose )
HDfprintf(stdout, "(u, %d, %d) ", type, (idx + lag - 2));
unprotect_entry(cache_ptr, type, idx+lag-2, NO_CHANGE,
H5C__NO_FLAGS_SET);
}
if ( ( pass ) && ( do_renames ) && ( (idx + lag - 2) >= 0 ) &&
( (idx + lag - 2) <= max_indices[type] ) &&
( ( (idx + lag - 2) % 3 ) == 0 ) ) {
rename_entry(cache_ptr, type, (idx + lag - 2),
rename_to_main_addr);
}
if ( ( pass ) && ( (idx + lag - 3) >= 0 ) &&
( (idx + lag - 3) <= max_indices[type] ) &&
( ( (idx + lag - 3) % 5 ) == 0 ) ) {
if ( verbose )
HDfprintf(stdout, "(p, %d, %d) ", type, (idx + lag - 3));
protect_entry(cache_ptr, type, (idx + lag - 3));
}
if ( ( pass ) && ( (idx + lag - 5) >= 0 ) &&
( (idx + lag - 5) <= max_indices[type] ) &&
( ( (idx + lag - 5) % 5 ) == 0 ) ) {
if ( verbose )
HDfprintf(stdout, "(u, %d, %d) ", type, (idx + lag - 5));
unprotect_entry(cache_ptr, type, idx+lag-5, NO_CHANGE,
H5C__NO_FLAGS_SET);
}
if ( ( pass ) && ( idx >= 0 ) && ( idx <= max_indices[type] ) ) {
if ( verbose )
HDfprintf(stdout, "(p, %d, %d) ", type, idx);
protect_entry(cache_ptr, type, idx);
}
if ( ( pass ) && ( (idx - lag + 2) >= 0 ) &&
( (idx - lag + 2) <= max_indices[type] ) &&
( ( (idx - lag + 2) % 7 ) == 0 ) ) {
if ( verbose )
HDfprintf(stdout, "(u, %d, %d) ", type, (idx - lag + 2));
unprotect_entry(cache_ptr, type, idx-lag+2, NO_CHANGE,
H5C__NO_FLAGS_SET);
}
if ( ( pass ) && ( (idx - lag + 1) >= 0 ) &&
( (idx - lag + 1) <= max_indices[type] ) &&
( ( (idx - lag + 1) % 7 ) == 0 ) ) {
if ( verbose )
HDfprintf(stdout, "(p, %d, %d) ", type, (idx - lag + 1));
protect_entry(cache_ptr, type, (idx - lag + 1));
}
if ( do_destroys ) {
if ( ( pass ) && ( (idx - lag) >= 0 ) &&
( ( idx - lag) <= max_indices[type] ) ) {
switch ( (idx - lag) %4 ) {
case 0: /* we just did an insert */
unprotect_entry(cache_ptr, type, idx - lag,
NO_CHANGE, H5C__NO_FLAGS_SET);
break;
case 1:
if ( (entries[type])[idx-lag].is_dirty ) {
unprotect_entry(cache_ptr, type, idx - lag,
NO_CHANGE, H5C__NO_FLAGS_SET);
} else {
unprotect_entry(cache_ptr, type, idx - lag,
dirty_unprotects,
H5C__NO_FLAGS_SET);
}
break;
case 2: /* we just did an insrt */
unprotect_entry(cache_ptr, type, idx - lag,
NO_CHANGE, H5C__DELETED_FLAG);
break;
case 3:
if ( (entries[type])[idx-lag].is_dirty ) {
unprotect_entry(cache_ptr, type, idx - lag,
NO_CHANGE, H5C__DELETED_FLAG);
} else {
unprotect_entry(cache_ptr, type, idx - lag,
dirty_destroys,
H5C__DELETED_FLAG);
}
break;
default:
HDassert(0); /* this can't happen... */
break;
}
}
} else {
if ( ( pass ) && ( (idx - lag) >= 0 ) &&
( ( idx - lag) <= max_indices[type] ) ) {
if ( verbose )
HDfprintf(stdout, "(u, %d, %d) ", type, (idx - lag));
unprotect_entry(cache_ptr, type, idx - lag,
dirty_unprotects, H5C__NO_FLAGS_SET);
}
}
if ( verbose )
HDfprintf(stdout, "\n");
idx++;
}
type++;
}
if ( ( pass ) && ( display_stats ) ) {
H5C_stats(cache_ptr, "test cache", display_detailed_stats);
}
return;
} /* row_major_scan_forward() */
/*-------------------------------------------------------------------------
* Function: hl_row_major_scan_forward()
*
* Purpose: Do a high locality sequence of inserts, protects, and
* unprotects while scanning through the set of entries.
* If pass is false on entry, do nothing.
*
* Return: void
*
* Programmer: John Mainzer
* 10/21/04
*
* Modifications:
*
* JRM -- 1/21/05
* Added the max_index parameter to allow the caller to
* throttle the size of the inner loop, and thereby the
* execution time of the function.
*
*-------------------------------------------------------------------------
*/
static void
hl_row_major_scan_forward(H5C_t * cache_ptr,
int32_t max_index,
hbool_t verbose,
hbool_t reset_stats,
hbool_t display_stats,
hbool_t display_detailed_stats,
hbool_t do_inserts,
hbool_t dirty_inserts)
{
const char * fcn_name = "hl_row_major_scan_forward";
int32_t type;
int32_t idx;
int32_t i;
int32_t lag = 100;
int32_t local_max_index;
if ( verbose )
HDfprintf(stdout, "%s(): entering.\n", fcn_name);
HDassert( lag > 5 );
HDassert( max_index >= 200 );
HDassert( max_index <= MAX_ENTRIES );
type = 0;
if ( ( pass ) && ( reset_stats ) ) {
H5C_stats__reset(cache_ptr);
}
while ( ( pass ) && ( type < NUMBER_OF_ENTRY_TYPES ) )
{
idx = -lag;
local_max_index = MIN(max_index, max_indices[type]);
while ( ( pass ) && ( idx <= (local_max_index + lag) ) )
{
if ( ( pass ) && ( do_inserts ) && ( (idx + lag) >= 0 ) &&
( (idx + lag) <= max_indices[type] ) &&
( ((idx + lag) % 2) == 0 ) &&
( ! entry_in_cache(cache_ptr, type, (idx + lag)) ) ) {
if ( verbose )
HDfprintf(stdout, "(i, %d, %d) ", type, (idx + lag));
insert_entry(cache_ptr, type, (idx + lag), dirty_inserts,
H5C__NO_FLAGS_SET);
}
i = idx;
while ( ( pass ) && ( i >= idx - lag ) && ( i >= 0 ) )
{
if ( ( pass ) && ( i >= 0 ) && ( i <= local_max_index ) ) {
if ( verbose )
HDfprintf(stdout, "(p, %d, %d) ", type, i);
protect_entry(cache_ptr, type, i);
if ( verbose )
HDfprintf(stdout, "(u, %d, %d) ", type, i);
unprotect_entry(cache_ptr, type, i, NO_CHANGE,
H5C__NO_FLAGS_SET);
}
i--;
}
if ( verbose )
HDfprintf(stdout, "\n");
idx++;
}
type++;
}
if ( ( pass ) && ( display_stats ) ) {
H5C_stats(cache_ptr, "test cache", display_detailed_stats);
}
return;
} /* hl_row_major_scan_forward() */
/*-------------------------------------------------------------------------
* Function: row_major_scan_backward()
*
* Purpose: Do a sequence of inserts, protects, unprotects, renames,
* destroys while scanning backwards through the set of
* entries. If pass is false on entry, do nothing.
*
* Return: void
*
* Programmer: John Mainzer
* 6/12/04
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static void
row_major_scan_backward(H5C_t * cache_ptr,
int32_t lag,
hbool_t verbose,
hbool_t reset_stats,
hbool_t display_stats,
hbool_t display_detailed_stats,
hbool_t do_inserts,
hbool_t dirty_inserts,
hbool_t do_renames,
hbool_t rename_to_main_addr,
hbool_t do_destroys,
int dirty_destroys,
int dirty_unprotects)
{
const char * fcn_name = "row_major_scan_backward";
int32_t type;
int32_t idx;
if ( verbose )
HDfprintf(stdout, "%s(): Entering.\n", fcn_name);
HDassert( lag > 5 );
type = NUMBER_OF_ENTRY_TYPES - 1;
if ( ( pass ) && ( reset_stats ) ) {
H5C_stats__reset(cache_ptr);
}
while ( ( pass ) && ( type >= 0 ) )
{
idx = max_indices[type] + lag;
while ( ( pass ) && ( idx >= -lag ) )
{
if ( ( pass ) && ( do_inserts ) && ( (idx - lag) >= 0 ) &&
( (idx - lag) <= max_indices[type] ) &&
( ((idx - lag) % 2) == 1 ) &&
( ! entry_in_cache(cache_ptr, type, (idx - lag)) ) ) {
if ( verbose )
HDfprintf(stdout, "(i, %d, %d) ", type, (idx - lag));
insert_entry(cache_ptr, type, (idx - lag), dirty_inserts,
H5C__NO_FLAGS_SET);
}
if ( ( pass ) && ( (idx - lag + 1) >= 0 ) &&
( (idx - lag + 1) <= max_indices[type] ) &&
( ( (idx - lag + 1) % 3 ) == 0 ) ) {
if ( verbose )
HDfprintf(stdout, "(p, %d, %d) ", type, (idx - lag + 1));
protect_entry(cache_ptr, type, (idx - lag + 1));
}
if ( ( pass ) && ( (idx - lag + 2) >= 0 ) &&
( (idx - lag + 2) <= max_indices[type] ) &&
( ( (idx - lag + 2) % 3 ) == 0 ) ) {
if ( verbose )
HDfprintf(stdout, "(u, %d, %d) ", type, (idx - lag + 2));
unprotect_entry(cache_ptr, type, idx-lag+2, NO_CHANGE,
H5C__NO_FLAGS_SET);
}
if ( ( pass ) && ( do_renames ) && ( (idx - lag + 2) >= 0 ) &&
( (idx - lag + 2) <= max_indices[type] ) &&
( ( (idx - lag + 2) % 3 ) == 0 ) ) {
rename_entry(cache_ptr, type, (idx - lag + 2),
rename_to_main_addr);
}
if ( ( pass ) && ( (idx - lag + 3) >= 0 ) &&
( (idx - lag + 3) <= max_indices[type] ) &&
( ( (idx - lag + 3) % 5 ) == 0 ) ) {
if ( verbose )
HDfprintf(stdout, "(p, %d, %d) ", type, (idx - lag + 3));
protect_entry(cache_ptr, type, (idx - lag + 3));
}
if ( ( pass ) && ( (idx - lag + 5) >= 0 ) &&
( (idx - lag + 5) <= max_indices[type] ) &&
( ( (idx - lag + 5) % 5 ) == 0 ) ) {
if ( verbose )
HDfprintf(stdout, "(u, %d, %d) ", type, (idx - lag + 5));
unprotect_entry(cache_ptr, type, idx-lag+5, NO_CHANGE,
H5C__NO_FLAGS_SET);
}
if ( ( pass ) && ( idx >= 0 ) && ( idx <= max_indices[type] ) ) {
if ( verbose )
HDfprintf(stdout, "(p, %d, %d) ", type, idx);
protect_entry(cache_ptr, type, idx);
}
if ( ( pass ) && ( (idx + lag - 2) >= 0 ) &&
( (idx + lag - 2) <= max_indices[type] ) &&
( ( (idx + lag - 2) % 7 ) == 0 ) ) {
if ( verbose )
HDfprintf(stdout, "(u, %d, %d) ", type, (idx + lag - 2));
unprotect_entry(cache_ptr, type, idx+lag-2, NO_CHANGE,
H5C__NO_FLAGS_SET);
}
if ( ( pass ) && ( (idx + lag - 1) >= 0 ) &&
( (idx + lag - 1) <= max_indices[type] ) &&
( ( (idx + lag - 1) % 7 ) == 0 ) ) {
if ( verbose )
HDfprintf(stdout, "(p, %d, %d) ", type, (idx + lag - 1));
protect_entry(cache_ptr, type, (idx + lag - 1));
}
if ( do_destroys ) {
if ( ( pass ) && ( (idx + lag) >= 0 ) &&
( ( idx + lag) <= max_indices[type] ) ) {
switch ( (idx + lag) %4 ) {
case 0:
if ( (entries[type])[idx+lag].is_dirty ) {
unprotect_entry(cache_ptr, type, idx + lag,
NO_CHANGE, H5C__NO_FLAGS_SET);
} else {
unprotect_entry(cache_ptr, type, idx + lag,
dirty_unprotects,
H5C__NO_FLAGS_SET);
}
break;
case 1: /* we just did an insert */
unprotect_entry(cache_ptr, type, idx + lag,
NO_CHANGE, H5C__NO_FLAGS_SET);
break;
case 2:
if ( (entries[type])[idx + lag].is_dirty ) {
unprotect_entry(cache_ptr, type, idx + lag,
NO_CHANGE, H5C__DELETED_FLAG);
} else {
unprotect_entry(cache_ptr, type, idx + lag,
dirty_destroys,
H5C__DELETED_FLAG);
}
break;
case 3: /* we just did an insrt */
unprotect_entry(cache_ptr, type, idx + lag,
NO_CHANGE, H5C__DELETED_FLAG);
break;
default:
HDassert(0); /* this can't happen... */
break;
}
}
} else {
if ( ( pass ) && ( (idx + lag) >= 0 ) &&
( ( idx + lag) <= max_indices[type] ) ) {
if ( verbose )
HDfprintf(stdout, "(u, %d, %d) ", type, (idx - lag));
unprotect_entry(cache_ptr, type, idx + lag,
dirty_unprotects, H5C__NO_FLAGS_SET);
}
}
if ( verbose )
HDfprintf(stdout, "\n");
idx--;
}
type--;
}
if ( ( pass ) && ( display_stats ) ) {
H5C_stats(cache_ptr, "test cache", display_detailed_stats);
}
return;
} /* row_major_scan_backward() */
/*-------------------------------------------------------------------------
* Function: hl_row_major_scan_backward()
*
* Purpose: Do a high locality sequence of inserts, protects, and
* unprotects while scanning through the set of entries.
* If pass is false on entry, do nothing.
*
* Return: void
*
* Programmer: John Mainzer
* 10/21/04
*
* Modifications:
*
* JRM -- 1/21/05
* Added the max_index parameter to allow the caller to
* throttle the size of the inner loop, and thereby the
* execution time of the function.
*
*-------------------------------------------------------------------------
*/
static void
hl_row_major_scan_backward(H5C_t * cache_ptr,
int32_t max_index,
hbool_t verbose,
hbool_t reset_stats,
hbool_t display_stats,
hbool_t display_detailed_stats,
hbool_t do_inserts,
hbool_t dirty_inserts)
{
const char * fcn_name = "hl_row_major_scan_backward";
int32_t type;
int32_t idx;
int32_t i;
int32_t lag = 100;
int32_t local_max_index;
if ( verbose )
HDfprintf(stdout, "%s(): entering.\n", fcn_name);
HDassert( lag > 5 );
HDassert( max_index >= 200 );
HDassert( max_index <= MAX_ENTRIES );
type = NUMBER_OF_ENTRY_TYPES - 1;
if ( ( pass ) && ( reset_stats ) ) {
H5C_stats__reset(cache_ptr);
}
while ( ( pass ) && ( type >= 0 ) )
{
idx = max_indices[type] + lag;
local_max_index = MIN(max_index, max_indices[type]);
while ( ( pass ) && ( idx >= -lag ) )
{
if ( ( pass ) && ( do_inserts ) && ( (idx + lag) >= 0 ) &&
( (idx + lag) <= local_max_index ) &&
( ((idx + lag) % 2) == 0 ) &&
( ! entry_in_cache(cache_ptr, type, (idx + lag)) ) ) {
if ( verbose )
HDfprintf(stdout, "(i, %d, %d) ", type, (idx + lag));
insert_entry(cache_ptr, type, (idx + lag), dirty_inserts,
H5C__NO_FLAGS_SET);
}
i = idx;
while ( ( pass ) && ( i >= idx - lag ) && ( i >= 0 ) )
{
if ( ( pass ) && ( i >= 0 ) && ( i <= local_max_index ) ) {
if ( verbose )
HDfprintf(stdout, "(p, %d, %d) ", type, i);
protect_entry(cache_ptr, type, i);
if ( verbose )
HDfprintf(stdout, "(u, %d, %d) ", type, i);
unprotect_entry(cache_ptr, type, i, NO_CHANGE,
H5C__NO_FLAGS_SET);
}
i--;
}
if ( verbose )
HDfprintf(stdout, "\n");
idx--;
}
type--;
}
if ( ( pass ) && ( display_stats ) ) {
H5C_stats(cache_ptr, "test cache", display_detailed_stats);
}
return;
} /* hl_row_major_scan_backward() */
/*-------------------------------------------------------------------------
* Function: col_major_scan_forward()
*
* Purpose: Do a sequence of inserts, protects, and unprotects
* while scanning through the set of entries. If
* pass is false on entry, do nothing.
*
* Return: void
*
* Programmer: John Mainzer
* 6/23/04
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static void
col_major_scan_forward(H5C_t * cache_ptr,
int32_t lag,
hbool_t verbose,
hbool_t reset_stats,
hbool_t display_stats,
hbool_t display_detailed_stats,
hbool_t do_inserts,
hbool_t dirty_inserts,
int dirty_unprotects)
{
const char * fcn_name = "col_major_scan_forward()";
int32_t type;
int32_t idx;
if ( verbose )
HDfprintf(stdout, "%s: entering.\n", fcn_name);
HDassert( lag > 5 );
type = 0;
if ( ( pass ) && ( reset_stats ) ) {
H5C_stats__reset(cache_ptr);
}
idx = -lag;
while ( ( pass ) && ( (idx - lag) <= MAX_ENTRIES ) )
{
type = 0;
while ( ( pass ) && ( type < NUMBER_OF_ENTRY_TYPES ) )
{
if ( ( pass ) && ( do_inserts ) && ( (idx + lag) >= 0 ) &&
( (idx + lag) <= max_indices[type] ) &&
( ((idx + lag) % 3) == 0 ) &&
( ! entry_in_cache(cache_ptr, type, (idx + lag)) ) ) {
if ( verbose )
HDfprintf(stdout, "(i, %d, %d) ", type, (idx + lag));
insert_entry(cache_ptr, type, (idx + lag), dirty_inserts,
H5C__NO_FLAGS_SET);
}
if ( ( pass ) && ( idx >= 0 ) && ( idx <= max_indices[type] ) ) {
if ( verbose )
HDfprintf(stdout, "(p, %d, %d) ", type, idx);
protect_entry(cache_ptr, type, idx);
}
if ( ( pass ) && ( (idx - lag) >= 0 ) &&
( (idx - lag) <= max_indices[type] ) ) {
if ( verbose )
HDfprintf(stdout, "(u, %d, %d) ", type, (idx - lag));
unprotect_entry(cache_ptr, type, idx - lag,
dirty_unprotects, H5C__NO_FLAGS_SET);
}
if ( verbose )
HDfprintf(stdout, "\n");
type++;
}
idx++;
}
if ( ( pass ) && ( display_stats ) ) {
H5C_stats(cache_ptr, "test cache", display_detailed_stats);
}
return;
} /* col_major_scan_forward() */
/*-------------------------------------------------------------------------
* Function: hl_col_major_scan_forward()
*
* Purpose: Do a high locality sequence of inserts, protects, and
* unprotects while scanning through the set of entries. If
* pass is false on entry, do nothing.
*
* Return: void
*
* Programmer: John Mainzer
* 19/25/04
*
* Modifications:
*
* JRM -- 1/21/05
* Added the max_index parameter to allow the caller to
* throttle the size of the inner loop, and thereby the
* execution time of the function.
*
*-------------------------------------------------------------------------
*/
static void
hl_col_major_scan_forward(H5C_t * cache_ptr,
int32_t max_index,
hbool_t verbose,
hbool_t reset_stats,
hbool_t display_stats,
hbool_t display_detailed_stats,
hbool_t do_inserts,
hbool_t dirty_inserts,
int dirty_unprotects)
{
const char * fcn_name = "hl_col_major_scan_forward()";
int32_t type;
int32_t idx;
int32_t lag = 200;
int32_t i;
int32_t local_max_index;
if ( verbose )
HDfprintf(stdout, "%s: entering.\n", fcn_name);
HDassert( lag > 5 );
HDassert( max_index >= 500 );
HDassert( max_index <= MAX_ENTRIES );
type = 0;
if ( ( pass ) && ( reset_stats ) ) {
H5C_stats__reset(cache_ptr);
}
idx = 0;
local_max_index = MIN(max_index, MAX_ENTRIES);
while ( ( pass ) && ( idx <= local_max_index ) )
{
i = idx;
while ( ( pass ) && ( i >= 0 ) && ( i >= (idx - lag) ) ) {
type = 0;
while ( ( pass ) && ( type < NUMBER_OF_ENTRY_TYPES ) )
{
if ( ( pass ) && ( do_inserts ) && ( i == idx ) &&
( i <= local_max_index ) &&
( (i % 3) == 0 ) &&
( ! entry_in_cache(cache_ptr, type, i) ) ) {
if ( verbose )
HDfprintf(stdout, "(i, %d, %d) ", type, i);
insert_entry(cache_ptr, type, i, dirty_inserts,
H5C__NO_FLAGS_SET);
}
if ( ( pass ) && ( i >= 0 ) && ( i <= local_max_index ) ) {
if ( verbose )
HDfprintf(stdout, "(p, %d, %d) ", type, i);
protect_entry(cache_ptr, type, i);
}
if ( ( pass ) && ( i >= 0 ) &&
( i <= max_indices[type] ) ) {
if ( verbose )
HDfprintf(stdout, "(u, %d, %d) ", type, i);
unprotect_entry(cache_ptr, type, i,
dirty_unprotects, H5C__NO_FLAGS_SET);
}
if ( verbose )
HDfprintf(stdout, "\n");
type++;
}
i--;
}
idx++;
}
if ( ( pass ) && ( display_stats ) ) {
H5C_stats(cache_ptr, "test cache", display_detailed_stats);
}
return;
} /* hl_col_major_scan_forward() */
/*-------------------------------------------------------------------------
* Function: col_major_scan_backward()
*
* Purpose: Do a sequence of inserts, protects, and unprotects
* while scanning backwards through the set of
* entries. If pass is false on entry, do nothing.
*
* Return: void
*
* Programmer: John Mainzer
* 6/23/04
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static void
col_major_scan_backward(H5C_t * cache_ptr,
int32_t lag,
hbool_t verbose,
hbool_t reset_stats,
hbool_t display_stats,
hbool_t display_detailed_stats,
hbool_t do_inserts,
hbool_t dirty_inserts,
int dirty_unprotects)
{
const char * fcn_name = "col_major_scan_backward()";
int mile_stone = 1;
int32_t type;
int32_t idx;
if ( verbose )
HDfprintf(stdout, "%s: entering.\n", fcn_name);
HDassert( lag > 5 );
if ( ( pass ) && ( reset_stats ) ) {
H5C_stats__reset(cache_ptr);
}
idx = MAX_ENTRIES + lag;
if ( verbose ) /* 1 */
HDfprintf(stdout, "%s: point %d.\n", fcn_name, mile_stone++);
while ( ( pass ) && ( (idx + lag) >= 0 ) )
{
type = NUMBER_OF_ENTRY_TYPES - 1;
while ( ( pass ) && ( type >= 0 ) )
{
if ( ( pass ) && ( do_inserts) && ( (idx - lag) >= 0 ) &&
( (idx - lag) <= max_indices[type] ) &&
( ((idx - lag) % 3) == 0 ) &&
( ! entry_in_cache(cache_ptr, type, (idx - lag)) ) ) {
if ( verbose )
HDfprintf(stdout, "(i, %d, %d) ", type, (idx - lag));
insert_entry(cache_ptr, type, (idx - lag), dirty_inserts,
H5C__NO_FLAGS_SET);
}
if ( ( pass ) && ( idx >= 0 ) && ( idx <= max_indices[type] ) ) {
if ( verbose )
HDfprintf(stdout, "(p, %d, %d) ", type, idx);
protect_entry(cache_ptr, type, idx);
}
if ( ( pass ) && ( (idx + lag) >= 0 ) &&
( (idx + lag) <= max_indices[type] ) ) {
if ( verbose )
HDfprintf(stdout, "(u, %d, %d) ", type, (idx + lag));
unprotect_entry(cache_ptr, type, idx + lag,
dirty_unprotects, H5C__NO_FLAGS_SET);
}
if ( verbose )
HDfprintf(stdout, "\n");
type--;
}
idx--;
}
if ( verbose ) /* 2 */
HDfprintf(stdout, "%s: point %d.\n", fcn_name, mile_stone++);
if ( ( pass ) && ( display_stats ) ) {
H5C_stats(cache_ptr, "test cache", display_detailed_stats);
}
if ( verbose )
HDfprintf(stdout, "%s: exiting.\n", fcn_name);
return;
} /* col_major_scan_backward() */
/*-------------------------------------------------------------------------
* Function: hl_col_major_scan_backward()
*
* Purpose: Do a high locality sequence of inserts, protects, and
* unprotects while scanning backwards through the set of
* entries. If pass is false on entry, do nothing.
*
* Return: void
*
* Programmer: John Mainzer
* 10/25/04
*
* Modifications:
*
* JRM -- 1/21/05
* Added the max_index parameter to allow the caller to
* throttle the size of the inner loop, and thereby the
* execution time of the function.
*
*-------------------------------------------------------------------------
*/
static void
hl_col_major_scan_backward(H5C_t * cache_ptr,
int32_t max_index,
hbool_t verbose,
hbool_t reset_stats,
hbool_t display_stats,
hbool_t display_detailed_stats,
hbool_t do_inserts,
hbool_t dirty_inserts,
int dirty_unprotects)
{
const char * fcn_name = "hl_col_major_scan_backward()";
int32_t type;
int32_t idx;
int32_t lag = 50;
int32_t i;
int32_t local_max_index;
if ( verbose )
HDfprintf(stdout, "%s: entering.\n", fcn_name);
HDassert( lag > 5 );
HDassert( max_index >= 500 );
HDassert( max_index <= MAX_ENTRIES );
type = 0;
local_max_index = MIN(max_index, MAX_ENTRIES);
if ( ( pass ) && ( reset_stats ) ) {
H5C_stats__reset(cache_ptr);
}
idx = local_max_index;
while ( ( pass ) && ( idx >= 0 ) )
{
i = idx;
while ( ( pass ) && ( i <= local_max_index ) && ( i <= (idx + lag) ) ) {
type = 0;
while ( ( pass ) && ( type < NUMBER_OF_ENTRY_TYPES ) )
{
if ( ( pass ) && ( do_inserts ) && ( i == idx ) &&
( i <= local_max_index ) &&
( ! entry_in_cache(cache_ptr, type, i) ) ) {
if ( verbose )
HDfprintf(stdout, "(i, %d, %d) ", type, i);
insert_entry(cache_ptr, type, i, dirty_inserts,
H5C__NO_FLAGS_SET);
}
if ( ( pass ) && ( i >= 0 ) && ( i <= local_max_index ) ) {
if ( verbose )
HDfprintf(stdout, "(p, %d, %d) ", type, i);
protect_entry(cache_ptr, type, i);
}
if ( ( pass ) && ( i >= 0 ) &&
( i <= local_max_index ) ) {
if ( verbose )
HDfprintf(stdout, "(u, %d, %d) ", type, i);
unprotect_entry(cache_ptr, type, i,
dirty_unprotects, H5C__NO_FLAGS_SET);
}
if ( verbose )
HDfprintf(stdout, "\n");
type++;
}
i++;
}
idx--;
}
if ( ( pass ) && ( display_stats ) ) {
H5C_stats(cache_ptr, "test cache", display_detailed_stats);
}
return;
} /* hl_col_major_scan_backward() */
/**************************************************************************/
/**************************************************************************/
/********************************* 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,
/* 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,
/* 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,
/* 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);
} /* 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,
/* 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,
/* 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,
/* 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);
} /* 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,
/* 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,
/* 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,
/* 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);
} /* 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,
/* 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,
/* 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,
/* 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);
} /* 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);
} /* 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);
} /* 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);
} /* 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);
} /* 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,
/* 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,
/* 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,
/* 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 */
} /* write_permitted_check() */
/*-------------------------------------------------------------------------
* 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 ) {
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);
} /* 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:
*
*-------------------------------------------------------------------------
*/
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);
}
} /* 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 ( 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++;
}
} /* check_flush_cache__multi_entry_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:
*
*-------------------------------------------------------------------------
*/
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
);
}
} /* 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 ) ) {
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 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;
}
}
} /* check_flush_cache__single_entry_test() */
/*-------------------------------------------------------------------------
* 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);
} /* check_flush_protected_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);
} /* 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);
} /* 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);
} /* check_rename_err() */
/*-------------------------------------------------------------------------
* 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:
*
*-------------------------------------------------------------------------
*/
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);
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);
} /* 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, 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);
} /* check_double_unprotect_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;
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);
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);
} /* 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);
} /* 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);
} /* 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);
} /* 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 0
/* 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);
} /* check_auto_cache_resize_aux_fcns() */
/*-------------------------------------------------------------------------
* Function: check_fapl_mdc_api_calls()
*
* Purpose: Verify that the file access property list related
* metadata cache related API calls are functioning
* correctly.
*
* Since we have tested the H5C code elsewhere, it should
* be sufficient to verify that the desired configuration
* data is getting to the cache.
*
* Return: void
*
* Programmer: John Mainzer
* 4/12/04
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
#define CACHE_CONFIGS_EQUAL(a, b, cmp_set_init, cmp_init_size) \
( ( (a).version == (b).version ) && \
( (a).rpt_fcn_enabled == (b).rpt_fcn_enabled ) && \
( ( ! cmp_set_init ) || \
( (a).set_initial_size == (b).set_initial_size ) ) && \
( ( ! cmp_init_size ) || \
( (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 ) )
#define XLATE_EXT_TO_INT_MDC_CONFIG(i, e) \
{ \
(i).version = H5C__CURR_AUTO_SIZE_CTL_VER; \
if ( (e).rpt_fcn_enabled ) \
(i).rpt_fcn = H5C_def_auto_resize_rpt_fcn; \
else \
(i).rpt_fcn = NULL; \
(i).set_initial_size = (e).set_initial_size; \
(i).initial_size = (e).initial_size; \
(i).min_clean_fraction = (e).min_clean_fraction; \
(i).max_size = (e).max_size; \
(i).min_size = (e).min_size; \
(i).epoch_length = (long int)((e).epoch_length); \
(i).incr_mode = (e).incr_mode; \
(i).lower_hr_threshold = (e).lower_hr_threshold; \
(i).increment = (e).increment; \
(i).apply_max_increment = (e).apply_max_increment; \
(i).max_increment = (e).max_increment; \
(i).decr_mode = (e).decr_mode; \
(i).upper_hr_threshold = (e).upper_hr_threshold; \
(i).decrement = (e).decrement; \
(i).apply_max_decrement = (e).apply_max_decrement; \
(i).max_decrement = (e).max_decrement; \
(i).epochs_before_eviction = (int)((e).epochs_before_eviction); \
(i).apply_empty_reserve = (e).apply_empty_reserve; \
(i).empty_reserve = (e).empty_reserve; \
}
static void
check_fapl_mdc_api_calls(void)
{
const char * fcn_name = "check_fapl_mdc_api_calls()";
char filename[512];
herr_t result;
hid_t fapl_id = -1;
hid_t test_fapl_id = -1;
hid_t file_id = -1;
H5F_t * file_ptr = NULL;
H5C_t * cache_ptr = NULL;
H5AC_cache_config_t default_config = H5AC__DEFAULT_CACHE_CONFIG;
H5AC_cache_config_t mod_config =
{
/* int version = */
H5AC__CURR_CACHE_CONFIG_VERSION,
/* hbool_t rpt_fcn_enabled = */ FALSE,
/* hbool_t set_initial_size = */ TRUE,
/* size_t initial_size = */ (1 * 1024 * 1024 + 1),
/* double min_clean_fraction = */ 0.2,
/* size_t max_size = */ (16 * 1024 * 1024 + 1),
/* size_t min_size = */ ( 1 * 1024 * 1024 + 1),
/* long int epoch_length = */ 50001,
/* enum H5C_cache_incr_mode incr_mode = */ H5C_incr__threshold,
/* double lower_hr_threshold = */ 0.91,
/* double increment = */ 2.1,
/* hbool_t apply_max_increment = */ TRUE,
/* size_t max_increment = */ (4 * 1024 * 1024 + 1),
/* enum H5C_cache_decr_mode decr_mode = */ H5C_decr__age_out,
/* double upper_hr_threshold = */ 0.998,
/* double decrement = */ 0.91,
/* hbool_t apply_max_decrement = */ TRUE,
/* size_t max_decrement = */ (1 * 1024 * 1024 - 1),
/* int epochs_before_eviction = */ 4,
/* hbool_t apply_empty_reserve = */ TRUE,
/* double empty_reserve = */ 0.05
};
H5AC_cache_config_t scratch;
H5C_auto_size_ctl_t default_auto_size_ctl;
H5C_auto_size_ctl_t mod_auto_size_ctl;
TESTING("MDC/FAPL related API calls");
pass = TRUE;
XLATE_EXT_TO_INT_MDC_CONFIG(default_auto_size_ctl, default_config)
XLATE_EXT_TO_INT_MDC_CONFIG(mod_auto_size_ctl, mod_config)
/* Create a FAPL and verify that it contains the default
* initial mdc configuration
*/
if ( pass ) {
fapl_id = H5Pcreate(H5P_FILE_ACCESS);
if ( fapl_id < 0 ) {
pass = FALSE;
failure_mssg = "H5Pcreate(H5P_FILE_ACCESS) failed.\n";
}
}
if ( pass ) {
scratch.version = H5C__CURR_AUTO_SIZE_CTL_VER;
result = H5Pget_mdc_config(fapl_id, &scratch);
if ( result < 0 ) {
pass = FALSE;
failure_mssg = "H5Pget_mdc_config() failed.\n";
} else if (!CACHE_CONFIGS_EQUAL(default_config, scratch, TRUE, TRUE)) {
pass = FALSE;
failure_mssg = "retrieved config doesn't match default.";
}
}
/* Modify the initial mdc configuration in a FAPL, and verify that
* the changes can be read back
*/
if ( pass ) {
result = H5Pset_mdc_config(fapl_id, &mod_config);
if ( result < 0 ) {
pass = FALSE;
failure_mssg = "H5Pset_mdc_config() failed.\n";
}
}
if ( pass ) {
scratch.version = H5C__CURR_AUTO_SIZE_CTL_VER;
result = H5Pget_mdc_config(fapl_id, &scratch);
if ( result < 0 ) {
pass = FALSE;
failure_mssg = "H5Pget_mdc_config() failed.\n";
} else if ( ! CACHE_CONFIGS_EQUAL(mod_config, scratch, TRUE, TRUE) ) {
pass = FALSE;
failure_mssg = "retrieved config doesn't match mod config.";
}
}
if ( pass ) {
if ( H5Pclose(fapl_id) < 0 ) {
pass = FALSE;
failure_mssg = "H5Pclose() failed.\n";
}
}
/* Open a file using the default FAPL. Verify that the resulting
* metadata cache uses the default configuration as well. Get a
* copy of the FAPL from the file, and verify that it contains the
* default initial meta data cache configuration. Close and delete
* the file.
*/
/* setup the file name */
if ( pass ) {
if ( h5_fixname(FILENAME[0], H5P_DEFAULT, filename, sizeof(filename))
== NULL ) {
pass = FALSE;
failure_mssg = "h5_fixname() failed.\n";
}
}
/* create the file using the default FAPL */
if ( pass ) {
file_id = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
if ( file_id < 0 ) {
pass = FALSE;
failure_mssg = "H5Fcreate() failed.\n";
}
}
/* get a pointer to the files internal data structure */
if ( pass ) {
file_ptr = H5I_object_verify(file_id, H5I_FILE);
if ( file_ptr == NULL ) {
pass = FALSE;
failure_mssg = "Can't get file_ptr.\n";
} else {
cache_ptr = file_ptr->shared->cache;
}
}
/* verify that we can access the internal version of the cache config */
if ( pass ) {
if ( ( cache_ptr == NULL ) ||
( cache_ptr->magic != H5C__H5C_T_MAGIC ) ||
( cache_ptr->resize_ctl.version != H5C__CURR_AUTO_SIZE_CTL_VER ) ){
pass = FALSE;
failure_mssg = "Can't access cache resize_ctl.\n";
}
}
/* conpare the cache's internal configuration with the expected value */
if ( pass ) {
if ( ! RESIZE_CONFIGS_ARE_EQUAL(default_auto_size_ctl, \
cache_ptr->resize_ctl, TRUE) ) {
pass = FALSE;
failure_mssg = "Unexpected value(s) in cache resize_ctl.\n";
}
}
/* get a copy of the files FAPL */
if ( pass ) {
fapl_id = H5Fget_access_plist(file_id);
if ( fapl_id < 0 ) {
pass = FALSE;
failure_mssg = "H5Fget_access_plist() failed.\n";
}
}
/* compare the initial cache config from the copy of the file's FAPL
* to the expected value. If all goes well, close the copy of the FAPL.
*/
if ( pass ) {
scratch.version = H5C__CURR_AUTO_SIZE_CTL_VER;
result = H5Pget_mdc_config(fapl_id, &scratch);
if ( result < 0 ) {
pass = FALSE;
failure_mssg = "H5Pget_mdc_config() failed.\n";
} else if (!CACHE_CONFIGS_EQUAL(default_config, scratch, TRUE, TRUE)) {
pass = FALSE;
failure_mssg = "config retrieved from file doesn't match default.";
} else if ( H5Pclose(fapl_id) < 0 ) {
pass = FALSE;
failure_mssg = "H5Pclose() failed.\n";
}
}
/* close the file and delete it */
if ( pass ) {
if ( H5Fclose(file_id) < 0 ) {
pass = FALSE;
failure_mssg = "H5Fclose() failed.\n";
} else if ( HDremove(filename) < 0 ) {
pass = FALSE;
failure_mssg = "HDremove() failed.\n";
}
}
/* Open a file using a FAPL with a modified initial metadata cache
* configuration. Verify that the resulting metadata cache uses the
* modified configuration as well. Get a copy of the FAPL from the
* file, and verify that it contains the modified initial meta data
* cache configuration. Close and delete the file.
*/
/* Create a FAPL */
if ( pass ) {
fapl_id = H5Pcreate(H5P_FILE_ACCESS);
if ( fapl_id < 0 ) {
pass = FALSE;
failure_mssg = "H5Pcreate(H5P_FILE_ACCESS) failed.\n";
}
}
/* Modify the initial mdc configuration in the FAPL. */
if ( pass ) {
result = H5Pset_mdc_config(fapl_id, &mod_config);
if ( result < 0 ) {
pass = FALSE;
failure_mssg = "H5Pset_mdc_config() failed.\n";
}
}
/* setup the file name */
if ( pass ) {
if ( h5_fixname(FILENAME[0], H5P_DEFAULT, filename, sizeof(filename))
== NULL ) {
pass = FALSE;
failure_mssg = "h5_fixname() failed.\n";
}
}
/* create the file using the modified FAPL */
if ( pass ) {
file_id = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl_id);
if ( file_id < 0 ) {
pass = FALSE;
failure_mssg = "H5Fcreate() failed.\n";
}
}
/* get a pointer to the files internal data structure */
if ( pass ) {
file_ptr = H5I_object_verify(file_id, H5I_FILE);
if ( file_ptr == NULL ) {
pass = FALSE;
failure_mssg = "Can't get file_ptr.\n";
} else {
cache_ptr = file_ptr->shared->cache;
}
}
/* verify that we can access the internal version of the cache config */
if ( pass ) {
if ( ( cache_ptr == NULL ) ||
( cache_ptr->magic != H5C__H5C_T_MAGIC ) ||
( cache_ptr->resize_ctl.version != H5C__CURR_AUTO_SIZE_CTL_VER ) ){
pass = FALSE;
failure_mssg = "Can't access cache resize_ctl.\n";
}
}
/* conpare the cache's internal configuration with the expected value */
if ( pass ) {
if ( ! RESIZE_CONFIGS_ARE_EQUAL(mod_auto_size_ctl, \
cache_ptr->resize_ctl, TRUE) ) {
pass = FALSE;
failure_mssg = "Unexpected value(s) in cache resize_ctl.\n";
}
}
/* get a copy of the files FAPL */
if ( pass ) {
test_fapl_id = H5Fget_access_plist(file_id);
if ( test_fapl_id < 0 ) {
pass = FALSE;
failure_mssg = "H5Fget_access_plist() failed.\n";
}
}
/* compare the initial cache config from the copy of the file's FAPL
* to the expected value. If all goes well, close the copy of the FAPL.
*/
if ( pass ) {
scratch.version = H5C__CURR_AUTO_SIZE_CTL_VER;
result = H5Pget_mdc_config(test_fapl_id, &scratch);
if ( result < 0 ) {
pass = FALSE;
failure_mssg = "H5Pget_mdc_config() failed.\n";
} else if ( ! CACHE_CONFIGS_EQUAL(mod_config, scratch, TRUE, TRUE) ) {
pass = FALSE;
failure_mssg = "config retrieved from file doesn't match.";
} else if ( H5Pclose(test_fapl_id) < 0 ) {
pass = FALSE;
failure_mssg = "H5Pclose() failed.\n";
}
}
/* close the fapl used to create the file */
if ( pass ) {
if ( H5Pclose(fapl_id) < 0 ) {
pass = FALSE;
failure_mssg = "H5Pclose() failed.\n";
}
}
/* close the file and delete it */
if ( pass ) {
if ( H5Fclose(file_id) < 0 ) {
pass = FALSE;
failure_mssg = "H5Fclose() failed.\n";
} else if ( HDremove(filename) < 0 ) {
pass = FALSE;
failure_mssg = "HDremove() failed.\n";
}
}
if ( pass ) { PASSED(); } else { H5_FAILED(); }
if ( ! pass )
HDfprintf(stdout, "%s: failure_mssg = \"%s\".\n",
fcn_name, failure_mssg);
} /* check_fapl_mdc_api_calls() */
/*-------------------------------------------------------------------------
* Function: validate_mdc_config()
*
* Purpose: Verify that the file indicated by the file_id parameter
* has both internal and external configuration matching
* *config_ptr.
*
* Do nothin on success. On failure, set pass to FALSE, and
* load an error message into failue_mssg. Note that
* failure_msg is assumed to be at least 128 bytes in length.
*
* Return: void
*
* Programmer: John Mainzer
* 4/14/04
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static void
validate_mdc_config(hid_t file_id,
H5AC_cache_config_t * ext_config_ptr,
hbool_t compare_init,
int test_num)
{
/* const char * fcn_name = "validate_mdc_config()"; */
static char msg[256];
H5F_t * file_ptr = NULL;
H5C_t * cache_ptr = NULL;
H5AC_cache_config_t scratch;
H5C_auto_size_ctl_t int_config;
XLATE_EXT_TO_INT_MDC_CONFIG(int_config, (*ext_config_ptr))
/* get a pointer to the files internal data structure */
if ( pass ) {
file_ptr = H5I_object_verify(file_id, H5I_FILE);
if ( file_ptr == NULL ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Can't get file_ptr #%d.", test_num);
failure_mssg = msg;
} else {
cache_ptr = file_ptr->shared->cache;
}
}
/* verify that we can access the internal version of the cache config */
if ( pass ) {
if ( ( cache_ptr == NULL ) ||
( cache_ptr->magic != H5C__H5C_T_MAGIC ) ||
( cache_ptr->resize_ctl.version != H5C__CURR_AUTO_SIZE_CTL_VER ) ){
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"Can't access cache resize_ctl #%d.", test_num);
failure_mssg = msg;
}
}
/* compare the cache's internal configuration with the expected value */
if ( pass ) {
if ( ! RESIZE_CONFIGS_ARE_EQUAL(int_config, cache_ptr->resize_ctl,
compare_init) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"Unexpected internal config #%d.", test_num);
failure_mssg = msg;
}
}
/* obtain external cache config */
if ( pass ) {
scratch.version = H5AC__CURR_CACHE_CONFIG_VERSION;
if ( H5Fget_mdc_config(file_id, &scratch) < 0 ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"H5Fget_mdc_config() failed #%d.", test_num);
failure_mssg = msg;
}
}
if ( pass ) {
/* Recall that in any configuration supplied by the cache
* at run time, the set_initial_size field will always
* be FALSE, regardless of the value passed in. Thus we
* always resume that this field need not match that of
* the supplied external configuration.
*
* The cache also sets the initial_size field to the current
* cache max size instead of the value initialy supplied.
* Depending on circumstances, this may or may not match
* the original. Hence the compare_init parameter.
*/
if ( ! CACHE_CONFIGS_EQUAL((*ext_config_ptr), scratch, \
FALSE, compare_init) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"Unexpected external config #%d.", test_num);
failure_mssg = msg;
}
}
return;
} /* validate_mdc_config() */
/*-------------------------------------------------------------------------
* Function: check_file_mdc_api_calls()
*
* Purpose: Verify that the file related metadata cache API calls are
* functioning correctly.
*
* Since we have tested the H5C code elsewhere, it should
* be sufficient to verify that the desired configuration
* data is getting in and out of the cache. Similarly,
* we need only verify that the cache monitoring calls
* return the data that the cache thinks they should return.
* We shouldn't need to verify data correctness beyond that
* point.
*
* Return: void
*
* Programmer: John Mainzer
* 4/14/04
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static void
check_file_mdc_api_calls(void)
{
const char * fcn_name = "check_file_mdc_api_calls()";
char filename[512];
hid_t file_id = -1;
size_t max_size;
size_t min_clean_size;
size_t cur_size;
int cur_num_entries;
double hit_rate;
H5AC_cache_config_t default_config = H5AC__DEFAULT_CACHE_CONFIG;
H5AC_cache_config_t mod_config_1 =
{
/* int version = */ H5C__CURR_AUTO_SIZE_CTL_VER,
/* hbool_t rpt_fcn_enabled = */ FALSE,
/* hbool_t set_initial_size = */ TRUE,
/* size_t initial_size = */ (1 * 1024 * 1024 + 1),
/* double min_clean_fraction = */ 0.2,
/* size_t max_size = */ (16 * 1024 * 1024 + 1),
/* size_t min_size = */ ( 1 * 1024 * 1024 + 1),
/* long int epoch_length = */ 50001,
/* enum H5C_cache_incr_mode incr_mode = */ H5C_incr__threshold,
/* double lower_hr_threshold = */ 0.91,
/* double increment = */ 2.1,
/* hbool_t apply_max_increment = */ TRUE,
/* size_t max_increment = */ (4 * 1024 * 1024 + 1),
/* enum H5C_cache_decr_mode decr_mode = */ H5C_decr__age_out,
/* double upper_hr_threshold = */ 0.998,
/* double decrement = */ 0.91,
/* hbool_t apply_max_decrement = */ TRUE,
/* size_t max_decrement = */ (1 * 1024 * 1024 - 1),
/* int epochs_before_eviction = */ 4,
/* hbool_t apply_empty_reserve = */ TRUE,
/* double empty_reserve = */ 0.05
};
H5AC_cache_config_t mod_config_2 =
{
/* int version = */ H5C__CURR_AUTO_SIZE_CTL_VER,
/* hbool_t rpt_fcn_enabled = */ TRUE,
/* hbool_t set_initial_size = */ TRUE,
/* size_t initial_size = */ (512 * 1024),
/* double min_clean_fraction = */ 0.1,
/* size_t max_size = */ ( 8 * 1024 * 1024),
/* size_t min_size = */ ( 512 * 1024),
/* long int epoch_length = */ 25000,
/* enum H5C_cache_incr_mode incr_mode = */ H5C_incr__threshold,
/* double lower_hr_threshold = */ 0.9,
/* double increment = */ 2.0,
/* hbool_t apply_max_increment = */ TRUE,
/* size_t max_increment = */ (2 * 1024 * 1024),
/* enum H5C_cache_decr_mode decr_mode = */ H5C_decr__threshold,
/* double upper_hr_threshold = */ 0.9995,
/* double decrement = */ 0.95,
/* hbool_t apply_max_decrement = */ TRUE,
/* size_t max_decrement = */ (512 * 1024),
/* int epochs_before_eviction = */ 4,
/* hbool_t apply_empty_reserve = */ TRUE,
/* double empty_reserve = */ 0.05
};
H5AC_cache_config_t mod_config_3 =
{
/* int version = */ H5C__CURR_AUTO_SIZE_CTL_VER,
/* hbool_t rpt_fcn_enabled = */ FALSE,
/* hbool_t set_initial_size = */ TRUE,
/* size_t initial_size = */ (1 * 1024 * 1024),
/* double min_clean_fraction = */ 0.2,
/* size_t max_size = */ (16 * 1024 * 1024),
/* size_t min_size = */ ( 1 * 1024 * 1024),
/* long int epoch_length = */ 50000,
/* enum H5C_cache_incr_mode incr_mode = */ H5C_incr__off,
/* double lower_hr_threshold = */ 0.90,
/* 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.999,
/* double decrement = */ 0.9,
/* hbool_t apply_max_decrement = */ FALSE,
/* size_t max_decrement = */ (1 * 1024 * 1024 - 1),
/* int epochs_before_eviction = */ 3,
/* hbool_t apply_empty_reserve = */ FALSE,
/* double empty_reserve = */ 0.05
};
H5AC_cache_config_t mod_config_4 =
{
/* int version = */ H5C__CURR_AUTO_SIZE_CTL_VER,
/* hbool_t rpt_fcn_enabled = */ FALSE,
/* hbool_t set_initial_size = */ TRUE,
/* size_t initial_size = */ (1 * 1024 * 1024),
/* double min_clean_fraction = */ 0.15,
/* size_t max_size = */ (20 * 1024 * 1024),
/* size_t min_size = */ ( 1 * 1024 * 1024),
/* long int epoch_length = */ 75000,
/* enum H5C_cache_incr_mode incr_mode = */ H5C_incr__threshold,
/* double lower_hr_threshold = */ 0.9,
/* double increment = */ 2.0,
/* hbool_t apply_max_increment = */ TRUE,
/* size_t max_increment = */ (2 * 1024 * 1024),
/* enum H5C_cache_decr_mode decr_mode = */
H5C_decr__age_out_with_threshold,
/* double upper_hr_threshold = */ 0.999,
/* double decrement = */ 0.9,
/* hbool_t apply_max_decrement = */ TRUE,
/* size_t max_decrement = */ (1 * 1024 * 1024),
/* int epochs_before_eviction = */ 3,
/* hbool_t apply_empty_reserve = */ TRUE,
/* double empty_reserve = */ 0.1
};
TESTING("MDC/FILE related API calls");
pass = TRUE;
/* Open a file with the default FAPL. Verify that the cache is
* configured as per the default both by looking at its internal
* configuration, and via the H5Fget_mdc_config() call.
*
* Then set serveral different configurations, and verify that
* they took as per above.
*/
/* setup the file name */
if ( pass ) {
if ( h5_fixname(FILENAME[0], H5P_DEFAULT, filename, sizeof(filename))
== NULL ) {
pass = FALSE;
failure_mssg = "h5_fixname() failed.\n";
}
}
/* create the file using the default FAPL */
if ( pass ) {
file_id = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
if ( file_id < 0 ) {
pass = FALSE;
failure_mssg = "H5Fcreate() failed.\n";
}
}
/* verify that the cache is set to the default config */
validate_mdc_config(file_id, &default_config, TRUE, 1);
/* set alternate config 1 */
if ( pass ) {
if ( H5Fset_mdc_config(file_id, &mod_config_1) < 0 ) {
pass = FALSE;
failure_mssg = "H5Fset_mdc_config() failed 1.\n";
}
}
/* verify that the cache is now set to the alternate config */
validate_mdc_config(file_id, &mod_config_1, TRUE, 2);
/* set alternate config 2 */
if ( pass ) {
if ( H5Fset_mdc_config(file_id, &mod_config_2) < 0 ) {
pass = FALSE;
failure_mssg = "H5Fset_mdc_config() failed 2.\n";
}
}
/* verify that the cache is now set to the alternate config */
validate_mdc_config(file_id, &mod_config_2, TRUE, 3);
/* set alternate config 3 */
if ( pass ) {
if ( H5Fset_mdc_config(file_id, &mod_config_3) < 0 ) {
pass = FALSE;
failure_mssg = "H5Fset_mdc_config() failed 3.\n";
}
}
/* verify that the cache is now set to the alternate config */
validate_mdc_config(file_id, &mod_config_3, TRUE, 4);
/* set alternate config 4 */
if ( pass ) {
if ( H5Fset_mdc_config(file_id, &mod_config_4) < 0 ) {
pass = FALSE;
failure_mssg = "H5Fset_mdc_config() failed 4.\n";
}
}
/* verify that the cache is now set to the alternate config */
validate_mdc_config(file_id, &mod_config_4, TRUE, 5);
/* Run some quick smoke checks on the cache status monitoring
* calls -- no interesting data as the cache hasn't had a
* chance to do much yet.
*/
if ( pass ) {
if ( H5Fget_mdc_hit_rate(file_id, &hit_rate) < 0 ) {
pass = FALSE;
failure_mssg = "H5Fget_mdc_hit_rate() failed 1.\n";
} else if ( hit_rate != 0.0 ) {
pass = FALSE;
failure_mssg =
"H5Fget_mdc_hit_rate() returned unexpected hit rate.\n";
}
#if 0 /* this may be useful now and then -- keep it around */
else {
HDfprintf(stdout,
"H5Fget_mdc_hit_rate() reports hit_rate = %lf:\n",
hit_rate);
}
#endif
}
if ( pass ) {
if ( H5Fget_mdc_size(file_id, &max_size, &min_clean_size,
&cur_size, &cur_num_entries) < 0 ) {
pass = FALSE;
failure_mssg = "H5Fget_mdc_size() failed 1.\n";
} else if ( ( mod_config_4.initial_size != max_size ) ||
( min_clean_size != (size_t)
((double)max_size * mod_config_4.min_clean_fraction) ) ) {
pass = FALSE;
failure_mssg = "H5Fget_mdc_size() returned unexpected value(s).\n";
}
#if 0 /* this may be useful now and then -- keep it around */
else {
HDfprintf(stdout, "H5Fget_mdc_size() reports:\n");
HDfprintf(stdout, " max_size: %ld, min_clean_size: %ld\n",
(long)max_size, (long)min_clean_size);
HDfprintf(stdout, " cur_size: %ld, cur_num_entries: %d\n",
(long)cur_size, cur_num_entries);
}
#endif
}
/* close the file and delete it */
if ( pass ) {
if ( H5Fclose(file_id) < 0 ) {
pass = FALSE;
failure_mssg = "H5Fclose() failed.\n";
} else if ( HDremove(filename) < 0 ) {
pass = FALSE;
failure_mssg = "HDremove() failed.\n";
}
}
if ( pass ) { PASSED(); } else { H5_FAILED(); }
if ( ! pass )
HDfprintf(stdout, "%s: failure_mssg = \"%s\".\n",
fcn_name, failure_mssg);
} /* check_file_mdc_api_calls() */
/*-------------------------------------------------------------------------
* Function: check_and_validate_cache_hit_rate()
*
* Purpose: Use the API functions to get and reset the cache hit rate.
* Verify that the value returned by the API call agrees with
* the cache internal data structures.
*
* If the number of cache accesses exceeds the value provided
* in the min_accesses parameter, and the hit rate is less than
* min_hit_rate, set pass to FALSE, and set failure_mssg to
* a string indicating that hit rate was unexpectedly low.
*
* Return hit rate in *hit_rate_ptr, and print the data to
* stdout if requested.
*
* If an error is detected, set pass to FALSE, and set
* failure_mssg to an appropriate value.
*
* Return: void
*
* Programmer: John Mainzer
* 4/18/04
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static void
check_and_validate_cache_hit_rate(hid_t file_id,
double * hit_rate_ptr,
hbool_t dump_data,
int64_t min_accesses,
double min_hit_rate)
{
/* const char * fcn_name = "check_and_validate_cache_hit_rate()"; */
herr_t result;
int64_t cache_hits;
int64_t cache_accesses;
double expected_hit_rate;
double hit_rate;
H5F_t * file_ptr = NULL;
H5C_t * cache_ptr = NULL;
/* get a pointer to the files internal data structure */
if ( pass ) {
file_ptr = H5I_object_verify(file_id, H5I_FILE);
if ( file_ptr == NULL ) {
pass = FALSE;
failure_mssg = "Can't get file_ptr.";
} else {
cache_ptr = file_ptr->shared->cache;
}
}
/* verify that we can access the cache data structure */
if ( pass ) {
if ( ( cache_ptr == NULL ) ||
( cache_ptr->magic != H5C__H5C_T_MAGIC ) ) {
pass = FALSE;
failure_mssg = "Can't access cache resize_ctl.";
}
}
/* compare the cache's internal configuration with the expected value */
if ( pass ) {
cache_hits = cache_ptr->cache_hits;
cache_accesses = cache_ptr->cache_accesses;
if ( cache_accesses > 0 ) {
expected_hit_rate = ((double)cache_hits) / ((double)cache_accesses);
} else {
expected_hit_rate = 0.0;
}
result = H5Fget_mdc_hit_rate(file_id, &hit_rate);
if ( result < 0 ) {
pass = FALSE;
failure_mssg = "H5Fget_mdc_hit_rate() failed.";
} else if ( hit_rate != expected_hit_rate ) {
pass = FALSE;
failure_mssg = "unexpected hit rate.";
}
}
if ( pass ) { /* reset the hit rate */
result = H5Freset_mdc_hit_rate_stats(file_id);
if ( result < 0 ) {
pass = FALSE;
failure_mssg = "H5Freset_mdc_hit_rate_stats() failed.";
}
}
/* set *hit_rate_ptr if appropriate */
if ( ( pass ) && ( hit_rate_ptr != NULL ) ) {
*hit_rate_ptr = hit_rate;
}
/* dump data to stdout if requested */
if ( ( pass ) && ( dump_data ) ) {
HDfprintf(stdout,
"cache_hits: %ld, cache_accesses: %ld, hit_rate: %lf\n",
(long)cache_hits, (long)cache_accesses, hit_rate);
}
if ( ( pass ) &&
( cache_accesses > min_accesses ) &&
( hit_rate < min_hit_rate ) ) {
pass = FALSE;
failure_mssg = "Unexpectedly low hit rate.";
}
return;
} /* check_and_validate_cache_hit_rate() */
/*-------------------------------------------------------------------------
* Function: check_and_validate_cache_size()
*
* Purpose: Use the API function to get the cache size data. Verify
* that the values returned by the API call agree with
* the cache internal data structures.
*
* Return size data in the locations specified by the pointer
* parameters if these parameters are not NULL. Print the
* data to stdout if requested.
*
* If an error is detected, set pass to FALSE, and set
* failure_mssg to an appropriate value.
*
* Return: void
*
* Programmer: John Mainzer
* 4/18/04
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static void
check_and_validate_cache_size(hid_t file_id,
size_t * max_size_ptr,
size_t * min_clean_size_ptr,
size_t * cur_size_ptr,
int32_t * cur_num_entries_ptr,
hbool_t dump_data)
{
/* const char * fcn_name = "check_and_validate_cache_size()"; */
herr_t result;
size_t expected_max_size;
size_t max_size;
size_t expected_min_clean_size;
size_t min_clean_size;
size_t expected_cur_size;
size_t cur_size;
int32_t expected_cur_num_entries;
int cur_num_entries;
H5F_t * file_ptr = NULL;
H5C_t * cache_ptr = NULL;
/* get a pointer to the files internal data structure */
if ( pass ) {
file_ptr = H5I_object_verify(file_id, H5I_FILE);
if ( file_ptr == NULL ) {
pass = FALSE;
failure_mssg = "Can't get file_ptr.";
} else {
cache_ptr = file_ptr->shared->cache;
}
}
/* verify that we can access the cache data structure */
if ( pass ) {
if ( ( cache_ptr == NULL ) ||
( cache_ptr->magic != H5C__H5C_T_MAGIC ) ) {
pass = FALSE;
failure_mssg = "Can't access cache data structure.";
}
}
/* compare the cache's internal configuration with the expected value */
if ( pass ) {
expected_max_size = cache_ptr->max_cache_size;
expected_min_clean_size = cache_ptr->min_clean_size;
expected_cur_size = cache_ptr->index_size;
expected_cur_num_entries = cache_ptr->index_len;
result = H5Fget_mdc_size(file_id,
&max_size,
&min_clean_size,
&cur_size,
&cur_num_entries);
if ( result < 0 ) {
pass = FALSE;
failure_mssg = "H5Fget_mdc_size() failed.";
} else if ( ( max_size != expected_max_size ) ||
( min_clean_size != expected_min_clean_size ) ||
( cur_size != expected_cur_size ) ||
( cur_num_entries != (int)expected_cur_num_entries ) ) {
pass = FALSE;
failure_mssg = "H5Fget_mdc_size() returned unexpected value(s).";
}
}
/* return size values if requested */
if ( ( pass ) && ( max_size_ptr != NULL ) ) {
*max_size_ptr = max_size;
}
if ( ( pass ) && ( min_clean_size_ptr != NULL ) ) {
*min_clean_size_ptr = min_clean_size;
}
if ( ( pass ) && ( cur_size_ptr != NULL ) ) {
*cur_size_ptr = cur_size;
}
if ( ( pass ) && ( cur_num_entries_ptr != NULL ) ) {
*cur_num_entries_ptr = cur_num_entries;
}
/* dump data to stdout if requested */
if ( ( pass ) && ( dump_data ) ) {
HDfprintf(stdout,
"max_sz: %ld, min_clean_sz: %ld, cur_sz: %ld, cur_ent: %ld\n",
(long)max_size, (long)min_clean_size, (long)cur_size,
(long)cur_num_entries);
}
return;
} /* check_and_validate_cache_size() */
/*-------------------------------------------------------------------------
* Function: mdc_api_call_smoke_check()
*
* Purpose:
*
* Return: void
*
* Programmer: John Mainzer
* 4/14/04
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
#define CHUNK_SIZE 2
#define DSET_SIZE (200 * CHUNK_SIZE)
#define NUM_DSETS 6
#define NUM_RANDOM_ACCESSES 200000
static void
mdc_api_call_smoke_check(void)
{
const char * fcn_name = "mdc_api_call_smoke_check()";
char filename[512];
hbool_t valid_chunk;
hbool_t dump_hit_rate = FALSE;
int64_t min_accesses = 1000;
double min_hit_rate = 0.90;
hbool_t dump_cache_size = FALSE;
hid_t file_id = -1;
hid_t dataspace_id;
hid_t filespace_ids[NUM_DSETS];
hid_t memspace_id;
hid_t dataset_ids[NUM_DSETS];
hid_t properties;
char dset_name[64];
int i, j, k, l, m, n;
herr_t status;
hsize_t dims[2];
hsize_t a_size[2];
hsize_t offset[2];
hsize_t chunk_size[2];
int data_chunk[CHUNK_SIZE][CHUNK_SIZE];
H5AC_cache_config_t default_config = H5AC__DEFAULT_CACHE_CONFIG;
H5AC_cache_config_t mod_config_1 =
{
/* int version = */ H5C__CURR_AUTO_SIZE_CTL_VER,
/* hbool_t rpt_fcn_enabled = */ FALSE,
/* hbool_t set_initial_size = */ TRUE,
/* size_t initial_size = */ 500000,
/* double min_clean_fraction = */ 0.1,
/* size_t max_size = */ 16000000,
/* size_t min_size = */ 250000,
/* long int epoch_length = */ 50000,
/* enum H5C_cache_incr_mode incr_mode = */ H5C_incr__off,
/* double lower_hr_threshold = */ 0.95,
/* double increment = */ 2.0,
/* hbool_t apply_max_increment = */ FALSE,
/* size_t max_increment = */ 4000000,
/* enum H5C_cache_decr_mode decr_mode = */ H5C_decr__off,
/* double upper_hr_threshold = */ 0.999,
/* double decrement = */ 0.9,
/* hbool_t apply_max_decrement = */ FALSE,
/* size_t max_decrement = */ 1000000,
/* int epochs_before_eviction = */ 2,
/* hbool_t apply_empty_reserve = */ TRUE,
/* double empty_reserve = */ 0.05
};
H5AC_cache_config_t mod_config_2 =
{
/* int version = */ H5C__CURR_AUTO_SIZE_CTL_VER,
/* hbool_t rpt_fcn_enabled = */ FALSE,
/* hbool_t set_initial_size = */ TRUE,
/* size_t initial_size = */ 12000000,
/* double min_clean_fraction = */ 0.1,
/* size_t max_size = */ 16000000,
/* size_t min_size = */ 250000,
/* long int epoch_length = */ 50000,
/* enum H5C_cache_incr_mode incr_mode = */ H5C_incr__off,
/* double lower_hr_threshold = */ 0.95,
/* double increment = */ 2.0,
/* hbool_t apply_max_increment = */ FALSE,
/* size_t max_increment = */ 4000000,
/* enum H5C_cache_decr_mode decr_mode = */ H5C_decr__off,
/* double upper_hr_threshold = */ 0.999,
/* double decrement = */ 0.9,
/* hbool_t apply_max_decrement = */ FALSE,
/* size_t max_decrement = */ 1000000,
/* int epochs_before_eviction = */ 2,
/* hbool_t apply_empty_reserve = */ TRUE,
/* double empty_reserve = */ 0.05
};
H5AC_cache_config_t mod_config_3 =
{
/* int version = */ H5C__CURR_AUTO_SIZE_CTL_VER,
/* hbool_t rpt_fcn_enabled = */ FALSE,
/* hbool_t set_initial_size = */ TRUE,
/* size_t initial_size = */ 2000000,
/* double min_clean_fraction = */ 0.1,
/* size_t max_size = */ 16000000,
/* size_t min_size = */ 250000,
/* long int epoch_length = */ 50000,
/* enum H5C_cache_incr_mode incr_mode = */ H5C_incr__off,
/* double lower_hr_threshold = */ 0.95,
/* double increment = */ 2.0,
/* hbool_t apply_max_increment = */ FALSE,
/* size_t max_increment = */ 4000000,
/* enum H5C_cache_decr_mode decr_mode = */ H5C_decr__off,
/* double upper_hr_threshold = */ 0.999,
/* double decrement = */ 0.9,
/* hbool_t apply_max_decrement = */ FALSE,
/* size_t max_decrement = */ 1000000,
/* int epochs_before_eviction = */ 2,
/* hbool_t apply_empty_reserve = */ TRUE,
/* double empty_reserve = */ 0.05
};
TESTING("MDC API smoke check");
pass = TRUE;
/* Open a file with the default FAPL. Verify that the cache is
* configured as per the default both by looking at its internal
* configuration, and via the H5Fget_mdc_config() call.
*
* Then set the cache to mod_config_1, which fixes cache size at
* 500000 bytes, and turns off automatic cache resize.
*/
/* setup the file name */
if ( pass ) {
if ( h5_fixname(FILENAME[0], H5P_DEFAULT, filename, sizeof(filename))
== NULL ) {
pass = FALSE;
failure_mssg = "h5_fixname() failed.\n";
}
}
/* create the file using the default FAPL */
if ( pass ) {
file_id = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
if ( file_id < 0 ) {
pass = FALSE;
failure_mssg = "H5Fcreate() failed.\n";
}
}
/* verify that the cache is set to the default config */
validate_mdc_config(file_id, &default_config, TRUE, 1);
/* set alternate config 1 */
if ( pass ) {
if ( H5Fset_mdc_config(file_id, &mod_config_1) < 0 ) {
pass = FALSE;
failure_mssg = "H5Fset_mdc_config() failed 1.\n";
}
}
/* verify that the cache is now set to the alternate config */
validate_mdc_config(file_id, &mod_config_1, TRUE, 2);
/* create the datasets */
if ( pass ) {
i = 0;
while ( ( pass ) && ( i < NUM_DSETS ) )
{
/* create a dataspace for the chunked dataset */
dims[0] = DSET_SIZE;
dims[1] = DSET_SIZE;
dataspace_id = H5Screate_simple(2, dims, NULL);
if ( dataspace_id < 0 ) {
pass = FALSE;
failure_mssg = "H5Screate_simple() failed.";
}
/* set the dataset creation plist to specify that the raw data is
* to be partioned into 10X10 element chunks.
*/
if ( pass ) {
chunk_size[0] = CHUNK_SIZE;
chunk_size[1] = CHUNK_SIZE;
properties = H5Pcreate(H5P_DATASET_CREATE);
if ( properties < 0 ) {
pass = FALSE;
failure_mssg = "H5Pcreate() failed.";
}
}
if ( pass ) {
if ( H5Pset_chunk(properties, 2, chunk_size) < 0 ) {
pass = FALSE;
failure_mssg = "H5Pset_chunk() failed.";
}
}
/* create the dataset */
if ( pass ) {
sprintf(dset_name, "/dset%03d", i);
dataset_ids[i] = H5Dcreate(file_id, dset_name, H5T_STD_I32BE,
dataspace_id, properties);
if ( dataset_ids[i] < 0 ) {
pass = FALSE;
failure_mssg = "H5Dcreate() failed.";
}
}
/* get the file space ID */
if ( pass ) {
filespace_ids[i] = H5Dget_space(dataset_ids[i]);
if ( filespace_ids[i] < 0 ) {
pass = FALSE;
failure_mssg = "H5Dget_space() failed.";
}
}
i++;
}
}
/* create the mem space to be used to read and write chunks */
if ( pass ) {
dims[0] = CHUNK_SIZE;
dims[1] = CHUNK_SIZE;
memspace_id = H5Screate_simple(2, dims, NULL);
if ( memspace_id < 0 ) {
pass = FALSE;
failure_mssg = "H5Screate_simple() failed.";
}
}
/* select in memory hyperslab */
if ( pass ) {
offset[0] = 0; /*offset of hyperslab in memory*/
offset[1] = 0;
a_size[0] = CHUNK_SIZE; /*size of hyperslab*/
a_size[1] = CHUNK_SIZE;
status = H5Sselect_hyperslab(memspace_id, H5S_SELECT_SET, offset, NULL,
a_size, NULL);
if ( status < 0 ) {
pass = FALSE;
failure_mssg = "H5Sselect_hyperslab() failed.";
}
}
/* initialize all datasets on a round robin basis */
i = 0;
while ( ( pass ) && ( i < DSET_SIZE ) )
{
j = 0;
while ( ( pass ) && ( j < DSET_SIZE ) )
{
m = 0;
while ( ( pass ) && ( m < NUM_DSETS ) )
{
/* initialize the slab */
for ( k = 0; k < CHUNK_SIZE; k++ )
{
for ( l = 0; l < CHUNK_SIZE; l++ )
{
data_chunk[k][l] = (DSET_SIZE * DSET_SIZE * m) +
(DSET_SIZE * (i + k)) + j + l;
}
}
/* select on disk hyperslab */
offset[0] = i; /*offset of hyperslab in file*/
offset[1] = j;
a_size[0] = CHUNK_SIZE; /*size of hyperslab*/
a_size[1] = CHUNK_SIZE;
status = H5Sselect_hyperslab(filespace_ids[m], H5S_SELECT_SET,
offset, NULL, a_size, NULL);
if ( status < 0 ) {
pass = FALSE;
failure_mssg = "disk H5Sselect_hyperslab() failed.";
}
/* write the chunk to file */
status = H5Dwrite(dataset_ids[m], H5T_NATIVE_INT, memspace_id,
filespace_ids[m], H5P_DEFAULT, data_chunk);
if ( status < 0 ) {
pass = FALSE;
failure_mssg = "H5Dwrite() failed.";
}
m++;
}
j += CHUNK_SIZE;
}
/* check the cache hit rate, and reset the counters.
* Hit rate should be just about unity here, so we will just
* get the data and (possibly) print it without checking it
* beyond ensuring that it agrees with the cache internal
* data structures.
*
* similarly, check cache size.
*/
if ( ( pass ) && ( i % (DSET_SIZE / 4) == 0 ) ) {
check_and_validate_cache_hit_rate(file_id, NULL, dump_hit_rate,
min_accesses, min_hit_rate);
check_and_validate_cache_size(file_id, NULL, NULL, NULL, NULL,
dump_cache_size);
}
i += CHUNK_SIZE;
}
/* set alternate config 2 */
if ( pass ) {
if ( H5Fset_mdc_config(file_id, &mod_config_2) < 0 ) {
pass = FALSE;
failure_mssg = "H5Fset_mdc_config() failed 2.\n";
}
}
/* verify that the cache is now set to the alternate config */
validate_mdc_config(file_id, &mod_config_2, TRUE, 3);
/* do random reads on all datasets */
n = 0;
while ( ( pass ) && ( n < NUM_RANDOM_ACCESSES ) )
{
m = rand() % NUM_DSETS;
i = (rand() % (DSET_SIZE / CHUNK_SIZE)) * CHUNK_SIZE;
j = (rand() % (DSET_SIZE / CHUNK_SIZE)) * CHUNK_SIZE;
/* select on disk hyperslab */
offset[0] = i; /*offset of hyperslab in file*/
offset[1] = j;
a_size[0] = CHUNK_SIZE; /*size of hyperslab*/
a_size[1] = CHUNK_SIZE;
status = H5Sselect_hyperslab(filespace_ids[m], H5S_SELECT_SET,
offset, NULL, a_size, NULL);
if ( status < 0 ) {
pass = FALSE;
failure_mssg = "disk hyperslab create failed.";
}
/* read the chunk from file */
if ( pass ) {
status = H5Dread(dataset_ids[m], H5T_NATIVE_INT, memspace_id,
filespace_ids[m], H5P_DEFAULT, data_chunk);
if ( status < 0 ) {
pass = FALSE;
failure_mssg = "disk hyperslab create failed.";
}
}
/* validate the slab */
if ( pass ) {
valid_chunk = TRUE;
for ( k = 0; k < CHUNK_SIZE; k++ )
{
for ( l = 0; l < CHUNK_SIZE; l++ )
{
if ( data_chunk[k][l]
!=
((DSET_SIZE * DSET_SIZE * m) +
(DSET_SIZE * (i + k)) + j + l) ) {
valid_chunk = FALSE;
#if 0 /* this will be useful from time to time -- lets keep it*/
HDfprintf(stdout,
"data_chunk[%0d][%0d] = %0d, expect %0d.\n",
k, l, data_chunk[k][l],
((DSET_SIZE * DSET_SIZE * m) +
(DSET_SIZE * (i + k)) + j + l));
HDfprintf(stdout,
"m = %d, i = %d, j = %d, k = %d, l = %d\n",
m, i, j, k, l);
#endif
}
}
}
if ( ! valid_chunk ) {
#if 1
pass = FALSE;
failure_mssg = "slab validation failed.";
#else /* as above */
fprintf(stdout, "Chunk (%0d, %0d) in /dset%03d is invalid.\n",
i, j, m);
#endif
}
}
if ( ( pass ) && ( n % (NUM_RANDOM_ACCESSES / 4) == 0 ) ) {
check_and_validate_cache_hit_rate(file_id, NULL, dump_hit_rate,
min_accesses, min_hit_rate);
check_and_validate_cache_size(file_id, NULL, NULL, NULL, NULL,
dump_cache_size);
}
n++;
}
/* close the file spaces we are done with */
i = 1;
while ( ( pass ) && ( i < NUM_DSETS ) )
{
if ( H5Sclose(filespace_ids[i]) < 0 ) {
pass = FALSE;
failure_mssg = "H5Sclose() failed.";
}
i++;
}
/* close the datasets we are done with */
i = 1;
while ( ( pass ) && ( i < NUM_DSETS ) )
{
if ( H5Dclose(dataset_ids[i]) < 0 ) {
pass = FALSE;
failure_mssg = "H5Dclose() failed.";
}
i++;
}
/* set alternate config 3 */
if ( pass ) {
if ( H5Fset_mdc_config(file_id, &mod_config_3) < 0 ) {
pass = FALSE;
failure_mssg = "H5Fset_mdc_config() failed 3.\n";
}
}
/* verify that the cache is now set to the alternate config */
validate_mdc_config(file_id, &mod_config_3, TRUE, 4);
/* do random reads on data set 0 only */
m = 0;
n = 0;
while ( ( pass ) && ( n < NUM_RANDOM_ACCESSES ) )
{
i = (rand() % (DSET_SIZE / CHUNK_SIZE)) * CHUNK_SIZE;
j = (rand() % (DSET_SIZE / CHUNK_SIZE)) * CHUNK_SIZE;
/* select on disk hyperslab */
offset[0] = i; /*offset of hyperslab in file*/
offset[1] = j;
a_size[0] = CHUNK_SIZE; /*size of hyperslab*/
a_size[1] = CHUNK_SIZE;
status = H5Sselect_hyperslab(filespace_ids[m], H5S_SELECT_SET,
offset, NULL, a_size, NULL);
if ( status < 0 ) {
pass = FALSE;
failure_mssg = "disk hyperslab create failed.";
}
/* read the chunk from file */
if ( pass ) {
status = H5Dread(dataset_ids[m], H5T_NATIVE_INT, memspace_id,
filespace_ids[m], H5P_DEFAULT, data_chunk);
if ( status < 0 ) {
pass = FALSE;
failure_mssg = "disk hyperslab create failed.";
}
}
/* validate the slab */
if ( pass ) {
valid_chunk = TRUE;
for ( k = 0; k < CHUNK_SIZE; k++ )
{
for ( l = 0; l < CHUNK_SIZE; l++ )
{
if ( data_chunk[k][l]
!=
((DSET_SIZE * DSET_SIZE * m) +
(DSET_SIZE * (i + k)) + j + l) ) {
valid_chunk = FALSE;
}
#if 0 /* this will be useful from time to time -- lets keep it */
HDfprintf(stdout, "data_chunk[%0d][%0d] = %0d, expect %0d.\n",
k, l, data_chunk[k][l],
((DSET_SIZE * DSET_SIZE * m) +
(DSET_SIZE * (i + k)) + j + l));
#endif
}
}
if ( ! valid_chunk ) {
pass = FALSE;
failure_mssg = "slab validation failed.";
#if 0 /* as above */
fprintf(stdout, "Chunk (%0d, %0d) in /dset%03d is invalid.\n",
i, j, m);
#endif
}
}
if ( ( pass ) && ( n % (NUM_RANDOM_ACCESSES / 4) == 0 ) ) {
check_and_validate_cache_hit_rate(file_id, NULL, dump_hit_rate,
min_accesses, min_hit_rate);
check_and_validate_cache_size(file_id, NULL, NULL, NULL, NULL,
dump_cache_size);
}
n++;
}
/* close file space 0 */
if ( pass ) {
if ( H5Sclose(filespace_ids[0]) < 0 ) {
pass = FALSE;
failure_mssg = "H5Sclose(filespace_ids[0]) failed.";
}
}
/* close the data space */
if ( pass ) {
if ( H5Sclose(dataspace_id) < 0 ) {
pass = FALSE;
failure_mssg = "H5Sclose(dataspace) failed.";
}
}
/* close the mem space */
if ( pass ) {
if ( H5Sclose(memspace_id) < 0 ) {
pass = FALSE;
failure_mssg = "H5Sclose(memspace_id) failed.";
}
}
/* close dataset 0 */
if ( pass ) {
if ( H5Dclose(dataset_ids[0]) < 0 ) {
pass = FALSE;
failure_mssg = "H5Dclose(dataset_ids[0]) failed.";
}
}
/* close the file and delete it */
if ( pass ) {
if ( H5Fclose(file_id) < 0 ) {
pass = FALSE;
failure_mssg = "H5Fclose() failed.\n";
}
else if ( HDremove(filename) < 0 ) {
pass = FALSE;
failure_mssg = "HDremove() failed.\n";
}
}
if ( pass ) { PASSED(); } else { H5_FAILED(); }
if ( ! pass )
HDfprintf(stdout, "%s: failure_mssg = \"%s\".\n",
fcn_name, failure_mssg);
} /* mdc_api_call_smoke_check() */
/* The following array of invalid external MDC cache configurations is
* used to test error rejection in the MDC related API calls.
*/
#define NUM_INVALID_CONFIGS 29
H5AC_cache_config_t invalid_configs[NUM_INVALID_CONFIGS] =
{
{
/* 0 -- bad version */
/* int version = */ -1,
/* hbool_t rpt_fcn_enabled = */ FALSE,
/* hbool_t set_initial_size = */ TRUE,
/* size_t initial_size = */ (1 * 1024 * 1024),
/* double min_clean_fraction = */ 0.25,
/* size_t max_size = */ (16 * 1024 * 1024),
/* size_t min_size = */ ( 1 * 1024 * 1024),
/* long int epoch_length = */ 50000,
/* enum H5C_cache_incr_mode incr_mode = */ H5C_incr__threshold,
/* double lower_hr_threshold = */ 0.9,
/* 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.999,
/* double decrement = */ 0.9,
/* hbool_t apply_max_decrement = */ TRUE,
/* size_t max_decrement = */ (1 * 1024 * 1024),
/* int epochs_before_eviction = */ 3,
/* hbool_t apply_empty_reserve = */ TRUE,
/* double empty_reserve = */ 0.1
},
{
/* 1 -- bad rpt_fcn_enabled */
/* int version = */ H5C__CURR_AUTO_SIZE_CTL_VER,
/* hbool_t rpt_fcn_enabled = */ -1,
/* hbool_t set_initial_size = */ TRUE,
/* size_t initial_size = */ (1 * 1024 * 1024),
/* double min_clean_fraction = */ 0.25,
/* size_t max_size = */ (16 * 1024 * 1024),
/* size_t min_size = */ ( 1 * 1024 * 1024),
/* long int epoch_length = */ 50000,
/* enum H5C_cache_incr_mode incr_mode = */ H5C_incr__threshold,
/* double lower_hr_threshold = */ 0.9,
/* 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.999,
/* double decrement = */ 0.9,
/* hbool_t apply_max_decrement = */ TRUE,
/* size_t max_decrement = */ (1 * 1024 * 1024),
/* int epochs_before_eviction = */ 3,
/* hbool_t apply_empty_reserve = */ TRUE,
/* double empty_reserve = */ 0.1
},
{
/* 2 -- bad set_initial_size */
/* int version = */ H5C__CURR_AUTO_SIZE_CTL_VER,
/* hbool_t rpt_fcn_enabled = */ FALSE,
/* hbool_t set_initial_size = */ 2,
/* size_t initial_size = */ (1 * 1024 * 1024),
/* double min_clean_fraction = */ 0.25,
/* size_t max_size = */ (16 * 1024 * 1024),
/* size_t min_size = */ ( 1 * 1024 * 1024),
/* long int epoch_length = */ 50000,
/* enum H5C_cache_incr_mode incr_mode = */ H5C_incr__threshold,
/* double lower_hr_threshold = */ 0.9,
/* 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.999,
/* double decrement = */ 0.9,
/* hbool_t apply_max_decrement = */ TRUE,
/* size_t max_decrement = */ (1 * 1024 * 1024),
/* int epochs_before_eviction = */ 3,
/* hbool_t apply_empty_reserve = */ TRUE,
/* double empty_reserve = */ 0.1
},
{
/* 3 -- max_size too big */
/* int version = */ H5C__CURR_AUTO_SIZE_CTL_VER,
/* hbool_t rpt_fcn_enabled = */ FALSE,
/* hbool_t set_initial_size = */ TRUE,
/* size_t initial_size = */ (1 * 1024 * 1024),
/* double min_clean_fraction = */ 0.25,
/* size_t max_size = */ H5C__MAX_MAX_CACHE_SIZE + 1,
/* size_t min_size = */ ( 1 * 1024 * 1024),
/* long int epoch_length = */ 50000,
/* enum H5C_cache_incr_mode incr_mode = */ H5C_incr__threshold,
/* double lower_hr_threshold = */ 0.9,
/* 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.999,
/* double decrement = */ 0.9,
/* hbool_t apply_max_decrement = */ TRUE,
/* size_t max_decrement = */ (1 * 1024 * 1024),
/* int epochs_before_eviction = */ 3,
/* hbool_t apply_empty_reserve = */ TRUE,
/* double empty_reserve = */ 0.1
},
{
/* 4 -- min_size too small */
/* int version = */ H5C__CURR_AUTO_SIZE_CTL_VER,
/* hbool_t rpt_fcn_enabled = */ FALSE,
/* hbool_t set_initial_size = */ TRUE,
/* size_t initial_size = */ (1 * 1024 * 1024),
/* double min_clean_fraction = */ 0.25,
/* size_t max_size = */ (16 * 1024 * 1024),
/* size_t min_size = */ H5C__MIN_MAX_CACHE_SIZE - 1,
/* long int epoch_length = */ 50000,
/* enum H5C_cache_incr_mode incr_mode = */ H5C_incr__threshold,
/* double lower_hr_threshold = */ 0.9,
/* 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.999,
/* double decrement = */ 0.9,
/* hbool_t apply_max_decrement = */ TRUE,
/* size_t max_decrement = */ (1 * 1024 * 1024),
/* int epochs_before_eviction = */ 3,
/* hbool_t apply_empty_reserve = */ TRUE,
/* double empty_reserve = */ 0.1
},
{
/* 5 -- min_size > max_size */
/* int version = */ H5C__CURR_AUTO_SIZE_CTL_VER,
/* hbool_t rpt_fcn_enabled = */ FALSE,
/* hbool_t set_initial_size = */ FALSE,
/* size_t initial_size = */ (1 * 1024 * 1024),
/* double min_clean_fraction = */ 0.25,
/* size_t max_size = */ (16 * 1024 * 1024),
/* size_t min_size = */ (16 * 1024 * 1024 + 1),
/* long int epoch_length = */ 50000,
/* enum H5C_cache_incr_mode incr_mode = */ H5C_incr__threshold,
/* double lower_hr_threshold = */ 0.9,
/* 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.999,
/* double decrement = */ 0.9,
/* hbool_t apply_max_decrement = */ TRUE,
/* size_t max_decrement = */ (1 * 1024 * 1024),
/* int epochs_before_eviction = */ 3,
/* hbool_t apply_empty_reserve = */ TRUE,
/* double empty_reserve = */ 0.1
},
{
/* 6 -- initial size out of range (too big) */
/* int version = */ H5C__CURR_AUTO_SIZE_CTL_VER,
/* hbool_t rpt_fcn_enabled = */ FALSE,
/* hbool_t set_initial_size = */ TRUE,
/* size_t initial_size = */ (16 * 1024 * 1024 + 1),
/* double min_clean_fraction = */ 0.25,
/* size_t max_size = */ (16 * 1024 * 1024),
/* size_t min_size = */ ( 1 * 1024 * 1024),
/* long int epoch_length = */ 50000,
/* enum H5C_cache_incr_mode incr_mode = */ H5C_incr__threshold,
/* double lower_hr_threshold = */ 0.9,
/* 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.999,
/* double decrement = */ 0.9,
/* hbool_t apply_max_decrement = */ TRUE,
/* size_t max_decrement = */ (1 * 1024 * 1024),
/* int epochs_before_eviction = */ 3,
/* hbool_t apply_empty_reserve = */ TRUE,
/* double empty_reserve = */ 0.1
},
{
/* 7 -- initial_size out of range (too small) */
/* int version = */ H5C__CURR_AUTO_SIZE_CTL_VER,
/* hbool_t rpt_fcn_enabled = */ FALSE,
/* hbool_t set_initial_size = */ TRUE,
/* size_t initial_size = */ (1 * 1024 * 1024 - 1),
/* double min_clean_fraction = */ 0.25,
/* size_t max_size = */ (16 * 1024 * 1024),
/* size_t min_size = */ ( 1 * 1024 * 1024),
/* long int epoch_length = */ 50000,
/* enum H5C_cache_incr_mode incr_mode = */ H5C_incr__threshold,
/* double lower_hr_threshold = */ 0.9,
/* 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.999,
/* double decrement = */ 0.9,
/* hbool_t apply_max_decrement = */ TRUE,
/* size_t max_decrement = */ (1 * 1024 * 1024),
/* int epochs_before_eviction = */ 3,
/* hbool_t apply_empty_reserve = */ TRUE,
/* double empty_reserve = */ 0.1
},
{
/* 8 -- min_clean_fraction too big */
/* int version = */ H5C__CURR_AUTO_SIZE_CTL_VER,
/* hbool_t rpt_fcn_enabled = */ FALSE,
/* hbool_t set_initial_size = */ TRUE,
/* size_t initial_size = */ (1 * 1024 * 1024),
/* double min_clean_fraction = */ 1.000001,
/* size_t max_size = */ (16 * 1024 * 1024),
/* size_t min_size = */ ( 1 * 1024 * 1024),
/* long int epoch_length = */ 50000,
/* enum H5C_cache_incr_mode incr_mode = */ H5C_incr__threshold,
/* double lower_hr_threshold = */ 0.9,
/* 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.999,
/* double decrement = */ 0.9,
/* hbool_t apply_max_decrement = */ TRUE,
/* size_t max_decrement = */ (1 * 1024 * 1024),
/* int epochs_before_eviction = */ 3,
/* hbool_t apply_empty_reserve = */ TRUE,
/* double empty_reserve = */ 0.1
},
{
/* 9 -- min_clean_fraction too small */
/* int version = */ H5C__CURR_AUTO_SIZE_CTL_VER,
/* hbool_t rpt_fcn_enabled = */ FALSE,
/* hbool_t set_initial_size = */ TRUE,
/* size_t initial_size = */ (1 * 1024 * 1024),
/* double min_clean_fraction = */ -0.00000001,
/* size_t max_size = */ (16 * 1024 * 1024),
/* size_t min_size = */ ( 1 * 1024 * 1024),
/* long int epoch_length = */ 50000,
/* enum H5C_cache_incr_mode incr_mode = */ H5C_incr__threshold,
/* double lower_hr_threshold = */ 0.9,
/* 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.999,
/* double decrement = */ 0.9,
/* hbool_t apply_max_decrement = */ TRUE,
/* size_t max_decrement = */ (1 * 1024 * 1024),
/* int epochs_before_eviction = */ 3,
/* hbool_t apply_empty_reserve = */ TRUE,
/* double empty_reserve = */ 0.1
},
{
/* 10 -- epoch_length too small */
/* int version = */ H5C__CURR_AUTO_SIZE_CTL_VER,
/* hbool_t rpt_fcn_enabled = */ FALSE,
/* hbool_t set_initial_size = */ TRUE,
/* size_t initial_size = */ (1 * 1024 * 1024),
/* double min_clean_fraction = */ 0.25,
/* size_t max_size = */ (16 * 1024 * 1024),
/* size_t min_size = */ ( 1 * 1024 * 1024),
/* long int epoch_length = */ H5C__MIN_AR_EPOCH_LENGTH - 1,
/* enum H5C_cache_incr_mode incr_mode = */ H5C_incr__threshold,
/* double lower_hr_threshold = */ 0.9,
/* 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.999,
/* double decrement = */ 0.9,
/* hbool_t apply_max_decrement = */ TRUE,
/* size_t max_decrement = */ (1 * 1024 * 1024),
/* int epochs_before_eviction = */ 3,
/* hbool_t apply_empty_reserve = */ TRUE,
/* double empty_reserve = */ 0.1
},
{
/* 11 -- epoch_length too big */
/* int version = */ H5C__CURR_AUTO_SIZE_CTL_VER,
/* hbool_t rpt_fcn_enabled = */ FALSE,
/* hbool_t set_initial_size = */ TRUE,
/* size_t initial_size = */ (1 * 1024 * 1024),
/* double min_clean_fraction = */ 0.25,
/* size_t max_size = */ (16 * 1024 * 1024),
/* size_t min_size = */ ( 1 * 1024 * 1024),
/* long int epoch_length = */ H5C__MAX_AR_EPOCH_LENGTH + 1,
/* enum H5C_cache_incr_mode incr_mode = */ H5C_incr__threshold,
/* double lower_hr_threshold = */ 0.9,
/* 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.999,
/* double decrement = */ 0.9,
/* hbool_t apply_max_decrement = */ TRUE,
/* size_t max_decrement = */ (1 * 1024 * 1024),
/* int epochs_before_eviction = */ 3,
/* hbool_t apply_empty_reserve = */ TRUE,
/* double empty_reserve = */ 0.1
},
{
/* 12 -- invalid incr_mode */
/* int version = */ H5C__CURR_AUTO_SIZE_CTL_VER,
/* hbool_t rpt_fcn_enabled = */ FALSE,
/* hbool_t set_initial_size = */ TRUE,
/* size_t initial_size = */ (1 * 1024 * 1024),
/* double min_clean_fraction = */ 0.25,
/* size_t max_size = */ (16 * 1024 * 1024),
/* size_t min_size = */ ( 1 * 1024 * 1024),
/* long int epoch_length = */ 50000,
/* enum H5C_cache_incr_mode incr_mode = */ -1,
/* double lower_hr_threshold = */ 0.9,
/* 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.999,
/* double decrement = */ 0.9,
/* hbool_t apply_max_decrement = */ TRUE,
/* size_t max_decrement = */ (1 * 1024 * 1024),
/* int epochs_before_eviction = */ 3,
/* hbool_t apply_empty_reserve = */ TRUE,
/* double empty_reserve = */ 0.1
},
{
/* 13 -- lower_hr_threshold too small */
/* int version = */ H5C__CURR_AUTO_SIZE_CTL_VER,
/* hbool_t rpt_fcn_enabled = */ FALSE,
/* hbool_t set_initial_size = */ TRUE,
/* size_t initial_size = */ (1 * 1024 * 1024),
/* double min_clean_fraction = */ 0.25,
/* size_t max_size = */ (16 * 1024 * 1024),
/* size_t min_size = */ ( 1 * 1024 * 1024),
/* long int epoch_length = */ 50000,
/* enum H5C_cache_incr_mode incr_mode = */ H5C_incr__threshold,
/* double lower_hr_threshold = */ -0.000001,
/* 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.999,
/* double decrement = */ 0.9,
/* hbool_t apply_max_decrement = */ TRUE,
/* size_t max_decrement = */ (1 * 1024 * 1024),
/* int epochs_before_eviction = */ 3,
/* hbool_t apply_empty_reserve = */ TRUE,
/* double empty_reserve = */ 0.1
},
{
/* 14 -- lower_hr_threshold too big */
/* int version = */ H5C__CURR_AUTO_SIZE_CTL_VER,
/* hbool_t rpt_fcn_enabled = */ FALSE,
/* hbool_t set_initial_size = */ TRUE,
/* size_t initial_size = */ (1 * 1024 * 1024),
/* double min_clean_fraction = */ 0.25,
/* size_t max_size = */ (16 * 1024 * 1024),
/* size_t min_size = */ ( 1 * 1024 * 1024),
/* long int epoch_length = */ 50000,
/* enum H5C_cache_incr_mode incr_mode = */ H5C_incr__threshold,
/* double lower_hr_threshold = */ 1.00000001,
/* 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.999,
/* double decrement = */ 0.9,
/* hbool_t apply_max_decrement = */ TRUE,
/* size_t max_decrement = */ (1 * 1024 * 1024),
/* int epochs_before_eviction = */ 3,
/* hbool_t apply_empty_reserve = */ TRUE,
/* double empty_reserve = */ 0.1
},
{
/* 15 -- increment too small */
/* int version = */ H5C__CURR_AUTO_SIZE_CTL_VER,
/* hbool_t rpt_fcn_enabled = */ FALSE,
/* hbool_t set_initial_size = */ TRUE,
/* size_t initial_size = */ (1 * 1024 * 1024),
/* double min_clean_fraction = */ 0.25,
/* size_t max_size = */ (16 * 1024 * 1024),
/* size_t min_size = */ ( 1 * 1024 * 1024),
/* long int epoch_length = */ 50000,
/* enum H5C_cache_incr_mode incr_mode = */ H5C_incr__threshold,
/* double lower_hr_threshold = */ 0.9,
/* double increment = */ 0.999999999999,
/* 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.999,
/* double decrement = */ 0.9,
/* hbool_t apply_max_decrement = */ TRUE,
/* size_t max_decrement = */ (1 * 1024 * 1024),
/* int epochs_before_eviction = */ 3,
/* hbool_t apply_empty_reserve = */ TRUE,
/* double empty_reserve = */ 0.1
},
{
/* 16 -- bad apply_max_increment */
/* int version = */ H5C__CURR_AUTO_SIZE_CTL_VER,
/* hbool_t rpt_fcn_enabled = */ FALSE,
/* hbool_t set_initial_size = */ TRUE,
/* size_t initial_size = */ (1 * 1024 * 1024),
/* double min_clean_fraction = */ 0.25,
/* size_t max_size = */ (16 * 1024 * 1024),
/* size_t min_size = */ ( 1 * 1024 * 1024),
/* long int epoch_length = */ 50000,
/* enum H5C_cache_incr_mode incr_mode = */ H5C_incr__threshold,
/* double lower_hr_threshold = */ 0.9,
/* double increment = */ 2.0,
/* hbool_t apply_max_increment = */ -1,
/* 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.999,
/* double decrement = */ 0.9,
/* hbool_t apply_max_decrement = */ TRUE,
/* size_t max_decrement = */ (1 * 1024 * 1024),
/* int epochs_before_eviction = */ 3,
/* hbool_t apply_empty_reserve = */ TRUE,
/* double empty_reserve = */ 0.1
},
{
/* 17 -- bad decr_mode */
/* int version = */ H5C__CURR_AUTO_SIZE_CTL_VER,
/* hbool_t rpt_fcn_enabled = */ FALSE,
/* hbool_t set_initial_size = */ TRUE,
/* size_t initial_size = */ (1 * 1024 * 1024),
/* double min_clean_fraction = */ 0.25,
/* size_t max_size = */ (16 * 1024 * 1024),
/* size_t min_size = */ ( 1 * 1024 * 1024),
/* long int epoch_length = */ 50000,
/* enum H5C_cache_incr_mode incr_mode = */ H5C_incr__threshold,
/* double lower_hr_threshold = */ 0.9,
/* double increment = */ 2.0,
/* hbool_t apply_max_increment = */ TRUE,
/* size_t max_increment = */ (4 * 1024 * 1024),
/* enum H5C_cache_decr_mode decr_mode = */ -1,
/* double upper_hr_threshold = */ 0.999,
/* double decrement = */ 0.9,
/* hbool_t apply_max_decrement = */ TRUE,
/* size_t max_decrement = */ (1 * 1024 * 1024),
/* int epochs_before_eviction = */ 3,
/* hbool_t apply_empty_reserve = */ TRUE,
/* double empty_reserve = */ 0.1
},
{
/* 18 -- upper_hr_threshold too big */
/* int version = */ H5C__CURR_AUTO_SIZE_CTL_VER,
/* hbool_t rpt_fcn_enabled = */ FALSE,
/* hbool_t set_initial_size = */ TRUE,
/* size_t initial_size = */ (1 * 1024 * 1024),
/* double min_clean_fraction = */ 0.25,
/* size_t max_size = */ (16 * 1024 * 1024),
/* size_t min_size = */ ( 1 * 1024 * 1024),
/* long int epoch_length = */ 50000,
/* enum H5C_cache_incr_mode incr_mode = */ H5C_incr__threshold,
/* double lower_hr_threshold = */ 0.9,
/* 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 = */ 1.00001,
/* double decrement = */ 0.9,
/* hbool_t apply_max_decrement = */ TRUE,
/* size_t max_decrement = */ (1 * 1024 * 1024),
/* int epochs_before_eviction = */ 3,
/* hbool_t apply_empty_reserve = */ TRUE,
/* double empty_reserve = */ 0.1
},
{
/* 19 -- decrement too small */
/* int version = */ H5C__CURR_AUTO_SIZE_CTL_VER,
/* hbool_t rpt_fcn_enabled = */ FALSE,
/* hbool_t set_initial_size = */ TRUE,
/* size_t initial_size = */ (1 * 1024 * 1024),
/* double min_clean_fraction = */ 0.25,
/* size_t max_size = */ (16 * 1024 * 1024),
/* size_t min_size = */ ( 1 * 1024 * 1024),
/* long int epoch_length = */ 50000,
/* enum H5C_cache_incr_mode incr_mode = */ H5C_incr__threshold,
/* double lower_hr_threshold = */ 0.9,
/* 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.999,
/* double decrement = */ -0.0000000001,
/* hbool_t apply_max_decrement = */ TRUE,
/* size_t max_decrement = */ (1 * 1024 * 1024),
/* int epochs_before_eviction = */ 3,
/* hbool_t apply_empty_reserve = */ TRUE,
/* double empty_reserve = */ 0.1
},
{
/* 20 -- decrement too big */
/* int version = */ H5C__CURR_AUTO_SIZE_CTL_VER,
/* hbool_t rpt_fcn_enabled = */ FALSE,
/* hbool_t set_initial_size = */ TRUE,
/* size_t initial_size = */ (1 * 1024 * 1024),
/* double min_clean_fraction = */ 0.25,
/* size_t max_size = */ (16 * 1024 * 1024),
/* size_t min_size = */ ( 1 * 1024 * 1024),
/* long int epoch_length = */ 50000,
/* enum H5C_cache_incr_mode incr_mode = */ H5C_incr__threshold,
/* double lower_hr_threshold = */ 0.9,
/* 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.999,
/* double decrement = */ 1.0000000001,
/* hbool_t apply_max_decrement = */ TRUE,
/* size_t max_decrement = */ (1 * 1024 * 1024),
/* int epochs_before_eviction = */ 3,
/* hbool_t apply_empty_reserve = */ TRUE,
/* double empty_reserve = */ 0.1
},
{
/* 21 -- epochs_before_eviction too small */
/* int version = */ H5C__CURR_AUTO_SIZE_CTL_VER,
/* hbool_t rpt_fcn_enabled = */ FALSE,
/* hbool_t set_initial_size = */ TRUE,
/* size_t initial_size = */ (1 * 1024 * 1024),
/* double min_clean_fraction = */ 0.25,
/* size_t max_size = */ (16 * 1024 * 1024),
/* size_t min_size = */ ( 1 * 1024 * 1024),
/* long int epoch_length = */ 50000,
/* enum H5C_cache_incr_mode incr_mode = */ H5C_incr__threshold,
/* double lower_hr_threshold = */ 0.9,
/* 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,
/* double upper_hr_threshold = */ 0.999,
/* double decrement = */ 0.9,
/* hbool_t apply_max_decrement = */ TRUE,
/* size_t max_decrement = */ (1 * 1024 * 1024),
/* int epochs_before_eviction = */ 0,
/* hbool_t apply_empty_reserve = */ TRUE,
/* double empty_reserve = */ 0.1
},
{
/* 22 -- epochs_before_eviction too big */
/* int version = */ H5C__CURR_AUTO_SIZE_CTL_VER,
/* hbool_t rpt_fcn_enabled = */ FALSE,
/* hbool_t set_initial_size = */ TRUE,
/* size_t initial_size = */ (1 * 1024 * 1024),
/* double min_clean_fraction = */ 0.25,
/* size_t max_size = */ (16 * 1024 * 1024),
/* size_t min_size = */ ( 1 * 1024 * 1024),
/* long int epoch_length = */ 50000,
/* enum H5C_cache_incr_mode incr_mode = */ H5C_incr__threshold,
/* double lower_hr_threshold = */ 0.9,
/* 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,
/* double upper_hr_threshold = */ 0.999,
/* double decrement = */ 0.9,
/* hbool_t apply_max_decrement = */ TRUE,
/* size_t max_decrement = */ (1 * 1024 * 1024),
/* int epochs_before_eviction = */ H5C__MAX_EPOCH_MARKERS + 1,
/* hbool_t apply_empty_reserve = */ TRUE,
/* double empty_reserve = */ 0.1
},
{
/* 23 -- invalid apply_empty_reserve */
/* int version = */ H5C__CURR_AUTO_SIZE_CTL_VER,
/* hbool_t rpt_fcn_enabled = */ FALSE,
/* hbool_t set_initial_size = */ TRUE,
/* size_t initial_size = */ (1 * 1024 * 1024),
/* double min_clean_fraction = */ 0.25,
/* size_t max_size = */ (16 * 1024 * 1024),
/* size_t min_size = */ ( 1 * 1024 * 1024),
/* long int epoch_length = */ 50000,
/* enum H5C_cache_incr_mode incr_mode = */ H5C_incr__threshold,
/* double lower_hr_threshold = */ 0.9,
/* 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.999,
/* double decrement = */ 0.9,
/* hbool_t apply_max_decrement = */ TRUE,
/* size_t max_decrement = */ (1 * 1024 * 1024),
/* int epochs_before_eviction = */ 3,
/* hbool_t apply_empty_reserve = */ 2,
/* double empty_reserve = */ 0.1
},
{
/* 24 -- empty_reserve too small */
/* int version = */ H5C__CURR_AUTO_SIZE_CTL_VER,
/* hbool_t rpt_fcn_enabled = */ FALSE,
/* hbool_t set_initial_size = */ TRUE,
/* size_t initial_size = */ (1 * 1024 * 1024),
/* double min_clean_fraction = */ 0.25,
/* size_t max_size = */ (16 * 1024 * 1024),
/* size_t min_size = */ ( 1 * 1024 * 1024),
/* long int epoch_length = */ 50000,
/* enum H5C_cache_incr_mode incr_mode = */ H5C_incr__threshold,
/* double lower_hr_threshold = */ 0.9,
/* 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.999,
/* double decrement = */ 0.9,
/* hbool_t apply_max_decrement = */ TRUE,
/* size_t max_decrement = */ (1 * 1024 * 1024),
/* int epochs_before_eviction = */ 3,
/* hbool_t apply_empty_reserve = */ TRUE,
/* double empty_reserve = */ -0.0000000001
},
{
/* 25 -- empty_reserve too big */
/* int version = */ H5C__CURR_AUTO_SIZE_CTL_VER,
/* hbool_t rpt_fcn_enabled = */ FALSE,
/* hbool_t set_initial_size = */ TRUE,
/* size_t initial_size = */ (1 * 1024 * 1024),
/* double min_clean_fraction = */ 0.25,
/* size_t max_size = */ (16 * 1024 * 1024),
/* size_t min_size = */ ( 1 * 1024 * 1024),
/* long int epoch_length = */ 50000,
/* enum H5C_cache_incr_mode incr_mode = */ H5C_incr__threshold,
/* double lower_hr_threshold = */ 0.9,
/* 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.999,
/* double decrement = */ 0.9,
/* hbool_t apply_max_decrement = */ TRUE,
/* size_t max_decrement = */ (1 * 1024 * 1024),
/* int epochs_before_eviction = */ 3,
/* hbool_t apply_empty_reserve = */ TRUE,
/* double empty_reserve = */ 1.00000000001
},
{
/* 26 -- upper_hr_threshold too small */
/* int version = */ H5C__CURR_AUTO_SIZE_CTL_VER,
/* hbool_t rpt_fcn_enabled = */ FALSE,
/* hbool_t set_initial_size = */ TRUE,
/* size_t initial_size = */ (1 * 1024 * 1024),
/* double min_clean_fraction = */ 0.25,
/* size_t max_size = */ (16 * 1024 * 1024),
/* size_t min_size = */ ( 1 * 1024 * 1024),
/* long int epoch_length = */ 50000,
/* enum H5C_cache_incr_mode incr_mode = */ H5C_incr__threshold,
/* double lower_hr_threshold = */ 0.9,
/* 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.000000001,
/* double decrement = */ 0.9,
/* hbool_t apply_max_decrement = */ TRUE,
/* size_t max_decrement = */ (1 * 1024 * 1024),
/* int epochs_before_eviction = */ 3,
/* hbool_t apply_empty_reserve = */ TRUE,
/* double empty_reserve = */ 0.1
},
{
/* 27 -- upper_hr_threshold too big */
/* int version = */ H5C__CURR_AUTO_SIZE_CTL_VER,
/* hbool_t rpt_fcn_enabled = */ FALSE,
/* hbool_t set_initial_size = */ TRUE,
/* size_t initial_size = */ (1 * 1024 * 1024),
/* double min_clean_fraction = */ 0.25,
/* size_t max_size = */ (16 * 1024 * 1024),
/* size_t min_size = */ ( 1 * 1024 * 1024),
/* long int epoch_length = */ 50000,
/* enum H5C_cache_incr_mode incr_mode = */ H5C_incr__threshold,
/* double lower_hr_threshold = */ 0.9,
/* 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 = */ 1.00000001,
/* double decrement = */ 0.9,
/* hbool_t apply_max_decrement = */ TRUE,
/* size_t max_decrement = */ (1 * 1024 * 1024),
/* int epochs_before_eviction = */ 3,
/* hbool_t apply_empty_reserve = */ TRUE,
/* double empty_reserve = */ 0.1
},
{
/* 28 -- upper_hr_threshold <= lower_hr_threshold */
/* int version = */ H5C__CURR_AUTO_SIZE_CTL_VER,
/* hbool_t rpt_fcn_enabled = */ FALSE,
/* hbool_t set_initial_size = */ TRUE,
/* size_t initial_size = */ (1 * 1024 * 1024),
/* double min_clean_fraction = */ 0.25,
/* size_t max_size = */ (16 * 1024 * 1024),
/* size_t min_size = */ ( 1 * 1024 * 1024),
/* long int epoch_length = */ 50000,
/* enum H5C_cache_incr_mode incr_mode = */ H5C_incr__threshold,
/* double lower_hr_threshold = */ 0.9,
/* 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.9,
/* double decrement = */ 0.9,
/* hbool_t apply_max_decrement = */ TRUE,
/* size_t max_decrement = */ (1 * 1024 * 1024),
/* int epochs_before_eviction = */ 3,
/* hbool_t apply_empty_reserve = */ TRUE,
/* double empty_reserve = */ 0.1
}
};
/*-------------------------------------------------------------------------
* Function: check_fapl_mdc_api_errs()
*
* Purpose: Verify that the FAPL related MDC API calls reject input
* errors gracefully.
*
* Return: void
*
* Programmer: John Mainzer
* 4/19/04
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static void
check_fapl_mdc_api_errs(void)
{
const char * fcn_name = "check_fapl_mdc_api_errs()";
static char msg[128];
int i;
herr_t result;
hid_t fapl_id;
H5AC_cache_config_t default_config = H5AC__DEFAULT_CACHE_CONFIG;
H5AC_cache_config_t scratch;
TESTING("MDC/FAPL related API input errors");
pass = TRUE;
/* first test H5Pget_mdc_config().
*/
scratch.version = H5C__CURR_AUTO_SIZE_CTL_VER;
if ( pass ) {
H5E_BEGIN_TRY { result = H5Pget_mdc_config(-1, &scratch); } H5E_END_TRY;
if ( result >= 0 ) {
pass = FALSE;
failure_mssg = "H5Pget_mdc_config() accepted invalid plist_id.";
}
}
/* Create a FAPL for test purposes, and veify that it contains the
* default MDC configuration.
*/
if ( pass ) {
fapl_id = H5Pcreate(H5P_FILE_ACCESS);
if ( fapl_id < 0 ) {
pass = FALSE;
failure_mssg = "H5Pcreate(H5P_FILE_ACCESS) failed.\n";
}
}
scratch.version = H5C__CURR_AUTO_SIZE_CTL_VER;
if ( ( pass ) &&
( ( H5Pget_mdc_config(fapl_id, &scratch) < 0 ) ||
( !CACHE_CONFIGS_EQUAL(default_config, scratch, TRUE, TRUE) ) ) ) {
pass = FALSE;
failure_mssg = "New FAPL has unexpected metadata cache config?!?!?.\n";
}
if ( pass ) {
H5E_BEGIN_TRY {
result = H5Pget_mdc_config(fapl_id, NULL);
} H5E_END_TRY;
if ( result >= 0 ) {
pass = FALSE;
failure_mssg = "H5Pget_mdc_config() accepted NULL config_ptr.";
}
}
/* one last test for H5Pget_mdc_config() */
scratch.version = -1; /* a convenient, invalid value */
if ( pass ) {
H5E_BEGIN_TRY {
result = H5Pget_mdc_config(fapl_id, &scratch);
} H5E_END_TRY;
if ( result >= 0 ) {
pass = FALSE;
failure_mssg = "H5Pget_mdc_config() accepted bad config version.";
}
}
/* now test H5Pset_mdc_config()
*/
scratch.version = H5C__CURR_AUTO_SIZE_CTL_VER;
if ( pass ) {
H5E_BEGIN_TRY {
result = H5Pset_mdc_config(-1, &default_config);
} H5E_END_TRY;
if ( result >= 0 ) {
pass = FALSE;
failure_mssg = "H5Pset_mdc_config() accepted bad invalid plist_id.";
}
}
if ( pass ) {
H5E_BEGIN_TRY {
result = H5Pset_mdc_config(fapl_id, NULL);
} H5E_END_TRY;
if ( result >= 0 ) {
pass = FALSE;
failure_mssg = "H5Pset_mdc_config() accepted NULL config_ptr.";
}
}
i = 0;
while ( ( pass ) && ( i < NUM_INVALID_CONFIGS ) )
{
H5E_BEGIN_TRY {
result = H5Pset_mdc_config(fapl_id, &(invalid_configs[i]));
} H5E_END_TRY;
if ( result >= 0 ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"H5Pset_mdc_config() accepted invalid_configs[%d].", i);
failure_mssg = msg;
}
i++;
}
/* verify that none of the above calls to H5Pset_mdc_config() changed
* the configuration in the FAPL.
*/
scratch.version = H5C__CURR_AUTO_SIZE_CTL_VER;
if ( ( pass ) &&
( ( H5Pget_mdc_config(fapl_id, &scratch) < 0 ) ||
( !CACHE_CONFIGS_EQUAL(default_config, scratch, TRUE, TRUE) ) ) ) {
pass = FALSE;
failure_mssg = "FAPL metadata cache config changed???.\n";
}
if ( pass ) { PASSED(); } else { H5_FAILED(); }
if ( ! pass )
HDfprintf(stdout, "%s: failure_mssg = \"%s\".\n",
fcn_name, failure_mssg);
} /* check_fapl_mdc_api_errs() */
/*-------------------------------------------------------------------------
* Function: check_file_mdc_api_errs()
*
* Purpose: Verify that the file related MDC API calls reject input
* errors gracefully.
*
* Return: void
*
* Programmer: John Mainzer
* 4/19/04
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static void
check_file_mdc_api_errs(void)
{
const char * fcn_name = "check_file_mdc_api_errs()";
char filename[512];
static char msg[128];
int i;
herr_t result;
hid_t file_id;
size_t max_size;
size_t min_clean_size;
size_t cur_size;
int cur_num_entries;
double hit_rate;
H5AC_cache_config_t default_config = H5AC__DEFAULT_CACHE_CONFIG;
H5AC_cache_config_t scratch;
TESTING("MDC/FILE related API input errors");
pass = TRUE;
/* Create a file for test purposes, and veify that its metadata cache
* set to the default MDC configuration.
*/
/* setup the file name */
if ( pass ) {
if ( h5_fixname(FILENAME[0], H5P_DEFAULT, filename, sizeof(filename))
== NULL ) {
pass = FALSE;
failure_mssg = "h5_fixname() failed.\n";
}
}
if ( pass ) {
file_id = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
if ( file_id < 0 ) {
pass = FALSE;
failure_mssg = "H5Fcreate() failed.\n";
}
}
validate_mdc_config(file_id, &default_config, TRUE, 1);
/* test H5Fget_mdc_config(). */
scratch.version = H5C__CURR_AUTO_SIZE_CTL_VER;
if ( pass ) {
H5E_BEGIN_TRY {
result = H5Fget_mdc_config(-1, &scratch);
} H5E_END_TRY;
if ( result >= 0 ) {
pass = FALSE;
failure_mssg = "H5Fget_mdc_config() accepted invalid file_id.";
}
}
if ( pass ) {
H5E_BEGIN_TRY {
result = H5Fget_mdc_config(file_id, NULL);
} H5E_END_TRY;
if ( result >= 0 ) {
pass = FALSE;
failure_mssg = "H5Fget_mdc_config() accepted NULL config_ptr.";
}
}
scratch.version = -1; /* a convenient, invalid value */
if ( pass ) {
H5E_BEGIN_TRY {
result = H5Fget_mdc_config(file_id, &scratch);
} H5E_END_TRY;
if ( result >= 0 ) {
pass = FALSE;
failure_mssg = "H5Fget_mdc_config() accepted bad config version.";
}
}
/* test H5Fset_mdc_config() */
scratch.version = H5C__CURR_AUTO_SIZE_CTL_VER;
if ( pass ) {
H5E_BEGIN_TRY {
result = H5Fset_mdc_config(-1, &default_config);
} H5E_END_TRY;
if ( result >= 0 ) {
pass = FALSE;
failure_mssg = "H5Fset_mdc_config() accepted bad invalid file_id.";
}
}
if ( pass ) {
H5E_BEGIN_TRY {
result = H5Fset_mdc_config(file_id, NULL);
} H5E_END_TRY;
if ( result >= 0 ) {
pass = FALSE;
failure_mssg = "H5Fset_mdc_config() accepted NULL config_ptr.";
}
}
i = 0;
while ( ( pass ) && ( i < NUM_INVALID_CONFIGS ) )
{
H5E_BEGIN_TRY {
result = H5Fset_mdc_config(file_id, &(invalid_configs[i]));
} H5E_END_TRY;
if ( result >= 0 ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"H5Fset_mdc_config() accepted invalid_configs[%d].", i);
failure_mssg = msg;
}
i++;
}
/* verify that none of the above calls to H5Fset_mdc_config() changed
* the configuration in the FAPL.
*/
validate_mdc_config(file_id, &default_config, TRUE, 2);
/* test H5Fget_mdc_hit_rate() */
if ( pass ) {
H5E_BEGIN_TRY {
result = H5Fget_mdc_hit_rate(-1, &hit_rate);
} H5E_END_TRY;
if ( result >= 0 ) {
pass = FALSE;
failure_mssg = "H5Fget_mdc_hit_rate() accepted bad file_id.";
}
}
if ( pass ) {
H5E_BEGIN_TRY {
result = H5Fget_mdc_hit_rate(file_id, NULL);
} H5E_END_TRY;
if ( result >= 0 ) {
pass = FALSE;
failure_mssg = "H5Fget_mdc_hit_rate() accepted NULL hit_rate_ptr.";
}
}
/* test H5Freset_mdc_hit_rate_stats() */
if ( pass ) {
H5E_BEGIN_TRY {
result = H5Freset_mdc_hit_rate_stats(-1);
} H5E_END_TRY;
if ( result >= 0 ) {
pass = FALSE;
failure_mssg =
"H5Freset_mdc_hit_rate_stats() accepted bad file_id.";
}
}
/* test H5Fget_mdc_size() */
if ( pass ) {
H5E_BEGIN_TRY {
result = H5Fget_mdc_size(-1, &max_size, &min_clean_size,
&cur_size, &cur_num_entries);
} H5E_END_TRY;
if ( result >= 0 ) {
pass = FALSE;
failure_mssg = "H5Fget_mdc_size() accepted bad file_id.";
}
}
if ( pass ) {
if ( ( H5Fget_mdc_size(file_id, &max_size, NULL, NULL, NULL) < 0 ) ||
( H5Fget_mdc_size(file_id, NULL, &min_clean_size,
NULL, NULL) < 0 ) ||
( H5Fget_mdc_size(file_id, NULL, NULL, &cur_size, NULL) < 0 ) ||
( H5Fget_mdc_size(file_id, NULL, NULL, NULL,
&cur_num_entries) < 0 ) ||
( H5Fget_mdc_size(file_id, NULL, NULL, NULL, NULL) < 0 ) ) {
pass = FALSE;
failure_mssg = "H5Fget_mdc_size() failed to handle NULL params.";
}
}
/* close the file and delete it */
if ( pass ) {
if ( H5Fclose(file_id) < 0 ) {
pass = FALSE;
failure_mssg = "H5Fclose() failed.\n";
} else if ( HDremove(filename) < 0 ) {
pass = FALSE;
failure_mssg = "HDremove() failed.\n";
}
}
if ( pass ) { PASSED(); } else { H5_FAILED(); }
if ( ! pass )
HDfprintf(stdout, "%s: failure_mssg = \"%s\".\n",
fcn_name, failure_mssg);
} /* check_file_mdc_api_errs() */
/*-------------------------------------------------------------------------
* 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 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
#if 1
write_permitted_check();
check_flush_cache();
check_flush_protected_err();
check_destroy_protected_err();
check_duplicate_insert_err();
check_rename_err();
check_double_protect_err();
check_double_unprotect_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();
check_fapl_mdc_api_calls();
check_file_mdc_api_calls();
#endif
mdc_api_call_smoke_check();
#if 1
check_fapl_mdc_api_errs();
check_file_mdc_api_errs();
#endif
return(0);
} /* main() */
Reference in New Issue View Git Blame Copy Permalink