mirror/hdf5
2
0
Fork 0
mirror of https://github.com/HDFGroup/hdf5.git synced 2024-12-27 08:01:04 +08:00
Code Issues Packages Projects Releases Wiki Activity
ce42be8e9c
hdf5/testpar/t_cache.c
Quincey Koziol fef5124981 [svn-r17411] Description: 
Make H5AC_flush just flush the cache and make H5AC_dest perform the
proper parallel synchronization before destroying the cache.  Also, further
discriminate between 'closing' and 'non-closing' actions in H5F_flush.

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 (kagiso) w/PGI compilers, w/C++ & FORTRAN, w/threadsafe,
                                in debug mode
        Linux/64-amd64 2.6 (smirom) w/Intel compilers w/default API=1.6.x,
                                w/C++ & FORTRAN, in production mode
        Solaris/32 2.10 (linew) w/deprecated symbols disabled, w/C++ & FORTRAN,
                                w/szip filter, in production mode
        Linux/64-ia64 2.6 (cobalt) w/Intel compilers, w/C++ & FORTRAN,
                                in production mode
        Linux/64-ia64 2.4 (tg-login3) w/parallel, w/FORTRAN, in production mode
        Linux/64-amd64 2.6 (abe) w/parallel, w/FORTRAN, in production mode
        Mac OS X/32 10.5.8 (amazon) in debug mode
        Mac OS X/32 10.5.8 (amazon) w/C++ & FORTRAN, w/threadsafe,
                                in production mode
2009-08-23 19:50:39 -05:00

5964 lines
159 KiB
C
Raw Blame History

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Copyright by The HDF Group. *
* Copyright by the Board of Trustees of the University of Illinois. *
* All rights reserved. *
* *
* This file is part of HDF5. The full HDF5 copyright notice, including *
* terms governing use, modification, and redistribution, is contained in *
* the files COPYING and Copyright.html. COPYING can be found at the root *
* of the source code distribution tree; Copyright.html can be found at the *
* root level of an installed copy of the electronic HDF5 document set and *
* is linked from the top-level documents page. It can also be found at *
* http://hdfgroup.org/HDF5/doc/Copyright.html. If you do not have *
* access to either file, you may request a copy from help@hdfgroup.org. *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/*
* Parallel metadata cache tests.
*
*/
#include "h5test.h"
#include "testpar.h"
#include "H5Iprivate.h"
#include "H5ACprivate.h"
#define H5C_PACKAGE /*suppress error about including H5Cpkg */
#include "H5Cpkg.h"
#define H5AC_PACKAGE /*suppress error about including H5Cpkg */
#include "H5ACpkg.h"
#define H5F_PACKAGE /*suppress error about including H5Fpkg */
#include "H5Fpkg.h"
int nerrors = 0;
int failures = 0;
hbool_t verbose = TRUE; /* used to control error messages */
#if 0
/* So far we haven't needed this, but that may change.
* Keep it around for now
*/
hid_t noblock_dxpl_id=(-1);
#endif
#define NFILENAME 2
#define PARATESTFILE filenames[0]
const char *FILENAME[NFILENAME]={"CacheTestDummy", NULL};
char filenames[NFILENAME][PATH_MAX];
hid_t fapl; /* file access property list */
int world_mpi_size = -1;
int world_mpi_rank = -1;
int world_server_mpi_rank = -1;
MPI_Comm world_mpi_comm = MPI_COMM_NULL;
int file_mpi_size = -1;
int file_mpi_rank = -1;
MPI_Comm file_mpi_comm = MPI_COMM_NULL;
/* the following globals are used to maintain rudementary statistics
* to check the validity of the statistics maintained by H5C.c
*/
long datum_clears = 0;
long datum_pinned_clears = 0;
long datum_destroys = 0;
long datum_flushes = 0;
long datum_pinned_flushes = 0;
long datum_loads = 0;
long global_pins = 0;
long global_dirty_pins = 0;
long local_pins = 0;
/*****************************************************************************
* struct datum
*
* Instances of struct datum are used to store information on entries
* that may be loaded into the cache. The individual fields are
* discussed below:
*
* header: Instance of H5C_cache_entry_t used by the for its data.
* This field is only used on the file processes, not on the
* server process.
*
* This field MUST be the first entry in this structure.
*
* base_addr: Base address of the entry.
*
* 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.
*
* dirty: Boolean flag indicating whether the entry is dirty.
*
* For current purposes, an entry is clean until it is
* modified, and dirty until written to the server (cache
* on process 0) or until it is marked clean (all other
* caches).
*
* valid: Boolean flag indicating whether the entry contains
* valid data. Attempts to read an entry whose valid
* flag is not set should trigger an error.
*
* locked: Boolean flag that is set to true iff the entry is in
* the cache and locked.
*
* global_pinned: Boolean flag that is set to true iff the entry has
* been pinned collectively in all caches. Since writes must
* be collective across all processes, only entries pinned
* in this fashion may be marked dirty.
*
* local_pinned: Boolean flag that is set to true iff the entry
* has been pinned in the local cache, but probably not all
* caches. Such pins will typically not be consistant across
* processes, and thus cannot be marked as dirty unless they
* happen to overlap some collective operation.
*
* cleared: Boolean flag that is set to true whenever the entry is
* dirty, and is cleared via a call to clear_datum().
*
* flushed: Boolean flag that is set to true whenever the entry is
* dirty, and is flushed via a call to flush_datum().
*
* index: Index of this instance of datum in the data_index[] array
* discussed below.
*
*****************************************************************************/
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;
hbool_t locked;
hbool_t global_pinned;
hbool_t local_pinned;
hbool_t cleared;
hbool_t flushed;
int index;
};
/*****************************************************************************
* data array
*
* The data array is an array of instances of datum of size
* NUM_DATA_ENTRIES that is used to track the particulars of all
* the entries that may be loaded into the cache.
*
* It exists on all processes, although the master copy is maintained
* by the server process. If the cache is performing correctly, all
* versions should be effectively identical. By that I mean that
* the data received from the server should always match that in
* the local version of the data array.
*
*****************************************************************************/
#define NUM_DATA_ENTRIES 100000
struct datum data[NUM_DATA_ENTRIES];
/* Many tests use the size of data array as the size of test loops.
* On some machines, this results in unacceptably long test runs.
*
* To deal with this issue, I have introduced the virt_num_data_entries
* global, which can be set to a lower value to throtle the length of
* tests.
*
* Note that this value must always be divisible by 40, and must be an
* even divisor of NUM_DATA_ENTRIES. So far, all tests have been with
* powers of 10 that meet these criteria.
*
* Further, this value must be consistant across all processes.
*/
#define STD_VIRT_NUM_DATA_ENTRIES NUM_DATA_ENTRIES
#define EXPRESS_VIRT_NUM_DATA_ENTRIES (NUM_DATA_ENTRIES / 10)
/* Use a smaller test size to avoid creating huge MPE logfiles. */
#define MPE_VIRT_NUM_DATA_ENTIES (NUM_DATA_ENTRIES / 100)
int virt_num_data_entries = NUM_DATA_ENTRIES;
/*****************************************************************************
* data_index array
*
* The data_index array is an array of integer used to maintain a list
* of instances of datum in the data array in increasing base_addr order.
*
* This array is necessary, as rename operations can swap the values
* of the base_addr fields of two instances of datum. Without this
* array, we would no longer be able to use a binary search on a sorted
* list to find the indexes of instances of datum given the values of
* their base_addr fields.
*
*****************************************************************************/
int data_index[NUM_DATA_ENTRIES];
/*****************************************************************************
* struct mssg
*
* The mssg structure is used as a generic container for messages to
* and from the server. Not all fields are used in all cases.
*
* req: Integer field containing the type of the message.
*
* src: World communicator MPI rank of the sending process.
*
* dest: World communicator MPI rank of the destination process.
*
* mssg_num: Serial number assigned to the message by the sender.
*
* base_addr: Base address of a datum. Not used in all mssgs.
*
* len: Length of a datum (in bytes). Not used in all mssgs.
*
* ver: Version number of a datum. Not used in all mssgs.
*
* magic: Magic number for error detection. Must be set to
* MSSG_MAGIC.
*
*****************************************************************************/
#define DO_WRITE_REQ_ACK FALSE
#define DO_SYNC_AFTER_WRITE TRUE
#define WRITE_REQ_CODE 0
#define WRITE_REQ_ACK_CODE 1
#define READ_REQ_CODE 2
#define READ_REQ_REPLY_CODE 3
#define SYNC_REQ_CODE 4
#define SYNC_ACK_CODE 5
#define DONE_REQ_CODE 6
#define MAX_REQ_CODE 6
#define MSSG_MAGIC 0x1248
struct mssg_t
{
int req;
int src;
int dest;
long int mssg_num;
haddr_t base_addr;
int len;
int ver;
unsigned magic;
};
MPI_Datatype mpi_mssg_t; /* for MPI derived type created from mssg */
/*****************************************************************************/
/************************** function declarations ****************************/
/*****************************************************************************/
/* stats functions */
static void reset_stats(void);
/* MPI setup functions */
static hbool_t set_up_file_communicator(void);
/* data array manipulation functions */
static int addr_to_datum_index(haddr_t base_addr);
static void init_data(void);
/* test coodination related functions */
static int do_express_test(void);
static void do_sync(void);
static int get_max_nerrors(void);
/* mssg xfer related functions */
static hbool_t recv_mssg(struct mssg_t *mssg_ptr, int mssg_tag_offset);
static hbool_t send_mssg(struct mssg_t *mssg_ptr, hbool_t add_req_to_tag);
static hbool_t setup_derived_types(void);
static hbool_t takedown_derived_types(void);
/* server functions */
static hbool_t server_main(void);
static hbool_t serve_read_request(struct mssg_t * mssg_ptr);
static hbool_t serve_sync_request(struct mssg_t * mssg_ptr);
static hbool_t serve_write_request(struct mssg_t * mssg_ptr);
/* call back functions & related data structures */
static herr_t clear_datum(H5F_t * f, void * thing, hbool_t dest);
static herr_t destroy_datum(H5F_t UNUSED * f, void * thing);
static herr_t flush_datum(H5F_t *f, hid_t UNUSED dxpl_id, hbool_t dest, haddr_t addr,
void *thing);
static void * load_datum(H5F_t UNUSED *f, hid_t UNUSED dxpl_id, haddr_t addr,
const void UNUSED *udata1, void UNUSED *udata2);
static herr_t size_datum(H5F_t UNUSED * f, void * thing, size_t * size_ptr);
#define DATUM_ENTRY_TYPE H5AC_TEST_ID
#define NUMBER_OF_ENTRY_TYPES 1
const H5C_class_t types[NUMBER_OF_ENTRY_TYPES] =
{
{
DATUM_ENTRY_TYPE,
(H5C_load_func_t)load_datum,
(H5C_flush_func_t)flush_datum,
(H5C_dest_func_t)destroy_datum,
(H5C_clear_func_t)clear_datum,
(H5C_notify_func_t)NULL,
(H5C_size_func_t)size_datum
}
};
/* 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,
int min_idx, int max_idx,
int min_count, int max_count);
void local_pin_random_entry(H5C_t * cache_ptr, H5F_t * file_ptr,
int min_idx, int max_idx);
void local_unpin_all_entries(H5C_t * cache_ptr, H5F_t * file_ptr,
hbool_t via_unprotect);
int local_unpin_next_pinned_entry(H5C_t * cache_ptr, H5F_t * file_ptr,
int start_idx, hbool_t via_unprotect);
void lock_and_unlock_random_entries(H5C_t * cache_ptr, H5F_t * file_ptr,
int min_idx, int max_idx,
int min_count, int max_count);
void lock_and_unlock_random_entry(H5C_t * cache_ptr, H5F_t * file_ptr,
int min_idx, int max_idx);
void lock_entry(H5C_t * cache_ptr, H5F_t * file_ptr, int32_t idx);
void mark_pinned_entry_dirty(H5C_t * cache_ptr, H5F_t * file_ptr,
int32_t idx, hbool_t size_changed, size_t new_size);
void mark_pinned_or_protected_entry_dirty(H5C_t * cache_ptr,
H5F_t * file_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);
hbool_t take_down_cache(hid_t fid);
void unlock_entry(H5C_t * cache_ptr, H5F_t * file_ptr,
int32_t type, unsigned int flags);
void unpin_entry(H5C_t * cache_ptr, H5F_t * file_ptr, int32_t idx,
hbool_t global, hbool_t dirty, hbool_t via_unprotect);
/* test functions */
hbool_t server_smoke_check(void);
hbool_t smoke_check_1(void);
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);
/*****************************************************************************/
/****************************** stats functions ******************************/
/*****************************************************************************/
#ifdef UNUSED
/*****************************************************************************
*
* Function: print_stats()
*
* Purpose: Print the rudementary stats maintained by t_cache.
*
* This is a debugging function, which will not normally
* be run as part of t_cache.
*
* Return: void
*
* Programmer: JRM -- 4/17/06
*
* Modifications:
*
* None.
*
*****************************************************************************/
static void
print_stats(void)
{
HDfprintf(stdout,
"%d: datum clears / pinned clears / destroys = %ld / %ld / %ld\n",
world_mpi_rank, datum_clears, datum_pinned_clears,
datum_destroys );
HDfprintf(stdout,
"%d: datum flushes / pinned flushes / loads = %ld / %ld / %ld\n",
world_mpi_rank, datum_flushes, datum_pinned_flushes,
datum_loads );
HDfprintf(stdout,
"%d: pins: global / global dirty / local = %ld / %ld / %ld\n",
world_mpi_rank, global_pins, global_dirty_pins, local_pins);
HDfflush(stdout);
return;
} /* print_stats() */
#endif /* UNUSED */
/*****************************************************************************
*
* Function: reset_stats()
*
* Purpose: Reset the rudementary stats maintained by t_cache.
*
* Return: void
*
* Programmer: JRM -- 4/17/06
*
* Modifications:
*
* None.
*
*****************************************************************************/
static void
reset_stats(void)
{
datum_clears = 0;
datum_pinned_clears = 0;
datum_destroys = 0;
datum_flushes = 0;
datum_pinned_flushes = 0;
datum_loads = 0;
global_pins = 0;
global_dirty_pins = 0;
local_pins = 0;
return;
} /* reset_stats() */
/*****************************************************************************/
/**************************** MPI setup functions ****************************/
/*****************************************************************************/
/*****************************************************************************
*
* Function: set_up_file_communicator()
*
* Purpose: Create the MPI communicator used to open a HDF5 file with.
* In passing, also initialize the file_mpi... globals.
*
* Return: Success: TRUE
*
* Failure: FALSE
*
* Programmer: JRM -- 11/16/05
*
* Modifications:
*
* None.
*
*****************************************************************************/
static hbool_t
set_up_file_communicator(void)
{
const char * fcn_name = "set_up_file_communicator()";
hbool_t success = TRUE;
int mpi_result;
int num_excluded_ranks;
int excluded_ranks[1];
MPI_Group file_group;
MPI_Group world_group;
if ( success ) {
mpi_result = MPI_Comm_group(world_mpi_comm, &world_group);
if ( mpi_result != MPI_SUCCESS ) {
nerrors++;
success = FALSE;
if ( verbose ) {
fprintf(stdout,
"%d:%s: MPI_Comm_group() failed with error %d.\n",
world_mpi_rank, fcn_name, mpi_result);
}
}
}
if ( success ) {
num_excluded_ranks = 1;
excluded_ranks[0] = world_server_mpi_rank;
mpi_result = MPI_Group_excl(world_group, num_excluded_ranks,
excluded_ranks, &file_group);
if ( mpi_result != MPI_SUCCESS ) {
nerrors++;
success = FALSE;
if ( verbose ) {
fprintf(stdout,
"%d:%s: MPI_Group_excl() failed with error %d.\n",
world_mpi_rank, fcn_name, mpi_result);
}
}
}
if ( success ) {
mpi_result = MPI_Comm_create(world_mpi_comm, file_group,
&file_mpi_comm);
if ( mpi_result != MPI_SUCCESS ) {
nerrors++;
success = FALSE;
if ( verbose ) {
fprintf(stdout,
"%d:%s: MPI_Comm_create() failed with error %d.\n",
world_mpi_rank, fcn_name, mpi_result);
}
} else {
if ( world_mpi_rank != world_server_mpi_rank ) {
if ( file_mpi_comm == MPI_COMM_NULL ) {
nerrors++;
success = FALSE;
if ( verbose ) {
fprintf(stdout,
"%d:%s: file_mpi_comm == MPI_COMM_NULL.\n",
world_mpi_rank, fcn_name);
}
}
} else {
file_mpi_size = world_mpi_size - 1; /* needed by the server */
if ( file_mpi_comm != MPI_COMM_NULL ) {
nerrors++;
success = FALSE;
if ( verbose ) {
fprintf(stdout,
"%d:%s: file_mpi_comm != MPI_COMM_NULL.\n",
world_mpi_rank, fcn_name);
}
}
}
}
}
if ( ( success ) && ( world_mpi_rank != world_server_mpi_rank ) ) {
mpi_result = MPI_Comm_size(file_mpi_comm, &file_mpi_size);
if ( mpi_result != MPI_SUCCESS ) {
nerrors++;
success = FALSE;
if ( verbose ) {
fprintf(stdout,
"%d:%s: MPI_Comm_size() failed with error %d.\n",
world_mpi_rank, fcn_name, mpi_result);
}
}
}
if ( ( success ) && ( world_mpi_rank != world_server_mpi_rank ) ) {
mpi_result = MPI_Comm_rank(file_mpi_comm, &file_mpi_rank);
if ( mpi_result != MPI_SUCCESS ) {
nerrors++;
success = FALSE;
if ( verbose ) {
fprintf(stdout,
"%d:%s: MPI_Comm_rank() failed with error %d.\n",
world_mpi_rank, fcn_name, mpi_result);
}
}
}
return(success);
} /* set_up_file_communicator() */
/*****************************************************************************/
/******************** data array manipulation functions **********************/
/*****************************************************************************/
/*****************************************************************************
*
* Function: addr_to_datum_index()
*
* Purpose: Given the base address of a datum, find and return its index
* in the data array.
*
* Return: Success: index of target datum.
*
* Failure: -1.
*
* Programmer: JRM -- 12/20/05
*
* Modifications:
*
* None.
*
*****************************************************************************/
static int
addr_to_datum_index(haddr_t base_addr)
{
/* const char * fcn_name = "addr_to_datum_index()"; */
int top = NUM_DATA_ENTRIES - 1;
int bottom = 0;
int middle = (NUM_DATA_ENTRIES - 1) / 2;
int ret_value = -1;
while ( top >= bottom )
{
if ( base_addr < data[data_index[middle]].base_addr ) {
top = middle - 1;
middle = (top + bottom) / 2;
} else if ( base_addr > data[data_index[middle]].base_addr ) {
bottom = middle + 1;
middle = (top + bottom) / 2;
} else /* ( base_addr == data[data_index[middle]].base_addr ) */ {
ret_value = data_index[middle];
bottom = top + 1; /* to force exit from while loop */
}
}
return(ret_value);
} /* addr_to_datum_index() */
/*****************************************************************************
*
* Function: init_data()
*
* Purpose: Initialize the data array, from which cache entries are
* loaded.
*
* Return: Success: TRUE
*
* Failure: FALSE
*
* Programmer: JRM -- 12/20/05
*
* Modifications:
*
* JRM -- 7/11/06
* Added support for the local_len field.
*
* JRM -- 2/4/09
* Added initialization for the cleared and flushed fields.
*
* Mike McGreevy, July 2, 2009
* Changed base address from 0 to 512 since the superblock will
* always be at address 0.
*
*****************************************************************************/
static void
init_data(void)
{
/* 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.
*
* At present, I am using the first 20 entries of the Fibonacci
* sequence multiplied by 2. We will see how it works.
*/
const int num_addr_offsets = 20;
const haddr_t addr_offsets[20] = { 2, 2, 4, 6, 10,
16, 26, 42, 68, 110,
178, 288, 466, 754, 1220,
1974, 3194, 5168, 8362, 13539};
int i;
int j = 0;
haddr_t addr = 512;
/* this must hold so renames don't change entry size. */
HDassert( (NUM_DATA_ENTRIES / 2) % 20 == 0 );
HDassert( (virt_num_data_entries / 2) % 20 == 0 );
for ( i = 0; i < NUM_DATA_ENTRIES; i++ )
{
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;
data[i].locked = FALSE;
data[i].global_pinned = FALSE;
data[i].local_pinned = FALSE;
data[i].cleared = FALSE;
data[i].flushed = FALSE;
data[i].index = i;
data_index[i] = i;
addr += addr_offsets[j];
HDassert( addr > data[i].base_addr );
j = (j + 1) % num_addr_offsets;
}
return;
} /* init_data() */
/*****************************************************************************/
/******************** test coodination related functions *********************/
/*****************************************************************************/
/*****************************************************************************
*
* Function: do_express_test()
*
* Purpose: Do an MPI_Allreduce to obtain the maximum value returned
* by GetTestExpress() across all processes. Return this
* value.
*
* Envirmoment variables can be different across different
* processes. This function ensures that all processes agree
* on whether to do an express test.
*
* Return: Success: Maximum of the values returned by
* GetTestExpress() across all processes.
*
* Failure: -1
*
* Programmer: JRM -- 4/25/06
*
* Modifications:
*
* None.
*
*****************************************************************************/
static int
do_express_test(void)
{
const char * fcn_name = "do_express_test()";
int express_test;
int max_express_test;
int result;
express_test = GetTestExpress();
result = MPI_Allreduce((void *)&express_test,
(void *)&max_express_test,
1,
MPI_INT,
MPI_MAX,
world_mpi_comm);
if ( result != MPI_SUCCESS ) {
nerrors++;
max_express_test = -1;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: MPI_Allreduce() failed.\n",
world_mpi_rank, fcn_name );
}
}
return(max_express_test);
} /* do_express_test() */
/*****************************************************************************
*
* Function: do_sync()
*
* Purpose: Ensure that all messages sent by this process have been
* processed before proceeding.
*
* Do this by exchanging sync req / sync ack messages with
* the server.
*
* Do nothing if nerrors is greater than zero.
*
* Return: void
*
* Programmer: JRM -- 5/10/06
*
* Modifications:
*
* None.
*
*****************************************************************************/
static void
do_sync(void)
{
const char * fcn_name = "do_sync()";
struct mssg_t mssg;
if ( nerrors <= 0 ) {
/* compose the message */
mssg.req = SYNC_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;
mssg.len = 0;
mssg.ver = 0;
mssg.magic = MSSG_MAGIC;
if ( ! send_mssg(&mssg, FALSE) ) {
nerrors++;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: send_mssg() failed.\n",
world_mpi_rank, fcn_name);
}
}
}
if ( nerrors <= 0 ) {
if ( ! recv_mssg(&mssg, SYNC_ACK_CODE) ) {
nerrors++;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: recv_mssg() failed.\n",
world_mpi_rank, fcn_name);
}
} else if ( ( mssg.req != SYNC_ACK_CODE ) ||
( mssg.src != world_server_mpi_rank ) ||
( mssg.dest != world_mpi_rank ) ||
( mssg.magic != MSSG_MAGIC ) ) {
nerrors++;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: Bad data in sync ack.\n",
world_mpi_rank, fcn_name);
}
}
}
return;
} /* do_sync() */
/*****************************************************************************
*
* Function: get_max_nerrors()
*
* Purpose: Do an MPI_Allreduce to obtain the maximum value of nerrors
* across all processes. Return this value.
*
* Return: Success: Maximum of the nerrors global variables across
* all processes.
*
* Failure: -1
*
* Programmer: JRM -- 1/3/06
*
* Modifications:
*
* None.
*
*****************************************************************************/
static int
get_max_nerrors(void)
{
const char * fcn_name = "get_max_nerrors()";
int max_nerrors;
int result;
result = MPI_Allreduce((void *)&nerrors,
(void *)&max_nerrors,
1,
MPI_INT,
MPI_MAX,
world_mpi_comm);
if ( result != MPI_SUCCESS ) {
nerrors++;
max_nerrors = -1;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: MPI_Allreduce() failed.\n",
world_mpi_rank, fcn_name );
}
}
return(max_nerrors);
} /* get_max_nerrors() */
/*****************************************************************************/
/************************ mssg xfer related functions ************************/
/*****************************************************************************/
/*****************************************************************************
*
* Function: recv_mssg()
*
* Purpose: Receive a message from any process in the provided instance
* of struct mssg.
*
* Return: Success: TRUE
*
* Failure: FALSE
*
* Programmer: JRM -- 12/22/05
*
* Modifications:
*
* JRM -- 5/10/06
* Added mssg_tag_offset parameter and supporting code.
*
*****************************************************************************/
#define CACHE_TEST_TAG 99 /* different from any used by the library */
static hbool_t
recv_mssg(struct mssg_t *mssg_ptr,
int mssg_tag_offset)
{
const char * fcn_name = "recv_mssg()";
hbool_t success = TRUE;
int mssg_tag = CACHE_TEST_TAG;
int result;
MPI_Status status;
if ( ( mssg_ptr == NULL ) ||
( mssg_tag_offset < 0 ) ||
( mssg_tag_offset> MAX_REQ_CODE ) ) {
nerrors++;
success = FALSE;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: bad param(s) on entry.\n",
world_mpi_rank, fcn_name);
}
} else {
mssg_tag += mssg_tag_offset;
}
if ( success ) {
result = MPI_Recv((void *)mssg_ptr, 1, mpi_mssg_t, MPI_ANY_SOURCE,
mssg_tag, world_mpi_comm, &status);
if ( result != MPI_SUCCESS ) {
nerrors++;
success = FALSE;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: MPI_Recv() failed.\n",
world_mpi_rank, fcn_name );
}
} else if ( mssg_ptr->magic != MSSG_MAGIC ) {
nerrors++;
success = FALSE;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: invalid magic.\n", world_mpi_rank,
fcn_name);
}
} else if ( mssg_ptr->src != status.MPI_SOURCE ) {
nerrors++;
success = FALSE;
if ( verbose ) {
HDfprintf(stdout,
"%d:%s: mssg_ptr->src != status.MPI_SOURCE.\n",
world_mpi_rank, fcn_name);
}
}
}
return(success);
} /* recv_mssg() */
/*****************************************************************************
*
* Function: send_mssg()
*
* Purpose: Send the provided instance of mssg to the indicated target.
*
* Note that all source and destination ranks are in the
* global communicator.
*
* Return: Success: TRUE
*
* Failure: FALSE
*
* Programmer: JRM -- 12/22/05
*
* Modifications:
*
* JRM -- 5/10/06
* Added the add_req_to_tag parameter and supporting code.
*
*****************************************************************************/
static hbool_t
send_mssg(struct mssg_t *mssg_ptr,
hbool_t add_req_to_tag)
{
const char * fcn_name = "send_mssg()";
hbool_t success = TRUE;
int mssg_tag = CACHE_TEST_TAG;
int result;
static long mssg_num = 0;
if ( ( mssg_ptr == NULL ) ||
( mssg_ptr->src != world_mpi_rank ) ||
( mssg_ptr->dest < 0 ) ||
( mssg_ptr->dest == mssg_ptr->src ) ||
( mssg_ptr->dest >= world_mpi_size ) ||
( mssg_ptr->req < 0 ) ||
( mssg_ptr->req > MAX_REQ_CODE ) ||
( mssg_ptr->magic != MSSG_MAGIC ) ) {
nerrors++;
success = FALSE;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: Invalid mssg on entry.\n",
world_mpi_rank, fcn_name);
}
}
if ( success ) {
mssg_ptr->mssg_num = mssg_num++;
if ( add_req_to_tag ) {
mssg_tag += mssg_ptr->req;
}
result = MPI_Send((void *)mssg_ptr, 1, mpi_mssg_t,
mssg_ptr->dest, mssg_tag, world_mpi_comm);
if ( result != MPI_SUCCESS ) {
nerrors++;
success = FALSE;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: MPI_Send() failed.\n",
world_mpi_rank, fcn_name);
}
}
}
return(success);
} /* send_mssg() */
/*****************************************************************************
*
* Function: setup_derived_types()
*
* Purpose: Set up the derived types used by the test bed. At present,
* only the mpi_mssg derived type is needed.
*
* Return: Success: TRUE
*
* Failure: FALSE
*
* Programmer: JRM -- 12/22/05
*
* Modifications:
*
* None.
*
*****************************************************************************/
static hbool_t
setup_derived_types(void)
{
const char * fcn_name = "setup_derived_types()";
hbool_t success = TRUE;
int i;
int result;
MPI_Datatype mpi_types[8] = {MPI_INT, MPI_INT, MPI_INT, MPI_LONG,
HADDR_AS_MPI_TYPE, MPI_INT, MPI_INT,
MPI_UNSIGNED};
int block_len[8] = {1, 1, 1, 1, 1, 1, 1, 1};
MPI_Aint displs[8];
struct mssg_t sample; /* used to compute displacements */
/* setup the displacements array */
if ( ( MPI_SUCCESS != MPI_Address(&sample.req, &displs[0]) ) ||
( MPI_SUCCESS != MPI_Address(&sample.src, &displs[1]) ) ||
( MPI_SUCCESS != MPI_Address(&sample.dest, &displs[2]) ) ||
( MPI_SUCCESS != MPI_Address(&sample.mssg_num, &displs[3]) ) ||
( MPI_SUCCESS != MPI_Address(&sample.base_addr, &displs[4]) ) ||
( MPI_SUCCESS != MPI_Address(&sample.len, &displs[5]) ) ||
( MPI_SUCCESS != MPI_Address(&sample.ver, &displs[6]) ) ||
( MPI_SUCCESS != MPI_Address(&sample.magic, &displs[7]) ) ) {
nerrors++;
success = FALSE;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: MPI_Address() call failed.\n",
world_mpi_rank, fcn_name);
}
} else {
/* Now calculate the actual displacements */
for ( i = 7; i >= 0; --i)
{
displs[i] -= displs[0];
}
}
if ( success ) {
result = MPI_Type_struct(8, block_len, displs, mpi_types, &mpi_mssg_t);
if ( result != MPI_SUCCESS ) {
nerrors++;
success = FALSE;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: MPI_Type_struct() call failed.\n",
world_mpi_rank, fcn_name);
}
}
}
if ( success ) {
result = MPI_Type_commit(&mpi_mssg_t);
if ( result != MPI_SUCCESS) {
nerrors++;
success = FALSE;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: MPI_Type_commit() call failed.\n",
world_mpi_rank, fcn_name);
}
}
}
return(success);
} /* setup_derived_types */
/*****************************************************************************
*
* Function: takedown_derived_types()
*
* Purpose: take down the derived types used by the test bed. At present,
* only the mpi_mssg derived type is needed.
*
* Return: Success: TRUE
*
* Failure: FALSE
*
* Programmer: JRM -- 12/22/05
*
* Modifications:
*
* None.
*
*****************************************************************************/
static hbool_t
takedown_derived_types(void)
{
const char * fcn_name = "takedown_derived_types()";
hbool_t success = TRUE;
int result;
result = MPI_Type_free(&mpi_mssg_t);
if ( result != MPI_SUCCESS ) {
nerrors++;
success = FALSE;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: MPI_Type_free() call failed.\n",
world_mpi_rank, fcn_name);
}
}
return(success);
} /* takedown_derived_types() */
/*****************************************************************************/
/***************************** server functions ******************************/
/*****************************************************************************/
/*****************************************************************************
*
* Function: server_main()
*
* Purpose: Main function for the server process. This process exists
* to provide an independant view of the data array.
*
* The function handles request from the other processes in
* the test until the count of done messages received equals
* the number of client processes.
*
* Return: Success: TRUE
*
* Failure: FALSE
*
* Programmer: JRM -- 12/22/05
*
* Modifications:
*
* JRM -- 5/10/06
* Updated for sync message.
*
*****************************************************************************/
static hbool_t
server_main(void)
{
const char * fcn_name = "server_main()";
hbool_t done = FALSE;
hbool_t success = TRUE;
int done_count = 0;
struct mssg_t mssg;
if ( world_mpi_rank != world_server_mpi_rank ) {
nerrors++;
success = FALSE;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: This isn't the server process?!?!?\n",
world_mpi_rank, fcn_name);
}
}
while ( ( success ) && ( ! done ) )
{
success = recv_mssg(&mssg, 0);
if ( success ) {
switch ( mssg.req )
{
case WRITE_REQ_CODE:
success = serve_write_request(&mssg);
break;
case WRITE_REQ_ACK_CODE:
success = FALSE;
HDfprintf(stdout, "%s: Received write ack?!?.\n", fcn_name);
break;
case READ_REQ_CODE:
success = serve_read_request(&mssg);
break;
case READ_REQ_REPLY_CODE:
success = FALSE;
HDfprintf(stdout, "%s: Received read req reply?!?.\n",
fcn_name);
break;
case SYNC_REQ_CODE:
success = serve_sync_request(&mssg);
break;
case SYNC_ACK_CODE:
success = FALSE;
HDfprintf(stdout, "%s: Received sync ack?!?.\n",
fcn_name);
break;
case DONE_REQ_CODE:
done_count++;
/* HDfprintf(stdout, "%d:%s: done_count = %d.\n",
world_mpi_rank, fcn_name, done_count); */
if ( done_count >= file_mpi_size ) {
done = TRUE;
}
break;
default:
nerrors++;
success = FALSE;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: Unknown request code.\n",
world_mpi_rank, fcn_name);
}
break;
}
}
}
return(success);
} /* server_main() */
/*****************************************************************************
*
* Function: serve_read_request()
*
* Purpose: Serve a read request.
*
* The function accepts a pointer to an instance of struct
* mssg_t as input. If all sanity checks pass, it sends
* a copy of the indicated datum from the data array to
* the requesting process.
*
* Return: Success: TRUE
*
* Failure: FALSE
*
* Programmer: JRM -- 12/22/05
*
* Modifications:
*
* None.
*
*****************************************************************************/
static hbool_t
serve_read_request(struct mssg_t * mssg_ptr)
{
const char * fcn_name = "serve_read_request()";
hbool_t success = TRUE;
int target_index;
haddr_t target_addr;
struct mssg_t reply;
if ( ( mssg_ptr == NULL ) ||
( mssg_ptr->req != READ_REQ_CODE ) ||
( mssg_ptr->magic != MSSG_MAGIC ) ) {
nerrors++;
success = FALSE;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: Bad mssg on entry.\n",
world_mpi_rank, fcn_name);
}
}
if ( success ) {
target_addr = mssg_ptr->base_addr;
target_index = addr_to_datum_index(target_addr);
if ( target_index < 0 ) {
nerrors++;
success = FALSE;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: addr lookup failed for %a.\n",
world_mpi_rank, fcn_name, target_addr);
}
} else if ( data[target_index].len != mssg_ptr->len ) {
nerrors++;
success = FALSE;
if ( verbose ) {
HDfprintf(stdout,
"%d:%s: data[i].len = %d != mssg->len = %d.\n",
world_mpi_rank, fcn_name,
data[target_index].len, mssg_ptr->len);
}
} else if ( ! (data[target_index].valid) ) {
nerrors++;
success = FALSE;
if ( verbose ) {
HDfprintf(stdout,
"%d:%s: proc %d read invalid entry. idx/base_addr = %d/%a.\n",
world_mpi_rank, fcn_name,
mssg_ptr->src, target_index,
target_index,
data[target_index].base_addr);
}
} else {
/* compose the reply message */
reply.req = READ_REQ_REPLY_CODE;
reply.src = world_mpi_rank;
reply.dest = mssg_ptr->src;
reply.mssg_num = -1; /* set by send function */
reply.base_addr = data[target_index].base_addr;
reply.len = data[target_index].len;
reply.ver = data[target_index].ver;
reply.magic = MSSG_MAGIC;
}
}
if ( success ) {
success = send_mssg(&reply, TRUE);
}
return(success);
} /* serve_read_request() */
/*****************************************************************************
*
* Function: serve_sync_request()
*
* Purpose: Serve a sync request.
*
* The function accepts a pointer to an instance of struct
* mssg_t as input. If all sanity checks pass, it sends a
* sync ack to the requesting process.
*
* This service exist to allow the sending process to ensure
* that all previous messages have been processed before
* proceeding.
*
* Return: Success: TRUE
*
* Failure: FALSE
*
* Programmer: JRM -- 5/10/06
*
* Modifications:
*
* None.
*
*****************************************************************************/
static hbool_t
serve_sync_request(struct mssg_t * mssg_ptr)
{
const char * fcn_name = "serve_sync_request()";
hbool_t success = TRUE;
struct mssg_t reply;
if ( ( mssg_ptr == NULL ) ||
( mssg_ptr->req != SYNC_REQ_CODE ) ||
( mssg_ptr->magic != MSSG_MAGIC ) ) {
nerrors++;
success = FALSE;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: Bad mssg on entry.\n",
world_mpi_rank, fcn_name);
}
}
if ( success ) {
/* compose the reply message */
reply.req = SYNC_ACK_CODE;
reply.src = world_mpi_rank;
reply.dest = mssg_ptr->src;
reply.mssg_num = -1; /* set by send function */
reply.base_addr = 0;
reply.len = 0;
reply.ver = 0;
reply.magic = MSSG_MAGIC;
}
if ( success ) {
success = send_mssg(&reply, TRUE);
}
return(success);
} /* serve_sync_request() */
/*****************************************************************************
*
* Function: serve_write_request()
*
* Purpose: Serve a write request.
*
* The function accepts a pointer to an instance of struct
* mssg_t as input. If all sanity checks pass, it updates
* the version number of the target data array entry as
* specified in the message.
*
* Return: Success: TRUE
*
* Failure: FALSE
*
* Programmer: JRM -- 12/21/05
*
* Modifications:
*
* JRM -- 5/9/06
* Added code supporting a write ack message. This is a
* speculative fix to a bug observed on Cobalt. If it
* doesn't work, it will help narrow down the possibilities.
*
*****************************************************************************/
static hbool_t
serve_write_request(struct mssg_t * mssg_ptr)
{
const char * fcn_name = "serve_write_request()";
hbool_t success = TRUE;
int target_index;
int new_ver_num;
haddr_t target_addr;
#if DO_WRITE_REQ_ACK
struct mssg_t reply;
#endif /* DO_WRITE_REQ_ACK */
if ( ( mssg_ptr == NULL ) ||
( mssg_ptr->req != WRITE_REQ_CODE ) ||
( mssg_ptr->magic != MSSG_MAGIC ) ) {
nerrors++;
success = FALSE;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: Bad mssg on entry.\n",
world_mpi_rank, fcn_name);
}
}
if ( success ) {
target_addr = mssg_ptr->base_addr;
target_index = addr_to_datum_index(target_addr);
if ( target_index < 0 ) {
nerrors++;
success = FALSE;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: addr lookup failed for %a.\n",
world_mpi_rank, fcn_name, target_addr);
}
} else if ( data[target_index].len != mssg_ptr->len ) {
nerrors++;
success = FALSE;
if ( verbose ) {
HDfprintf(stdout,
"%d:%s: data[i].len = %d != mssg->len = %d.\n",
world_mpi_rank, fcn_name,
data[target_index].len, mssg_ptr->len);
}
}
}
if ( success ) {
new_ver_num = mssg_ptr->ver;
if ( new_ver_num <= data[target_index].ver ) {
nerrors++;
success = FALSE;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: new ver = %d <= old ver = %d.\n",
world_mpi_rank, fcn_name,
new_ver_num, data[target_index].ver);
}
}
}
if ( success ) {
/* process the write */
data[target_index].ver = new_ver_num;
data[target_index].valid = TRUE;
#if DO_WRITE_REQ_ACK
/* compose the reply message */
reply.req = WRITE_REQ_ACK_CODE;
reply.src = world_mpi_rank;
reply.dest = mssg_ptr->src;
reply.mssg_num = -1; /* set by send function */
reply.base_addr = data[target_index].base_addr;
reply.len = data[target_index].len;
reply.ver = data[target_index].ver;
reply.magic = MSSG_MAGIC;
/* and send it */
success = send_mssg(&reply, TRUE);
#endif /* DO_WRITE_REQ_ACK */
}
return(success);
} /* serve_write_request() */
/*****************************************************************************/
/**************************** Call back functions ****************************/
/*****************************************************************************/
/*-------------------------------------------------------------------------
* Function: clear_datum
*
* Purpose: Mark the datum as clean and destroy it if requested.
* Do not write it to the server, or increment the version.
*
* Return: SUCCEED
*
* Programmer: John Mainzer
* 12/29/05
*
* 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.
*
* JRM -- 2/4/09
* Added code to set the cleared flag when a dirty entry is
* cleared.
*
*-------------------------------------------------------------------------
*/
static herr_t
clear_datum(H5F_t * f,
void * thing,
hbool_t dest)
{
int idx;
struct datum * entry_ptr;
HDassert( thing );
entry_ptr = (struct datum *)thing;
idx = addr_to_datum_index(entry_ptr->base_addr);
HDassert( idx >= 0 );
HDassert( idx < NUM_DATA_ENTRIES );
HDassert( idx < virt_num_data_entries );
HDassert( &(data[idx]) == entry_ptr );
HDassert( entry_ptr->header.addr == entry_ptr->base_addr );
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 );
if ( entry_ptr->header.is_dirty ) {
entry_ptr->cleared = TRUE;
}
entry_ptr->header.is_dirty = FALSE;
entry_ptr->dirty = FALSE;
if ( dest ) {
destroy_datum(f, thing);
}
datum_clears++;
if ( entry_ptr->header.is_pinned ) {
datum_pinned_clears++;
HDassert( entry_ptr->global_pinned || entry_ptr->local_pinned );
}
return(SUCCEED);
} /* clear_datum() */
/*-------------------------------------------------------------------------
* Function: destroy_datum()
*
* Purpose: Destroy the entry. At present, this means do nothing other
* than verify that the entry is clean. In particular, do not
* write it to the server process.
*
* Return: SUCCEED
*
* Programmer: John Mainzer
* 12/29/05
*
* 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.
*
*-------------------------------------------------------------------------
*/
static herr_t
destroy_datum(H5F_t UNUSED * f,
void * thing)
{
int idx;
struct datum * entry_ptr;
HDassert( thing );
entry_ptr = (struct datum *)thing;
idx = addr_to_datum_index(entry_ptr->base_addr);
HDassert( idx >= 0 );
HDassert( idx < NUM_DATA_ENTRIES );
HDassert( idx < virt_num_data_entries );
HDassert( &(data[idx]) == entry_ptr );
HDassert( entry_ptr->header.addr == entry_ptr->base_addr );
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) );
HDassert( !(entry_ptr->global_pinned) );
HDassert( !(entry_ptr->local_pinned) );
HDassert( !(entry_ptr->header.is_pinned) );
datum_destroys++;
return(SUCCEED);
} /* destroy_datum() */
/*-------------------------------------------------------------------------
* Function: flush_datum
*
* Purpose: Flush the entry to the server process and mark it as clean.
* Then destroy the entry if requested.
*
* Return: SUCCEED if successful, and FAIL otherwise.
*
* Programmer: John Mainzer
* 12/29/05
*
* Modifications:
*
* JRM -- 5/9/06
* Added code to receive the write request ack messages
* from the server. This is part of a speculative fix to
* 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.
*
* JRM -- 2/4/09
* Added code to set the flushed flag when a dirty entry
* is flushed.
*
*-------------------------------------------------------------------------
*/
static herr_t
flush_datum(H5F_t *f,
hid_t UNUSED dxpl_id,
hbool_t dest,
haddr_t UNUSED addr,
void *thing)
{
const char * fcn_name = "flush_datum()";
herr_t ret_value = SUCCEED;
int idx;
struct datum * entry_ptr;
struct mssg_t mssg;
HDassert( thing );
entry_ptr = (struct datum *)thing;
idx = addr_to_datum_index(entry_ptr->base_addr);
HDassert( idx >= 0 );
HDassert( idx < NUM_DATA_ENTRIES );
HDassert( idx < virt_num_data_entries );
HDassert( &(data[idx]) == entry_ptr );
HDassert( entry_ptr->header.addr == entry_ptr->base_addr );
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 );
if ( ( file_mpi_rank != 0 ) && ( entry_ptr->dirty ) ) {
ret_value = FAIL;
HDfprintf(stdout,
"%d:%s: Flushed dirty entry from non-zero file process.",
world_mpi_rank, fcn_name);
}
if ( ret_value == SUCCEED ) {
if ( entry_ptr->header.is_dirty ) {
/* compose the message */
mssg.req = WRITE_REQ_CODE;
mssg.src = world_mpi_rank;
mssg.dest = world_server_mpi_rank;
mssg.mssg_num = -1; /* set by send function */
mssg.base_addr = entry_ptr->base_addr;
mssg.len = entry_ptr->len;
mssg.ver = entry_ptr->ver;
mssg.magic = MSSG_MAGIC;
if ( ! send_mssg(&mssg, FALSE) ) {
nerrors++;
ret_value = FAIL;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: send_mssg() failed.\n",
world_mpi_rank, fcn_name);
}
}
else
{
entry_ptr->header.is_dirty = FALSE;
entry_ptr->dirty = FALSE;
entry_ptr->flushed = TRUE;
}
}
}
#if DO_WRITE_REQ_ACK
if ( ( ret_value == SUCCEED ) && ( entry_ptr->header.is_dirty ) ) {
if ( ! recv_mssg(&mssg, WRITE_REQ_ACK_CODE) ) {
nerrors++;
ret_value = FAIL;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: recv_mssg() failed.\n",
world_mpi_rank, fcn_name);
}
} else if ( ( mssg.req != WRITE_REQ_ACK_CODE ) ||
( mssg.src != world_server_mpi_rank ) ||
( mssg.dest != world_mpi_rank ) ||
( mssg.base_addr != entry_ptr->base_addr ) ||
( mssg.len != entry_ptr->len ) ||
( mssg.ver != entry_ptr->ver ) ||
( mssg.magic != MSSG_MAGIC ) ) {
nerrors++;
ret_value = FAIL;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: Bad data in write req ack.\n",
world_mpi_rank, fcn_name);
}
}
}
#endif /* DO_WRITE_REQ_ACK */
if ( ret_value == SUCCEED ) {
if ( dest ) {
ret_value = destroy_datum(f, thing);
}
}
datum_flushes++;
if ( entry_ptr->header.is_pinned ) {
datum_pinned_flushes++;
HDassert( entry_ptr->global_pinned || entry_ptr->local_pinned );
}
return(ret_value);
} /* flush_datum() */
/*-------------------------------------------------------------------------
* Function: load_datum
*
* Purpose: Read the requested entry from the server and mark it as
* clean.
*
* Return: SUCCEED if successful, FAIL otherwise.
*
* Programmer: John Mainzer
* 12/29/05
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static void *
load_datum(H5F_t UNUSED *f,
hid_t UNUSED dxpl_id,
haddr_t addr,
const void UNUSED *udata1,
void UNUSED *udata2)
{
const char * fcn_name = "load_datum()";
hbool_t success = TRUE;
int idx;
struct datum * entry_ptr = NULL;
struct mssg_t mssg;
idx = addr_to_datum_index(addr);
HDassert( idx >= 0 );
HDassert( idx < NUM_DATA_ENTRIES );
HDassert( idx < virt_num_data_entries );
entry_ptr = &(data[idx]);
HDassert( addr == entry_ptr->base_addr );
HDassert( ! entry_ptr->global_pinned );
HDassert( ! entry_ptr->local_pinned );
/* compose the read message */
mssg.req = READ_REQ_CODE;
mssg.src = world_mpi_rank;
mssg.dest = world_server_mpi_rank;
mssg.mssg_num = -1; /* set by send function */
mssg.base_addr = entry_ptr->base_addr;
mssg.len = entry_ptr->len;
mssg.ver = 0; /* bogus -- should be corrected by server */
mssg.magic = MSSG_MAGIC;
if ( ! send_mssg(&mssg, FALSE) ) {
nerrors++;
success = FALSE;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: send_mssg() failed.\n",
world_mpi_rank, fcn_name);
}
}
if ( success ) {
if ( ! recv_mssg(&mssg, READ_REQ_REPLY_CODE) ) {
nerrors++;
success = FALSE;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: recv_mssg() failed.\n",
world_mpi_rank, fcn_name);
}
}
}
if ( success ) {
if ( ( mssg.req != READ_REQ_REPLY_CODE ) ||
( mssg.src != world_server_mpi_rank ) ||
( mssg.dest != world_mpi_rank ) ||
( mssg.base_addr != entry_ptr->base_addr ) ||
( mssg.len != entry_ptr->len ) ||
( mssg.ver < entry_ptr->ver ) ||
( mssg.magic != MSSG_MAGIC ) ) {
nerrors++;
success = FALSE;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: Bad data in read req reply.\n",
world_mpi_rank, fcn_name);
}
#if 0 /* This has been useful debugging code -- keep it for now. */
if ( mssg.req != READ_REQ_REPLY_CODE ) {
HDfprintf(stdout, "%d:%s: mssg.req != READ_REQ_REPLY_CODE.\n",
world_mpi_rank, fcn_name);
HDfprintf(stdout, "%d:%s: mssg.req = %d.\n",
world_mpi_rank, fcn_name, (int)(mssg.req));
}
if ( mssg.src != world_server_mpi_rank ) {
HDfprintf(stdout, "%d:%s: mssg.src != world_server_mpi_rank.\n",
world_mpi_rank, fcn_name);
}
if ( mssg.dest != world_mpi_rank ) {
HDfprintf(stdout, "%d:%s: mssg.dest != world_mpi_rank.\n",
world_mpi_rank, fcn_name);
}
if ( mssg.base_addr != entry_ptr->base_addr ) {
HDfprintf(stdout,
"%d:%s: mssg.base_addr != entry_ptr->base_addr.\n",
world_mpi_rank, fcn_name);
HDfprintf(stdout, "%d:%s: mssg.base_addr = %a.\n",
world_mpi_rank, fcn_name, mssg.base_addr);
HDfprintf(stdout, "%d:%s: entry_ptr->base_addr = %a.\n",
world_mpi_rank, fcn_name, entry_ptr->base_addr);
}
if ( mssg.len != entry_ptr->len ) {
HDfprintf(stdout, "%d:%s: mssg.len != entry_ptr->len.\n",
world_mpi_rank, fcn_name);
HDfprintf(stdout, "%d:%s: mssg.len = %a.\n",
world_mpi_rank, fcn_name, mssg.len);
}
if ( mssg.ver < entry_ptr->ver ) {
HDfprintf(stdout, "%d:%s: mssg.ver < entry_ptr->ver.\n",
world_mpi_rank, fcn_name);
}
if ( mssg.magic != MSSG_MAGIC ) {
HDfprintf(stdout, "%d:%s: mssg.magic != MSSG_MAGIC.\n",
world_mpi_rank, fcn_name);
}
#endif /* JRM */
} else {
entry_ptr->ver = mssg.ver;
entry_ptr->header.is_dirty = FALSE;
entry_ptr->dirty = FALSE;
}
}
if ( ! success ) {
entry_ptr = NULL;
}
datum_loads++;
return(entry_ptr);
} /* load_datum() */
/*-------------------------------------------------------------------------
* Function: size_datum
*
* Purpose: Get the size of the specified entry. Just look at the
* local copy, as size can't change.
*
* Return: SUCCEED
*
* Programmer: John Mainzer
* 6/10/04
*
* 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.
*
*-------------------------------------------------------------------------
*/
static herr_t
size_datum(H5F_t UNUSED * f,
void * thing,
size_t * size_ptr)
{
int idx;
struct datum * entry_ptr;
HDassert( thing );
HDassert( size_ptr );
entry_ptr = (struct datum *)thing;
idx = addr_to_datum_index(entry_ptr->base_addr);
HDassert( idx >= 0 );
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->local_len;
return(SUCCEED);
} /* size_datum() */
/*****************************************************************************/
/************************** test utility functions ***************************/
/*****************************************************************************/
/*****************************************************************************
* 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) );
if ( nerrors == 0 ) {
result = H5AC_expunge_entry(file_ptr, -1, &(types[0]),
entry_ptr->header.addr, H5AC__NO_FLAGS_SET);
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, 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
* 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:
*
* JRM -- 8/11/06
* Updated code to reflect the fact that entries can now be
* inserted pinned. Note that since all inserts are dirty,
* any pins must be global pins.
*
*****************************************************************************/
void
insert_entry(H5C_t * cache_ptr,
H5F_t * file_ptr,
int32_t idx,
unsigned int flags)
{
const char * fcn_name = "insert_entry()";
hbool_t insert_pinned;
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) );
insert_pinned = ((flags & H5C__PIN_ENTRY_FLAG) != 0 );
if ( nerrors == 0 ) {
(entry_ptr->ver)++;
entry_ptr->dirty = TRUE;
result = H5AC_set(file_ptr, -1, &(types[0]), entry_ptr->base_addr,
(void *)(&(entry_ptr->header)), flags);
if ( ( result < 0 ) ||
( entry_ptr->header.type != &(types[0]) ) ||
( entry_ptr->len != entry_ptr->header.size ) ||
( entry_ptr->base_addr != entry_ptr->header.addr ) ) {
nerrors++;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: Error in H5AC_set().\n",
world_mpi_rank, fcn_name);
}
}
if ( ! (entry_ptr->header.is_dirty) ) {
/* it is possible that we just exceeded the dirty bytes
* threshold, triggering a write of the newly inserted
* entry. Test for this, and only flag an error if this
* is not the case.
*/
struct H5AC_aux_t * aux_ptr;
aux_ptr = ((H5AC_aux_t *)(cache_ptr->aux_ptr));
if ( ! ( ( aux_ptr != NULL ) &&
( aux_ptr->magic == H5AC__H5AC_AUX_T_MAGIC ) &&
( aux_ptr->dirty_bytes == 0 ) ) ) {
nerrors++;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: data[%d].header.is_dirty = %d.\n",
world_mpi_rank, fcn_name, idx,
(int)(data[idx].header.is_dirty));
}
}
}
if ( insert_pinned ) {
HDassert( entry_ptr->header.is_pinned );
entry_ptr->global_pinned = TRUE;
global_pins++;
} else {
HDassert( ! ( entry_ptr->header.is_pinned ) );
entry_ptr->global_pinned = FALSE;
}
/* HDassert( entry_ptr->header.is_dirty ); */
HDassert( ((entry_ptr->header).type)->id == DATUM_ENTRY_TYPE );
}
return;
} /* insert_entry() */
/*****************************************************************************
* Function: local_pin_and_unpin_random_entries()
*
* Purpose: Pin a random number of randomly selected entries in cache, and
* then unpin a random number of entries.
*
* Do nothing if nerrors is non-zero on entry.
*
* Return: void
*
* Programmer: John Mainzer
* 4/12/06
*
* Modifications:
*
*****************************************************************************/
void
local_pin_and_unpin_random_entries(H5C_t * cache_ptr,
H5F_t * file_ptr,
int min_idx,
int max_idx,
int min_count,
int max_count)
{
/* const char * fcn_name = "local_pin_and_unpin_random_entries()"; */
if ( nerrors == 0 ) {
hbool_t via_unprotect;
int count;
int i;
int idx;
HDassert( cache_ptr );
HDassert( file_ptr );
HDassert( 0 <= min_idx );
HDassert( min_idx < max_idx );
HDassert( max_idx < NUM_DATA_ENTRIES );
HDassert( max_idx < virt_num_data_entries );
HDassert( 0 <= min_count );
HDassert( min_count < max_count );
count = (HDrand() % (max_count - min_count)) + min_count;
HDassert( min_count <= count );
HDassert( count <= max_count );
for ( i = 0; i < count; i++ )
{
local_pin_random_entry(cache_ptr, file_ptr, min_idx, max_idx);
}
count = (HDrand() % (max_count - min_count)) + min_count;
HDassert( min_count <= count );
HDassert( count <= max_count );
i = 0;
idx = 0;
while ( ( i < count ) && ( idx >= 0 ) )
{
via_unprotect = ( (((unsigned)i) & 0x0001) == 0 );
idx = local_unpin_next_pinned_entry(cache_ptr, file_ptr,
idx, via_unprotect);
i++;
}
}
return;
} /* local_pin_and_unpin_random_entries() */
/*****************************************************************************
* Function: local_pin_random_entry()
*
* Purpose: Pin a randomly selected entry in cache, and mark the entry
* as being locally pinned. Since this entry will not in
* general be pinned in any other cache, we can't mark it
* dirty.
*
* Do nothing if nerrors is non-zero on entry.
*
* Return: void
*
* Programmer: John Mainzer
* 4/12/06
*
* Modifications:
*
*****************************************************************************/
void
local_pin_random_entry(H5C_t * cache_ptr,
H5F_t * file_ptr,
int min_idx,
int max_idx)
{
/* const char * fcn_name = "local_pin_random_entry()"; */
int idx;
if ( nerrors == 0 ) {
HDassert( cache_ptr );
HDassert( file_ptr );
HDassert( 0 <= min_idx );
HDassert( min_idx < max_idx );
HDassert( max_idx < NUM_DATA_ENTRIES );
HDassert( max_idx < virt_num_data_entries );
do
{
idx = (HDrand() % (max_idx - min_idx)) + min_idx;
HDassert( min_idx <= idx );
HDassert( idx <= max_idx );
}
while ( data[idx].global_pinned || data[idx].local_pinned );
pin_entry(cache_ptr, file_ptr, idx, FALSE, FALSE);
}
return;
} /* local_pin_random_entry() */
/*****************************************************************************
* Function: local_unpin_all_entries()
*
* Purpose: Unpin all local pinned entries.
*
* Do nothing if nerrors is non-zero on entry.
*
* Return: void
*
* Programmer: John Mainzer
* 4/12/06
*
* Modifications:
*
*****************************************************************************/
void
local_unpin_all_entries(H5C_t * cache_ptr,
H5F_t * file_ptr,
hbool_t via_unprotect)
{
/* const char * fcn_name = "local_unpin_all_entries()"; */
if ( nerrors == 0 ) {
int idx;
HDassert( cache_ptr );
HDassert( file_ptr );
idx = 0;
while ( idx >= 0 )
{
idx = local_unpin_next_pinned_entry(cache_ptr, file_ptr,
idx, via_unprotect);
}
}
return;
} /* local_unpin_all_entries() */
/*****************************************************************************
* Function: local_unpin_next_pinned_entry()
*
* Purpose: Find the next locally pinned entry after the specified
* starting point, and unpin it.
*
* Do nothing if nerrors is non-zero on entry.
*
* Return: Index of the unpinned entry if there is one, or -1 if
* nerrors is non-zero on entry, or if there is no locally
* pinned entry.
*
* Programmer: John Mainzer
* 4/12/06
*
* Modifications:
*
*****************************************************************************/
int
local_unpin_next_pinned_entry(H5C_t * cache_ptr,
H5F_t * file_ptr,
int start_idx,
hbool_t via_unprotect)
{
/* const char * fcn_name = "local_unpin_next_pinned_entry()"; */
int i = 0;
int idx = -1;
if ( nerrors == 0 ) {
HDassert( cache_ptr );
HDassert( file_ptr );
HDassert( 0 <= start_idx );
HDassert( start_idx < NUM_DATA_ENTRIES );
HDassert( start_idx < virt_num_data_entries );
idx = start_idx;
while ( ( i < virt_num_data_entries ) &&
( ! ( data[idx].local_pinned ) ) )
{
i++;
idx++;
if ( idx >= virt_num_data_entries ) {
idx = 0;
}
}
if ( data[idx].local_pinned ) {
unpin_entry(cache_ptr, file_ptr, idx, FALSE, FALSE, via_unprotect);
} else {
idx = -1;
}
}
return(idx);
} /* local_unpin_next_pinned_entry() */
/*****************************************************************************
* Function: lock_and_unlock_random_entries()
*
* Purpose: Obtain a random number in the closed interval [min_count,
* max_count]. Then protect and unprotect that number of
* random entries.
*
* Do nothing if nerrors is non-zero on entry.
*
* Return: void
*
* Programmer: John Mainzer
* 1/12/06
*
* Modifications:
*
*****************************************************************************/
void
lock_and_unlock_random_entries(H5C_t * cache_ptr,
H5F_t * file_ptr,
int min_idx,
int max_idx,
int min_count,
int max_count)
{
/* const char * fcn_name = "lock_and_unlock_random_entries()"; */
int count;
int i;
if ( nerrors == 0 ) {
HDassert( cache_ptr );
HDassert( file_ptr );
HDassert( 0 <= min_count );
HDassert( min_count < max_count );
count = (HDrand() % (max_count - min_count)) + min_count;
HDassert( min_count <= count );
HDassert( count <= max_count );
for ( i = 0; i < count; i++ )
{
lock_and_unlock_random_entry(cache_ptr, file_ptr, min_idx, max_idx);
}
}
return;
} /* lock_and_unlock_random_entries() */
/*****************************************************************************
* Function: lock_and_unlock_random_entry()
*
* Purpose: Protect and then unprotect a random entry with index in
* the data[] array in the close interval [min_idx, max_idx].
*
* Do nothing if nerrors is non-zero on entry.
*
* Return: void
*
* Programmer: John Mainzer
* 1/4/06
*
* Modifications:
*
*****************************************************************************/
void
lock_and_unlock_random_entry(H5C_t * cache_ptr,
H5F_t * file_ptr,
int min_idx,
int max_idx)
{
/* const char * fcn_name = "lock_and_unlock_random_entry()"; */
int idx;
if ( nerrors == 0 ) {
HDassert( cache_ptr );
HDassert( file_ptr );
HDassert( 0 <= min_idx );
HDassert( min_idx < max_idx );
HDassert( max_idx < NUM_DATA_ENTRIES );
HDassert( max_idx < virt_num_data_entries );
idx = (HDrand() % (max_idx - min_idx)) + min_idx;
HDassert( min_idx <= idx );
HDassert( idx <= max_idx );
lock_entry(cache_ptr, file_ptr, idx);
unlock_entry(cache_ptr, file_ptr, idx, H5AC__NO_FLAGS_SET);
}
return;
} /* lock_and_unlock_random_entry() */
/*****************************************************************************
* Function: lock_entry()
*
* Purpose: Protect the entry indicated by the index.
*
* Do nothing if nerrors is non-zero on entry.
*
* Return: void
*
* Programmer: John Mainzer
* 1/4/06
*
* Modifications:
*
* JRM -- 7/11/06
* Modified asserts to handle the new local_len field in
* datum.
*
*****************************************************************************/
void
lock_entry(H5C_t * cache_ptr,
H5F_t * file_ptr,
int32_t idx)
{
const char * fcn_name = "lock_entry()";
struct datum * entry_ptr;
H5C_cache_entry_t * cache_entry_ptr;
if ( nerrors == 0 ) {
HDassert( cache_ptr );
HDassert( ( 0 <= idx ) && ( idx < NUM_DATA_ENTRIES ) );
HDassert( idx < virt_num_data_entries );
entry_ptr = &(data[idx]);
HDassert( ! (entry_ptr->locked) );
cache_entry_ptr = H5AC_protect(file_ptr, -1, &(types[0]),
entry_ptr->base_addr,
NULL, NULL, H5AC_WRITE);
if ( ( cache_entry_ptr != (void *)(&(entry_ptr->header)) ) ||
( 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 ) ) {
nerrors++;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: error in H5AC_protect().\n",
world_mpi_rank, fcn_name);
}
} else {
entry_ptr->locked = TRUE;
}
HDassert( ((entry_ptr->header).type)->id == DATUM_ENTRY_TYPE );
}
return;
} /* lock_entry() */
/*****************************************************************************
* Function: mark_pinned_entry_dirty()
*
* Purpose: Mark dirty the entry indicated by the index,
*
* Do nothing if nerrors is non-zero on entry.
*
* Return: void
*
* Programmer: John Mainzer
* 4/14/06
*
* Modifications:
*
*****************************************************************************/
void
mark_pinned_entry_dirty(H5C_t * cache_ptr,
H5F_t * file_ptr,
int32_t idx,
hbool_t size_changed,
size_t new_size)
{
const char * fcn_name = "mark_pinned_entry_dirty()";
herr_t result;
struct datum * entry_ptr;
if ( nerrors == 0 ) {
HDassert( file_ptr );
HDassert( cache_ptr );
HDassert( ( 0 <= idx ) && ( idx < NUM_DATA_ENTRIES ) );
HDassert( idx < virt_num_data_entries );
entry_ptr = &(data[idx]);
HDassert ( entry_ptr->global_pinned );
HDassert ( ! (entry_ptr->local_pinned) );
(entry_ptr->ver)++;
entry_ptr->dirty = TRUE;
result = H5AC_mark_pinned_entry_dirty(file_ptr,
(void *)entry_ptr,
size_changed,
new_size);
if ( result < 0 ) {
nerrors++;
if ( verbose ) {
HDfprintf(stdout,
"%d:%s: error in H5AC_mark_pinned_entry_dirty().\n",
world_mpi_rank, fcn_name);
}
}
else
{
global_dirty_pins++;
}
}
return;
} /* mark_pinned_entry_dirty() */
/*****************************************************************************
* Function: mark_pinned_or_protected_entry_dirty()
*
* Purpose: Use the H5AC_mark_pinned_or_protected_entry_dirty() call to
* mark dirty the entry indicated by the index,
*
* Do nothing if nerrors is non-zero on entry.
*
* Return: void
*
* Programmer: John Mainzer
* 5/18/06
*
* Modifications:
*
*****************************************************************************/
void
mark_pinned_or_protected_entry_dirty(H5C_t * cache_ptr,
H5F_t * file_ptr,
int32_t idx)
{
const char * fcn_name = "mark_pinned_or_protected_entry_dirty()";
herr_t result;
struct datum * entry_ptr;
if ( nerrors == 0 ) {
HDassert( file_ptr );
HDassert( cache_ptr );
HDassert( ( 0 <= idx ) && ( idx < NUM_DATA_ENTRIES ) );
HDassert( idx < virt_num_data_entries );
entry_ptr = &(data[idx]);
HDassert ( entry_ptr->locked || entry_ptr->global_pinned );
(entry_ptr->ver)++;
entry_ptr->dirty = TRUE;
result = H5AC_mark_pinned_or_protected_entry_dirty(file_ptr,
(void *)entry_ptr);
if ( result < 0 ) {
nerrors++;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: error in %s.\n",
world_mpi_rank, fcn_name,
"H5AC_mark_pinned_or_protected_entry_dirty()");
}
}
else if ( ! ( entry_ptr->locked ) )
{
global_dirty_pins++;
}
}
return;
} /* mark_pinned_or_protected_entry_dirty() */
/*****************************************************************************
* Function: pin_entry()
*
* Purpose: Pin the entry indicated by the index.
*
* Do nothing if nerrors is non-zero on entry.
*
* Return: void
*
* Programmer: John Mainzer
* 4/11/06
*
* Modifications:
*
*****************************************************************************/
void
pin_entry(H5C_t * cache_ptr,
H5F_t * file_ptr,
int32_t idx,
hbool_t global,
hbool_t dirty)
{
/* const char * fcn_name = "pin_entry()"; */
unsigned int flags = H5AC__PIN_ENTRY_FLAG;
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->global_pinned) );
HDassert ( ! (entry_ptr->local_pinned) );
HDassert ( ! ( dirty && ( ! global ) ) );
lock_entry(cache_ptr, file_ptr, idx);
if ( dirty ) {
flags |= H5AC__DIRTIED_FLAG;
}
unlock_entry(cache_ptr, file_ptr, idx, flags);
HDassert( (entry_ptr->header).is_pinned );
HDassert( ( ! dirty ) || ( (entry_ptr->header).is_dirty ) );
if ( global ) {
entry_ptr->global_pinned = TRUE;
global_pins++;
} else {
entry_ptr->local_pinned = TRUE;
local_pins++;
}
}
return;
} /* pin_entry() */
/*****************************************************************************
* 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
* by new_idex. Touch up the data array so that flush will
* not choke.
*
* Do nothing if nerrors isn't zero, or if old_idx equals
* new_idx.
*
* Return: void
*
* Programmer: John Mainzer
* 1/10/06
*
* Modifications:
*
* 7/11/06 -- JRM
* Added support for the phony_len field in datum.
*
*****************************************************************************/
void
rename_entry(H5C_t * cache_ptr,
H5F_t * file_ptr,
int32_t old_idx,
int32_t new_idx)
{
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;
struct datum * new_entry_ptr;
if ( ( nerrors == 0 ) && ( old_idx != new_idx ) ) {
HDassert( cache_ptr );
HDassert( file_ptr );
HDassert( ( 0 <= old_idx ) && ( old_idx < NUM_DATA_ENTRIES ) );
HDassert( old_idx < virt_num_data_entries );
HDassert( ( 0 <= new_idx ) && ( new_idx < NUM_DATA_ENTRIES ) );
HDassert( new_idx < virt_num_data_entries );
old_entry_ptr = &(data[old_idx]);
new_entry_ptr = &(data[new_idx]);
HDassert( ((old_entry_ptr->header).type)->id == DATUM_ENTRY_TYPE );
HDassert( !(old_entry_ptr->header.is_protected) );
HDassert( !(old_entry_ptr->locked) );
HDassert( old_entry_ptr->len == new_entry_ptr->len );
old_addr = old_entry_ptr->base_addr;
new_addr = new_entry_ptr->base_addr;
result = H5AC_rename(file_ptr, &(types[0]), old_addr, new_addr);
if ( ( result < 0 ) || ( old_entry_ptr->header.addr != new_addr ) ) {
nerrors++;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: H5AC_rename() failed.\n",
world_mpi_rank, fcn_name);
}
} else {
HDassert( ((old_entry_ptr->header).type)->id == DATUM_ENTRY_TYPE );
HDassert( old_entry_ptr->header.is_dirty );
old_entry_ptr->dirty = TRUE;
/* touch up versions, base_addrs, and data_index */
if ( old_entry_ptr->ver < new_entry_ptr->ver ) {
old_entry_ptr->ver = new_entry_ptr->ver;
} else {
(old_entry_ptr->ver)++;
}
old_entry_ptr->base_addr = new_addr;
new_entry_ptr->base_addr = old_addr;
data_index[old_entry_ptr->index] = new_idx;
data_index[new_entry_ptr->index] = old_idx;
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;
}
}
}
return;
} /* rename_entry() */
/*****************************************************************************
* 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()
*
* Purpose: Setup the parallel cache for a test, and return the file id
* and a pointer to the cache's internal data structures.
*
* To do this, we must create a file, flush it (so that we
* don't have to worry about entries in the metadata cache),
* look up the address of the metadata cache, and then instruct
* the cache to omit sanity checks on dxpl IDs.
*
* Return: Success: TRUE
*
* Failure: FALSE
*
* Programmer: JRM -- 1/4/06
*
* Modifications:
*
* None.
*
*****************************************************************************/
hbool_t
setup_cache_for_test(hid_t * fid_ptr,
H5F_t ** file_ptr_ptr,
H5C_t ** cache_ptr_ptr)
{
const char * fcn_name = "setup_cache_for_test()";
hbool_t success = FALSE; /* will set to TRUE if appropriate. */
hbool_t enable_rpt_fcn = FALSE;
hid_t fid = -1;
H5AC_cache_config_t config;
H5F_t * file_ptr = NULL;
H5C_t * cache_ptr = NULL;
HDassert ( fid_ptr != NULL );
HDassert ( file_ptr_ptr != NULL );
HDassert ( cache_ptr_ptr != NULL );
fid = H5Fcreate(filenames[0], H5F_ACC_TRUNC, H5P_DEFAULT, fapl);
if ( fid < 0 ) {
nerrors++;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: H5Fcreate() failed.\n",
world_mpi_rank, fcn_name);
}
} else if ( H5Fflush(fid, H5F_SCOPE_GLOBAL) < 0 ) {
nerrors++;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: H5Fflush() failed.\n",
world_mpi_rank, fcn_name);
}
} else {
file_ptr = H5I_object_verify(fid, H5I_FILE);
}
if ( file_ptr == NULL ) {
nerrors++;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: Can't get file_ptr.\n",
world_mpi_rank, fcn_name);
}
} else {
cache_ptr = file_ptr->shared->cache;
}
if ( cache_ptr == NULL ) {
nerrors++;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: Can't get cache_ptr.\n",
world_mpi_rank, fcn_name);
}
} else if ( cache_ptr->magic != H5C__H5C_T_MAGIC ) {
nerrors++;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: Bad cache_ptr magic.\n",
world_mpi_rank, fcn_name);
}
} else {
*fid_ptr = fid;
*file_ptr_ptr = file_ptr;
*cache_ptr_ptr = cache_ptr;
H5C_set_skip_flags(cache_ptr, TRUE, TRUE);
H5C_stats__reset(cache_ptr);
success = TRUE;
}
if ( ( success ) && ( enable_rpt_fcn ) ) {
config.version = H5AC__CURR_CACHE_CONFIG_VERSION;
if ( H5AC_get_cache_auto_resize_config(cache_ptr, &config)
!= SUCCEED ) {
HDfprintf(stdout,
"%d:%s: H5AC_get_cache_auto_resize_config() failed.\n",
world_mpi_rank, fcn_name);
} else {
config.rpt_fcn_enabled = TRUE;
if ( H5AC_set_cache_auto_resize_config(cache_ptr, &config)
!= SUCCEED ) {
HDfprintf(stdout,
"%d:%s: H5AC_set_cache_auto_resize_config() failed.\n",
world_mpi_rank, fcn_name);
} else {
HDfprintf(stdout, "%d:%s: rpt_fcn enabled.\n",
world_mpi_rank, fcn_name);
}
}
}
#if DO_SYNC_AFTER_WRITE
if ( success ) {
if ( H5AC_set_write_done_callback(cache_ptr, do_sync) != SUCCEED ) {
nerrors++;
if ( verbose ) {
HDfprintf(stdout,
"%d:%s: H5C_set_write_done_callback failed.\n",
world_mpi_rank, fcn_name);
}
}
}
#endif /* DO_SYNC_AFTER_WRITE */
return(success);
} /* setup_cache_for_test() */
/*****************************************************************************
*
* Function: setup_noblock_dxpl_id()
*
* Purpose: Setup the noblock_dxpl_id global. Increment nerrors if
* errors are detected. Do nothing if nerrors is non-zero
* on entry.
*
* Return: void.
*
* Programmer: JRM -- 1/5/06
*
* Modifications:
*
* None.
*
*****************************************************************************/
/* So far we haven't needed this, but that may change.
* Keep it around for now
*/
#if 0
void
setup_noblock_dxpl_id(void)
{
const char * fcn_name = "setup_noblock_dxpl_id()";
H5P_genclass_t *xfer_pclass; /* Dataset transfer property list
* class object
*/
H5P_genplist_t *xfer_plist; /* Dataset transfer property list object */
unsigned block_before_meta_write; /* "block before meta write"
* property value
*/
unsigned library_internal = 1; /* "library internal" property value */
H5FD_mpio_xfer_t xfer_mode; /* I/O transfer mode property value */
/* Sanity check */
HDassert(H5P_CLS_DATASET_XFER_g!=(-1));
/* Get the dataset transfer property list class object */
if ( ( nerrors == 0 ) &&
( NULL == (xfer_pclass = H5I_object(H5P_CLS_DATASET_XFER_g)) ) ) {
nerrors++;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: can't get property list class.\n",
world_mpi_rank, fcn_name);
}
}
/* Get an ID for the non-blocking, collective H5AC dxpl */
if ( ( nerrors == 0 ) &&
( (noblock_dxpl_id = H5P_create_id(xfer_pclass)) < 0 ) ) {
nerrors++;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: can't register property list.\n",
world_mpi_rank, fcn_name);
}
}
/* Get the property list object */
if ( ( nerrors == 0 ) &&
( NULL == (xfer_plist = H5I_object(H5AC_noblock_dxpl_id)) ) ) {
nerrors++;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: can't get new property list object.\n",
world_mpi_rank, fcn_name);
}
}
/* Insert 'block before metadata write' property */
block_before_meta_write=0;
if ( ( nerrors == 0 ) &&
( H5P_insert(xfer_plist, H5AC_BLOCK_BEFORE_META_WRITE_NAME,
H5AC_BLOCK_BEFORE_META_WRITE_SIZE,
&block_before_meta_write,
NULL, NULL, NULL, NULL, NULL, NULL) < 0 ) ) {
nerrors++;
if ( verbose ) {
HDfprintf(stdout,
"%d:%s: can't insert metadata cache dxpl property 1.\n",
world_mpi_rank, fcn_name);
}
}
/* Insert 'library internal' property */
if ( ( nerrors == 0 ) &&
( H5P_insert(xfer_plist, H5AC_LIBRARY_INTERNAL_NAME,
H5AC_LIBRARY_INTERNAL_SIZE, &library_internal,
NULL, NULL, NULL, NULL, NULL, NULL ) < 0 ) ) {
nerrors++;
if ( verbose ) {
HDfprintf(stdout,
"%d:%s: can't insert metadata cache dxpl property 2.\n",
world_mpi_rank, fcn_name);
}
}
/* Set the transfer mode */
xfer_mode = H5FD_MPIO_COLLECTIVE;
if ( ( nerrors == 0 ) &&
( H5P_set(xfer_plist, H5D_XFER_IO_XFER_MODE_NAME, &xfer_mode) < 0 ) ) {
nerrors++;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: unable to set value.\n", world_mpi_rank,
fcn_name);
}
}
return(success);
} /* setup_noblock_dxpl_id() */
#endif
/*****************************************************************************
*
* Function: setup_rand()
*
* Purpose: Use gettimeofday() to obtain a seed for rand(), print the
* seed to stdout, and then pass it to srand().
*
* Increment nerrors if any errors are detected.
*
* Return: void.
*
* Programmer: JRM -- 1/12/06
*
* Modifications:
*
* JRM -- 5/9/06
* Modified function to facilitate setting predefined seeds.
*
*****************************************************************************/
void
setup_rand(void)
{
const char * fcn_name = "setup_rand()";
hbool_t use_predefined_seeds = FALSE;
int num_predefined_seeds = 3;
unsigned predefined_seeds[3] = {33402, 33505, 33422};
unsigned seed;
struct timeval tv;
struct timezone tz;
if ( ( use_predefined_seeds ) &&
( world_mpi_size == num_predefined_seeds ) ) {
HDassert( world_mpi_rank >= 0 );
HDassert( world_mpi_rank < world_mpi_size );
seed = predefined_seeds[world_mpi_rank];
HDfprintf(stdout, "%d:%s: predefined_seed = %d.\n",
world_mpi_rank, fcn_name, seed);
fflush(stdout);
HDsrand(seed);
} else {
if ( HDgettimeofday(&tv, &tz) != 0 ) {
nerrors++;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: gettimeofday() failed.\n",
world_mpi_rank, fcn_name);
}
} else {
seed = (unsigned)tv.tv_usec;
HDfprintf(stdout, "%d:%s: seed = %d.\n",
world_mpi_rank, fcn_name, seed);
fflush(stdout);
HDsrand(seed);
}
}
return;
} /* setup_rand() */
/*****************************************************************************
*
* Function: take_down_cache()
*
* Purpose: Take down the parallel cache after a test.
*
* To do this, we must close the file, and delete if if
* possible.
*
* Return: Success: TRUE
*
* Failure: FALSE
*
* Programmer: JRM -- 1/4/06
*
* Modifications:
*
* None.
*
*****************************************************************************/
hbool_t
take_down_cache(hid_t fid)
{
const char * fcn_name = "take_down_cache()";
hbool_t success = FALSE; /* will set to TRUE if appropriate. */
/* close the file and delete it */
if ( H5Fclose(fid) < 0 ) {
nerrors++;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: H5Fclose() failed.\n",
world_mpi_rank, fcn_name);
}
} else if ( world_mpi_rank == world_server_mpi_rank ) {
if ( HDremove(filenames[0]) < 0 ) {
nerrors++;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: HDremove() failed.\n",
world_mpi_rank, fcn_name);
}
} else {
success = TRUE;
}
} else {
success = TRUE;
}
return(success);
} /* take_down_cache() */
/*****************************************************************************
* Function: unlock_entry()
*
* Purpose: Unprotect the entry indicated by the index.
*
* Do nothing if nerrors is non-zero on entry.
*
* Return: void
*
* Programmer: John Mainzer
* 1/4/06
*
* Modifications:
*
* 7/11/06
* Updated for the new local_len field in datum.
*
*****************************************************************************/
void
unlock_entry(H5C_t * cache_ptr,
H5F_t * file_ptr,
int32_t idx,
unsigned int flags)
{
const char * fcn_name = "unlock_entry()";
herr_t dirtied;
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->locked );
dirtied = ((flags & H5AC__DIRTIED_FLAG) == H5AC__DIRTIED_FLAG );
if ( dirtied ) {
(entry_ptr->ver)++;
entry_ptr->dirty = TRUE;
}
result = H5AC_unprotect(file_ptr, -1, &(types[0]),
entry_ptr->base_addr,
(void *)(&(entry_ptr->header)), flags);
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 ) ) {
nerrors++;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: error in H5C_unprotect().\n",
world_mpi_rank, fcn_name);
}
} else {
entry_ptr->locked = FALSE;
}
HDassert( ((entry_ptr->header).type)->id == DATUM_ENTRY_TYPE );
if ( ( (flags & H5AC__DIRTIED_FLAG) != 0 ) &&
( (flags & H5C__DELETED_FLAG) == 0 ) &&
( ! ( ( ( world_mpi_rank == 0 ) && ( entry_ptr->flushed ) )
||
( ( world_mpi_rank != 0 ) && ( entry_ptr->cleared ) )
)
)
) {
HDassert( entry_ptr->header.is_dirty );
HDassert( entry_ptr->dirty );
}
}
return;
} /* unlock_entry() */
/*****************************************************************************
* Function: unpin_entry()
*
* Purpose: Unpin the entry indicated by the index.
*
* Do nothing if nerrors is non-zero on entry.
*
* Return: void
*
* Programmer: John Mainzer
* 4/12/06
*
* Modifications:
*
* JRM -- 8/15/06
* Added assertion that entry is pinned on entry.
*
*****************************************************************************/
void
unpin_entry(H5C_t * cache_ptr,
H5F_t * file_ptr,
int32_t idx,
hbool_t global,
hbool_t dirty,
hbool_t via_unprotect)
{
const char * fcn_name = "unpin_entry()";
herr_t result;
unsigned int flags = H5AC__UNPIN_ENTRY_FLAG;
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).is_pinned );
HDassert ( ! ( entry_ptr->global_pinned && entry_ptr->local_pinned) );
HDassert ( ( global && entry_ptr->global_pinned ) ||
( ! global && entry_ptr->local_pinned ) );
HDassert ( ! ( dirty && ( ! global ) ) );
if ( via_unprotect ) {
lock_entry(cache_ptr, file_ptr, idx);
if ( dirty ) {
flags |= H5AC__DIRTIED_FLAG;
}
unlock_entry(cache_ptr, file_ptr, idx, flags);
} else {
if ( dirty ) {
mark_pinned_entry_dirty(cache_ptr, file_ptr, idx, FALSE,
(size_t)0);
}
result = H5AC_unpin_entry(file_ptr, (void *)entry_ptr);
if ( result < 0 ) {
nerrors++;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: error in H5AC_unpin_entry().\n",
world_mpi_rank, fcn_name);
}
}
}
HDassert( ! ((entry_ptr->header).is_pinned) );
if ( global ) {
entry_ptr->global_pinned = FALSE;
} else {
entry_ptr->local_pinned = FALSE;
}
}
return;
} /* unpin_entry() */
/*****************************************************************************/
/****************************** test functions *******************************/
/*****************************************************************************/
/*****************************************************************************
*
* Function: server_smoke_check()
*
* Purpose: Quick smoke check for the server process.
*
* Return: Success: TRUE
*
* Failure: FALSE
*
* Programmer: JRM -- 12/21/05
*
* Modifications:
*
* JRM -- 5/9/06
* Added code supporting the write request ack message. This
* message was added to eliminate one possible cause of a
* bug spotted on cobalt. If this doesn't fix the problem,
* it will narrow things down a bit.
*
* JRM -- 5/10/06
* Added call to do_sync(). This is part of an attempt to
* optimize out the slowdown caused by the addition of the
* write request ack message.
*
*****************************************************************************/
hbool_t
server_smoke_check(void)
{
const char * fcn_name = "server_smoke_check()";
hbool_t success = TRUE;
int max_nerrors;
struct mssg_t mssg;
if ( world_mpi_rank == 0 ) {
TESTING("server smoke check");
}
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 */
{
/* compose the write message */
mssg.req = WRITE_REQ_CODE;
mssg.src = world_mpi_rank;
mssg.dest = world_server_mpi_rank;
mssg.mssg_num = -1; /* set by send function */
mssg.base_addr = data[world_mpi_rank].base_addr;
mssg.len = data[world_mpi_rank].len;
mssg.ver = ++(data[world_mpi_rank].ver);
mssg.magic = MSSG_MAGIC;
if ( ! ( success = send_mssg(&mssg, FALSE) ) ) {
nerrors++;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: send_mssg() failed on write.\n",
world_mpi_rank, fcn_name);
}
}
#if DO_WRITE_REQ_ACK
/* try to receive the write ack from the server */
if ( success ) {
success = recv_mssg(&mssg, WRITE_REQ_ACK_CODE);
if ( ! success ) {
nerrors++;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: recv_mssg() failed.\n",
world_mpi_rank, fcn_name);
}
}
}
/* verify that we received the expected ack message */
if ( success ) {
if ( ( mssg.req != WRITE_REQ_ACK_CODE ) ||
( mssg.src != world_server_mpi_rank ) ||
( mssg.dest != world_mpi_rank ) ||
( mssg.base_addr != data[world_mpi_rank].base_addr ) ||
( mssg.len != data[world_mpi_rank].len ) ||
( mssg.ver != data[world_mpi_rank].ver ) ||
( mssg.magic != MSSG_MAGIC ) ) {
success = FALSE;
nerrors++;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: Bad data in write req ack.\n",
world_mpi_rank, fcn_name);
}
}
}
#endif /* DO_WRITE_REQ_ACK */
do_sync();
/* compose the read message */
mssg.req = READ_REQ_CODE;
mssg.src = world_mpi_rank;
mssg.dest = world_server_mpi_rank;
mssg.mssg_num = -1; /* set by send function */
mssg.base_addr = data[world_mpi_rank].base_addr;
mssg.len = data[world_mpi_rank].len;
mssg.ver = 0; /* bogus -- should be corrected by server */
mssg.magic = MSSG_MAGIC;
if ( success ) {
success = send_mssg(&mssg, FALSE);
if ( ! success ) {
nerrors++;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: send_mssg() failed on write.\n",
world_mpi_rank, fcn_name);
}
}
}
/* try to receive the reply from the server */
if ( success ) {
success = recv_mssg(&mssg, READ_REQ_REPLY_CODE);
if ( ! success ) {
nerrors++;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: recv_mssg() failed.\n",
world_mpi_rank, fcn_name);
}
}
}
/* verify that we got the expected result */
if ( success ) {
if ( ( mssg.req != READ_REQ_REPLY_CODE ) ||
( mssg.src != world_server_mpi_rank ) ||
( mssg.dest != world_mpi_rank ) ||
( mssg.base_addr != data[world_mpi_rank].base_addr ) ||
( mssg.len != data[world_mpi_rank].len ) ||
( mssg.ver != data[world_mpi_rank].ver ) ||
( mssg.magic != MSSG_MAGIC ) ) {
success = FALSE;
nerrors++;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: Bad data in read req reply.\n",
world_mpi_rank, fcn_name);
}
}
}
/* 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);
}
}
}
}
max_nerrors = get_max_nerrors();
if ( world_mpi_rank == 0 ) {
if ( max_nerrors == 0 ) {
PASSED();
} else {
failures++;
H5_FAILED();
}
}
success = ( ( success ) && ( max_nerrors == 0 ) );
return(success);
} /* server_smoke_check() */
/*****************************************************************************
*
* Function: smoke_check_1()
*
* Purpose: First smoke check for the parallel cache.
*
* Return: Success: TRUE
*
* Failure: FALSE
*
* Programmer: JRM -- 1/4/06
*
* Modifications:
*
* None.
*
*****************************************************************************/
hbool_t
smoke_check_1(void)
{
const char * fcn_name = "smoke_check_1()";
hbool_t success = TRUE;
int i;
int max_nerrors;
hid_t fid = -1;
H5F_t * file_ptr = NULL;
H5C_t * cache_ptr = NULL;
struct mssg_t mssg;
if ( world_mpi_rank == 0 ) {
TESTING("smoke check #1");
}
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);
}
}
for ( i = 0; i < (virt_num_data_entries / 2); i++ )
{
insert_entry(cache_ptr, file_ptr, i, H5AC__NO_FLAGS_SET);
}
for ( i = (virt_num_data_entries / 2) - 1; i >= 0; i-- )
{
lock_entry(cache_ptr, file_ptr, i);
unlock_entry(cache_ptr, file_ptr, i, H5AC__NO_FLAGS_SET);
}
/* rename the first half of the entries... */
for ( i = 0; i < (virt_num_data_entries / 2); i++ )
{
lock_entry(cache_ptr, file_ptr, i);
unlock_entry(cache_ptr, file_ptr, i, H5AC__NO_FLAGS_SET);
rename_entry(cache_ptr, file_ptr, i,
(i + (virt_num_data_entries / 2)));
}
/* ...and then rename them back. */
for ( i = (virt_num_data_entries / 2) - 1; i >= 0; i-- )
{
lock_entry(cache_ptr, file_ptr, i);
unlock_entry(cache_ptr, file_ptr, i, H5AC__NO_FLAGS_SET);
rename_entry(cache_ptr, file_ptr, i,
(i + (virt_num_data_entries / 2)));
}
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);
}
}
}
}
max_nerrors = get_max_nerrors();
if ( world_mpi_rank == 0 ) {
if ( max_nerrors == 0 ) {
PASSED();
} else {
failures++;
H5_FAILED();
}
}
success = ( ( success ) && ( max_nerrors == 0 ) );
return(success);
} /* smoke_check_1() */
/*****************************************************************************
*
* Function: smoke_check_2()
*
* Purpose: Second smoke check for the parallel cache.
*
* Introduce random reads, but keep all processes with roughly
* the same work load.
*
* Return: Success: TRUE
*
* Failure: FALSE
*
* Programmer: JRM -- 1/12/06
*
* Modifications:
*
* JRM -- 4/13/06
* Added pinned entry tests.
*
* JRM -- 4/28/06
* Modified test to rename pinned entries.
*
*****************************************************************************/
hbool_t
smoke_check_2(void)
{
const char * fcn_name = "smoke_check_2()";
hbool_t success = TRUE;
int i;
int max_nerrors;
hid_t fid = -1;
H5F_t * file_ptr = NULL;
H5C_t * cache_ptr = NULL;
struct mssg_t mssg;
if ( world_mpi_rank == 0 ) {
TESTING("smoke check #2");
}
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);
}
}
for ( i = 0; i < (virt_num_data_entries / 2); i++ )
{
insert_entry(cache_ptr, file_ptr, i, H5AC__NO_FLAGS_SET);
if ( i > 100 ) {
lock_and_unlock_random_entries(cache_ptr, file_ptr,
(i - 100), i, 0, 10);
}
}
for ( i = 0; i < (virt_num_data_entries / 2); i+=61 )
{
/* Make sure we don't step on any locally pinned entries */
if ( data[i].local_pinned ) {
unpin_entry(cache_ptr, file_ptr, i, FALSE, FALSE, FALSE);
}
pin_entry(cache_ptr, file_ptr, i, TRUE, FALSE);
}
for ( i = (virt_num_data_entries / 2) - 1; i >= 0; i-=2 )
{
lock_entry(cache_ptr, file_ptr, i);
unlock_entry(cache_ptr, file_ptr, i, H5AC__NO_FLAGS_SET);
lock_and_unlock_random_entries(cache_ptr, file_ptr, 0,
(virt_num_data_entries / 20),
0, 100);
local_pin_and_unpin_random_entries(cache_ptr, file_ptr, 0,
(virt_num_data_entries / 4),
0, 3);
}
for ( i = 0; i < (virt_num_data_entries / 2); i+=2 )
{
lock_entry(cache_ptr, file_ptr, i);
unlock_entry(cache_ptr, file_ptr, i, H5AC__DIRTIED_FLAG);
lock_and_unlock_random_entries(cache_ptr, file_ptr, 0,
(virt_num_data_entries / 10),
0, 100);
}
/* we can't rename pinned entries, so release any local pins now. */
local_unpin_all_entries(cache_ptr, file_ptr, FALSE);
/* rename the first half of the entries... */
for ( i = 0; i < (virt_num_data_entries / 2); i++ )
{
lock_entry(cache_ptr, file_ptr, i);
unlock_entry(cache_ptr, file_ptr, i, H5AC__NO_FLAGS_SET);
rename_entry(cache_ptr, file_ptr, i,
(i + (virt_num_data_entries / 2)));
lock_and_unlock_random_entries(cache_ptr, file_ptr, 0,
((virt_num_data_entries / 50) - 1),
0, 100);
}
/* ...and then rename them back. */
for ( i = (virt_num_data_entries / 2) - 1; i >= 0; i-- )
{
lock_entry(cache_ptr, file_ptr, i);
unlock_entry(cache_ptr, file_ptr, i, H5AC__DIRTIED_FLAG);
rename_entry(cache_ptr, file_ptr, i,
(i + (virt_num_data_entries / 2)));
lock_and_unlock_random_entries(cache_ptr, file_ptr, 0,
(virt_num_data_entries / 100),
0, 100);
}
for ( i = 0; i < (virt_num_data_entries / 2); i+=61 )
{
hbool_t via_unprotect = ( (((unsigned)i) & 0x01) == 0 );
hbool_t dirty = ( (((unsigned)i) & 0x02) == 0 );
unpin_entry(cache_ptr, file_ptr, i, TRUE, dirty, via_unprotect);
}
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);
}
}
}
}
max_nerrors = get_max_nerrors();
if ( world_mpi_rank == 0 ) {
if ( max_nerrors == 0 ) {
PASSED();
} else {
failures++;
H5_FAILED();
}
}
success = ( ( success ) && ( max_nerrors == 0 ) );
return(success);
} /* smoke_check_2() */
/*****************************************************************************
*
* Function: smoke_check_3()
*
* Purpose: Third smoke check for the parallel cache.
*
* Use random reads to vary the loads on the diffferent
* processors. Also force different cache size adjustments.
*
* In this test, load process 0 heavily, and the other
* processes lightly.
*
* Return: Success: TRUE
*
* Failure: FALSE
*
* Programmer: JRM -- 1/13/06
*
* Modifications:
*
* Added code intended to ensure correct operation with large
* numbers of processors.
* JRM - 1/31/06
*
* Added pinned entry tests. JRM - 4/14/06
*
*****************************************************************************/
hbool_t
smoke_check_3(void)
{
const char * fcn_name = "smoke_check_3()";
hbool_t success = TRUE;
hbool_t verbose = FALSE;
int cp = 0;
int i;
int max_nerrors;
int min_count;
int max_count;
int min_idx;
int max_idx;
hid_t fid = -1;
H5F_t * file_ptr = NULL;
H5C_t * cache_ptr = NULL;
struct mssg_t mssg;
if ( world_mpi_rank == 0 ) {
TESTING("smoke check #3");
}
/* 0 */
if ( verbose ) { HDfprintf(stderr, "%d: cp = %d\n", world_mpi_rank, cp++); }
nerrors = 0;
init_data();
reset_stats();
if ( world_mpi_rank == world_server_mpi_rank ) {
/* 1 */
if ( verbose ) {HDfprintf(stderr, "%d: cp = %d\n", world_mpi_rank, cp++);}
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);
}
}
/* 2 */
if ( verbose ) {HDfprintf(stderr, "%d: cp = %d\n", world_mpi_rank, cp++);}
}
else /* run the clients */
{
/* 1 */
if ( verbose ) {HDfprintf(stderr, "%d: cp = %d\n", world_mpi_rank, cp++);}
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);
}
}
/* 2 */
if ( verbose ) {HDfprintf(stderr, "%d: cp = %d\n", world_mpi_rank, cp++);}
min_count = 100 / ((file_mpi_rank + 1) * (file_mpi_rank + 1));
max_count = min_count + 50;
for ( i = 0; i < (virt_num_data_entries / 4); i++ )
{
insert_entry(cache_ptr, file_ptr, i, H5AC__NO_FLAGS_SET);
if ( i > 100 ) {
lock_and_unlock_random_entries(cache_ptr, file_ptr,
(i - 100), i,
min_count, max_count);
}
}
/* 3 */
if ( verbose ) {HDfprintf(stderr, "%d: cp = %d\n", world_mpi_rank, cp++);}
min_count = 100 / ((file_mpi_rank + 2) * (file_mpi_rank + 2));
max_count = min_count + 50;
for ( i = (virt_num_data_entries / 4);
i < (virt_num_data_entries / 2);
i++ )
{
insert_entry(cache_ptr, file_ptr, i, H5AC__NO_FLAGS_SET);
if ( i % 59 == 0 ) {
hbool_t dirty = ( (i % 2) == 0);
if ( data[i].local_pinned ) {
unpin_entry(cache_ptr, file_ptr, i, FALSE, FALSE, FALSE);
}
pin_entry(cache_ptr, file_ptr, i, TRUE, dirty);
HDassert( !dirty || data[i].header.is_dirty );
HDassert( data[i].header.is_pinned );
HDassert( data[i].global_pinned );
HDassert( ! data[i].local_pinned );
}
if ( i > 100 ) {
lock_and_unlock_random_entries(cache_ptr, file_ptr,
(i - 100), i,
min_count, max_count);
}
local_pin_and_unpin_random_entries(cache_ptr, file_ptr,
0, virt_num_data_entries / 4,
0, (file_mpi_rank + 2));
}
/* 4 */
if ( verbose ) {HDfprintf(stderr, "%d: cp = %d\n", world_mpi_rank, cp++);}
/* flush the file to be sure that we have no problems flushing
* pinned entries
*/
if ( H5Fflush(fid, H5F_SCOPE_GLOBAL) < 0 ) {
nerrors++;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: H5Fflush() failed.\n",
world_mpi_rank, fcn_name);
}
}
/* 5 */
if ( verbose ) {HDfprintf(stderr, "%d: cp = %d\n", world_mpi_rank, cp++);}
min_idx = 0;
max_idx = ((virt_num_data_entries / 10) /
((file_mpi_rank + 1) * (file_mpi_rank + 1))) - 1;
if ( max_idx <= min_idx ) {
max_idx = min_idx + 10;
}
for ( i = (virt_num_data_entries / 2) - 1; i >= 0; i-- )
{
if ( ( i >= (virt_num_data_entries / 4) ) && ( i % 59 == 0 ) ) {
hbool_t via_unprotect = ( (((unsigned)i) & 0x02) == 0 );
hbool_t dirty = ( (((unsigned)i) & 0x04) == 0 );
HDassert( data[i].global_pinned );
HDassert( ! data[i].local_pinned );
unpin_entry(cache_ptr, file_ptr, i, TRUE, dirty,
via_unprotect);
}
if ( i % 2 == 0 ) {
lock_entry(cache_ptr, file_ptr, i);
unlock_entry(cache_ptr, file_ptr, i, H5AC__NO_FLAGS_SET);
local_pin_and_unpin_random_entries(cache_ptr, file_ptr, 0,
virt_num_data_entries / 2,
0, 2);
lock_and_unlock_random_entries(cache_ptr, file_ptr,
min_idx, max_idx, 0, 100);
}
}
/* 6 */
if ( verbose ) {HDfprintf(stderr, "%d: cp = %d\n", world_mpi_rank, cp++);}
min_idx = 0;
max_idx = ((virt_num_data_entries / 10) /
((file_mpi_rank + 3) * (file_mpi_rank + 3))) - 1;
if ( max_idx <= min_idx ) {
max_idx = min_idx + 10;
}
for ( i = 0; i < (virt_num_data_entries / 2); i+=2 )
{
lock_entry(cache_ptr, file_ptr, i);
unlock_entry(cache_ptr, file_ptr, i, H5AC__DIRTIED_FLAG);
lock_and_unlock_random_entries(cache_ptr, file_ptr,
min_idx, max_idx, 0, 100);
}
/* 7 */
if ( verbose ) {HDfprintf(stderr, "%d: cp = %d\n", world_mpi_rank, cp++);}
/* we can't rename pinned entries, so release any local pins now. */
local_unpin_all_entries(cache_ptr, file_ptr, FALSE);
min_count = 10 / (file_mpi_rank + 1);
max_count = min_count + 100;
/* rename the first half of the entries... */
for ( i = 0; i < (virt_num_data_entries / 2); i++ )
{
lock_entry(cache_ptr, file_ptr, i);
unlock_entry(cache_ptr, file_ptr, i, H5AC__NO_FLAGS_SET);
rename_entry(cache_ptr, file_ptr, i,
(i + (virt_num_data_entries / 2)));
lock_and_unlock_random_entries(cache_ptr, file_ptr, 0,
(virt_num_data_entries / 20),
min_count, max_count);
}
/* 8 */
if ( verbose ) {HDfprintf(stderr, "%d: cp = %d\n", world_mpi_rank, cp++);}
/* ...and then rename them back. */
for ( i = (virt_num_data_entries / 2) - 1; i >= 0; i-- )
{
lock_entry(cache_ptr, file_ptr, i);
unlock_entry(cache_ptr, file_ptr, i, H5AC__DIRTIED_FLAG);
rename_entry(cache_ptr, file_ptr, i,
(i + (virt_num_data_entries / 2)));
lock_and_unlock_random_entries(cache_ptr, file_ptr, 0,
(virt_num_data_entries / 40),
min_count, max_count);
}
/* 9 */
if ( verbose ) {HDfprintf(stderr, "%d: cp = %d\n", world_mpi_rank, cp++);}
/* finally, do some dirty lock/unlocks while we give the cache
* a chance t reduce its size.
*/
min_count = 200 / ((file_mpi_rank + 1) * (file_mpi_rank + 1));
max_count = min_count + 100;
for ( i = 0; i < (virt_num_data_entries / 2); i+=2 )
{
local_pin_and_unpin_random_entries(cache_ptr, file_ptr, 0,
(virt_num_data_entries / 2),
0, 5);
lock_entry(cache_ptr, file_ptr, i);
unlock_entry(cache_ptr, file_ptr, i, H5AC__DIRTIED_FLAG);
if ( i > 100 ) {
lock_and_unlock_random_entries(cache_ptr, file_ptr,
(i - 100), i,
min_count, max_count);
}
}
/* 10 */
if ( verbose ) {HDfprintf(stderr, "%d: cp = %d\n", world_mpi_rank, cp++);}
/* release any local pins before we take down the cache. */
local_unpin_all_entries(cache_ptr, file_ptr, FALSE);
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);
}
}
}
/* 11 */
if ( verbose ) {HDfprintf(stderr, "%d: cp = %d\n", world_mpi_rank, cp++);}
/* verify that all instances 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);
}
}
}
/* 12 */
if ( verbose ) {HDfprintf(stderr, "%d: cp = %d\n", world_mpi_rank, cp++);}
}
max_nerrors = get_max_nerrors();
if ( world_mpi_rank == 0 ) {
if ( max_nerrors == 0 ) {
PASSED();
} else {
failures++;
H5_FAILED();
}
}
success = ( ( success ) && ( max_nerrors == 0 ) );
return(success);
} /* smoke_check_3() */
/*****************************************************************************
*
* Function: smoke_check_4()
*
* Purpose: Fourth smoke check for the parallel cache.
*
* Use random reads to vary the loads on the diffferent
* processors. Also force different cache size adjustments.
*
* In this test, load process 0 lightly, and the other
* processes heavily.
*
* Return: Success: TRUE
*
* Failure: FALSE
*
* Programmer: JRM -- 1/13/06
*
* Modifications:
*
* Added code intended to insure correct operation with large
* numbers of processors.
* JRM - 1/31/06
*
* Added code testing pinned insertion of entries.
*
* JRM - 8/15/06
*
*****************************************************************************/
hbool_t
smoke_check_4(void)
{
const char * fcn_name = "smoke_check_4()";
hbool_t success = TRUE;
int i;
int max_nerrors;
int min_count;
int max_count;
int min_idx;
int max_idx;
hid_t fid = -1;
H5F_t * file_ptr = NULL;
H5C_t * cache_ptr = NULL;
struct mssg_t mssg;
if ( world_mpi_rank == 0 ) {
TESTING("smoke check #4");
}
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);
}
}
min_count = 100 * (file_mpi_rank % 4);
max_count = min_count + 50;
for ( i = 0; i < (virt_num_data_entries / 4); i++ )
{
insert_entry(cache_ptr, file_ptr, i, H5AC__NO_FLAGS_SET);
if ( i > 100 ) {
lock_and_unlock_random_entries(cache_ptr, file_ptr,
(i - 100), i,
min_count, max_count);
}
}
min_count = 10 * (file_mpi_rank % 4);
max_count = min_count + 100;
for ( i = (virt_num_data_entries / 4);
i < (virt_num_data_entries / 2);
i++ )
{
if ( i % 2 == 0 ) {
insert_entry(cache_ptr, file_ptr, i, H5AC__NO_FLAGS_SET);
} else {
/* Insert some entries pinned, and then unpin them
* immediately. We have tested pinned entries elsewhere,
* so it should be sufficient to verify that the
* entries are in fact pinned (which unpin_entry() should do).
*/
insert_entry(cache_ptr, file_ptr, i, H5C__PIN_ENTRY_FLAG);
unpin_entry(cache_ptr, file_ptr, i, TRUE, FALSE, FALSE);
}
if ( i % 59 == 0 ) {
hbool_t dirty = ( (i % 2) == 0);
if ( data[i].local_pinned ) {
unpin_entry(cache_ptr, file_ptr, i, FALSE, FALSE, FALSE);
}
pin_entry(cache_ptr, file_ptr, i, TRUE, dirty);
HDassert( !dirty || data[i].header.is_dirty );
HDassert( data[i].header.is_pinned );
HDassert( data[i].global_pinned );
HDassert( ! data[i].local_pinned );
}
if ( i > 100 ) {
lock_and_unlock_random_entries(cache_ptr, file_ptr,
(i - 100), i,
min_count, max_count);
}
local_pin_and_unpin_random_entries(cache_ptr, file_ptr, 0,
(virt_num_data_entries / 4),
0, (file_mpi_rank + 2));
}
/* flush the file to be sure that we have no problems flushing
* pinned entries
*/
if ( H5Fflush(fid, H5F_SCOPE_GLOBAL) < 0 ) {
nerrors++;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: H5Fflush() failed.\n",
world_mpi_rank, fcn_name);
}
}
min_idx = 0;
max_idx = (((virt_num_data_entries / 10) / 4) *
((file_mpi_rank % 4) + 1)) - 1;
for ( i = (virt_num_data_entries / 2) - 1; i >= 0; i-- )
{
if ( ( i >= (virt_num_data_entries / 4) ) && ( i % 59 == 0 ) ) {
hbool_t via_unprotect = ( (((unsigned)i) & 0x02) == 0 );
hbool_t dirty = ( (((unsigned)i) & 0x04) == 0 );
HDassert( data[i].global_pinned );
HDassert( ! data[i].local_pinned );
unpin_entry(cache_ptr, file_ptr, i, TRUE, dirty, via_unprotect);
}
if ( i % 2 == 0 ) {
lock_entry(cache_ptr, file_ptr, i);
unlock_entry(cache_ptr, file_ptr, i, H5AC__NO_FLAGS_SET);
lock_and_unlock_random_entries(cache_ptr, file_ptr,
min_idx, max_idx, 0, 100);
}
}
min_idx = 0;
max_idx = (((virt_num_data_entries / 10) / 8) *
((file_mpi_rank % 4) + 1)) - 1;
for ( i = 0; i < (virt_num_data_entries / 2); i+=2 )
{
lock_entry(cache_ptr, file_ptr, i);
unlock_entry(cache_ptr, file_ptr, i, H5AC__DIRTIED_FLAG);
lock_and_unlock_random_entries(cache_ptr, file_ptr,
min_idx, max_idx, 0, 100);
}
/* we can't rename pinned entries, so release any local pins now. */
local_unpin_all_entries(cache_ptr, file_ptr, FALSE);
min_count = 10 * (file_mpi_rank % 4);
max_count = min_count + 100;
/* rename the first half of the entries... */
for ( i = 0; i < (virt_num_data_entries / 2); i++ )
{
lock_entry(cache_ptr, file_ptr, i);
unlock_entry(cache_ptr, file_ptr, i, H5AC__NO_FLAGS_SET);
rename_entry(cache_ptr, file_ptr, i,
(i + (virt_num_data_entries / 2)));
lock_and_unlock_random_entries(cache_ptr, file_ptr, 0,
(virt_num_data_entries / 20),
min_count, max_count);
}
/* ...and then rename them back. */
for ( i = (virt_num_data_entries / 2) - 1; i >= 0; i-- )
{
lock_entry(cache_ptr, file_ptr, i);
unlock_entry(cache_ptr, file_ptr, i, H5AC__DIRTIED_FLAG);
rename_entry(cache_ptr, file_ptr, i,
(i + (virt_num_data_entries / 2)));
lock_and_unlock_random_entries(cache_ptr, file_ptr, 0,
(virt_num_data_entries / 40),
min_count, max_count);
}
/* finally, do some dirty lock/unlocks while we give the cache
* a chance t reduce its size.
*/
min_count = 100 * (file_mpi_rank % 4);
max_count = min_count + 100;
for ( i = 0; i < (virt_num_data_entries / 2); i+=2 )
{
lock_entry(cache_ptr, file_ptr, i);
unlock_entry(cache_ptr, file_ptr, i, H5AC__DIRTIED_FLAG);
if ( i > 100 ) {
lock_and_unlock_random_entries(cache_ptr, file_ptr,
(i - 100), i,
min_count, max_count);
}
}
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);
}
}
}
}
max_nerrors = get_max_nerrors();
if ( world_mpi_rank == 0 ) {
if ( max_nerrors == 0 ) {
PASSED();
} else {
failures++;
H5_FAILED();
}
}
success = ( ( success ) && ( max_nerrors == 0 ) );
return(success);
} /* smoke_check_4() */
/*****************************************************************************
*
* Function: smoke_check_5()
*
* Purpose: Similar to smoke check 1, but modified to verify that
* H5AC_mark_pinned_or_protected_entry_dirty() works in
* the parallel case.
*
* Return: Success: TRUE
*
* Failure: FALSE
*
* Programmer: JRM -- 5/18/06
*
* Modifications:
*
* JRM -- 7/12/06
* Added test code for H5AC_expunge_entry() and
* H5AC_resize_pinned_entry().
*
*****************************************************************************/
hbool_t
smoke_check_5(void)
{
const char * fcn_name = "smoke_check_5()";
hbool_t success = TRUE;
hbool_t verbose = FALSE;
int cp = 0;
int i;
int max_nerrors;
hid_t fid = -1;
H5F_t * file_ptr = NULL;
H5C_t * cache_ptr = NULL;
struct mssg_t mssg;
if ( world_mpi_rank == 0 ) {
TESTING("smoke check #5");
}
/* 0 */
if ( verbose ) { HDfprintf(stderr, "%d: cp = %d\n", world_mpi_rank, cp++); }
nerrors = 0;
init_data();
reset_stats();
if ( world_mpi_rank == world_server_mpi_rank ) {
/* 1 */
if ( verbose ) {
HDfprintf(stderr, "%d: cp = %d\n", world_mpi_rank, cp++);
}
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);
}
}
/* 2 */
if ( verbose ) {
HDfprintf(stderr, "%d: cp = %d\n", world_mpi_rank, cp++);
}
}
else /* run the clients */
{
/* 1 */
if ( verbose ) {
HDfprintf(stderr, "%d: cp = %d\n", world_mpi_rank, cp++);
}
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);
}
}
/* 2 */
if ( verbose ) {
HDfprintf(stderr, "%d: cp = %d\n", world_mpi_rank, cp++);
}
for ( i = 0; i < (virt_num_data_entries / 2); i++ )
{
insert_entry(cache_ptr, file_ptr, i, H5AC__NO_FLAGS_SET);
}
/* 3 */
if ( verbose ) {
HDfprintf(stderr, "%d: cp = %d\n", world_mpi_rank, cp++);
}
/* flush the file so we can lock known clean entries. */
if ( H5Fflush(fid, H5F_SCOPE_GLOBAL) < 0 ) {
nerrors++;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: H5Fflush() failed.\n",
world_mpi_rank, fcn_name);
}
}
/* 4 */
if ( verbose ) {
HDfprintf(stderr, "%d: cp = %d\n", world_mpi_rank, cp++);
}
for ( i = 0; i < (virt_num_data_entries / 4); i++ )
{
lock_entry(cache_ptr, file_ptr, i);
if ( i % 2 == 0 )
{
mark_pinned_or_protected_entry_dirty(cache_ptr, file_ptr, i);
}
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);
}
}
/* 5 */
if ( verbose ) {
HDfprintf(stderr, "%d: cp = %d\n", world_mpi_rank, cp++);
}
for ( i = (virt_num_data_entries / 2) - 1;
i >= (virt_num_data_entries / 4);
i-- )
{
pin_entry(cache_ptr, file_ptr, i, TRUE, FALSE);
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,
file_ptr, i);
}
else
{
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);
}
/* 6 */
if ( verbose ) {
HDfprintf(stderr, "%d: cp = %d\n", world_mpi_rank, cp++);
}
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);
}
}
}
/* 7 */
if ( verbose ) {
HDfprintf(stderr, "%d: cp = %d\n", world_mpi_rank, cp++);
}
/* 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) );
}
/* 8 */
if ( verbose ) {
HDfprintf(stderr, "%d: cp = %d\n", world_mpi_rank, cp++);
}
/* 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);
}
}
}
/* 9 */
if ( verbose ) {
HDfprintf(stderr, "%d: cp = %d\n", world_mpi_rank, cp++);
}
}
max_nerrors = get_max_nerrors();
if ( world_mpi_rank == 0 ) {
if ( max_nerrors == 0 ) {
PASSED();
} else {
failures++;
H5_FAILED();
}
}
success = ( ( success ) && ( max_nerrors == 0 ) );
return(success);
} /* smoke_check_5() */
/*****************************************************************************
*
* 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\" 1 0 1048576 0.500000 16777216 1048576 50000 1 0.900000 2.000000 1 1.000000 0.250000 1 4194304 3 0.999000 0.900000 1 1048576 3 1 0.100000 262144 0\n",
"H5AC_set 0x0 15 0x0 2 0\n",
"H5AC_set 0x2 15 0x0 2 0\n",
"H5AC_set 0x4 15 0x0 4 0\n",
"H5AC_set 0x8 15 0x0 6 0\n",
"H5AC_protect 0 15 H5AC_WRITE 2 1\n",
"H5AC_mark_pinned_or_protected_entry_dirty 0 0\n",
"H5AC_unprotect 0 15 0 0 0\n",
"H5AC_protect 2 15 H5AC_WRITE 2 1\n",
"H5AC_pin_protected_entry 2 0\n",
"H5AC_unprotect 2 15 0 0 0\n",
"H5AC_unpin_entry 2 0\n",
"H5AC_expunge_entry 2 15 0\n",
"H5AC_protect 4 15 H5AC_WRITE 4 1\n",
"H5AC_pin_protected_entry 4 0\n",
"H5AC_unprotect 4 15 0 0 0\n",
"H5AC_mark_pinned_entry_dirty 0x4 0 0 0\n",
"H5AC_resize_pinned_entry 0x4 2 0\n",
"H5AC_resize_pinned_entry 0x4 4 0\n",
"H5AC_unpin_entry 4 0\n",
"H5AC_rename 0 8a65 15 0\n",
"H5AC_rename 8a65 0 15 0\n",
"H5AC_flush 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.
*
* Return: Success: 0
*
* Failure: 1
*
* Programmer: JRM -- 12/23/05
*
* Modifications:
*
* None.
*
*****************************************************************************/
int
main(int argc, char **argv)
{
const char * fcn_name = "main()";
int express_test;
unsigned u;
int mpi_size;
int mpi_rank;
int max_nerrors;
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &mpi_size);
MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
world_mpi_size = mpi_size;
world_mpi_rank = mpi_rank;
world_server_mpi_rank = mpi_size - 1;
world_mpi_comm = MPI_COMM_WORLD;
H5open();
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;
} else {
virt_num_data_entries = STD_VIRT_NUM_DATA_ENTRIES;
}
#ifdef H5_HAVE_MPE
if ( MAINPROCESS ) { printf(" Tests compiled for MPE.\n"); }
virt_num_data_entries = MPE_VIRT_NUM_DATA_ENTIES;
#endif /* H5_HAVE_MPE */
if (MAINPROCESS){
printf("===================================\n");
printf("Parallel metadata cache tests\n");
printf(" mpi_size = %d\n", mpi_size);
printf(" express_test = %d\n", express_test);
printf("===================================\n");
}
if ( mpi_size < 3 ) {
if ( MAINPROCESS ) {
printf(" Need at least 3 processes. Exiting.\n");
}
goto finish;
}
set_up_file_communicator();
setup_derived_types();
/* h5_fixname() will hang some processes don't participate.
*
* Thus we set up the fapl global with the world communicator,
* make our calls to h5_fixname(), discard the fapl, and then
* create it again with the file communicator.
*/
/* setup file access property list with the world communicator */
if ( FAIL == (fapl = H5Pcreate(H5P_FILE_ACCESS)) ) {
nerrors++;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: H5Pcreate() failed 1.\n",
world_mpi_rank, fcn_name);
}
}
if ( H5Pset_fapl_mpio(fapl, world_mpi_comm, MPI_INFO_NULL) < 0 ) {
nerrors++;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: H5Pset_fapl_mpio() failed 1.\n",
world_mpi_rank, fcn_name);
}
}
/* fix the file names */
for ( u = 0; u < sizeof(FILENAME) / sizeof(FILENAME[0]) - 1; ++u )
{
if ( h5_fixname(FILENAME[u], fapl, filenames[u],
sizeof(filenames[u])) == NULL ) {
nerrors++;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: h5_fixname() failed.\n",
world_mpi_rank, fcn_name);
}
break;
}
}
/* close the fapl before we set it up again */
if ( H5Pclose(fapl) < 0 ) {
nerrors++;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: H5Pclose() failed.\n",
world_mpi_rank, fcn_name);
}
}
/* now create the fapl again, excluding the server process. */
if ( world_mpi_rank != world_server_mpi_rank ) {
/* setup file access property list */
if ( FAIL == (fapl = H5Pcreate(H5P_FILE_ACCESS)) ) {
nerrors++;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: H5Pcreate() failed 2.\n",
world_mpi_rank, fcn_name);
}
}
if ( H5Pset_fapl_mpio(fapl, file_mpi_comm, MPI_INFO_NULL) < 0 ) {
nerrors++;
if ( verbose ) {
HDfprintf(stdout, "%d:%s: H5Pset_fapl_mpio() failed 2.\n",
world_mpi_rank, fcn_name);
}
}
}
setup_rand();
max_nerrors = get_max_nerrors();
if ( max_nerrors != 0 ) {
/* errors in setup -- no point in continuing */
if ( world_mpi_rank == 0 ) {
HDfprintf(stdout, "Errors in test initialization. Exiting.\n");
}
goto finish;
}
/* run the tests */
#if 1
server_smoke_check();
#endif
#if 1
smoke_check_1();
#endif
#if 1
smoke_check_2();
#endif
#if 1
smoke_check_3();
#endif
#if 1
smoke_check_4();
#endif
#if 1
smoke_check_5();
#endif
#if 1
trace_file_check();
#endif
finish:
/* make sure all processes are finished before final report, cleanup
* and exit.
*/
MPI_Barrier(MPI_COMM_WORLD);
if (MAINPROCESS){ /* only process 0 reports */
printf("===================================\n");
if (failures){
printf("***metadata cache tests detected %d failures***\n",
failures);
}
else{
printf("metadata cache tests finished with no failures\n");
}
printf("===================================\n");
}
/* close HDF5 library */
H5close();
/* MPI_Finalize must be called AFTER H5close which may use MPI calls */
MPI_Finalize();
/* cannot just return (failures) because exit code is limited to 1byte */
return(failures != 0);
}
Reference in New Issue View Git Blame Copy Permalink