mirror of
https://github.com/HDFGroup/hdf5.git
synced 2025-02-17 16:10:24 +08:00
[svn-r16874] Description:
Add test for cache client 'notify' callback.
Tested on:
FreeBSD/32 6.3 (duty) in debug mode
FreeBSD/64 6.3 (liberty) w/C++ & FORTRAN, in debug mode
Linux/32 2.6 (jam) w/PGI compilers, w/C++ & FORTRAN, w/threadsafe,
in debug mode
Linux/64-amd64 2.6 (smirom) w/Intel compilers w/default API=1.6.x,
w/C++ & FORTRAN, in production mode
Solaris/32 2.10 (linew) w/deprecated symbols disabled, w/C++ & FORTRAN,
w/szip filter, in production mode
Linux/64-ia64 2.6 (cobalt) w/Intel compilers, w/C++ & FORTRAN,
in production mode
Linux/64-ia64 2.4 (tg-login3) w/parallel, w/FORTRAN, in debug mode
Linux/64-amd64 2.6 (abe) w/parallel, w/FORTRAN, in production mode
Mac OS X/32 10.5.6 (amazon) in debug mode
Mac OS X/32 10.5.6 (amazon) w/C++ & FORTRAN, w/threadsafe,
in production mode
This commit is contained in:
Quincey Koziol
parent
8ae072d760
commit
4d6fcb288a
201
test/cache.c
201
test/cache.c
@ -126,6 +126,7 @@ static unsigned check_metadata_blizzard_absence(hbool_t fill_via_insertion);
|
||||
static unsigned check_flush_deps(void);
|
||||
static unsigned check_flush_deps_err(void);
|
||||
static unsigned check_flush_deps_order(void);
|
||||
static unsigned check_notify_cb(void);
|
||||
|
||||
|
||||
/**************************************************************************/
|
||||
@ -33787,6 +33788,205 @@ done:
|
||||
return (unsigned)!pass;
|
||||
} /* check_flush_deps_order() */
|
||||
|
||||
|
||||
/*-------------------------------------------------------------------------
|
||||
* Function: check_notify_cb()
|
||||
*
|
||||
* Purpose: Exercise the client 'notify' callback.
|
||||
*
|
||||
* Return: 0 on success, non-zero on failure
|
||||
*
|
||||
* Programmer: Quincey Koziol
|
||||
* 4/28/09
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
static unsigned
|
||||
check_notify_cb(void)
|
||||
{
|
||||
H5C_t * cache_ptr = NULL; /* Metadata cache for this test */
|
||||
test_entry_t *base_addr; /* Base address of entries for test */
|
||||
test_entry_t * entry_ptr; /* Cache entry to examine/manipulate */
|
||||
int entry_type = NOTIFY_ENTRY_TYPE; /* Use entry w/notify callback (size of entries doesn't matter) */
|
||||
size_t entry_size = NOTIFY_ENTRY_SIZE; /* 1 byte */
|
||||
unsigned u; /* Local index variable */
|
||||
struct expected_entry_status expected[5] =
|
||||
{
|
||||
/* entry entry in at main flush dep flush dep child flush flush flush */
|
||||
/* type: index: size: cache: addr: dirty: prot: pinned: loaded: clrd: flshd: dest: par type: par idx: dep ref.count: dep height: order: */
|
||||
{ entry_type, 0, entry_size, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0}, 0, -1 },
|
||||
{ entry_type, 1, entry_size, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0}, 0, -1 },
|
||||
{ entry_type, 2, entry_size, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0}, 0, -1 },
|
||||
{ entry_type, 3, entry_size, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0}, 0, -1 },
|
||||
{ entry_type, 4, entry_size, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0}, 0, -1 }
|
||||
};
|
||||
|
||||
TESTING("'notify' callback");
|
||||
|
||||
pass = TRUE;
|
||||
|
||||
/* Allocate a cache, insert & remove entries, triggering 'notify' callback.
|
||||
* Verify that all performs as expected.
|
||||
*/
|
||||
|
||||
reset_entries();
|
||||
cache_ptr = setup_cache((size_t)(2 * 1024), (size_t)(1 * 1024));
|
||||
base_addr = entries[entry_type];
|
||||
|
||||
if ( !pass ) CACHE_ERROR("setup_cache failed")
|
||||
|
||||
/* Insert entries to work with into the cache */
|
||||
for(u = 0; u < 5; u++) {
|
||||
insert_entry(cache_ptr, entry_type, (int32_t)u, TRUE, H5C__NO_FLAGS_SET);
|
||||
if ( !pass ) CACHE_ERROR("insert_entry failed")
|
||||
|
||||
/* Change expected values, and verify the status of the entries
|
||||
* after each insertion
|
||||
*/
|
||||
expected[u].in_cache = TRUE;
|
||||
expected[u].is_dirty = TRUE;
|
||||
|
||||
/* Verify the status */
|
||||
verify_entry_status(cache_ptr, /* H5C_t * cache_ptr */
|
||||
(int)u, /* int tag */
|
||||
(int)5, /* int num_entries */
|
||||
expected); /* struct expected_entry_staus[] */
|
||||
if ( !pass ) CACHE_ERROR("verify_entry_status failed")
|
||||
|
||||
/* Check the entry's 'after insert' count */
|
||||
entry_ptr = &(base_addr[u]);
|
||||
if(1 != entry_ptr->notify_after_insert_count)
|
||||
CACHE_ERROR("invalid notify after insert count")
|
||||
if(0 != entry_ptr->notify_before_evict_count)
|
||||
CACHE_ERROR("invalid notify before evict count")
|
||||
} /* end for */
|
||||
|
||||
/* Remove entries from the cache */
|
||||
for(u = 0; u < 5; u++) {
|
||||
expunge_entry(cache_ptr, entry_type, (int32_t)u);
|
||||
if ( !pass ) CACHE_ERROR("expunge_entry failed")
|
||||
|
||||
/* Change expected values, and verify the status of the entries
|
||||
* after each insertion
|
||||
*/
|
||||
expected[u].in_cache = FALSE;
|
||||
expected[u].is_dirty = FALSE;
|
||||
expected[u].cleared = TRUE;
|
||||
expected[u].destroyed = TRUE;
|
||||
|
||||
/* Verify the status */
|
||||
verify_entry_status(cache_ptr, /* H5C_t * cache_ptr */
|
||||
(int)u, /* int tag */
|
||||
(int)5, /* int num_entries */
|
||||
expected); /* struct expected_entry_staus[] */
|
||||
if ( !pass ) CACHE_ERROR("verify_entry_status failed")
|
||||
|
||||
/* Check the entry's 'before evict' count */
|
||||
entry_ptr = &(base_addr[u]);
|
||||
if(1 != entry_ptr->notify_after_insert_count)
|
||||
CACHE_ERROR("invalid notify after insert count")
|
||||
if(1 != entry_ptr->notify_before_evict_count)
|
||||
CACHE_ERROR("invalid notify before evict count")
|
||||
} /* end for */
|
||||
|
||||
/* Protect entries to bring them into the cache */
|
||||
for(u = 0; u < 5; u++) {
|
||||
protect_entry(cache_ptr, entry_type, (int32_t)u);
|
||||
if ( !pass ) CACHE_ERROR("protect_entry failed")
|
||||
|
||||
/* Change expected values, and verify the status of the entries
|
||||
* after each insertion
|
||||
*/
|
||||
expected[u].in_cache = TRUE;
|
||||
expected[u].is_dirty = FALSE;
|
||||
expected[u].is_protected = TRUE;
|
||||
expected[u].loaded = TRUE;
|
||||
|
||||
/* Verify the status */
|
||||
verify_entry_status(cache_ptr, /* H5C_t * cache_ptr */
|
||||
(int)u, /* int tag */
|
||||
(int)5, /* int num_entries */
|
||||
expected); /* struct expected_entry_staus[] */
|
||||
if ( !pass ) CACHE_ERROR("verify_entry_status failed")
|
||||
|
||||
/* Check the entry's 'after insert' count */
|
||||
entry_ptr = &(base_addr[u]);
|
||||
if(2 != entry_ptr->notify_after_insert_count)
|
||||
CACHE_ERROR("invalid notify after insert count")
|
||||
if(1 != entry_ptr->notify_before_evict_count)
|
||||
CACHE_ERROR("invalid notify before evict count")
|
||||
} /* end for */
|
||||
|
||||
/* Unprotect entries, evicting them from the cache */
|
||||
for(u = 0; u < 5; u++) {
|
||||
unprotect_entry(cache_ptr, entry_type, (int32_t)u, TRUE, H5C__NO_FLAGS_SET);
|
||||
if ( !pass ) CACHE_ERROR("unprotect_entry failed")
|
||||
|
||||
/* Change expected values, and verify the status of the entries
|
||||
* after each insertion
|
||||
*/
|
||||
expected[u].in_cache = TRUE;
|
||||
expected[u].is_dirty = TRUE;
|
||||
expected[u].is_protected = FALSE;
|
||||
|
||||
/* Verify the status */
|
||||
verify_entry_status(cache_ptr, /* H5C_t * cache_ptr */
|
||||
(int)u, /* int tag */
|
||||
(int)5, /* int num_entries */
|
||||
expected); /* struct expected_entry_staus[] */
|
||||
if ( !pass ) CACHE_ERROR("verify_entry_status failed")
|
||||
|
||||
/* Check the entry's 'after insert' count */
|
||||
entry_ptr = &(base_addr[u]);
|
||||
if(2 != entry_ptr->notify_after_insert_count)
|
||||
CACHE_ERROR("invalid notify after insert count")
|
||||
if(1 != entry_ptr->notify_before_evict_count)
|
||||
CACHE_ERROR("invalid notify before evict count")
|
||||
} /* end for */
|
||||
|
||||
/* Remove entries from the cache */
|
||||
for(u = 0; u < 5; u++) {
|
||||
expunge_entry(cache_ptr, entry_type, (int32_t)u);
|
||||
if ( !pass ) CACHE_ERROR("expunge_entry failed")
|
||||
|
||||
/* Change expected values, and verify the status of the entries
|
||||
* after each insertion
|
||||
*/
|
||||
expected[u].in_cache = FALSE;
|
||||
expected[u].is_dirty = FALSE;
|
||||
expected[u].cleared = TRUE;
|
||||
expected[u].destroyed = TRUE;
|
||||
|
||||
/* Verify the status */
|
||||
verify_entry_status(cache_ptr, /* H5C_t * cache_ptr */
|
||||
(int)u, /* int tag */
|
||||
(int)5, /* int num_entries */
|
||||
expected); /* struct expected_entry_staus[] */
|
||||
if ( !pass ) CACHE_ERROR("verify_entry_status failed")
|
||||
|
||||
/* Check the entry's 'before evict' count */
|
||||
entry_ptr = &(base_addr[u]);
|
||||
if(2 != entry_ptr->notify_after_insert_count)
|
||||
CACHE_ERROR("invalid notify after insert count")
|
||||
if(2 != entry_ptr->notify_before_evict_count)
|
||||
CACHE_ERROR("invalid notify before evict count")
|
||||
} /* end for */
|
||||
|
||||
done:
|
||||
if(cache_ptr)
|
||||
takedown_cache(cache_ptr, FALSE, FALSE);
|
||||
|
||||
if ( pass )
|
||||
PASSED()
|
||||
else {
|
||||
H5_FAILED();
|
||||
HDfprintf(stdout, "%s.\n", failure_mssg);
|
||||
} /* end else */
|
||||
|
||||
return (unsigned)!pass;
|
||||
} /* check_notify_cb() */
|
||||
|
||||
|
||||
/*-------------------------------------------------------------------------
|
||||
* Function: main
|
||||
@ -33867,6 +34067,7 @@ main(void)
|
||||
nerrs += check_flush_deps();
|
||||
nerrs += check_flush_deps_err();
|
||||
nerrs += check_flush_deps_order();
|
||||
nerrs += check_notify_cb();
|
||||
|
||||
return(nerrs > 0);
|
||||
}
|
||||
|
||||
@ -43,6 +43,7 @@ test_entry_t large_entries[NUM_LARGE_ENTRIES], orig_large_entries[NUM_LARGE_ENTR
|
||||
test_entry_t huge_entries[NUM_HUGE_ENTRIES], orig_huge_entries[NUM_HUGE_ENTRIES];
|
||||
test_entry_t monster_entries[NUM_MONSTER_ENTRIES], orig_monster_entries[NUM_MONSTER_ENTRIES];
|
||||
test_entry_t variable_entries[NUM_VARIABLE_ENTRIES], orig_variable_entries[NUM_VARIABLE_ENTRIES];
|
||||
test_entry_t notify_entries[NUM_NOTIFY_ENTRIES], orig_notify_entries[NUM_NOTIFY_ENTRIES];
|
||||
|
||||
hbool_t orig_entry_arrays_init = FALSE;
|
||||
|
||||
@ -57,7 +58,8 @@ test_entry_t * entries[NUMBER_OF_ENTRY_TYPES] =
|
||||
large_entries,
|
||||
huge_entries,
|
||||
monster_entries,
|
||||
variable_entries
|
||||
variable_entries,
|
||||
notify_entries
|
||||
};
|
||||
|
||||
test_entry_t * orig_entries[NUMBER_OF_ENTRY_TYPES] =
|
||||
@ -71,7 +73,8 @@ test_entry_t * orig_entries[NUMBER_OF_ENTRY_TYPES] =
|
||||
orig_large_entries,
|
||||
orig_huge_entries,
|
||||
orig_monster_entries,
|
||||
orig_variable_entries
|
||||
orig_variable_entries,
|
||||
orig_notify_entries
|
||||
};
|
||||
|
||||
const int32_t max_indices[NUMBER_OF_ENTRY_TYPES] =
|
||||
@ -85,7 +88,8 @@ const int32_t max_indices[NUMBER_OF_ENTRY_TYPES] =
|
||||
NUM_LARGE_ENTRIES - 1,
|
||||
NUM_HUGE_ENTRIES - 1,
|
||||
NUM_MONSTER_ENTRIES - 1,
|
||||
NUM_VARIABLE_ENTRIES - 1
|
||||
NUM_VARIABLE_ENTRIES - 1,
|
||||
NUM_NOTIFY_ENTRIES - 1
|
||||
};
|
||||
|
||||
const size_t entry_sizes[NUMBER_OF_ENTRY_TYPES] =
|
||||
@ -99,7 +103,8 @@ const size_t entry_sizes[NUMBER_OF_ENTRY_TYPES] =
|
||||
LARGE_ENTRY_SIZE,
|
||||
HUGE_ENTRY_SIZE,
|
||||
MONSTER_ENTRY_SIZE,
|
||||
VARIABLE_ENTRY_SIZE
|
||||
VARIABLE_ENTRY_SIZE,
|
||||
NOTIFY_ENTRY_SIZE
|
||||
};
|
||||
|
||||
const haddr_t base_addrs[NUMBER_OF_ENTRY_TYPES] =
|
||||
@ -113,7 +118,8 @@ const haddr_t base_addrs[NUMBER_OF_ENTRY_TYPES] =
|
||||
LARGE_BASE_ADDR,
|
||||
HUGE_BASE_ADDR,
|
||||
MONSTER_BASE_ADDR,
|
||||
VARIABLE_BASE_ADDR
|
||||
VARIABLE_BASE_ADDR,
|
||||
NOTIFY_BASE_ADDR
|
||||
};
|
||||
|
||||
const haddr_t alt_base_addrs[NUMBER_OF_ENTRY_TYPES] =
|
||||
@ -127,7 +133,8 @@ const haddr_t alt_base_addrs[NUMBER_OF_ENTRY_TYPES] =
|
||||
LARGE_ALT_BASE_ADDR,
|
||||
HUGE_ALT_BASE_ADDR,
|
||||
MONSTER_ALT_BASE_ADDR,
|
||||
VARIABLE_ALT_BASE_ADDR
|
||||
VARIABLE_ALT_BASE_ADDR,
|
||||
NOTIFY_ALT_BASE_ADDR
|
||||
};
|
||||
|
||||
const char * entry_type_names[NUMBER_OF_ENTRY_TYPES] =
|
||||
@ -141,7 +148,8 @@ const char * entry_type_names[NUMBER_OF_ENTRY_TYPES] =
|
||||
"large entries -- 4 KB",
|
||||
"huge entries -- 16 KB",
|
||||
"monster entries -- 64 KB",
|
||||
"variable entries -- 1B - 10KB"
|
||||
"variable entries -- 1B - 10KB",
|
||||
"notify entries -- 1B"
|
||||
};
|
||||
|
||||
|
||||
@ -238,6 +246,15 @@ const H5C_class_t types[NUMBER_OF_ENTRY_TYPES] =
|
||||
(H5C_clear_func_t)variable_clear,
|
||||
(H5C_notify_func_t)NULL,
|
||||
(H5C_size_func_t)variable_size
|
||||
},
|
||||
{
|
||||
NOTIFY_ENTRY_TYPE,
|
||||
(H5C_load_func_t)notify_load,
|
||||
(H5C_flush_func_t)notify_flush,
|
||||
(H5C_dest_func_t)notify_dest,
|
||||
(H5C_clear_func_t)notify_clear,
|
||||
(H5C_notify_func_t)notify_notify,
|
||||
(H5C_size_func_t)notify_size
|
||||
}
|
||||
};
|
||||
|
||||
@ -248,6 +265,7 @@ static herr_t flush(H5F_t *f, hid_t dxpl_id, hbool_t dest,
|
||||
static void * load(H5F_t *f, hid_t dxpl_id, haddr_t addr,
|
||||
const void *udata1, void *udata2);
|
||||
static herr_t size(H5F_t * f, void * thing, size_t * size_ptr);
|
||||
static herr_t notify(H5C_notify_action_t action, void *thing);
|
||||
|
||||
|
||||
|
||||
@ -542,6 +560,13 @@ variable_clear(H5F_t * f, void * thing, hbool_t dest)
|
||||
return(clear(f, thing, dest));
|
||||
}
|
||||
|
||||
herr_t
|
||||
notify_clear(H5F_t * f, void * thing, hbool_t dest)
|
||||
{
|
||||
HDassert ( ((test_entry_t *)thing)->type == NOTIFY_ENTRY_TYPE );
|
||||
return(clear(f, thing, dest));
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*-------------------------------------------------------------------------
|
||||
@ -710,6 +735,13 @@ variable_dest(H5F_t * f, void * thing)
|
||||
return(destroy(f, thing));
|
||||
}
|
||||
|
||||
herr_t
|
||||
notify_dest(H5F_t * f, void * thing)
|
||||
{
|
||||
HDassert ( ((test_entry_t *)thing)->type == NOTIFY_ENTRY_TYPE );
|
||||
return(destroy(f, thing));
|
||||
}
|
||||
|
||||
|
||||
/*-------------------------------------------------------------------------
|
||||
* Function: flush & friends
|
||||
@ -888,6 +920,14 @@ variable_flush(H5F_t *f, hid_t dxpl_id, hbool_t dest, haddr_t addr,
|
||||
return(flush(f, dxpl_id, dest, addr, thing, flags_ptr));
|
||||
}
|
||||
|
||||
herr_t
|
||||
notify_flush(H5F_t *f, hid_t dxpl_id, hbool_t dest, haddr_t addr,
|
||||
void *thing, unsigned * flags_ptr)
|
||||
{
|
||||
HDassert ( ((test_entry_t *)thing)->type == NOTIFY_ENTRY_TYPE );
|
||||
return(flush(f, dxpl_id, dest, addr, thing, flags_ptr));
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*-------------------------------------------------------------------------
|
||||
@ -1029,6 +1069,13 @@ variable_load(H5F_t *f, hid_t dxpl_id, haddr_t addr,
|
||||
return(load(f, dxpl_id, addr, udata1, udata2));
|
||||
}
|
||||
|
||||
void *
|
||||
notify_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
|
||||
@ -1148,6 +1195,73 @@ variable_size(H5F_t * f, void * thing, size_t * size_ptr)
|
||||
return(size(f, thing, size_ptr));
|
||||
}
|
||||
|
||||
herr_t
|
||||
notify_size(H5F_t * f, void * thing, size_t * size_ptr)
|
||||
{
|
||||
HDassert ( ((test_entry_t *)thing)->type == NOTIFY_ENTRY_TYPE );
|
||||
return(size(f, thing, size_ptr));
|
||||
}
|
||||
|
||||
|
||||
/*-------------------------------------------------------------------------
|
||||
* Function: notify & friends
|
||||
*
|
||||
* Purpose: Record notifications of cache events for the entry.
|
||||
* The helper functions verify that the correct version of notify
|
||||
* is being called, and then call notify proper.
|
||||
*
|
||||
* Return: SUCCEED
|
||||
*
|
||||
* Programmer: Quincey Koziol
|
||||
* 4/28/09
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
static herr_t
|
||||
notify(H5C_notify_action_t action, 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->type == VARIABLE_ENTRY_TYPE ) || \
|
||||
( entry_ptr->size == entry_sizes[entry_ptr->type] ) );
|
||||
|
||||
/* Increment count for appropriate action */
|
||||
switch(action) {
|
||||
case H5C_NOTIFY_ACTION_AFTER_INSERT: /* Entry has been added to the cache */
|
||||
entry_ptr->notify_after_insert_count++;
|
||||
break;
|
||||
|
||||
case H5C_NOTIFY_ACTION_BEFORE_EVICT: /* Entry is about to be evicted from cache */
|
||||
entry_ptr->notify_before_evict_count++;
|
||||
break;
|
||||
|
||||
default:
|
||||
HDassert(0 && "Unknown notify action!?!");
|
||||
} /* end switch */
|
||||
|
||||
return(SUCCEED);
|
||||
} /* notify() */
|
||||
|
||||
herr_t
|
||||
notify_notify(H5C_notify_action_t action, void *thing)
|
||||
{
|
||||
HDassert ( ((test_entry_t *)thing)->type == NOTIFY_ENTRY_TYPE );
|
||||
return(notify(action, thing));
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
/**************************************************************************/
|
||||
@ -1678,6 +1792,9 @@ reset_entries(void)
|
||||
|
||||
base_addr[j].flush_order = 0;
|
||||
|
||||
base_addr[j].notify_after_insert_count = 0;
|
||||
base_addr[j].notify_before_evict_count = 0;
|
||||
|
||||
addr += (haddr_t)entry_size;
|
||||
alt_addr += (haddr_t)entry_size;
|
||||
} /* end for */
|
||||
|
||||
@ -51,8 +51,9 @@
|
||||
#define HUGE_ENTRY_TYPE 7
|
||||
#define MONSTER_ENTRY_TYPE 8
|
||||
#define VARIABLE_ENTRY_TYPE 9
|
||||
#define NOTIFY_ENTRY_TYPE 10
|
||||
|
||||
#define NUMBER_OF_ENTRY_TYPES 10
|
||||
#define NUMBER_OF_ENTRY_TYPES 11
|
||||
|
||||
#define PICO_ENTRY_SIZE (size_t)1
|
||||
#define NANO_ENTRY_SIZE (size_t)4
|
||||
@ -64,6 +65,7 @@
|
||||
#define HUGE_ENTRY_SIZE (size_t)(16 * 1024)
|
||||
#define MONSTER_ENTRY_SIZE (size_t)(64 * 1024)
|
||||
#define VARIABLE_ENTRY_SIZE (size_t)(10 * 1024)
|
||||
#define NOTIFY_ENTRY_SIZE (size_t)1
|
||||
|
||||
#define NUM_PICO_ENTRIES (10 * 1024)
|
||||
#define NUM_NANO_ENTRIES (10 * 1024)
|
||||
@ -75,6 +77,7 @@
|
||||
#define NUM_HUGE_ENTRIES (10 * 1024)
|
||||
#define NUM_MONSTER_ENTRIES (10 * 1024)
|
||||
#define NUM_VARIABLE_ENTRIES (10 * 1024)
|
||||
#define NUM_NOTIFY_ENTRIES (10 * 1024)
|
||||
|
||||
#define MAX_ENTRIES (10 * 1024)
|
||||
|
||||
@ -97,9 +100,11 @@
|
||||
(HUGE_ENTRY_SIZE * NUM_HUGE_ENTRIES))
|
||||
#define VARIABLE_BASE_ADDR (haddr_t)(MONSTER_BASE_ADDR + \
|
||||
(MONSTER_ENTRY_SIZE * NUM_MONSTER_ENTRIES))
|
||||
#define NOTIFY_BASE_ADDR (haddr_t)(VARIABLE_BASE_ADDR + \
|
||||
(VARIABLE_ENTRY_SIZE * NUM_VARIABLE_ENTRIES))
|
||||
|
||||
#define PICO_ALT_BASE_ADDR (haddr_t)(VARIABLE_BASE_ADDR + \
|
||||
(VARIABLE_ENTRY_SIZE * NUM_VARIABLE_ENTRIES))
|
||||
#define PICO_ALT_BASE_ADDR (haddr_t)(NOTIFY_BASE_ADDR + \
|
||||
(NOTIFY_ENTRY_SIZE * NUM_NOTIFY_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 + \
|
||||
@ -118,6 +123,8 @@
|
||||
(HUGE_ENTRY_SIZE * NUM_HUGE_ENTRIES))
|
||||
#define VARIABLE_ALT_BASE_ADDR (haddr_t)(MONSTER_ALT_BASE_ADDR + \
|
||||
(MONSTER_ENTRY_SIZE * NUM_MONSTER_ENTRIES))
|
||||
#define NOTIFY_ALT_BASE_ADDR (haddr_t)(VARIABLE_ALT_BASE_ADDR + \
|
||||
(VARIABLE_ENTRY_SIZE * NUM_VARIABLE_ENTRIES))
|
||||
|
||||
#define MAX_PINS 8 /* Maximum number of entries that can be
|
||||
* directly pinned by a single entry.
|
||||
@ -309,6 +316,9 @@ typedef struct test_entry_t
|
||||
hbool_t pinned_from_client; /* entry was pinned by client call */
|
||||
hbool_t pinned_from_cache; /* entry was pinned by cache internally */
|
||||
unsigned flush_order; /* Order that entry was flushed in */
|
||||
|
||||
unsigned notify_after_insert_count; /* Count of times that entry was inserted in cache */
|
||||
unsigned notify_before_evict_count; /* Count of times that entry was removed in cache */
|
||||
} test_entry_t;
|
||||
|
||||
/* The following is a cut down copy of the hash table manipulation
|
||||
@ -530,6 +540,7 @@ 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);
|
||||
herr_t variable_clear(H5F_t * f, void * thing, hbool_t dest);
|
||||
herr_t notify_clear(H5F_t * f, void * thing, hbool_t dest);
|
||||
|
||||
|
||||
herr_t pico_dest(H5F_t * f, void * thing);
|
||||
@ -542,6 +553,7 @@ 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);
|
||||
herr_t variable_dest(H5F_t * f, void * thing);
|
||||
herr_t notify_dest(H5F_t * f, void * thing);
|
||||
|
||||
|
||||
herr_t pico_flush(H5F_t *f, hid_t dxpl_id, hbool_t dest,
|
||||
@ -564,6 +576,8 @@ herr_t monster_flush(H5F_t *f, hid_t dxpl_id, hbool_t dest,
|
||||
haddr_t addr, void *thing, unsigned * flags_ptr);
|
||||
herr_t variable_flush(H5F_t *f, hid_t dxpl_id, hbool_t dest,
|
||||
haddr_t addr, void *thing, unsigned * flags_ptr);
|
||||
herr_t notify_flush(H5F_t *f, hid_t dxpl_id, hbool_t dest,
|
||||
haddr_t addr, void *thing, unsigned * flags_ptr);
|
||||
|
||||
|
||||
void * pico_load(H5F_t *f, hid_t dxpl_id, haddr_t addr,
|
||||
@ -586,6 +600,8 @@ void * monster_load(H5F_t *f, hid_t dxpl_id, haddr_t addr,
|
||||
const void *udata1, void *udata2);
|
||||
void * variable_load(H5F_t *f, hid_t dxpl_id, haddr_t addr,
|
||||
const void *udata1, void *udata2);
|
||||
void * notify_load(H5F_t *f, hid_t dxpl_id, haddr_t addr,
|
||||
const void *udata1, void *udata2);
|
||||
|
||||
|
||||
herr_t pico_size(H5F_t * f, void * thing, size_t * size_ptr);
|
||||
@ -598,6 +614,9 @@ 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);
|
||||
herr_t variable_size(H5F_t * f, void * thing, size_t * size_ptr);
|
||||
herr_t notify_size(H5F_t * f, void * thing, size_t * size_ptr);
|
||||
|
||||
herr_t notify_notify(H5C_notify_action_t action, void *thing);
|
||||
|
||||
/* callback table extern */
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user