[svn-r27084] Description:

    Clean up cache tests, to align w/v3 metadata cache changes

Tested on:
    MacOSX/64 10.10.3 (amazon) w/serial & parallel
    Linux/32 2.6.* (jam) w/serial & parallel

1 files changed, 93 insertions, 274 deletions

diff --git a/testpar/t_cache.c b/testpar/t_cache.c
index f526a8b..d36f34f 100644
--- a/testpar/t_cache.c
+++ b/testpar/t_cache.c
@@ -20,31 +20,22 @@
 
 #include "h5test.h"
 #include "testpar.h"
-#include "H5Iprivate.h"
-#include "H5ACprivate.h"
-
-#define H5C_PACKAGE             /*suppress error about including H5Cpkg   */
-
-#include "H5Cpkg.h"
 
 #define H5AC_PACKAGE            /*suppress error about including H5ACpkg  */
+#define H5C_PACKAGE             /*suppress error about including H5Cpkg   */
+#define H5F_PACKAGE             /*suppress error about including H5Fpkg   */
 
 #include "H5ACpkg.h"
+#include "H5Cpkg.h"
+#include "H5Fpkg.h"
+#include "H5Iprivate.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]
@@ -169,7 +160,7 @@ struct datum
     hbool_t		global_pinned;
     hbool_t		local_pinned;
     hbool_t		cleared;
-    hbool_t		flushed;
+    hbool_t             flushed;
     int			reads;
     int			writes;
     int			index;
@@ -466,20 +457,20 @@ static hbool_t trace_file_check(int metadata_write_strategy);
 #ifdef NOT_USED
 /*****************************************************************************
  *
- * Function:	print_stats()
+ * Function:    print_stats()
  *
- * Purpose:	Print the rudementary stats maintained by t_cache.
+ * 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.
+ *              This is a debugging function, which will not normally
+ *              be run as part of t_cache.
  *
- * Return:	void
+ * Return:      void
  *
- * Programmer:	JRM -- 4/17/06
+ * Programmer:  JRM -- 4/17/06
  *
  * Modifications:
  *
- *		None.
+ *              None.
  *
  *****************************************************************************/
 
@@ -487,16 +478,16 @@ static void
 print_stats(void)
 {
     HDfprintf(stdout,
-	      "%d: datum clears / pinned clears / destroys = %ld / %ld / %ld\n",
+              "%d: datum clears / pinned clears / destroys = %ld / %ld / %ld\n",
               world_mpi_rank, datum_clears, datum_pinned_clears,
-	      datum_destroys );
+              datum_destroys );
     HDfprintf(stdout,
-	      "%d: datum flushes / pinned flushes / loads  = %ld / %ld / %ld\n",
+              "%d: datum flushes / pinned flushes / loads  = %ld / %ld / %ld\n",
               world_mpi_rank, datum_flushes, datum_pinned_flushes,
-	      datum_loads );
+              datum_loads );
     HDfprintf(stdout,
-	      "%d: pins: global / global dirty / local = %ld / %ld / %ld\n",
-	      world_mpi_rank, global_pins, global_dirty_pins, local_pins);
+              "%d: pins: global / global dirty / local = %ld / %ld / %ld\n",
+              world_mpi_rank, global_pins, global_dirty_pins, local_pins);
     HDfflush(stdout);
 
     return;
@@ -504,6 +495,7 @@ print_stats(void)
 } /* print_stats() */
 #endif /* NOT_USED */
 
+
 /*****************************************************************************
  *
  * Function:	reset_stats()
@@ -793,7 +785,7 @@ init_data(void)
 	data[i].global_pinned = FALSE;
 	data[i].local_pinned  = FALSE;
 	data[i].cleared       = FALSE;
-	data[i].flushed       = FALSE;
+        data[i].flushed       = FALSE;
         data[i].reads         = 0;
         data[i].writes        = 0;
 	data[i].index         = i;
@@ -883,12 +875,7 @@ do_express_test(void)
  *
  * Programmer:	JRM -- 5/10/06
  *
- * Modifications:
- *
- *		None.
- *
  *****************************************************************************/
-
 static void
 do_sync(void)
 {
@@ -960,12 +947,7 @@ do_sync(void)
  *
  * Programmer:	JRM -- 1/3/06
  *
- * Modifications:
- *
- *		None.
- *
  *****************************************************************************/
-
 static int
 get_max_nerrors(void)
 {
@@ -1105,7 +1087,6 @@ recv_mssg(struct mssg_t *mssg_ptr,
  *		Added the add_req_to_tag parameter and supporting code.
  *
  *****************************************************************************/
-
 static hbool_t
 send_mssg(struct mssg_t *mssg_ptr,
 	  hbool_t add_req_to_tag)
@@ -1250,7 +1231,7 @@ setup_derived_types(void)
 
 } /* setup_derived_types */
 
-
+
 /*****************************************************************************
  *
  * Function:	takedown_derived_types()
@@ -1264,12 +1245,7 @@ setup_derived_types(void)
  *
  * Programmer:	JRM -- 12/22/05
  *
- * Modifications:
- *
- *		None.
- *
  *****************************************************************************/
-
 static hbool_t
 takedown_derived_types(void)
 {
@@ -1311,12 +1287,7 @@ takedown_derived_types(void)
  *
  * Programmer:	JRM -- 5/5/10
  *
- * Modifications:
- *
- *		None.
- *
  *****************************************************************************/
-
 static hbool_t
 reset_server_counters(void)
 {
@@ -1394,7 +1365,6 @@ reset_server_counters(void)
  *		Updated for sync message.
  *
  *****************************************************************************/
-
 static hbool_t
 server_main(void)
 {
@@ -1593,11 +1563,11 @@ serve_read_request(struct mssg_t * mssg_ptr)
             success = FALSE;
             if ( verbose ) {
                 HDfprintf(stdout,
-               "%d:%s: proc %d read invalid entry. idx/base_addr = %d/0x%llx.\n",
-                        world_mpi_rank, fcn_name,
-                        mssg_ptr->src,
+                  "%d:%s: proc %d read invalid entry. idx/base_addr = %d/%a.\n",
+                         world_mpi_rank, fcn_name,
+                         mssg_ptr->src,
 			target_index,
-			(long long)(data[target_index].base_addr));
+			data[target_index].base_addr);
             }
         } else {
 
@@ -1648,7 +1618,7 @@ serve_read_request(struct mssg_t * mssg_ptr)
 
 } /* serve_read_request() */
 
-
+
 /*****************************************************************************
  *
  * Function:	serve_sync_request()
@@ -1669,12 +1639,7 @@ serve_read_request(struct mssg_t * mssg_ptr)
  *
  * Programmer:	JRM -- 5/10/06
  *
- * Modifications:
- *
- *		None.
- *
  *****************************************************************************/
-
 static hbool_t
 serve_sync_request(struct mssg_t * mssg_ptr)
 {
@@ -2678,58 +2643,66 @@ load_datum(H5F_t UNUSED *f,
                           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.req != READ_REQ_REPLY_CODE ) {
 
-	    if ( mssg.src != world_server_mpi_rank ) {
+		        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));
+	            }
 
-		HDfprintf(stdout, "%d:%s: mssg.src != world_server_mpi_rank.\n",
-			  world_mpi_rank, fcn_name);
-	    }
+	            if ( mssg.src != world_server_mpi_rank ) {
 
-	    if ( mssg.dest != world_mpi_rank ) {
+		        HDfprintf(stdout, 
+                                 "%d:%s: mssg.src != world_server_mpi_rank.\n",
+			         world_mpi_rank, fcn_name);
+	            }
 
-		HDfprintf(stdout, "%d:%s: mssg.dest != world_mpi_rank.\n",
-			  world_mpi_rank, fcn_name);
-            }
+	            if ( mssg.dest != world_mpi_rank ) {
 
-	    if ( mssg.base_addr != entry_ptr->base_addr ) {
+		        HDfprintf(stdout, 
+                                  "%d:%s: mssg.dest != world_mpi_rank.\n",
+			          world_mpi_rank, fcn_name);
+                    }
 
-		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.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 ) {
+	            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);
-            }
+		        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 ) {
+	            if ( mssg.ver < entry_ptr->ver ) {
 
-		HDfprintf(stdout, "%d:%s: mssg.ver < entry_ptr->ver.\n",
-			  world_mpi_rank, fcn_name);
-            }
+		        HDfprintf(stdout, 
+                                  "%d:%s: mssg.ver < entry_ptr->ver.\n",
+			          world_mpi_rank, fcn_name);
+                    }
 
-	    if ( mssg.magic != MSSG_MAGIC ) {
+	            if ( mssg.magic != MSSG_MAGIC ) {
 
-		HDfprintf(stdout, "%d:%s: mssg.magic != MSSG_MAGIC.\n",
-			  world_mpi_rank, fcn_name);
-            }
+		        HDfprintf(stdout, "%d:%s: mssg.magic != MSSG_MAGIC.\n",
+			          world_mpi_rank, fcn_name);
+                     }
 #endif /* JRM */
-        } else {
+
+                } else {
 
             entry_ptr->ver = mssg.ver;
             entry_ptr->header.is_dirty = FALSE;
@@ -2803,7 +2776,7 @@ size_datum(H5F_t UNUSED *  f,
 
 } /* size_datum() */
 
-
+
 /*****************************************************************************/
 /************************** test utility functions ***************************/
 /*****************************************************************************/
@@ -2821,12 +2794,7 @@ size_datum(H5F_t UNUSED *  f,
  * Programmer:  John Mainzer
  *              07/11/06
  *
- * Modifications:
- *
- *              None.
- *
  *****************************************************************************/
-
 static void
 expunge_entry(H5F_t * file_ptr,
               int32_t idx)
@@ -2887,7 +2855,7 @@ expunge_entry(H5F_t * file_ptr,
 
 } /* expunge_entry() */
 
-
+
 /*****************************************************************************
  * Function:    insert_entry()
  *
@@ -2909,7 +2877,6 @@ expunge_entry(H5F_t * file_ptr,
  *              any pins must be global pins.
  *
  *****************************************************************************/
-
 static void
 insert_entry(H5C_t * cache_ptr,
              H5F_t * file_ptr,
@@ -2998,7 +2965,7 @@ insert_entry(H5C_t * cache_ptr,
 
 } /* insert_entry() */
 
-
+
 /*****************************************************************************
  * Function:    local_pin_and_unpin_random_entries()
  *
@@ -3012,10 +2979,7 @@ insert_entry(H5C_t * cache_ptr,
  * Programmer:  John Mainzer
  *              4/12/06
  *
- * Modifications:
- *
  *****************************************************************************/
-
 static void
 local_pin_and_unpin_random_entries(H5F_t * file_ptr,
                                    int min_idx,
@@ -3118,7 +3082,7 @@ local_pin_random_entry(H5F_t * file_ptr,
 
 } /* local_pin_random_entry() */
 
-
+
 /*****************************************************************************
  * Function:    local_unpin_all_entries()
  *
@@ -3131,10 +3095,7 @@ local_pin_random_entry(H5F_t * file_ptr,
  * Programmer:  John Mainzer
  *              4/12/06
  *
- * Modifications:
- *
  *****************************************************************************/
-
 static void
 local_unpin_all_entries(H5F_t * file_ptr,
 			hbool_t via_unprotect)
@@ -3160,7 +3121,7 @@ local_unpin_all_entries(H5F_t * file_ptr,
 
 } /* local_unpin_all_entries() */
 
-
+
 /*****************************************************************************
  * Function:    local_unpin_next_pinned_entry()
  *
@@ -3176,10 +3137,7 @@ local_unpin_all_entries(H5F_t * file_ptr,
  * Programmer:  John Mainzer
  *              4/12/06
  *
- * Modifications:
- *
  *****************************************************************************/
-
 static int
 local_unpin_next_pinned_entry(H5F_t * file_ptr,
                               int start_idx,
@@ -3222,7 +3180,7 @@ local_unpin_next_pinned_entry(H5F_t * file_ptr,
 
 } /* local_unpin_next_pinned_entry() */
 
-
+
 /*****************************************************************************
  * Function:    lock_and_unlock_random_entries()
  *
@@ -3237,10 +3195,7 @@ local_unpin_next_pinned_entry(H5F_t * file_ptr,
  * Programmer:  John Mainzer
  *              1/12/06
  *
- * Modifications:
- *
  *****************************************************************************/
-
 static void
 lock_and_unlock_random_entries(H5F_t * file_ptr,
                                int min_idx,
@@ -3273,7 +3228,7 @@ lock_and_unlock_random_entries(H5F_t * file_ptr,
 
 } /* lock_and_unlock_random_entries() */
 
-
+
 /*****************************************************************************
  * Function:    lock_and_unlock_random_entry()
  *
@@ -3287,10 +3242,7 @@ lock_and_unlock_random_entries(H5F_t * file_ptr,
  * Programmer:  John Mainzer
  *              1/4/06
  *
- * Modifications:
- *
  *****************************************************************************/
-
 static void
 lock_and_unlock_random_entry(H5F_t * file_ptr,
                              int min_idx,
@@ -3320,7 +3272,7 @@ lock_and_unlock_random_entry(H5F_t * file_ptr,
 
 } /* lock_and_unlock_random_entry() */
 
-
+
 /*****************************************************************************
  * Function:    lock_entry()
  *
@@ -3340,7 +3292,6 @@ lock_and_unlock_random_entry(H5F_t * file_ptr,
  * 		datum.
  *
  *****************************************************************************/
-
 static void
 lock_entry(H5F_t * file_ptr,
            int32_t idx)
@@ -3400,7 +3351,6 @@ lock_entry(H5F_t * file_ptr,
  *              4/14/06
  *
  *****************************************************************************/
-
 static void
 mark_entry_dirty(int32_t idx)
 {
@@ -3442,7 +3392,7 @@ mark_entry_dirty(int32_t idx)
 
 } /* mark_entry_dirty() */
 
-
+
 /*****************************************************************************
  * Function:    pin_entry()
  *
@@ -3455,10 +3405,7 @@ mark_entry_dirty(int32_t idx)
  * Programmer:  John Mainzer
  *              4/11/06
  *
- * Modifications:
- *
  *****************************************************************************/
-
 static void
 pin_entry(H5F_t * file_ptr,
           int32_t idx,
@@ -3512,8 +3459,8 @@ pin_entry(H5F_t * file_ptr,
 
 } /* pin_entry() */
 
-
 #ifdef H5_METADATA_TRACE_FILE
+
 /*****************************************************************************
  * Function:    pin_protected_entry()
  *
@@ -3527,12 +3474,7 @@ pin_entry(H5F_t * file_ptr,
  * Programmer:  John Mainzer
  *              01/04/06
  *
- * Modifications:
- *
- *              None.
- *
  *****************************************************************************/
-
 static void
 pin_protected_entry(int32_t idx,
 		    hbool_t global)
@@ -3793,7 +3735,7 @@ reset_server_counts(void)
 
 } /* reset_server_counts() */
 
-
+
 /*****************************************************************************
  * Function:    resize_entry()
  *
@@ -3808,12 +3750,7 @@ reset_server_counts(void)
  * Programmer:  John Mainzer
  *              7/11/06
  *
- * Modifications:
- *
- *              None
- *
  *****************************************************************************/
-
 static void
 resize_entry(int32_t idx,
 	     size_t  new_size)
@@ -4070,8 +4007,7 @@ setup_cache_for_test(hid_t * fid_ptr,
 
     if ( success ) {
 
-	if ( H5AC_set_sync_point_done_callback(cache_ptr, verify_writes) != 
-             SUCCEED ) {
+	if ( H5AC_set_sync_point_done_callback(cache_ptr, verify_writes) != SUCCEED ) {
 
             nerrors++;
             if ( verbose ) {
@@ -4215,7 +4151,7 @@ verify_writes(int num_writes,
 
 } /* verify_writes() */
 
-
+
 /*****************************************************************************
  *
  * Function:	setup_rand()
@@ -4235,7 +4171,6 @@ verify_writes(int num_writes,
  *		Modified function to facilitate setting predefined seeds.
  *
  *****************************************************************************/
-
 static void
 setup_rand(void)
 {
@@ -4282,7 +4217,7 @@ setup_rand(void)
 
 } /* setup_rand() */
 
-
+
 /*****************************************************************************
  *
  * Function:	take_down_cache()
@@ -4298,12 +4233,7 @@ setup_rand(void)
  *
  * Programmer:	JRM -- 1/4/06
  *
- * Modifications:
- *
- *		None.
- *
  *****************************************************************************/
-
 static hbool_t
 take_down_cache(hid_t fid)
 {
@@ -4760,7 +4690,7 @@ verify_total_writes(int expected_total_writes)
 
 } /* verify_total_writes() */
 
-
+
 /*****************************************************************************
  * Function:    unlock_entry()
  *
@@ -4779,7 +4709,6 @@ verify_total_writes(int expected_total_writes)
  * 		Updated for the new local_len field in datum.
  *
  *****************************************************************************/
-
 void
 unlock_entry(H5F_t * file_ptr,
              int32_t idx,
@@ -4847,7 +4776,7 @@ unlock_entry(H5F_t * file_ptr,
 
 } /* unlock_entry() */
 
-
+
 /*****************************************************************************
  * Function:    unpin_entry()
  *
@@ -4866,7 +4795,6 @@ unlock_entry(H5F_t * file_ptr,
  * 		Added assertion that entry is pinned on entry.
  *
  *****************************************************************************/
-
 static void
 unpin_entry(H5F_t * file_ptr,
             int32_t idx,
@@ -5716,7 +5644,6 @@ smoke_check_3(int metadata_write_strategy)
 {
     const char * fcn_name = "smoke_check_3()";
     hbool_t success = TRUE;
-    int cp = 0;
     int i;
     int max_nerrors;
     int min_count;
@@ -5749,18 +5676,12 @@ smoke_check_3(int metadata_write_strategy)
 	    break;
     }
 
-    /* 0 */
-    if ( verbose ) { HDfprintf(stderr, "%d: cp = %d\n", world_mpi_rank, cp++); }
-
     nerrors = 0;
     init_data();
     reset_stats();
 
     if ( world_mpi_rank == world_server_mpi_rank ) {
 
-        /* 1 */
-        if ( verbose ) {HDfprintf(stderr, "%d: cp = %d\n", world_mpi_rank, cp++);}
-
 	if ( ! server_main() ) {
 
             /* some error occured in the server -- report failure */
@@ -5770,15 +5691,9 @@ smoke_check_3(int metadata_write_strategy)
                           world_mpi_rank, fcn_name);
             }
         }
-
-        /* 2 */
-        if ( verbose ) {HDfprintf(stderr, "%d: cp = %d\n", world_mpi_rank, cp++);}
     }
     else /* run the clients */
     {
-        /* 1 */
-        if ( verbose ) {HDfprintf(stderr, "%d: cp = %d\n", world_mpi_rank, cp++);}
-
         if ( ! setup_cache_for_test(&fid, &file_ptr, &cache_ptr,
                                     metadata_write_strategy) ) {
 
@@ -5791,9 +5706,6 @@ smoke_check_3(int metadata_write_strategy)
             }
         }
 
-        /* 2 */
-        if ( verbose ) {HDfprintf(stderr, "%d: cp = %d\n", world_mpi_rank, cp++);}
-
         min_count = 100 / ((file_mpi_rank + 1) * (file_mpi_rank + 1));
         max_count = min_count + 50;
 
@@ -5808,9 +5720,6 @@ smoke_check_3(int metadata_write_strategy)
             }
         }
 
-        /* 3 */
-        if ( verbose ) {HDfprintf(stderr, "%d: cp = %d\n", world_mpi_rank, cp++);}
-
 
         min_count = 100 / ((file_mpi_rank + 2) * (file_mpi_rank + 2));
         max_count = min_count + 50;
@@ -5850,9 +5759,6 @@ smoke_check_3(int metadata_write_strategy)
 
 	}
 
-        /* 4 */
-        if ( verbose ) {HDfprintf(stderr, "%d: cp = %d\n", world_mpi_rank, cp++);}
-
 
 	/* flush the file to be sure that we have no problems flushing
 	 * pinned entries
@@ -5865,9 +5771,6 @@ smoke_check_3(int metadata_write_strategy)
             }
         }
 
-        /* 5 */
-        if ( verbose ) {HDfprintf(stderr, "%d: cp = %d\n", world_mpi_rank, cp++);}
-
 
         min_idx = 0;
         max_idx = ((virt_num_data_entries / 10) /
@@ -5902,9 +5805,6 @@ smoke_check_3(int metadata_write_strategy)
 	    }
         }
 
-        /* 6 */
-        if ( verbose ) {HDfprintf(stderr, "%d: cp = %d\n", world_mpi_rank, cp++);}
-
         min_idx = 0;
         max_idx = ((virt_num_data_entries / 10) /
                    ((file_mpi_rank + 3) * (file_mpi_rank + 3))) - 1;
@@ -5921,9 +5821,6 @@ smoke_check_3(int metadata_write_strategy)
                                            min_idx, max_idx, 0, 100);
         }
 
-        /* 7 */
-        if ( verbose ) {HDfprintf(stderr, "%d: cp = %d\n", world_mpi_rank, cp++);}
-
         /* we can't move pinned entries, so release any local pins now. */
         local_unpin_all_entries(file_ptr, FALSE);
 
@@ -5941,9 +5838,6 @@ smoke_check_3(int metadata_write_strategy)
                                            min_count, max_count);
         }
 
-        /* 8 */
-        if ( verbose ) {HDfprintf(stderr, "%d: cp = %d\n", world_mpi_rank, cp++);}
-
         /* ...and then move them back. */
         for ( i = (virt_num_data_entries / 2) - 1; i >= 0; i-- )
         {
@@ -5955,9 +5849,6 @@ smoke_check_3(int metadata_write_strategy)
                                            min_count, max_count);
         }
 
-        /* 9 */
-        if ( verbose ) {HDfprintf(stderr, "%d: cp = %d\n", world_mpi_rank, cp++);}
-
         /* finally, do some dirty lock/unlocks while we give the cache
          * a chance t reduce its size.
          */
@@ -5980,9 +5871,6 @@ smoke_check_3(int metadata_write_strategy)
             }
         }
 
-        /* 10 */
-        if ( verbose ) {HDfprintf(stderr, "%d: cp = %d\n", world_mpi_rank, cp++);}
-
         /* release any local pins before we take down the cache. */
         local_unpin_all_entries(file_ptr, FALSE);
 
@@ -5998,9 +5886,6 @@ smoke_check_3(int metadata_write_strategy)
             }
         }
 
-        /* 11 */
-        if ( verbose ) {HDfprintf(stderr, "%d: cp = %d\n", world_mpi_rank, cp++);}
-
         /* verify that all instances of datum are back where the started
          * and are clean.
          */
@@ -6036,9 +5921,6 @@ smoke_check_3(int metadata_write_strategy)
                 }
             }
         }
-
-        /* 12 */
-        if ( verbose ) {HDfprintf(stderr, "%d: cp = %d\n", world_mpi_rank, cp++);}
     }
 
     max_nerrors = get_max_nerrors();
@@ -6400,7 +6282,6 @@ smoke_check_5(int metadata_write_strategy)
 {
     const char * fcn_name = "smoke_check_5()";
     hbool_t success = TRUE;
-    int cp = 0;
     int i;
     int max_nerrors;
     hid_t fid = -1;
@@ -6430,20 +6311,12 @@ smoke_check_5(int metadata_write_strategy)
     }
 
 
-    /* 0 */
-    if ( verbose ) { HDfprintf(stderr, "%d: cp = %d\n", world_mpi_rank, cp++); }
-
     nerrors = 0;
     init_data();
     reset_stats();
 
     if ( world_mpi_rank == world_server_mpi_rank ) {
 
-        /* 1 */
-        if ( verbose ) {
-	    HDfprintf(stderr, "%d: cp = %d\n", world_mpi_rank, cp++);
-        }
-
 	if ( ! server_main() ) {
 
             /* some error occured in the server -- report failure */
@@ -6453,20 +6326,10 @@ smoke_check_5(int metadata_write_strategy)
                           world_mpi_rank, fcn_name);
             }
         }
-
-        /* 2 */
-        if ( verbose ) {
-	    HDfprintf(stderr, "%d: cp = %d\n", world_mpi_rank, cp++);
-        }
     }
     else /* run the clients */
     {
 
-        /* 1 */
-        if ( verbose ) {
-	    HDfprintf(stderr, "%d: cp = %d\n", world_mpi_rank, cp++);
-        }
-
         if ( ! setup_cache_for_test(&fid, &file_ptr, &cache_ptr,
                                     metadata_write_strategy) ) {
 
@@ -6479,21 +6342,11 @@ smoke_check_5(int metadata_write_strategy)
             }
         }
 
-        /* 2 */
-        if ( verbose ) {
-	    HDfprintf(stderr, "%d: cp = %d\n", world_mpi_rank, cp++);
-        }
-
         for ( i = 0; i < (virt_num_data_entries / 2); i++ )
         {
             insert_entry(cache_ptr, file_ptr, i, H5AC__NO_FLAGS_SET);
         }
 
-        /* 3 */
-        if ( verbose ) {
-	    HDfprintf(stderr, "%d: cp = %d\n", world_mpi_rank, cp++);
-        }
-
 	/* flush the file so we can lock known clean entries. */
         if ( H5Fflush(fid, H5F_SCOPE_GLOBAL) < 0 ) {
             nerrors++;
@@ -6503,11 +6356,6 @@ smoke_check_5(int metadata_write_strategy)
             }
         }
 
-        /* 4 */
-        if ( verbose ) {
-	    HDfprintf(stderr, "%d: cp = %d\n", world_mpi_rank, cp++);
-        }
-
         for ( i = 0; i < (virt_num_data_entries / 4); i++ )
         {
 	    lock_entry(file_ptr, i);
@@ -6531,11 +6379,6 @@ smoke_check_5(int metadata_write_strategy)
 	    }
         }
 
-        /* 5 */
-        if ( verbose ) {
-	    HDfprintf(stderr, "%d: cp = %d\n", world_mpi_rank, cp++);
-        }
-
         for ( i = (virt_num_data_entries / 2) - 1;
               i >= (virt_num_data_entries / 4);
 	      i-- )
@@ -6560,11 +6403,6 @@ smoke_check_5(int metadata_write_strategy)
 	    unpin_entry(file_ptr, i, TRUE, FALSE, FALSE);
         }
 
-        /* 6 */
-        if ( verbose ) {
-	    HDfprintf(stderr, "%d: cp = %d\n", world_mpi_rank, cp++);
-        }
-
         if ( fid >= 0 ) {
 
             if ( ! take_down_cache(fid) ) {
@@ -6577,11 +6415,6 @@ smoke_check_5(int metadata_write_strategy)
             }
         }
 
-        /* 7 */
-        if ( verbose ) {
-	    HDfprintf(stderr, "%d: cp = %d\n", world_mpi_rank, cp++);
-        }
-
         /* verify that all instance of datum are back where the started
          * and are clean.
          */
@@ -6592,11 +6425,6 @@ smoke_check_5(int metadata_write_strategy)
             HDassert( ! (data[i].dirty) );
         }
 
-        /* 8 */
-        if ( verbose ) {
-	    HDfprintf(stderr, "%d: cp = %d\n", world_mpi_rank, cp++);
-        }
-
         /* compose the done message */
         mssg.req       = DONE_REQ_CODE;
         mssg.src       = world_mpi_rank;
@@ -6621,11 +6449,6 @@ smoke_check_5(int metadata_write_strategy)
                 }
             }
         }
-
-        /* 9 */
-        if ( verbose ) {
-	    HDfprintf(stderr, "%d: cp = %d\n", world_mpi_rank, cp++);
-        }
     }
 
     max_nerrors = get_max_nerrors();
@@ -7079,7 +6902,7 @@ trace_file_check(int metadata_write_strategy)
 
 } /* trace_file_check() */
 
-
+
 /*****************************************************************************
  *
  * Function:	main()
@@ -7092,12 +6915,7 @@ trace_file_check(int metadata_write_strategy)
  *
  * Programmer:	JRM -- 12/23/05
  *
- * Modifications:
- *
- *		None.
- *
  *****************************************************************************/
-
 int
 main(int argc, char **argv)
 {
@@ -7123,7 +6941,8 @@ main(int argc, char **argv)
      * calls.  By then, MPI calls may not work.
      */
     if (H5dont_atexit() < 0){
-	printf("Failed to turn off atexit processing. Continue.\n");
+	printf("%d:Failed to turn off atexit processing. Continue.\n", 
+               mpi_rank);
     };
     H5open();