summaryrefslogtreecommitdiffstats
path: root/testpar/t_cache.c
diff options
context:
space:
mode:
Diffstat (limited to 'testpar/t_cache.c')
-rw-r--r--testpar/t_cache.c761
1 files changed, 738 insertions, 23 deletions
diff --git a/testpar/t_cache.c b/testpar/t_cache.c
index 4b7d298..448b760 100644
--- a/testpar/t_cache.c
+++ b/testpar/t_cache.c
@@ -93,6 +93,13 @@ long local_pins = 0;
*
* len: Length of the entry.
*
+ * local_len: Length of the entry according to the cache. This
+ * value must be positive, and may not be larger than len.
+ *
+ * The field exists to allow us change the sizes of entries
+ * in the cache without upsetting the server. This value
+ * is only used locally, and is never sent to the server.
+ *
* ver: Version number of the entry. This number is initialize
* to zero, and incremented each time the entry is modified.
*
@@ -131,6 +138,7 @@ struct datum
H5C_cache_entry_t header;
haddr_t base_addr;
size_t len;
+ size_t local_len;
int ver;
hbool_t dirty;
hbool_t valid;
@@ -325,6 +333,7 @@ const H5C_class_t types[NUMBER_OF_ENTRY_TYPES] =
/* test utility functions */
+void expunge_entry(H5C_t * cache_ptr, H5F_t * file_ptr, int32_t idx);
void insert_entry(H5C_t * cache_ptr, H5F_t * file_ptr,
int32_t idx, unsigned int flags);
void local_pin_and_unpin_random_entries(H5C_t * cache_ptr, H5F_t * file_ptr,
@@ -349,8 +358,12 @@ void mark_pinned_or_protected_entry_dirty(H5C_t * cache_ptr,
int32_t idx);
void pin_entry(H5C_t * cache_ptr, H5F_t * file_ptr, int32_t idx,
hbool_t global, hbool_t dirty);
+void pin_protected_entry(H5C_t * cache_ptr, H5F_t * file_ptr,
+ int32_t idx, hbool_t global);
void rename_entry(H5C_t * cache_ptr, H5F_t * file_ptr,
int32_t old_idx, int32_t new_idx);
+void resize_entry(H5C_t * cache_ptr, H5F_t * file_ptr,
+ int32_t idx, size_t new_size);
hbool_t setup_cache_for_test(hid_t * fid_ptr, H5F_t ** file_ptr_ptr,
H5C_t ** cache_ptr_ptr);
void setup_rand(void);
@@ -369,6 +382,7 @@ hbool_t smoke_check_2(void);
hbool_t smoke_check_3(void);
hbool_t smoke_check_4(void);
hbool_t smoke_check_5(void);
+hbool_t trace_file_check(void);
/*****************************************************************************/
@@ -627,7 +641,7 @@ set_up_file_communicator(void)
int
addr_to_datum_index(haddr_t base_addr)
{
- const char * fcn_name = "addr_to_datum_index()";
+ /* const char * fcn_name = "addr_to_datum_index()"; */
int top = NUM_DATA_ENTRIES - 1;
int bottom = 0;
int middle = (NUM_DATA_ENTRIES - 1) / 2;
@@ -673,14 +687,15 @@ addr_to_datum_index(haddr_t base_addr)
*
* Modifications:
*
- * None.
+ * JRM -- 7/11/06
+ * Added support for the local_len field.
*
*****************************************************************************/
void
init_data(void)
{
- const char * fcn_name = "init_data()";
+ /* const char * fcn_name = "init_data()"; */
/* The set of address offsets is chosen so as to avoid allowing the
* base addresses to fall in a pattern of that will annoy the hash
* table, and to give a good range of entry sizes.
@@ -705,6 +720,7 @@ init_data(void)
{
data[i].base_addr = addr;
data[i].len = (size_t)(addr_offsets[j]);
+ data[i].local_len = (size_t)(addr_offsets[j]);
data[i].ver = 0;
data[i].dirty = FALSE;
data[i].valid = FALSE;
@@ -814,7 +830,6 @@ do_sync(void)
{
const char * fcn_name = "do_sync()";
- herr_t ret_value = SUCCEED;
struct mssg_t mssg;
if ( nerrors <= 0 ) {
@@ -1640,6 +1655,12 @@ serve_write_request(struct mssg_t * mssg_ptr)
*
* Modifications:
*
+ * JRM -- 7/11/06
+ * Modified code to support the local_len field of datum.
+ * This field allow us to track the cache's value for the
+ * length of the entry, while retaining the original
+ * value for communications with the server.
+ *
*-------------------------------------------------------------------------
*/
@@ -1663,7 +1684,8 @@ clear_datum(H5F_t * f,
HDassert( &(data[idx]) == entry_ptr );
HDassert( entry_ptr->header.addr == entry_ptr->base_addr );
- HDassert( entry_ptr->header.size == entry_ptr->len );
+ HDassert( ( entry_ptr->header.size == entry_ptr->len ) ||
+ ( entry_ptr->header.size == entry_ptr->local_len ) );
entry_ptr->header.is_dirty = FALSE;
entry_ptr->dirty = FALSE;
@@ -1700,6 +1722,12 @@ clear_datum(H5F_t * f,
*
* Modifications:
*
+ * JRM -- 7/11/06
+ * Modified code to support the local_len field of datum.
+ * This field allow us to track the cache's value for the
+ * length of the entry, while retaining the original
+ * value for communications with the server.
+ *
*-------------------------------------------------------------------------
*/
@@ -1722,7 +1750,8 @@ destroy_datum(H5F_t UNUSED * f,
HDassert( &(data[idx]) == entry_ptr );
HDassert( entry_ptr->header.addr == entry_ptr->base_addr );
- HDassert( entry_ptr->header.size == entry_ptr->len );
+ HDassert( ( entry_ptr->header.size == entry_ptr->len ) ||
+ ( entry_ptr->header.size == entry_ptr->local_len ) );
HDassert( !(entry_ptr->dirty) );
HDassert( !(entry_ptr->header.is_dirty) );
@@ -1755,6 +1784,12 @@ destroy_datum(H5F_t UNUSED * f,
* a bug spotted on Cobalt. If it doesn't fix the problem,
* it will narrow down the possibilities.
*
+ * JRM -- 7/11/06
+ * Modified code to support the local_len field of datum.
+ * This field allow us to track the cache's value for the
+ * length of the entry, while retaining the original
+ * value for communications with the server.
+ *
*-------------------------------------------------------------------------
*/
@@ -1783,7 +1818,8 @@ flush_datum(H5F_t *f,
HDassert( &(data[idx]) == entry_ptr );
HDassert( entry_ptr->header.addr == entry_ptr->base_addr );
- HDassert( entry_ptr->header.size == entry_ptr->len );
+ HDassert( ( entry_ptr->header.size == entry_ptr->len ) ||
+ ( entry_ptr->header.size == entry_ptr->local_len ) );
HDassert( entry_ptr->header.is_dirty == entry_ptr->dirty );
@@ -2052,6 +2088,14 @@ load_datum(H5F_t UNUSED *f,
*
* Modifications:
*
+ * JRM -- 7/11/06
+ * Modified function to return the local_len field instead
+ * of the len field. These two fields usually contain the
+ * same value, but if the size of an entry is changed, we
+ * store the altered size in local_len without changing
+ * len. Note that local_len must be positive, and may
+ * not exceed len.
+ *
*-------------------------------------------------------------------------
*/
@@ -2074,10 +2118,12 @@ size_datum(H5F_t UNUSED * f,
HDassert( idx < NUM_DATA_ENTRIES );
HDassert( idx < virt_num_data_entries );
HDassert( &(data[idx]) == entry_ptr );
+ HDassert( entry_ptr->local_len > 0 );
+ HDassert( entry_ptr->local_len <= entry_ptr->len );
HDassert( entry_ptr->header.addr == entry_ptr->base_addr );
- *size_ptr = entry_ptr->len;
+ *size_ptr = entry_ptr->local_len;
return(SUCCEED);
@@ -2089,6 +2135,90 @@ size_datum(H5F_t UNUSED * f,
/*****************************************************************************/
/*****************************************************************************
+ * Function: expunge_entry()
+ *
+ * Purpose: Expunge the entry indicated by the type and index, mark it
+ * as clean, and don't increment its version number.
+ *
+ * Do nothing if nerrors is non-zero on entry.
+ *
+ * Return: void
+ *
+ * Programmer: John Mainzer
+ * 07/11/06
+ *
+ * Modifications:
+ *
+ * None.
+ *
+ *****************************************************************************/
+
+void
+expunge_entry(H5C_t * cache_ptr,
+ H5F_t * file_ptr,
+ int32_t idx)
+{
+ const char * fcn_name = "expunge_entry()";
+ hbool_t in_cache;
+ herr_t result;
+ struct datum * entry_ptr;
+
+ HDassert( cache_ptr );
+ HDassert( file_ptr );
+ HDassert( ( 0 <= idx ) && ( idx < NUM_DATA_ENTRIES ) );
+ HDassert( idx < virt_num_data_entries );
+
+ entry_ptr = &(data[idx]);
+
+ HDassert( !(entry_ptr->locked) );
+ HDassert( !(entry_ptr->global_pinned) );
+ HDassert( !(entry_ptr->local_pinned) );
+
+ entry_ptr->dirty = TRUE;
+
+ if ( nerrors == 0 ) {
+
+ result = H5AC_expunge_entry(file_ptr, -1, &(types[0]),
+ entry_ptr->header.addr);
+
+ if ( result < 0 ) {
+
+ nerrors++;
+ if ( verbose ) {
+ HDfprintf(stdout, "%d:%s: Error in H5AC_expunge_entry().\n",
+ world_mpi_rank, fcn_name);
+ }
+ }
+
+ HDassert( ((entry_ptr->header).type)->id == DATUM_ENTRY_TYPE );
+ HDassert( ! ((entry_ptr->header).is_dirty) );
+
+ result = H5C_get_entry_status(cache_ptr, entry_ptr->base_addr,
+ NULL, &in_cache, NULL, NULL, NULL);
+
+ if ( result < 0 ) {
+
+ nerrors++;
+ if ( verbose ) {
+ HDfprintf(stdout, "%d:%s: Error in H5C_get_entry_status().\n",
+ world_mpi_rank, fcn_name);
+ }
+ } else if ( in_cache ) {
+
+ nerrors++;
+ if ( verbose ) {
+ HDfprintf(stdout, "%d:%s: Expunged entry still in cache?!?\n",
+ world_mpi_rank, fcn_name);
+ }
+ }
+ }
+
+ return;
+
+} /* expunge_entry() */
+
+
+/*****************************************************************************
* Function: insert_entry()
*
* Purpose: Insert the entry indicated by the type and index, mark it
@@ -2205,7 +2335,7 @@ local_pin_and_unpin_random_entries(H5C_t * cache_ptr,
int min_count,
int max_count)
{
- const char * fcn_name = "local_pin_and_unpin_random_entries()";
+ /* const char * fcn_name = "local_pin_and_unpin_random_entries()"; */
if ( nerrors == 0 ) {
@@ -2280,7 +2410,7 @@ local_pin_random_entry(H5C_t * cache_ptr,
int min_idx,
int max_idx)
{
- const char * fcn_name = "local_pin_random_entry()";
+ /* const char * fcn_name = "local_pin_random_entry()"; */
int idx;
if ( nerrors == 0 ) {
@@ -2329,7 +2459,7 @@ local_unpin_all_entries(H5C_t * cache_ptr,
H5F_t * file_ptr,
hbool_t via_unprotect)
{
- const char * fcn_name = "local_unpin_all_entries()";
+ /* const char * fcn_name = "local_unpin_all_entries()"; */
if ( nerrors == 0 ) {
@@ -2377,7 +2507,7 @@ local_unpin_next_pinned_entry(H5C_t * cache_ptr,
int start_idx,
hbool_t via_unprotect)
{
- const char * fcn_name = "local_unpin_next_pinned_entry()";
+ /* const char * fcn_name = "local_unpin_next_pinned_entry()"; */
int i = 0;
int idx = -1;
@@ -2442,7 +2572,7 @@ lock_and_unlock_random_entries(H5C_t * cache_ptr,
int min_count,
int max_count)
{
- const char * fcn_name = "lock_and_unlock_random_entries()";
+ /* const char * fcn_name = "lock_and_unlock_random_entries()"; */
int count;
int i;
@@ -2492,7 +2622,7 @@ lock_and_unlock_random_entry(H5C_t * cache_ptr,
int min_idx,
int max_idx)
{
- const char * fcn_name = "lock_and_unlock_random_entry()";
+ /* const char * fcn_name = "lock_and_unlock_random_entry()"; */
int idx;
if ( nerrors == 0 ) {
@@ -2532,6 +2662,10 @@ lock_and_unlock_random_entry(H5C_t * cache_ptr,
*
* Modifications:
*
+ * JRM -- 7/11/06
+ * Modified asserts to handle the new local_len field in
+ * datum.
+ *
*****************************************************************************/
void
@@ -2559,7 +2693,8 @@ lock_entry(H5C_t * cache_ptr,
if ( ( cache_entry_ptr != (void *)(&(entry_ptr->header)) ) ||
( entry_ptr->header.type != &(types[0]) ) ||
- ( entry_ptr->len != entry_ptr->header.size ) ||
+ ( ( entry_ptr->len != entry_ptr->header.size ) &&
+ ( entry_ptr->local_len != entry_ptr->header.size ) ) ||
( entry_ptr->base_addr != entry_ptr->header.addr ) ) {
nerrors++;
@@ -2573,7 +2708,6 @@ lock_entry(H5C_t * cache_ptr,
}
-
HDassert( ((entry_ptr->header).type)->id == DATUM_ENTRY_TYPE );
}
@@ -2735,7 +2869,7 @@ pin_entry(H5C_t * cache_ptr,
hbool_t global,
hbool_t dirty)
{
- const char * fcn_name = "pin_entry()";
+ /* const char * fcn_name = "pin_entry()"; */
unsigned int flags = H5AC__PIN_ENTRY_FLAG;
struct datum * entry_ptr;
@@ -2785,6 +2919,85 @@ pin_entry(H5C_t * cache_ptr,
/*****************************************************************************
+ * Function: pin_protected_entry()
+ *
+ * Purpose: Insert the entry indicated by the type and index, mark it
+ * as dirty, and increment its version number.
+ *
+ * Do nothing if nerrors is non-zero on entry.
+ *
+ * Return: void
+ *
+ * Programmer: John Mainzer
+ * 01/04/06
+ *
+ * Modifications:
+ *
+ * None.
+ *
+ *****************************************************************************/
+
+void
+pin_protected_entry(H5C_t * cache_ptr,
+ H5F_t * file_ptr,
+ int32_t idx,
+ hbool_t global)
+{
+ const char * fcn_name = "pin_protected_entry()";
+ herr_t result;
+ struct datum * entry_ptr;
+
+ HDassert( cache_ptr );
+ HDassert( file_ptr );
+ HDassert( ( 0 <= idx ) && ( idx < NUM_DATA_ENTRIES ) );
+ HDassert( idx < virt_num_data_entries );
+
+ entry_ptr = &(data[idx]);
+
+ HDassert( entry_ptr->locked );
+
+ if ( nerrors == 0 ) {
+
+ result = H5AC_pin_protected_entry(file_ptr, (void *)entry_ptr);
+
+ if ( ( result < 0 ) ||
+ ( entry_ptr->header.type != &(types[0]) ) ||
+ ( ( entry_ptr->len != entry_ptr->header.size ) &&
+ ( entry_ptr->local_len != entry_ptr->header.size ) )||
+ ( entry_ptr->base_addr != entry_ptr->header.addr ) ||
+ ( ! ( (entry_ptr->header).is_pinned ) ) ) {
+
+ nerrors++;
+ if ( verbose ) {
+ HDfprintf(stdout,
+ "%d:%s: Error in H5AC_pin_protected entry().\n",
+ world_mpi_rank, fcn_name);
+ }
+ }
+
+ if ( global ) {
+
+ entry_ptr->global_pinned = TRUE;
+
+ global_pins++;
+
+ } else {
+
+ entry_ptr->local_pinned = TRUE;
+
+ local_pins++;
+
+ }
+
+ HDassert( ((entry_ptr->header).type)->id == DATUM_ENTRY_TYPE );
+ }
+
+ return;
+
+} /* pin_protected_entry() */
+
+
+/*****************************************************************************
* Function: rename_entry()
*
* Purpose: Rename the entry indicated old_idx to the entry indicated
@@ -2801,7 +3014,8 @@ pin_entry(H5C_t * cache_ptr,
*
* Modifications:
*
- * None.
+ * 7/11/06 -- JRM
+ * Added support for the phony_len field in datum.
*
*****************************************************************************/
@@ -2814,6 +3028,7 @@ rename_entry(H5C_t * cache_ptr,
const char * fcn_name = "rename_entry()";
herr_t result;
int tmp;
+ size_t tmp_len;
haddr_t old_addr = HADDR_UNDEF;
haddr_t new_addr = HADDR_UNDEF;
struct datum * old_entry_ptr;
@@ -2876,6 +3091,13 @@ rename_entry(H5C_t * cache_ptr,
tmp = old_entry_ptr->index;
old_entry_ptr->index = new_entry_ptr->index;
new_entry_ptr->index = tmp;
+
+ if ( old_entry_ptr->local_len != new_entry_ptr->local_len ) {
+
+ tmp_len = old_entry_ptr->local_len;
+ old_entry_ptr->local_len = new_entry_ptr->local_len;
+ new_entry_ptr->local_len = tmp_len;
+ }
}
}
@@ -2885,6 +3107,86 @@ rename_entry(H5C_t * cache_ptr,
/*****************************************************************************
+ * Function: resize_entry()
+ *
+ * Purpose: Resize the pinned entry indicated by idx to the new_size.
+ * Note that new_size must be greater than 0, and must be
+ * less than or equal to the original size of the entry.
+ *
+ * Do nothing if nerrors isn't zero.
+ *
+ * Return: void
+ *
+ * Programmer: John Mainzer
+ * 7/11/06
+ *
+ * Modifications:
+ *
+ * None
+ *
+ *****************************************************************************/
+
+void
+resize_entry(H5C_t * cache_ptr,
+ H5F_t * file_ptr,
+ int32_t idx,
+ size_t new_size)
+{
+ const char * fcn_name = "resize_entry()";
+ herr_t result;
+ struct datum * entry_ptr;
+
+ if ( nerrors == 0 ) {
+
+ HDassert( cache_ptr );
+ HDassert( file_ptr );
+ HDassert( ( 0 <= idx ) && ( idx < NUM_DATA_ENTRIES ) );
+ HDassert( idx < virt_num_data_entries );
+
+ entry_ptr = &(data[idx]);
+
+ HDassert( ((entry_ptr->header).type)->id == DATUM_ENTRY_TYPE );
+ HDassert( !(entry_ptr->header.is_protected) );
+ HDassert( !(entry_ptr->locked) );
+ HDassert( ( entry_ptr->global_pinned ) &&
+ ( ! entry_ptr->local_pinned ) );
+ HDassert( ( entry_ptr->header.size == entry_ptr->len ) ||
+ ( entry_ptr->header.size == entry_ptr->local_len ) );
+ HDassert( new_size > 0 );
+ HDassert( new_size <= entry_ptr->len );
+
+ result = H5AC_resize_pinned_entry(file_ptr, (void *)entry_ptr,
+ new_size);
+
+ if ( result < 0 ) {
+
+ nerrors++;
+ if ( verbose ) {
+ HDfprintf(stdout, "%d:%s: H5AC_rename() failed.\n",
+ world_mpi_rank, fcn_name);
+ }
+
+ } else {
+
+ HDassert( ((entry_ptr->header).type)->id == DATUM_ENTRY_TYPE );
+ HDassert( entry_ptr->header.is_dirty );
+ HDassert( entry_ptr->header.size == new_size );
+
+ entry_ptr->dirty = TRUE;
+ entry_ptr->local_len = new_size;
+
+ /* touch up version. */
+
+ (entry_ptr->ver)++;
+ }
+ }
+
+ return;
+
+} /* resize_entry() */
+
+
+/*****************************************************************************
*
* Function: setup_cache_for_test()
*
@@ -3283,6 +3585,9 @@ take_down_cache(hid_t fid)
*
* Modifications:
*
+ * 7/11/06
+ * Updated for the new local_len field in datum.
+ *
*****************************************************************************/
void
@@ -3321,7 +3626,8 @@ unlock_entry(H5C_t * cache_ptr,
if ( ( result < 0 ) ||
( entry_ptr->header.type != &(types[0]) ) ||
- ( entry_ptr->len != entry_ptr->header.size ) ||
+ ( ( entry_ptr->len != entry_ptr->header.size ) &&
+ ( entry_ptr->local_len != entry_ptr->header.size ) ) ||
( entry_ptr->base_addr != entry_ptr->header.addr ) ) {
nerrors++;
@@ -3408,7 +3714,8 @@ unpin_entry(H5C_t * cache_ptr,
if ( dirty ) {
- mark_pinned_entry_dirty(cache_ptr, file_ptr, idx, FALSE, (size_t)0);
+ mark_pinned_entry_dirty(cache_ptr, file_ptr, idx, FALSE,
+ (size_t)0);
}
@@ -4684,7 +4991,9 @@ smoke_check_4(void)
*
* Modifications:
*
- * None.
+ * JRM -- 7/12/06
+ * Added test code for H5AC_expunge_entry() and
+ * H5AC_resize_pinned_entry().
*
*****************************************************************************/
@@ -4758,6 +5067,17 @@ smoke_check_5(void)
}
unlock_entry(cache_ptr, file_ptr, i, H5AC__NO_FLAGS_SET);
+
+ if ( i % 2 == 1 )
+ {
+ if ( i % 4 == 1 ) {
+
+ lock_entry(cache_ptr, file_ptr, i);
+ unlock_entry(cache_ptr, file_ptr, i, H5AC__DIRTIED_FLAG);
+ }
+
+ expunge_entry(cache_ptr, file_ptr, i);
+ }
}
for ( i = (virt_num_data_entries / 2) - 1;
@@ -4768,6 +5088,11 @@ smoke_check_5(void)
if ( i % 2 == 0 )
{
+ if ( i % 8 <= 4 ) {
+
+ resize_entry(cache_ptr, file_ptr, i, data[i].len / 2);
+ }
+
if ( i % 4 == 0 )
{
mark_pinned_or_protected_entry_dirty(cache_ptr,
@@ -4778,7 +5103,13 @@ smoke_check_5(void)
mark_pinned_entry_dirty(cache_ptr, file_ptr, i,
FALSE, (size_t)0);
}
+
+ if ( i % 8 <= 4 ) {
+
+ resize_entry(cache_ptr, file_ptr, i, data[i].len);
+ }
}
+
unpin_entry(cache_ptr, file_ptr, i, TRUE, FALSE, FALSE);
}
@@ -4853,6 +5184,383 @@ smoke_check_5(void)
/*****************************************************************************
*
+ * Function: trace_file_check()
+ *
+ * Purpose: A basic test of the trace file capability. In essence,
+ * we invoke all operations that generate trace file output,
+ * and then verify that the expected output was generated.
+ *
+ * Note that the trace file is currently implemented at the
+ * H5AC level, so all calls have to go through H5AC. Thus it
+ * is more convenient to test trace file capabilities in the
+ * parallel cache test which works at the H5AC level, instead
+ * of in the serial test code which does everything at the
+ * H5C level.
+ *
+ * The function must test trace file output in the following
+ * functions:
+ *
+ * - H5AC_flush()
+ * - H5AC_set()
+ * - H5AC_mark_pinned_entry_dirty()
+ * - H5AC_mark_pinned_or_protected_entry_dirty()
+ * H5AC_rename()
+ * - H5AC_pin_protected_entry()
+ * - H5AC_protect()
+ * - H5AC_unpin_entry()
+ * - H5AC_unprotect()
+ * - H5AC_set_cache_auto_resize_config()
+ * - H5AC_expunge_entry()
+ * - H5AC_resize_pinned_entry()
+ *
+ * This test is skipped if H5_METADATA_TRACE_FILE is undefined.
+ *
+ * Return: Success: TRUE
+ *
+ * Failure: FALSE
+ *
+ * Programmer: JRM -- 6/13/06
+ *
+ * Modifications:
+ *
+ * JRM -- 7/11/06
+ * Updated fro H5AC_expunge_entry() and
+ * H5AC_resize_pinned_entry().
+ *
+ *****************************************************************************/
+
+hbool_t
+trace_file_check(void)
+{
+ hbool_t success = TRUE;
+
+#ifdef H5_METADATA_TRACE_FILE
+
+ const char * fcn_name = "trace_file_check()";
+ const char * expected_output[] =
+ {
+ "### HDF5 metadata cache trace file version 1 ###\n",
+ "H5AC_set_cache_auto_resize_config 1 0 1 0 \"t_cache_trace.txt\" 0 1048576 0.500000 16777216 1048576 50000 1 0.900000 2.000000 1 4194304 3 0.999000 0.900000 1 1048576 3 1 0.100000 262144 0\n",
+ "H5AC_set 0x0 12 0x0 2 0\n",
+ "H5AC_set 0x2 12 0x0 2 0\n",
+ "H5AC_set 0x4 12 0x0 4 0\n",
+ "H5AC_set 0x8 12 0x0 6 0\n",
+ "H5AC_protect 0 12 2 1\n",
+ "H5AC_mark_pinned_or_protected_entry_dirty 0 0\n",
+ "H5AC_protect 0 12 0 0 0\n",
+ "H5AC_protect 2 12 2 1\n",
+ "H5AC_pin_protected_entry 2 0\n",
+ "H5AC_protect 2 12 0 0 0\n",
+ "H5AC_unpin_entry 2 0\n",
+ "H5AC_expunge_entry 2 12 0\n",
+ "H5AC_protect 4 12 4 1\n",
+ "H5AC_pin_protected_entry 4 0\n",
+ "H5AC_protect 4 12 0 0 0\n",
+ "H5AC_mark_pinned_entry_dirty 0x4 0 0 0\n",
+ "H5AC_resize_pinned_entry 0x4 2 0 0\n",
+ "H5AC_resize_pinned_entry 0x4 4 0 0\n",
+ "H5AC_unpin_entry 4 0\n",
+ "H5AC_rename 0 8a65 12 0\n",
+ "H5AC_rename 8a65 0 12 0\n",
+ "H5AC_flush 0x0 0\n",
+ NULL
+ };
+ char buffer[256];
+ char trace_file_name[64];
+ hbool_t done = FALSE;
+ int i;
+ int max_nerrors;
+ int expected_line_len;
+ int actual_line_len;
+ hid_t fid = -1;
+ H5F_t * file_ptr = NULL;
+ H5C_t * cache_ptr = NULL;
+ FILE * trace_file_ptr = NULL;
+ H5AC_cache_config_t config;
+ struct mssg_t mssg;
+
+#endif /* H5_METADATA_TRACE_FILE */
+
+ if ( world_mpi_rank == 0 ) {
+
+ TESTING("trace file collection");
+ }
+
+#ifdef H5_METADATA_TRACE_FILE
+
+ nerrors = 0;
+ init_data();
+ reset_stats();
+
+ if ( world_mpi_rank == world_server_mpi_rank ) {
+
+ if ( ! server_main() ) {
+
+ /* some error occured in the server -- report failure */
+ nerrors++;
+ if ( verbose ) {
+ HDfprintf(stdout, "%d:%s: server_main() failed.\n",
+ world_mpi_rank, fcn_name);
+ }
+ }
+ }
+ else /* run the clients */
+ {
+
+ if ( ! setup_cache_for_test(&fid, &file_ptr, &cache_ptr) ) {
+
+ nerrors++;
+ fid = -1;
+ cache_ptr = NULL;
+ if ( verbose ) {
+ HDfprintf(stdout, "%d:%s: setup_cache_for_test() failed.\n",
+ world_mpi_rank, fcn_name);
+ }
+ }
+
+ if ( nerrors == 0 ) {
+
+ config.version = H5AC__CURR_CACHE_CONFIG_VERSION;
+
+ if ( H5AC_get_cache_auto_resize_config(cache_ptr, &config)
+ != SUCCEED ) {
+
+ nerrors++;
+ HDfprintf(stdout,
+ "%d:%s: H5AC_get_cache_auto_resize_config() failed.\n",
+ world_mpi_rank, fcn_name);
+
+ } else {
+
+ config.open_trace_file = TRUE;
+ strcpy(config.trace_file_name, "t_cache_trace.txt");
+
+ if ( H5AC_set_cache_auto_resize_config(cache_ptr, &config)
+ != SUCCEED ) {
+
+ nerrors++;
+ HDfprintf(stdout,
+ "%d:%s: H5AC_set_cache_auto_resize_config() failed.\n",
+ world_mpi_rank, fcn_name);
+ }
+ }
+ }
+
+ insert_entry(cache_ptr, file_ptr, 0, H5AC__NO_FLAGS_SET);
+ insert_entry(cache_ptr, file_ptr, 1, H5AC__NO_FLAGS_SET);
+ insert_entry(cache_ptr, file_ptr, 2, H5AC__NO_FLAGS_SET);
+ insert_entry(cache_ptr, file_ptr, 3, H5AC__NO_FLAGS_SET);
+
+ lock_entry(cache_ptr, file_ptr, 0);
+ mark_pinned_or_protected_entry_dirty(cache_ptr, file_ptr, 0);
+ unlock_entry(cache_ptr, file_ptr, 0, H5AC__NO_FLAGS_SET);
+
+ lock_entry(cache_ptr, file_ptr, 1);
+ pin_protected_entry(cache_ptr, file_ptr, 1, TRUE);
+ unlock_entry(cache_ptr, file_ptr, 1, H5AC__NO_FLAGS_SET);
+ unpin_entry(cache_ptr, file_ptr, 1, TRUE, FALSE, FALSE);
+
+ expunge_entry(cache_ptr,file_ptr, 1);
+
+ lock_entry(cache_ptr, file_ptr, 2);
+ pin_protected_entry(cache_ptr, file_ptr, 2, TRUE);
+ unlock_entry(cache_ptr, file_ptr, 2, H5AC__NO_FLAGS_SET);
+ mark_pinned_entry_dirty(cache_ptr, file_ptr, 2, FALSE, 0);
+ resize_entry(cache_ptr, file_ptr, 2, data[2].len / 2);
+ resize_entry(cache_ptr, file_ptr, 2, data[2].len);
+ unpin_entry(cache_ptr, file_ptr, 2, TRUE, FALSE, FALSE);
+
+ rename_entry(cache_ptr, file_ptr, 0, 20);
+ rename_entry(cache_ptr, file_ptr, 0, 20);
+
+ if ( H5Fflush(fid, H5F_SCOPE_GLOBAL) < 0 ) {
+ nerrors++;
+ if ( verbose ) {
+ HDfprintf(stdout, "%d:%s: H5Fflush() failed.\n",
+ world_mpi_rank, fcn_name);
+ }
+ }
+
+ if ( nerrors == 0 ) {
+
+ config.version = H5AC__CURR_CACHE_CONFIG_VERSION;
+
+ if ( H5AC_get_cache_auto_resize_config(cache_ptr, &config)
+ != SUCCEED ) {
+
+ nerrors++;
+ HDfprintf(stdout,
+ "%d:%s: H5AC_get_cache_auto_resize_config() failed.\n",
+ world_mpi_rank, fcn_name);
+
+ } else {
+
+ config.open_trace_file = FALSE;
+ config.close_trace_file = TRUE;
+ config.trace_file_name[0] = '\0';
+
+ if ( H5AC_set_cache_auto_resize_config(cache_ptr, &config)
+ != SUCCEED ) {
+
+ nerrors++;
+ HDfprintf(stdout,
+ "%d:%s: H5AC_set_cache_auto_resize_config() failed.\n",
+ world_mpi_rank, fcn_name);
+ }
+ }
+ }
+
+ if ( fid >= 0 ) {
+
+ if ( ! take_down_cache(fid) ) {
+
+ nerrors++;
+ if ( verbose ) {
+ HDfprintf(stdout, "%d:%s: take_down_cache() failed.\n",
+ world_mpi_rank, fcn_name);
+ }
+ }
+ }
+
+ /* verify that all instance of datum are back where the started
+ * and are clean.
+ */
+
+ for ( i = 0; i < NUM_DATA_ENTRIES; i++ )
+ {
+ HDassert( data_index[i] == i );
+ HDassert( ! (data[i].dirty) );
+ }
+
+ /* compose the done message */
+ mssg.req = DONE_REQ_CODE;
+ mssg.src = world_mpi_rank;
+ mssg.dest = world_server_mpi_rank;
+ mssg.mssg_num = -1; /* set by send function */
+ mssg.base_addr = 0; /* not used */
+ mssg.len = 0; /* not used */
+ mssg.ver = 0; /* not used */
+ mssg.magic = MSSG_MAGIC;
+
+ if ( success ) {
+
+ success = send_mssg(&mssg, FALSE);
+
+ if ( ! success ) {
+
+ nerrors++;
+ if ( verbose ) {
+ HDfprintf(stdout, "%d:%s: send_mssg() failed on done.\n",
+ world_mpi_rank, fcn_name);
+ }
+ }
+ }
+
+ if ( nerrors == 0 ) {
+
+ sprintf(trace_file_name, "t_cache_trace.txt.%d",
+ (int)file_mpi_rank);
+
+ if ( (trace_file_ptr = HDfopen(trace_file_name, "r")) == NULL ) {
+
+ nerrors++;
+ if ( verbose ) {
+ HDfprintf(stdout, "%d:%s: HDfopen failed.\n",
+ world_mpi_rank, fcn_name);
+ }
+ }
+ }
+
+ i = 0;
+ while ( ( nerrors == 0 ) && ( ! done ) )
+ {
+ if ( expected_output[i] == NULL ) {
+
+ expected_line_len = 0;
+
+ } else {
+
+ expected_line_len = HDstrlen(expected_output[i]);
+ }
+
+ if ( HDfgets(buffer, 255, trace_file_ptr) != NULL ) {
+
+ actual_line_len = strlen(buffer);
+
+ } else {
+
+ actual_line_len = 0;
+ }
+
+ if ( ( actual_line_len == 0 ) && ( expected_line_len == 0 ) ) {
+
+ done = TRUE;
+
+ } else if ( ( actual_line_len != expected_line_len ) ||
+ ( HDstrcmp(buffer, expected_output[i]) != 0 ) ) {
+
+ nerrors++;
+ if ( verbose ) {
+ HDfprintf(stdout,
+ "%d:%s: Unexpected data in trace file line %d.\n",
+ world_mpi_rank, fcn_name, i);
+ HDfprintf(stdout, "%d:%s: expected = \"%s\" %d\n",
+ world_mpi_rank, fcn_name, expected_output[i],
+ expected_line_len);
+ HDfprintf(stdout, "%d:%s: actual = \"%s\" %d\n",
+ world_mpi_rank, fcn_name, buffer,
+ actual_line_len);
+ }
+ } else {
+ i++;
+ }
+ }
+
+ if ( trace_file_ptr != NULL ) {
+
+ HDfclose(trace_file_ptr);
+ trace_file_ptr = NULL;
+#if 1
+ HDremove(trace_file_name);
+#endif
+ }
+ }
+
+ max_nerrors = get_max_nerrors();
+
+ if ( world_mpi_rank == 0 ) {
+
+ if ( max_nerrors == 0 ) {
+
+ PASSED();
+
+ } else {
+
+ failures++;
+ H5_FAILED();
+ }
+ }
+
+ success = ( ( success ) && ( max_nerrors == 0 ) );
+
+#else /* H5_METADATA_TRACE_FILE */
+
+ if ( world_mpi_rank == 0 ) {
+
+ SKIPPED();
+
+ HDfprintf(stdout, " trace file support disabled.\n");
+ }
+
+#endif /* H5_METADATA_TRACE_FILE */
+
+ return(success);
+
+} /* trace_file_check() */
+
+
+/*****************************************************************************
+ *
* Function: main()
*
* Purpose: Main function for the parallel cache test.
@@ -4890,7 +5598,11 @@ main(int argc, char **argv)
H5open();
- if ( (express_test = do_express_test()) ) {
+ express_test = do_express_test();
+#if 0 /* JRM */
+ express_test = 0;
+#endif /* JRM */
+ if ( express_test ) {
virt_num_data_entries = EXPRESS_VIRT_NUM_DATA_ENTRIES;
@@ -5030,7 +5742,10 @@ main(int argc, char **argv)
#endif
#if 1
smoke_check_5();
-#endif
+#endif
+#if 1
+ trace_file_check();
+#endif
finish:
/* make sure all processes are finished before final report, cleanup