[svn-r18711] Description:

	More changes to move metadata journaling code closer to trunk:

	- Retire old (H5AC1) cache code & tests
	- Remove 'clear_dirty_bits' callback from client class struct
	- Eliminate 'addr' & 'len' parameters from 'free_icr' client callbacks

Tested on:
	Mac OS X/32 10.6.3 (amazon) debug & production
        Linux/64-amd64 2.6 (abe) w/parallel, w/FORTRAN, in production mode

4 files changed, 12 insertions, 5916 deletions

diff --git a/testpar/Makefile.am b/testpar/Makefile.am
index 60c1685..a2759f1 100644
--- a/testpar/Makefile.am
+++ b/testpar/Makefile.am
@@ -25,7 +25,7 @@ INCLUDES=-I$(top_srcdir)/src -I$(top_srcdir)/test
 
 # Test programs and scripts.  These are our main targets.
 #
-TEST_PROG_PARA=t_mpi t_posix_compliant testphdf5 t_cache1 t_cache \
+TEST_PROG_PARA=t_mpi t_posix_compliant testphdf5 t_cache \
 		t_pflush1 t_pflush2
 TEST_SCRIPT_PARA=testph5.sh
 
diff --git a/testpar/Makefile.in b/testpar/Makefile.in
index f018401..e61c17e 100644
--- a/testpar/Makefile.in
+++ b/testpar/Makefile.in
@@ -65,16 +65,12 @@ CONFIG_HEADER = $(top_builddir)/src/H5config.h
 CONFIG_CLEAN_FILES = testph5.sh
 CONFIG_CLEAN_VPATH_FILES =
 am__EXEEXT_1 = t_mpi$(EXEEXT) t_posix_compliant$(EXEEXT) \
-	testphdf5$(EXEEXT) t_cache1$(EXEEXT) t_cache$(EXEEXT) \
-	t_pflush1$(EXEEXT) t_pflush2$(EXEEXT)
+	testphdf5$(EXEEXT) t_cache$(EXEEXT) t_pflush1$(EXEEXT) \
+	t_pflush2$(EXEEXT)
 t_cache_SOURCES = t_cache.c
 t_cache_OBJECTS = t_cache.$(OBJEXT)
 t_cache_LDADD = $(LDADD)
 t_cache_DEPENDENCIES = $(LIBH5TEST) $(LIBHDF5)
-t_cache1_SOURCES = t_cache1.c
-t_cache1_OBJECTS = t_cache1.$(OBJEXT)
-t_cache1_LDADD = $(LDADD)
-t_cache1_DEPENDENCIES = $(LIBH5TEST) $(LIBHDF5)
 t_mpi_SOURCES = t_mpi.c
 t_mpi_OBJECTS = t_mpi.$(OBJEXT)
 t_mpi_LDADD = $(LDADD)
@@ -111,9 +107,9 @@ CCLD = $(CC)
 LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \
 	--mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) \
 	$(LDFLAGS) -o $@
-SOURCES = t_cache.c t_cache1.c t_mpi.c t_pflush1.c t_pflush2.c \
+SOURCES = t_cache.c t_mpi.c t_pflush1.c t_pflush2.c \
 	t_posix_compliant.c $(testphdf5_SOURCES)
-DIST_SOURCES = t_cache.c t_cache1.c t_mpi.c t_pflush1.c t_pflush2.c \
+DIST_SOURCES = t_cache.c t_mpi.c t_pflush1.c t_pflush2.c \
 	t_posix_compliant.c $(testphdf5_SOURCES)
 ETAGS = etags
 CTAGS = ctags
@@ -382,7 +378,7 @@ INCLUDES = -I$(top_srcdir)/src -I$(top_srcdir)/test
 
 # Test programs and scripts.  These are our main targets.
 #
-TEST_PROG_PARA = t_mpi t_posix_compliant testphdf5 t_cache1 t_cache \
+TEST_PROG_PARA = t_mpi t_posix_compliant testphdf5 t_cache \
 		t_pflush1 t_pflush2
 
 TEST_SCRIPT_PARA = testph5.sh
@@ -458,9 +454,6 @@ clean-checkPROGRAMS:
 t_cache$(EXEEXT): $(t_cache_OBJECTS) $(t_cache_DEPENDENCIES) 
 	@rm -f t_cache$(EXEEXT)
 	$(LINK) $(t_cache_OBJECTS) $(t_cache_LDADD) $(LIBS)
-t_cache1$(EXEEXT): $(t_cache1_OBJECTS) $(t_cache1_DEPENDENCIES) 
-	@rm -f t_cache1$(EXEEXT)
-	$(LINK) $(t_cache1_OBJECTS) $(t_cache1_LDADD) $(LIBS)
 t_mpi$(EXEEXT): $(t_mpi_OBJECTS) $(t_mpi_DEPENDENCIES) 
 	@rm -f t_mpi$(EXEEXT)
 	$(LINK) $(t_mpi_OBJECTS) $(t_mpi_LDADD) $(LIBS)
@@ -484,7 +477,6 @@ distclean-compile:
 	-rm -f *.tab.c
 
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/t_cache.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/t_cache1.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/t_chunk_alloc.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/t_coll_chunk.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/t_dset.Po@am__quote@
diff --git a/testpar/t_cache.c b/testpar/t_cache.c
index aa2f282..95b7cdb3 100644
--- a/testpar/t_cache.c
+++ b/testpar/t_cache.c
@@ -76,8 +76,6 @@ MPI_Comm	file_mpi_comm = MPI_COMM_NULL;
  * 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;
@@ -317,10 +315,6 @@ hbool_t serve_write_request(struct mssg_t * mssg_ptr);
 
 /* call back functions & related data structures */
 
-static herr_t datum_clear_dirty_bits(haddr_t addr,
-                                     size_t len,
-                                     void * thing);
-
 static void * datum_deserialize(haddr_t addr,
                                 size_t len,
                                 const void * image_ptr,
@@ -341,9 +335,7 @@ static herr_t datum_serialize(const H5F_t *f,
                               size_t * new_len_ptr,
                               void ** new_image_ptr_ptr);
 
-static herr_t datum_free_icr(haddr_t addr,
-                             size_t len,
-                             void * thing);
+static herr_t datum_free_icr(void * thing);
 
 #define DATUM_ENTRY_TYPE	H5AC_TEST_ID
 
@@ -359,7 +351,6 @@ const H5C_class_t types[NUMBER_OF_ENTRY_TYPES] =
     (H5C_image_len_func_t)datum_image_len,
     (H5C_serialize_func_t)datum_serialize,
     (H5C_free_icr_func_t)datum_free_icr,
-    (H5C_clear_dirty_bits_func_t)datum_clear_dirty_bits
   }
 };
 
@@ -445,9 +436,8 @@ 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 );
+	      "%d: destroys = %ld\n",
+              world_mpi_rank, datum_destroys );
     HDfprintf(stdout,
 	      "%d: datum flushes / pinned flushes / loads  = %ld / %ld / %ld\n",
               world_mpi_rank, datum_flushes, datum_pinned_flushes,
@@ -480,8 +470,6 @@ print_stats(void)
 void
 reset_stats(void)
 {
-    datum_clears          = 0;
-    datum_pinned_clears   = 0;
     datum_destroys        = 0;
     datum_flushes         = 0;
     datum_pinned_flushes  = 0;
@@ -1678,68 +1666,6 @@ serve_write_request(struct mssg_t * mssg_ptr)
 /**************************** Call back functions ****************************/
 /*****************************************************************************/
 
-/*-------------------------------------------------------------------------
- * Function:	datum_clear_dirty_bits
- *
- * Purpose:	Clear the dirty bits of the target entry.
- *
- * Return:	SUCCEED
- *
- * Programmer:	John Mainzer
- *              10/30/07
- *
- * Modifications:
- *
- * 		None
- *
- *-------------------------------------------------------------------------
- */
-
-herr_t
-datum_clear_dirty_bits(UNUSED haddr_t addr,
-                       UNUSED size_t len,
-                       void * thing)
-{
-    int idx;
-    struct datum * entry_ptr;
-
-    HDassert( thing );
-
-    entry_ptr = (struct datum *)thing;
-
-    idx = addr_to_datum_index(entry_ptr->base_addr);
-
-    if ( callbacks_verbose ) {
-
-        HDfprintf(stdout,
-		  "%d: clear_dirty_bits() idx = %d, addr = %ld, len = %d.\n",
-		  world_mpi_rank, idx, (long)addr, (int)len);
-	fflush(stdout);
-    }
-
-    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 ) );
-
-    entry_ptr->dirty = FALSE;
-
-    datum_clears++;
-
-    if ( entry_ptr->header.is_pinned ) {
-
-        datum_pinned_clears++;
-        HDassert( entry_ptr->global_pinned || entry_ptr->local_pinned );
-    }
-
-    return(SUCCEED);
-
-} /* datum_clear_dirty_bits() */
-
 
 /*-------------------------------------------------------------------------
  * Function:	datum_deserialize
@@ -2151,9 +2077,7 @@ datum_serialize(const H5F_t UNUSED *f,
  */
 
 herr_t
-datum_free_icr(UNUSED haddr_t addr,
-               UNUSED size_t len,
-               void * thing)
+datum_free_icr(void * thing)
 {
     int idx;
     struct datum * entry_ptr;
@@ -2172,9 +2096,8 @@ datum_free_icr(UNUSED haddr_t addr,
     if ( callbacks_verbose ) {
 
         HDfprintf(stdout,
-	  "%d: free_icr() idx = %d, addr = %ld, len = %d, dirty = %d.\n",
-		  world_mpi_rank, idx, (long)addr, (int)len,
-		  (int)(entry_ptr->dirty));
+	  "%d: free_icr() idx = %d, dirty = %d.\n",
+		  world_mpi_rank, idx, (int)(entry_ptr->dirty));
 	fflush(stdout);
     }
 
diff --git a/testpar/t_cache1.c b/testpar/t_cache1.c
deleted file mode 100644
index a218a7d..0000000
--- a/testpar/t_cache1.c
+++ /dev/null
@@ -1,5819 +0,0 @@
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
- * 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 "H5AC1private.h"
-
-#define H5C1_PACKAGE             /*suppress error about including H5Cpkg   */
-
-#include "H5C1pkg.h"
-
-#define H5AC1_PACKAGE            /*suppress error about including H5Cpkg   */
-
-#include "H5AC1pkg.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 H5C1_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.
- *
- *	index:	Index of this instance of datum in the data_index[] array
- *		discussed below.
- *
- *****************************************************************************/
-
-struct datum
-{
-    H5C1_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;
-    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 */
-
-void print_stats(void);
-void reset_stats(void);
-
-/* MPI setup functions */
-
-hbool_t set_up_file_communicator(void);
-
-
-/* data array manipulation functions */
-
-int addr_to_datum_index(haddr_t base_addr);
-void init_data(void);
-
-
-/* test coodination related functions */
-
-int do_express_test(void);
-void do_sync(void);
-int get_max_nerrors(void);
-
-
-/* mssg xfer related functions */
-
-hbool_t recv_mssg(struct mssg_t *mssg_ptr, int mssg_tag_offset);
-hbool_t send_mssg(struct mssg_t *mssg_ptr, hbool_t add_req_to_tag);
-hbool_t setup_derived_types(void);
-hbool_t takedown_derived_types(void);
-
-
-/* server functions */
-
-hbool_t server_main(void);
-hbool_t serve_read_request(struct mssg_t * mssg_ptr);
-hbool_t serve_sync_request(struct mssg_t * mssg_ptr);
-hbool_t serve_write_request(struct mssg_t * mssg_ptr);
-
-
-/* call back functions & related data structures */
-
-herr_t clear_datum(H5F_t * f, void *  thing, hbool_t dest);
-herr_t destroy_datum(H5F_t UNUSED * f, void * thing);
-herr_t flush_datum(H5F_t *f, hid_t UNUSED dxpl_id, hbool_t dest, haddr_t addr,
-                   void *thing);
-void * load_datum(H5F_t UNUSED *f, hid_t UNUSED dxpl_id, haddr_t addr,
-                  const void UNUSED *udata1, void UNUSED *udata2);
-herr_t size_datum(H5F_t UNUSED * f, void * thing, size_t * size_ptr);
-
-#define DATUM_ENTRY_TYPE	H5AC1_TEST_ID
-
-#define NUMBER_OF_ENTRY_TYPES	1
-
-const H5C1_class_t types[NUMBER_OF_ENTRY_TYPES] =
-{
-  {
-    DATUM_ENTRY_TYPE,
-    (H5C1_load_func_t)load_datum,
-    (H5C1_flush_func_t)flush_datum,
-    (H5C1_dest_func_t)destroy_datum,
-    (H5C1_clear_func_t)clear_datum,
-    (H5C1_size_func_t)size_datum
-  }
-};
-
-
-/* test utility functions */
-
-void expunge_entry(H5C1_t * cache_ptr, H5F_t * file_ptr, int32_t idx);
-void insert_entry(H5C1_t * cache_ptr, H5F_t * file_ptr,
-                  int32_t idx, unsigned int flags);
-void local_pin_and_unpin_random_entries(H5C1_t * cache_ptr, H5F_t * file_ptr,
-                                        int min_idx, int max_idx,
-				        int min_count, int max_count);
-void local_pin_random_entry(H5C1_t * cache_ptr, H5F_t * file_ptr,
-                            int min_idx, int max_idx);
-void local_unpin_all_entries(H5C1_t * cache_ptr, H5F_t * file_ptr,
-			     hbool_t via_unprotect);
-int local_unpin_next_pinned_entry(H5C1_t * cache_ptr, H5F_t * file_ptr,
-                                  int start_idx, hbool_t via_unprotect);
-void lock_and_unlock_random_entries(H5C1_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(H5C1_t * cache_ptr, H5F_t * file_ptr,
-                                  int min_idx, int max_idx);
-void lock_entry(H5C1_t * cache_ptr, H5F_t * file_ptr, int32_t idx);
-void mark_pinned_entry_dirty(H5C1_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(H5C1_t * cache_ptr,
-                                          H5F_t * file_ptr,
-                                          int32_t idx);
-void pin_entry(H5C1_t * cache_ptr, H5F_t * file_ptr, int32_t idx,
-	       hbool_t global, hbool_t dirty);
-void pin_protected_entry(H5C1_t * cache_ptr, H5F_t * file_ptr,
-                         int32_t idx, hbool_t global);
-void rename_entry(H5C1_t * cache_ptr, H5F_t * file_ptr,
-                  int32_t old_idx, int32_t new_idx);
-void resize_entry(H5C1_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,
-                             H5C1_t ** cache_ptr_ptr);
-void setup_rand(void);
-hbool_t take_down_cache(hid_t fid);
-void unlock_entry(H5C1_t * cache_ptr, H5F_t * file_ptr,
-                  int32_t type, unsigned int flags);
-void unpin_entry(H5C1_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 ******************************/
-/*****************************************************************************/
-
-/*****************************************************************************
- *
- * 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.
- *
- *****************************************************************************/
-
-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() */
-
-/*****************************************************************************
- *
- * Function:	reset_stats()
- *
- * Purpose:	Reset the rudementary stats maintained by t_cache.
- *
- * Return:	void
- *
- * Programmer:	JRM -- 4/17/06
- *
- * Modifications:
- *
- *		None.
- *
- *****************************************************************************/
-
-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.
- *
- *****************************************************************************/
-
-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.
- *
- *****************************************************************************/
-
-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.
- *
- *****************************************************************************/
-
-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 = 0;
-
-    /* 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].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.
- *
- *****************************************************************************/
-
-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.
- *
- *****************************************************************************/
-
-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.
- *
- *****************************************************************************/
-
-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 */
-
-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.
- *
- *****************************************************************************/
-
-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.
- *
- *****************************************************************************/
-
-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.
- *
- *****************************************************************************/
-
-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.
- *
- *****************************************************************************/
-
-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.
- *
- *****************************************************************************/
-
-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 = %Zu != 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,
-			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.
- *
- *****************************************************************************/
-
-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.
- *
- *****************************************************************************/
-
-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 = %Zu != 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.
- *
- *-------------------------------------------------------------------------
- */
-
-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 ) );
-
-    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.
- *
- *-------------------------------------------------------------------------
- */
-
-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.
- *
- *-------------------------------------------------------------------------
- */
-
-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;
-            }
-        }
-    }
-
-#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:
- *
- *-------------------------------------------------------------------------
- */
-
-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.
- *
- *-------------------------------------------------------------------------
- */
-
-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(H5C1_t * cache_ptr,
-              H5F_t * file_ptr,
-              int32_t idx)
-{
-    const char * fcn_name = "expunge_entry()";
-    hbool_t in_cache;
-    herr_t result;
-    struct datum * entry_ptr;
-
-    HDassert( cache_ptr );
-    HDassert( file_ptr );
-    HDassert( ( 0 <= idx ) && ( idx < NUM_DATA_ENTRIES ) );
-    HDassert( idx < virt_num_data_entries );
-
-    entry_ptr = &(data[idx]);
-
-    HDassert( !(entry_ptr->locked) );
-    HDassert( !(entry_ptr->global_pinned) );
-    HDassert( !(entry_ptr->local_pinned) );
-
-    entry_ptr->dirty = TRUE;
-
-    if ( nerrors == 0 ) {
-
-        result = H5AC1_expunge_entry(file_ptr, -1, &(types[0]),
-			            entry_ptr->header.addr);
-
-        if ( result < 0 ) {
-
-            nerrors++;
-            if ( verbose ) {
-	        HDfprintf(stdout, "%d:%s: Error in H5AC1_expunge_entry().\n",
-	                  world_mpi_rank, fcn_name);
-            }
-        }
-
-        HDassert( ((entry_ptr->header).type)->id == DATUM_ENTRY_TYPE );
-	HDassert( ! ((entry_ptr->header).is_dirty) );
-
-	result = H5C1_get_entry_status(cache_ptr, entry_ptr->base_addr,
-				      NULL, &in_cache, NULL, NULL, NULL);
-
-	if ( result < 0 ) {
-
-            nerrors++;
-            if ( verbose ) {
-	        HDfprintf(stdout, "%d:%s: Error in H5C1_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(H5C1_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 & H5C1__PIN_ENTRY_FLAG) != 0 );
-
-    if ( nerrors == 0 ) {
-
-        (entry_ptr->ver)++;
-        entry_ptr->dirty = TRUE;
-
-        result = H5AC1_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 H5AC1_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 H5AC1_aux_t * aux_ptr;
-
-	    aux_ptr = ((H5AC1_aux_t *)(cache_ptr->aux_ptr));
-
-	    if ( ! ( ( aux_ptr != NULL ) &&
-		     ( aux_ptr->magic == H5AC1__H5AC1_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(H5C1_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(H5C1_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(H5C1_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(H5C1_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(H5C1_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(H5C1_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, H5AC1__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(H5C1_t * cache_ptr,
-           H5F_t * file_ptr,
-           int32_t idx)
-{
-    const char * fcn_name = "lock_entry()";
-    struct datum * entry_ptr;
-    H5C1_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 = H5AC1_protect(file_ptr, -1, &(types[0]),
-                                       entry_ptr->base_addr,
-                                       NULL, NULL, H5AC1_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 H5AC1_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(H5C1_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 = H5AC1_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 H5AC1_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 H5AC1_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(H5C1_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 = H5AC1_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,
-			  "H5AC1_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(H5C1_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 = H5AC1__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 |= H5AC1__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(H5C1_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 = H5AC1_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 H5AC1_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(H5C1_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 = H5AC1_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: H5AC1_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(H5C1_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 = H5AC1_resize_pinned_entry(file_ptr, (void *)entry_ptr,
-			                  new_size);
-
-        if ( result < 0 ) {
-
-            nerrors++;
-            if ( verbose ) {
-		HDfprintf(stdout, "%d:%s: H5AC1_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,
-                     H5C1_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;
-    H5AC1_cache_config_t config;
-    H5F_t * file_ptr = NULL;
-    H5C1_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->cache1;
-    }
-
-    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 != H5C1__H5C1_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;
-        H5C1_set_skip_flags(cache_ptr, TRUE, TRUE);
-        H5C1_stats__reset(cache_ptr);
-        success = TRUE;
-    }
-
-    if ( ( success ) && ( enable_rpt_fcn ) ) {
-
-        config.version = H5AC1__CURR_CACHE_CONFIG_VERSION;
-
-        if ( H5AC1_get_cache_auto_resize_config(cache_ptr, &config)
-             != SUCCEED ) {
-
-	    HDfprintf(stdout,
-                      "%d:%s: H5AC1_get_cache_auto_resize_config() failed.\n",
-                      world_mpi_rank, fcn_name);
-
-        } else {
-
-            config.rpt_fcn_enabled = TRUE;
-
-            if ( H5AC1_set_cache_auto_resize_config(cache_ptr, &config)
-                 != SUCCEED ) {
-
-	        HDfprintf(stdout,
-                         "%d:%s: H5AC1_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 ( H5AC1_set_write_done_callback(cache_ptr, do_sync) != SUCCEED ) {
-
-            nerrors++;
-            if ( verbose ) {
-	        HDfprintf(stdout,
-			  "%d:%s: H5C1_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(H5AC1_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, H5AC1_BLOCK_BEFORE_META_WRITE_NAME,
-                      H5AC1_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, H5AC1_LIBRARY_INTERNAL_NAME,
-                      H5AC1_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] = {18669, 89925, 12577};
-    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;
-            if ( verbose ) {
-                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(H5C1_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 & H5AC1__DIRTIED_FLAG) == H5AC1__DIRTIED_FLAG );
-
-        if ( dirtied ) {
-
-            (entry_ptr->ver)++;
-            entry_ptr->dirty = TRUE;
-        }
-
-        result = H5AC1_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 H5C1_unprotect().\n",
-                          world_mpi_rank, fcn_name);
-            }
-        } else {
-
-            entry_ptr->locked = FALSE;
-
-	}
-
-        HDassert( ((entry_ptr->header).type)->id == DATUM_ENTRY_TYPE );
-
-        if ( ( flags & H5AC1__DIRTIED_FLAG ) != 0
-                && ( (flags & H5C1__DELETED_FLAG) == 0 ) ) {
-
-            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(H5C1_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 = H5AC1__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 |= H5AC1__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 = H5AC1_unpin_entry(file_ptr, (void *)entry_ptr);
-
-	    if ( result < 0 ) {
-
-                nerrors++;
-                if ( verbose ) {
-                    HDfprintf(stdout, "%d:%s: error in H5AC1_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;
-    H5C1_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, H5AC1__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, H5AC1__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, H5AC1__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, H5AC1__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;
-    H5C1_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, H5AC1__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, H5AC1__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, H5AC1__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, H5AC1__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, H5AC1__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;
-    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;
-    H5C1_t * cache_ptr = NULL;
-    struct mssg_t mssg;
-
-    if ( world_mpi_rank == 0 ) {
-
-        TESTING("smoke check #3");
-    }
-
-    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 + 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, H5AC1__NO_FLAGS_SET);
-
-            if ( i > 100 ) {
-
-		lock_and_unlock_random_entries(cache_ptr, file_ptr,
-                                               (i - 100), i,
-                                               min_count, max_count);
-            }
-        }
-
-
-        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, H5AC1__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));
-
-	}
-
-
-	/* 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) /
-                   ((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, H5AC1__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);
-	    }
-        }
-
-        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, H5AC1__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 + 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, H5AC1__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, H5AC1__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 = 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, H5AC1__DIRTIED_FLAG);
-
-            if ( i > 100 ) {
-
-		lock_and_unlock_random_entries(cache_ptr, file_ptr,
-                                               (i - 100), i,
-                                               min_count, max_count);
-            }
-        }
-
-        /* 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);
-                }
-            }
-        }
-
-        /* 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);
-                }
-            }
-        }
-    }
-
-    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;
-    H5C1_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, H5AC1__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, H5AC1__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, H5C1__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, H5AC1__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, H5AC1__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, H5AC1__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, H5AC1__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, H5AC1__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
- * 		H5AC1_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 H5AC1_expunge_entry() and
- *		H5AC1_resize_pinned_entry().
- *
- *****************************************************************************/
-
-hbool_t
-smoke_check_5(void)
-{
-    const char * fcn_name = "smoke_check_5()";
-    hbool_t success = TRUE;
-    int i;
-    int max_nerrors;
-    hid_t fid = -1;
-    H5F_t * file_ptr = NULL;
-    H5C1_t * cache_ptr = NULL;
-    struct mssg_t mssg;
-
-    if ( world_mpi_rank == 0 ) {
-
-        TESTING("smoke check #5");
-    }
-
-    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, H5AC1__NO_FLAGS_SET);
-        }
-
-	/* 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);
-            }
-        }
-
-        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, H5AC1__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, H5AC1__DIRTIED_FLAG);
-		}
-
-		expunge_entry(cache_ptr, file_ptr, i);
-	    }
-        }
-
-        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);
-        }
-
-        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_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:
- *
- *                    - H5AC1_flush()
- *                    - H5AC1_set()
- *                    - H5AC1_mark_pinned_entry_dirty()
- *                    - H5AC1_mark_pinned_or_protected_entry_dirty()
- *                      H5AC1_rename()
- *                    - H5AC1_pin_protected_entry()
- *                    - H5AC1_protect()
- *                    - H5AC1_unpin_entry()
- *                    - H5AC1_unprotect()
- *                    - H5AC1_set_cache_auto_resize_config()
- *                    - H5AC1_expunge_entry()
- *                    - H5AC1_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 H5AC1_expunge_entry() and
- *		H5AC1_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",
-      "H5AC1_set_cache_auto_resize_config 1 0 1 0 \"t_cache1_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",
-      "H5AC1_set 0x0 15 0x0 2 0\n",
-      "H5AC1_set 0x2 15 0x0 2 0\n",
-      "H5AC1_set 0x4 15 0x0 4 0\n",
-      "H5AC1_set 0x8 15 0x0 6 0\n",
-      "H5AC1_protect 0 15 H5AC1_WRITE 2 1\n",
-      "H5AC1_mark_pinned_or_protected_entry_dirty 0 0\n",
-      "H5AC1_unprotect 0 15 0 0 0\n",
-      "H5AC1_protect 2 15 H5AC1_WRITE 2 1\n",
-      "H5AC1_pin_protected_entry 2 0\n",
-      "H5AC1_unprotect 2 15 0 0 0\n",
-      "H5AC1_unpin_entry 2 0\n",
-      "H5AC1_expunge_entry 2 15 0\n",
-      "H5AC1_protect 4 15 H5AC1_WRITE 4 1\n",
-      "H5AC1_pin_protected_entry 4 0\n",
-      "H5AC1_unprotect 4 15 0 0 0\n",
-      "H5AC1_mark_pinned_entry_dirty 0x4 0 0 0\n",
-      "H5AC1_resize_pinned_entry 0x4 2 0\n",
-      "H5AC1_resize_pinned_entry 0x4 4 0\n",
-      "H5AC1_unpin_entry 4 0\n",
-      "H5AC1_rename 0 8a65 15 0\n",
-      "H5AC1_rename 8a65 0 15 0\n",
-      "H5AC1_flush 0x0 0\n",
-      NULL
-    };
-    char buffer[256];
-    char trace_file_name[64];
-    hbool_t done = FALSE;
-    int i;
-    int max_nerrors;
-    int expected_line_len;
-    int actual_line_len;
-    hid_t fid = -1;
-    H5F_t * file_ptr = NULL;
-    H5C1_t * cache_ptr = NULL;
-    FILE * trace_file_ptr = NULL;
-    H5AC1_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 = H5AC1__CURR_CACHE_CONFIG_VERSION;
-
-            if ( H5AC1_get_cache_auto_resize_config(cache_ptr, &config)
-                 != SUCCEED ) {
-
-		nerrors++;
-	        HDfprintf(stdout,
-                        "%d:%s: H5AC1_get_cache_auto_resize_config() failed.\n",
-                        world_mpi_rank, fcn_name);
-
-            } else {
-
-                config.open_trace_file = TRUE;
-		strcpy(config.trace_file_name, "t_cache1_trace.txt");
-
-                if ( H5AC1_set_cache_auto_resize_config(cache_ptr, &config)
-                     != SUCCEED ) {
-
-		    nerrors++;
-	            HDfprintf(stdout,
-                         "%d:%s: H5AC1_set_cache_auto_resize_config() failed.\n",
-                          world_mpi_rank, fcn_name);
-                }
-            }
-        }
-
-	insert_entry(cache_ptr, file_ptr, 0, H5AC1__NO_FLAGS_SET);
-	insert_entry(cache_ptr, file_ptr, 1, H5AC1__NO_FLAGS_SET);
-	insert_entry(cache_ptr, file_ptr, 2, H5AC1__NO_FLAGS_SET);
-	insert_entry(cache_ptr, file_ptr, 3, H5AC1__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, H5AC1__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, H5AC1__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, H5AC1__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 = H5AC1__CURR_CACHE_CONFIG_VERSION;
-
-            if ( H5AC1_get_cache_auto_resize_config(cache_ptr, &config)
-                 != SUCCEED ) {
-
-		nerrors++;
-	        HDfprintf(stdout,
-                        "%d:%s: H5AC1_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 ( H5AC1_set_cache_auto_resize_config(cache_ptr, &config)
-                     != SUCCEED ) {
-
-		    nerrors++;
-	            HDfprintf(stdout,
-                         "%d:%s: H5AC1_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_cache1_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);
-}
-