[svn-r12774] Modified flush code in the metadata cache to allow it to

handle flush callbacks which can dirty other entries, and
resize and/or rename the target entry.

This feature is needed by the fractal heap code.

Also added associated test code.


H5Commit tested.  Test failed on heping, but the 
error appears to be a syntax error in an un-related
file.

Tests on copper & sol passed, along with tests on 
phoenix.

1 files changed, 813 insertions, 148 deletions

diff --git a/src/H5C.c b/src/H5C.c
index 8e4bb0e..498cc2f 100644
--- a/src/H5C.c
+++ b/src/H5C.c
@@ -559,10 +559,22 @@ if ( ( (entry_ptr) == NULL ) ||                                                \
 	if ( (cache_ptr)->pel_size > (cache_ptr)->max_pel_size )     \
 	    (cache_ptr)->max_pel_size = (cache_ptr)->pel_size;
 
-#define H5C__UPDATE_STATS_FOR_RENAME(cache_ptr, entry_ptr) \
+#define H5C__UPDATE_STATS_FOR_RENAME(cache_ptr, entry_ptr)               \
+	if ( cache_ptr->flush_in_progress ) {                            \
+            ((cache_ptr)->cache_flush_renames[(entry_ptr)->type->id])++; \
+	}                                                                \
+        if ( entry_ptr->flush_in_progress ) {                            \
+            ((cache_ptr)->entry_flush_renames[(entry_ptr)->type->id])++; \
+	}                                                                \
 	(((cache_ptr)->renames)[(entry_ptr)->type->id])++;
 
 #define H5C__UPDATE_STATS_FOR_ENTRY_SIZE_CHANGE(cache_ptr, entry_ptr, new_size)\
+	if ( cache_ptr->flush_in_progress ) {                                  \
+            ((cache_ptr)->cache_flush_size_changes[(entry_ptr)->type->id])++;  \
+	}                                                                      \
+        if ( entry_ptr->flush_in_progress ) {                                  \
+            ((cache_ptr)->entry_flush_size_changes[(entry_ptr)->type->id])++;  \
+	}                                                                      \
 	if ( (entry_ptr)->size < (new_size) ) {                                \
 	    ((cache_ptr)->size_increases[(entry_ptr)->type->id])++;            \
             if ( (cache_ptr)->index_size > (cache_ptr)->max_index_size )       \
@@ -571,7 +583,7 @@ if ( ( (entry_ptr) == NULL ) ||                                                \
                 (cache_ptr)->max_slist_size = (cache_ptr)->slist_size;         \
             if ( (cache_ptr)->pl_size > (cache_ptr)->max_pl_size )             \
                 (cache_ptr)->max_pl_size = (cache_ptr)->pl_size;               \
-	} else {                                                               \
+	} else if ( (entry_ptr)->size > (new_size) ) {                         \
 	    ((cache_ptr)->size_decreases[(entry_ptr)->type->id])++;            \
 	}
 
@@ -1077,9 +1089,49 @@ if ( ( (cache_ptr) == NULL ) ||                                          \
  *		JRM -- 6/27/06
  *		Added fail_val parameter.
  *
+ *		JRM -- 8/25/06
+ *		Added the H5C_DO_SANITY_CHECKS version of the macro.
+ *
+ *		This version maintains the slist_len_increase and 
+ *		slist_size_increase fields that are used in sanity
+ *		checks in the flush routines.
+ *
+ *		All this is needed as the fractal heap needs to be 
+ *		able to dirty, resize and/or rename entries during the 
+ *		flush.
+ *
  *-------------------------------------------------------------------------
  */
 
+#if H5C_DO_SANITY_CHECKS
+
+#define H5C__INSERT_ENTRY_IN_SLIST(cache_ptr, entry_ptr, fail_val)             \
+{                                                                              \
+    HDassert( (cache_ptr) );                                                   \
+    HDassert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                        \
+    HDassert( (entry_ptr) );                                                   \
+    HDassert( (entry_ptr)->size > 0 );                                         \
+    HDassert( H5F_addr_defined((entry_ptr)->addr) );                           \
+    HDassert( !((entry_ptr)->in_slist) );                                      \
+                                                                               \
+    if ( H5SL_insert((cache_ptr)->slist_ptr, entry_ptr, &(entry_ptr)->addr)    \
+                                                                         < 0 ) \
+        HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, (fail_val),                       \
+                    "Can't insert entry in skip list")                         \
+                                                                               \
+    (entry_ptr)->in_slist = TRUE;                                              \
+    (cache_ptr)->slist_len++;                                                  \
+    (cache_ptr)->slist_size += (entry_ptr)->size;                              \
+    (cache_ptr)->slist_len_increase++;                                         \
+    (cache_ptr)->slist_size_increase += (entry_ptr)->size;                     \
+                                                                               \
+    HDassert( (cache_ptr)->slist_len > 0 );                                    \
+    HDassert( (cache_ptr)->slist_size > 0 );                                   \
+                                                                               \
+} /* H5C__INSERT_ENTRY_IN_SLIST */
+
+#else /* H5C_DO_SANITY_CHECKS */
+
 #define H5C__INSERT_ENTRY_IN_SLIST(cache_ptr, entry_ptr, fail_val)             \
 {                                                                              \
     HDassert( (cache_ptr) );                                                   \
@@ -1103,6 +1155,8 @@ if ( ( (cache_ptr) == NULL ) ||                                          \
                                                                                \
 } /* H5C__INSERT_ENTRY_IN_SLIST */
 
+#endif /* H5C_DO_SANITY_CHECKS */
+
 
 /*-------------------------------------------------------------------------
  *
@@ -1169,11 +1223,21 @@ if ( ( (cache_ptr) == NULL ) ||                                          \
  *
  * Modifications:
  *
- *		None.
+ *		JRM -- 8/27/06
+ *		Added the H5C_DO_SANITY_CHECKS version of the macro.
+ *
+ *		This version maintains the slist_size_increase field 
+ *		that are used in sanity checks in the flush routines.
+ *
+ *		All this is needed as the fractal heap needs to be 
+ *		able to dirty, resize and/or rename entries during the 
+ *		flush.
  *
  *-------------------------------------------------------------------------
  */
 
+#if H5C_DO_SANITY_CHECKS
+
 #define H5C__UPDATE_SLIST_FOR_SIZE_CHANGE(cache_ptr, old_size, new_size) \
 {                                                                        \
     HDassert( (cache_ptr) );                                             \
@@ -1188,11 +1252,37 @@ if ( ( (cache_ptr) == NULL ) ||                                          \
     (cache_ptr)->slist_size -= (old_size);                               \
     (cache_ptr)->slist_size += (new_size);                               \
                                                                          \
+    (cache_ptr)->slist_size_increase -= (int64_t)(old_size);             \
+    (cache_ptr)->slist_size_increase += (int64_t)(new_size);             \
+                                                                         \
     HDassert( (new_size) <= (cache_ptr)->slist_size );                   \
     HDassert( ( (cache_ptr)->slist_len > 1 ) ||                          \
               ( (cache_ptr)->slist_size == (new_size) ) );               \
 } /* H5C__REMOVE_ENTRY_FROM_SLIST */
 
+#else /* H5C_DO_SANITY_CHECKS */
+
+#define H5C__UPDATE_SLIST_FOR_SIZE_CHANGE(cache_ptr, old_size, new_size) \
+{                                                                        \
+    HDassert( (cache_ptr) );                                             \
+    HDassert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                  \
+    HDassert( (old_size) > 0 );                                          \
+    HDassert( (new_size) > 0 );                                          \
+    HDassert( (old_size) <= (cache_ptr)->slist_size );                   \
+    HDassert( (cache_ptr)->slist_len > 0 );                              \
+    HDassert( ((cache_ptr)->slist_len > 1) ||                            \
+              ( (cache_ptr)->slist_size == (old_size) ) );               \
+                                                                         \
+    (cache_ptr)->slist_size -= (old_size);                               \
+    (cache_ptr)->slist_size += (new_size);                               \
+                                                                         \
+    HDassert( (new_size) <= (cache_ptr)->slist_size );                   \
+    HDassert( ( (cache_ptr)->slist_len > 1 ) ||                          \
+              ( (cache_ptr)->slist_size == (new_size) ) );               \
+} /* H5C__REMOVE_ENTRY_FROM_SLIST */
+
+#endif /* H5C_DO_SANITY_CHECKS */
+
 
 /**************************************************************************
  *
@@ -1997,6 +2087,127 @@ if ( ( (cache_ptr) == NULL ) ||                                          \
 
 /*-------------------------------------------------------------------------
  *
+ * Macro:	H5C__UPDATE_RP_FOR_SIZE_CHANGE
+ *
+ * Purpose:     Update the replacement policy data structures for a
+ *		size change of the specified cache entry.
+ *
+ *		To do this, determine if the entry is pinned.  If it is,
+ *		update the size of the pinned entry list.
+ *
+ *		If it isn't pinned, the entry must handled by the 
+ *		replacement policy.  Update the appropriate replacement
+ *		policy data structures.
+ *
+ *		At present, we only support the modified LRU policy, so
+ *		this function deals with that case unconditionally.  If
+ *		we ever support other replacement policies, the function
+ *		should switch on the current policy and act accordingly.
+ *
+ * Return:      N/A
+ *
+ * Programmer:  John Mainzer, 8/23/06
+ *
+ * Modifications:
+ *
+ *		None.
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#if H5C_MAINTAIN_CLEAN_AND_DIRTY_LRU_LISTS
+
+#define H5C__UPDATE_RP_FOR_SIZE_CHANGE(cache_ptr, entry_ptr, new_size)    \
+{                                                                         \
+    HDassert( (cache_ptr) );                                              \
+    HDassert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                   \
+    HDassert( (entry_ptr) );                                              \
+    HDassert( !((entry_ptr)->is_protected) );                             \
+    HDassert( (entry_ptr)->size > 0 );                                    \
+    HDassert( new_size > 0 );                                             \
+				  					  \
+    if ( (entry_ptr)->is_pinned ) {                                       \
+                                                                          \
+	H5C__DLL_UPDATE_FOR_SIZE_CHANGE((cache_ptr)->pel_len,             \
+			                (cache_ptr)->pel_size,            \
+			                (entry_ptr)->size,                \
+					(new_size));                      \
+                                                                          \
+    } else {                                                              \
+                                                                          \
+        /* modified LRU specific code */                                  \
+                                                                          \
+	/* Update the size of the LRU list */                             \
+                                                                          \
+	H5C__DLL_UPDATE_FOR_SIZE_CHANGE((cache_ptr)->LRU_list_len,        \
+			                (cache_ptr)->LRU_list_size,       \
+			                (entry_ptr)->size,                \
+					(new_size));                      \
+                                                                          \
+        /* Similarly, update the size of the clean or dirty LRU list as   \
+	 * appropriate.  At present, the entry must be clean, but that    \
+	 * could change.                                                  \
+         */                                                               \
+                                                                          \
+        if ( (entry_ptr)->is_dirty ) {                                    \
+                                                                          \
+	    H5C__DLL_UPDATE_FOR_SIZE_CHANGE((cache_ptr)->dLRU_list_len,   \
+			                    (cache_ptr)->dLRU_list_size,  \
+			                    (entry_ptr)->size,            \
+					    (new_size));                  \
+                                                                          \
+        } else {                                                          \
+                                                                          \
+	    H5C__DLL_UPDATE_FOR_SIZE_CHANGE((cache_ptr)->cLRU_list_len,   \
+			                    (cache_ptr)->cLRU_list_size,  \
+			                    (entry_ptr)->size,            \
+					    (new_size));                  \
+        }                                                                 \
+                                                                          \
+        /* End modified LRU specific code. */                             \
+    }                                                                     \
+                                                                          \
+} /* H5C__UPDATE_RP_FOR_SIZE_CHANGE */
+
+#else /* H5C_MAINTAIN_CLEAN_AND_DIRTY_LRU_LISTS */
+
+#define H5C__UPDATE_RP_FOR_SIZE_CHANGE(cache_ptr, entry_ptr, new_size)    \
+{                                                                         \
+    HDassert( (cache_ptr) );                                              \
+    HDassert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                   \
+    HDassert( (entry_ptr) );                                              \
+    HDassert( !((entry_ptr)->is_protected) );                             \
+    HDassert( (entry_ptr)->size > 0 );                                    \
+    HDassert( new_size > 0 );                                             \
+				  					  \
+    if ( (entry_ptr)->is_pinned ) {                                       \
+                                                                          \
+	H5C__DLL_UPDATE_FOR_SIZE_CHANGE((cache_ptr)->pel_len,             \
+			                (cache_ptr)->pel_size,            \
+			                (entry_ptr)->size,                \
+					(new_size));                      \
+                                                                          \
+    } else {                                                              \
+                                                                          \
+        /* modified LRU specific code */                                  \
+                                                                          \
+	/* Update the size of the LRU list */                             \
+                                                                          \
+	H5C__DLL_UPDATE_FOR_SIZE_CHANGE((cache_ptr)->LRU_list_len,        \
+			                (cache_ptr)->LRU_list_size,       \
+			                (entry_ptr)->size,                \
+					(new_size));                      \
+                                                                          \
+        /* End modified LRU specific code. */                             \
+    }                                                                     \
+                                                                          \
+} /* H5C__UPDATE_RP_FOR_SIZE_CHANGE */
+
+#endif /* H5C_MAINTAIN_CLEAN_AND_DIRTY_LRU_LISTS */
+
+
+/*-------------------------------------------------------------------------
+ *
  * Macro:	H5C__UPDATE_RP_FOR_UNPIN
  *
  * Purpose:     Update the replacement policy data structures for an
@@ -2352,7 +2563,8 @@ static herr_t H5C_verify_not_in_index(H5C_t * cache_ptr,
 static void *H5C_epoch_marker_load(H5F_t *f, hid_t dxpl_id, haddr_t addr,
                                    const void *udata1, void *udata2);
 static herr_t H5C_epoch_marker_flush(H5F_t *f, hid_t dxpl_id, hbool_t dest,
-                                     haddr_t addr, void *thing);
+                                     haddr_t addr, void *thing, 
+				     unsigned *flags_ptr);
 static herr_t H5C_epoch_marker_dest(H5F_t *f, void *thing);
 static herr_t H5C_epoch_marker_clear(H5F_t *f, void *thing, hbool_t dest);
 static herr_t H5C_epoch_marker_size(const H5F_t *f, const void *thing, size_t *size_ptr);
@@ -2377,11 +2589,11 @@ const H5C_class_t epoch_marker_class =
  ***************************************************************************/
 
 static void *
-H5C_epoch_marker_load(UNUSED H5F_t *f,
-                      UNUSED hid_t dxpl_id,
-                      UNUSED haddr_t addr,
-                      UNUSED const void *udata1,
-                      UNUSED void *udata2)
+H5C_epoch_marker_load(H5F_t UNUSED * f,
+                      hid_t UNUSED dxpl_id,
+                      haddr_t UNUSED addr,
+                      const void UNUSED * udata1,
+                      void UNUSED * udata2)
 {
     void * ret_value = NULL;      /* Return value */
 
@@ -2395,11 +2607,12 @@ done:
 }
 
 static herr_t
-H5C_epoch_marker_flush(UNUSED H5F_t *f,
-                       UNUSED hid_t dxpl_id,
-                       UNUSED hbool_t dest,
-                       UNUSED haddr_t addr,
-                       UNUSED void *thing)
+H5C_epoch_marker_flush(H5F_t UNUSED *f,
+                       hid_t UNUSED dxpl_id,
+                       hbool_t UNUSED dest,
+                       haddr_t UNUSED addr,
+                       void UNUSED *thing,
+		       unsigned UNUSED * flags_ptr)
 {
     herr_t ret_value = FAIL;      /* Return value */
 
@@ -2413,8 +2626,8 @@ done:
 }
 
 static herr_t
-H5C_epoch_marker_dest(UNUSED H5F_t *f,
-                      UNUSED void *thing)
+H5C_epoch_marker_dest(H5F_t UNUSED * f,
+                      void UNUSED * thing)
 {
     herr_t ret_value = FAIL;      /* Return value */
 
@@ -2428,9 +2641,9 @@ done:
 }
 
 static herr_t
-H5C_epoch_marker_clear(UNUSED H5F_t *f,
-                       UNUSED void *thing,
-                       UNUSED hbool_t dest)
+H5C_epoch_marker_clear(H5F_t UNUSED * f,
+                       void UNUSED * thing,
+                       hbool_t UNUSED dest)
 {
     herr_t ret_value = FAIL;      /* Return value */
 
@@ -2444,9 +2657,9 @@ done:
 }
 
 static herr_t
-H5C_epoch_marker_size(UNUSED const H5F_t *f,
-                      UNUSED const void *thing,
-                      UNUSED size_t *size_ptr)
+H5C_epoch_marker_size(const H5F_t UNUSED * f,
+                      const void UNUSED * thing,
+                      size_t UNUSED * size_ptr)
 {
     herr_t ret_value = FAIL;      /* Return value */
 
@@ -2518,6 +2731,15 @@ done:
  *		JRM -- 5/31/06
  *		Added initialization for the trace_file_ptr field.
  *
+ *		JRM -- 8/19/06
+ *		Added initialization for the flush_in_progress field.
+ *
+ *		JRM -- 8/25/06
+ *		Added initialization for the slist_len_increase and
+ *		slist_size_increase fields.  These fields are used 
+ *		for sanity checking in the flush process, and are not
+ *		compiled in unless H5C_DO_SANITY_CHECKS is TRUE.
+ *
  *-------------------------------------------------------------------------
  */
 
@@ -2572,6 +2794,8 @@ H5C_create(size_t		      max_cache_size,
 
     cache_ptr->magic 				= H5C__H5C_T_MAGIC;
 
+    cache_ptr->flush_in_progress		= FALSE;
+
     cache_ptr->trace_file_ptr			= NULL;
 
     cache_ptr->aux_ptr				= aux_ptr;
@@ -2593,6 +2817,11 @@ H5C_create(size_t		      max_cache_size,
     cache_ptr->slist_len			= 0;
     cache_ptr->slist_size			= (size_t)0;
 
+#if H5C_DO_SANITY_CHECKS
+    cache_ptr->slist_len_increase		= 0;
+    cache_ptr->slist_size_increase		= 0;
+#endif /* H5C_DO_SANITY_CHECKS */
+
     for ( i = 0; i < H5C__HASH_TABLE_LEN; i++ )
     {
         (cache_ptr->index)[i] = NULL;
@@ -2754,7 +2983,7 @@ H5C_def_auto_resize_rpt_fcn(H5C_t * cache_ptr,
 #ifndef NDEBUG
                             int32_t version,
 #else /* NDEBUG */
-                            UNUSED int32_t version,
+                            int32_t UNUSED version,
 #endif /* NDEBUG */
                             double hit_rate,
                             enum H5C_resize_status status,
@@ -3193,9 +3422,18 @@ done:
  *		Note that even with this flag set, it is still an error
  *		to try to flush a protected entry.
  *
- *		JRM -- 3/25/065
+ *		JRM -- 3/25/06
  *		Updated function to handle pinned entries.
  *
+ *		JRM -- 8/19/06
+ *		Added code managing the new flush_in_progress field of 
+ *		H5C_t.
+ *
+ *		Also reworked function to allow for the possibility that
+ *		entries will be dirtied, resized, or renamed during flush
+ *		callbacks.  As a result, we may have to make multiple 
+ *		passes through the skip list before the cache is flushed.
+ *
  *-------------------------------------------------------------------------
  */
 herr_t
@@ -3208,18 +3446,20 @@ H5C_flush_cache(H5F_t *  f,
     herr_t              status;
     herr_t		ret_value = SUCCEED;
     hbool_t             destroy;
+    hbool_t		flushed_entries_last_pass;
     hbool_t		flush_marked_entries;
     hbool_t		first_flush = TRUE;
     hbool_t		ignore_protected;
     hbool_t		tried_to_flush_protected_entry = FALSE;
+    int32_t		passes = 0;
     int32_t		protected_entries = 0;
     H5SL_node_t * 	node_ptr = NULL;
     H5C_cache_entry_t *	entry_ptr = NULL;
 #if H5C_DO_SANITY_CHECKS
-    int32_t		actual_slist_len = 0;
-    int32_t		initial_slist_len = 0;
-    size_t              actual_slist_size = 0;
-    size_t              initial_slist_size = 0;
+    int64_t		flushed_entries_count;
+    size_t		flushed_entries_size;
+    int64_t		initial_slist_len;
+    size_t              initial_slist_size;
 #endif /* H5C_DO_SANITY_CHECKS */
 
     FUNC_ENTER_NOAPI(H5C_flush_cache, FAIL)
@@ -3241,6 +3481,10 @@ H5C_flush_cache(H5F_t *  f,
 
     HDassert( ! ( destroy && ignore_protected ) );
 
+    HDassert( ! ( cache_ptr->flush_in_progress ) );
+
+    cache_ptr->flush_in_progress = TRUE;
+
     if ( destroy ) {
 
         status = H5C_flush_invalidate_cache(f,
@@ -3258,103 +3502,160 @@ H5C_flush_cache(H5F_t *  f,
 			"flush invalidate failed.")
         }
     } else {
-
-        if ( cache_ptr->slist_len == 0 ) {
-
-            node_ptr = NULL;
-            HDassert( cache_ptr->slist_size == 0 );
-
-        } else {
-
+	/* When we are only flushing marked entries, the slist will usually
+	 * still contain entries when we have flushed everything we should.
+	 * Thus we track whether we have flushed any entries in the last
+	 * pass, and terminate if we haven't.
+	 */
+
+	flushed_entries_last_pass = TRUE;
+
+        while ( ( passes < H5C__MAX_PASSES_ON_FLUSH ) &&
+		( cache_ptr->slist_len != 0 ) &&
+		( protected_entries == 0 ) &&
+		( flushed_entries_last_pass ) )
+	{
+	    flushed_entries_last_pass = FALSE;
             node_ptr = H5SL_first(cache_ptr->slist_ptr);
+       
+	    HDassert( node_ptr != NULL );
 
 #if H5C_DO_SANITY_CHECKS
-            /* H5C_flush_single_entry() now removes dirty entries from the
-             * slist as it flushes them.  Thus for sanity checks we must
-             * make note of the initial slist length and size before we
-             * do any flushes.
-             */
+	    /* For sanity checking, try to verify that the skip list has
+	     * the expected size and number of entries at the end of each
+	     * internal while loop (see below).
+	     *
+	     * Doing this get a bit tricky, as depending on flags, we may
+	     * or may not flush all the entries in the slist.
+	     *
+	     * To make things more entertaining, with the advent of the
+	     * fractal heap, the entry flush callback can cause entries
+	     * to be dirtied, resized, and/or renamed.
+	     *
+	     * To deal with this, we first make note of the initial 
+	     * skip list length and size:
+	     */
             initial_slist_len = cache_ptr->slist_len;
             initial_slist_size = cache_ptr->slist_size;
-#endif /* H5C_DO_SANITY_CHECKS */
-
-        }
-
-        while ( node_ptr != NULL )
-        {
-            entry_ptr = (H5C_cache_entry_t *)H5SL_item(node_ptr);
-
-            /* increment node pointer now, before we delete its target
-             * from the slist.
-             */
-            node_ptr = H5SL_next(node_ptr);
-
-            HDassert( entry_ptr != NULL );
-            HDassert( entry_ptr->in_slist );
 
-#if H5C_DO_SANITY_CHECKS
-            actual_slist_len++;
-            actual_slist_size += entry_ptr->size;
+	    /* We then zero counters that we use to track the number
+	     * and total size of entries flushed:
+	     */
+            flushed_entries_count = 0;
+            flushed_entries_size = 0;
+
+	    /* As mentioned above, there is the possibility that 
+	     * entries will be dirtied, resized, and/or flushed during
+	     * our pass through the skip list.  To capture the number 
+	     * of entries added, and the skip list size delta, 
+	     * zero the slist_len_increase and slist_size_increase of
+	     * the cache's instance of H5C_t.  These fields will be 
+	     * updated elsewhere to account for slist insertions and/or
+	     * dirty entry size changes.
+	     */
+	    cache_ptr->slist_len_increase = 0;
+	    cache_ptr->slist_size_increase = 0;
+
+	    /* at the end of the loop, use these values to compute the
+	     * expected slist length and size and compare this with the
+	     * value recorded in the cache's instance of H5C_t.
+	     */
 #endif /* H5C_DO_SANITY_CHECKS */
 
-            if ( ( ! flush_marked_entries ) || ( entry_ptr->flush_marker ) ) {
+	    while ( node_ptr != NULL )
+	    {
+                entry_ptr = (H5C_cache_entry_t *)H5SL_item(node_ptr);
 
-                if ( entry_ptr->is_protected ) {
+                /* increment node pointer now, before we delete its target
+                 * from the slist.
+                 */
+                node_ptr = H5SL_next(node_ptr);
 
-                    /* we probably have major problems -- but lets flush
-                     * everything we can before we decide whether to flag
-                     * an error.
-                     */
-                    tried_to_flush_protected_entry = TRUE;
-	            protected_entries++;
+                HDassert( entry_ptr != NULL );
+                HDassert( entry_ptr->in_slist );
 
-                } else {
+                if ( ( ! flush_marked_entries ) || 
+                     ( entry_ptr->flush_marker ) ) {
 
-                    status = H5C_flush_single_entry(f,
-                                                    primary_dxpl_id,
-                                                    secondary_dxpl_id,
-                                                    cache_ptr,
-                                                    NULL,
-                                                    entry_ptr->addr,
-                                                    flags,
-                                                    &first_flush,
-                                                    FALSE);
-                    if ( status < 0 ) {
+                    if ( entry_ptr->is_protected ) {
 
-                        /* This shouldn't happen -- if it does, we are toast so
-                         * just scream and die.
+                        /* we probably have major problems -- but lets flush
+                         * everything we can before we decide whether to flag
+                         * an error.
                          */
-                        HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, \
-                                    "Can't flush entry.")
+                        tried_to_flush_protected_entry = TRUE;
+	                protected_entries++;
+
+                    } else {
+#if H5C_DO_SANITY_CHECKS
+                        flushed_entries_count++;
+			flushed_entries_size += entry_ptr->size;
+#endif /* H5C_DO_SANITY_CHECKS */
+                        status = H5C_flush_single_entry(f,
+                                                        primary_dxpl_id,
+                                                        secondary_dxpl_id,
+                                                        cache_ptr,
+                                                        NULL,
+                                                        entry_ptr->addr,
+                                                        flags,
+                                                        &first_flush,
+                                                        FALSE);
+                        if ( status < 0 ) {
+
+                            /* This shouldn't happen -- if it does, we are 
+			     * toast so just scream and die.
+                             */
+                            HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, \
+                                        "Can't flush entry.")
+                        }
+			flushed_entries_last_pass = TRUE;
                     }
                 }
-            }
-        } /* while */
+            } /* while ( node_ptr != NULL ) */
 
 #if H5C_DO_SANITY_CHECKS
-        HDassert( actual_slist_len == initial_slist_len );
-        HDassert( actual_slist_size == initial_slist_size );
-
-        if ( ! flush_marked_entries ) {
+            /* Verify that the slist size and length are as expected. */
 
-            HDassert( cache_ptr->slist_len == 0 );
-            HDassert( cache_ptr->slist_size == 0 );
-        }
+	    HDassert( (initial_slist_len + cache_ptr->slist_len_increase - 
+                       flushed_entries_count) == cache_ptr->slist_len );
+	    HDassert( (initial_slist_size + cache_ptr->slist_size_increase -
+		       flushed_entries_size) == cache_ptr->slist_size );
 #endif /* H5C_DO_SANITY_CHECKS */
 
+	    passes++;
+
+	} /* while */
+
         HDassert( protected_entries <= cache_ptr->pl_len );
 
         if ( ( ( cache_ptr->pl_len > 0 ) && ( !ignore_protected ) )
              ||
              ( tried_to_flush_protected_entry ) ) {
 
-            HGOTO_ERROR(H5E_CACHE, H5E_PROTECT, FAIL, \
+            HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, \
 		        "cache has protected items")
         }
-    }
+
+	if ( ( cache_ptr->slist_len != 0 ) &&
+	     ( passes >= H5C__MAX_PASSES_ON_FLUSH ) ) {
+
+            HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, \
+		        "flush pass limit exceeded.")
+	}
+
+#if H5C_DO_SANITY_CHECKS
+        if ( ! flush_marked_entries ) {
+
+            HDassert( cache_ptr->slist_len == 0 );
+            HDassert( cache_ptr->slist_size == 0 );
+        }
+#endif /* H5C_DO_SANITY_CHECKS */
+
+   }
 
 done:
 
+    cache_ptr->flush_in_progress = FALSE;
 
     FUNC_LEAVE_NOAPI(ret_value)
 
@@ -3964,6 +4265,10 @@ done:
  *		JRM -- 8/9/06
  *		Added code supporting insertion of pinned entries.
  *
+ *		JRM -- 8/21/06
+ *		Added initialization for the new flush_in_progress and
+ *		destroy_in_progress fields.
+ *
  *-------------------------------------------------------------------------
  */
 
@@ -4040,6 +4345,9 @@ H5C_insert_entry(H5F_t * 	     f,
     entry_ptr->clear_on_unprotect = FALSE;
 #endif /* H5_HAVE_PARALLEL */
 
+    entry_ptr->flush_in_progress = FALSE;
+    entry_ptr->destroy_in_progress = FALSE;
+
     entry_ptr->ht_next = NULL;
     entry_ptr->ht_prev = NULL;
 
@@ -4702,6 +5010,15 @@ done:
  *		JRM -- 4/27/06
  *		Updated function to support renaming of pinned entries.
  *
+ *		JRM -- 8/24/06
+ *		Updated function to refrain from alterning the index, the
+ *		replacement policy data structures, and skip list when
+ *              the function is called within the flush callback for the
+ *              target entry and the target entry is being destroyed.
+ *
+ *              Note that in this case H5C_flush_single_entry() will handle
+ *              all these details for us.
+ *
  *-------------------------------------------------------------------------
  */
 
@@ -4715,6 +5032,9 @@ H5C_rename_entry(H5C_t *	     cache_ptr,
     hbool_t		was_dirty;
     H5C_cache_entry_t *	entry_ptr = NULL;
     H5C_cache_entry_t *	test_entry_ptr = NULL;
+#if H5C_DO_SANITY_CHECKS
+    hbool_t		removed_entry_from_slist = FALSE;
+#endif /* H5C_DO_SANITY_CHECKS */
 
     FUNC_ENTER_NOAPI(H5C_rename_entry, FAIL)
 
@@ -4733,7 +5053,6 @@ H5C_rename_entry(H5C_t *	     cache_ptr,
         }
 #endif /* H5C_DO_EXTREME_SANITY_CHECKS */
 
-
     H5C__SEARCH_INDEX(cache_ptr, old_addr, entry_ptr, FAIL)
 
     if ( ( entry_ptr == NULL ) || ( entry_ptr->type != type ) ) {
@@ -4768,7 +5087,7 @@ H5C_rename_entry(H5C_t *	     cache_ptr,
         }
     }
 
-    /* If we get this far, we have work to do.  Remove *entry_ptr from
+    /* If we get this far we have work to do.  Remove *entry_ptr from
      * the hash table (and skip list if necessary), change its address to the
      * new address, mark it as dirty (if it isn't already) and then re-insert.
      *
@@ -4777,26 +5096,69 @@ H5C_rename_entry(H5C_t *	     cache_ptr,
      *
      * Note that we do not check the size of the cache, or evict anything.
      * Since this is a simple re-name, cache size should be unaffected.
+     *
+     * Check to see if the target entry is in the process of being destroyed
+     * before we delete from the index, etc.  If it is, all we do is 
+     * change the addr.  If the entry is only in the process of being flushed,
+     * don't mark it as dirty either, lest we confuse the flush call back.
      */
 
-    H5C__DELETE_FROM_INDEX(cache_ptr, entry_ptr)
+    if ( ! ( entry_ptr->destroy_in_progress ) ) {
+
+        H5C__DELETE_FROM_INDEX(cache_ptr, entry_ptr)
 
-    if ( entry_ptr->in_slist ) {
+        if ( entry_ptr->in_slist ) {
+
+            HDassert( cache_ptr->slist_ptr );
+
+            H5C__REMOVE_ENTRY_FROM_SLIST(cache_ptr, entry_ptr)
+
+#if H5C_DO_SANITY_CHECKS
 
-        HDassert( cache_ptr->slist_ptr );
+            removed_entry_from_slist = TRUE;
 
-        H5C__REMOVE_ENTRY_FROM_SLIST(cache_ptr, entry_ptr)
+#endif /* H5C_DO_SANITY_CHECKS */
+        }
     }
 
     entry_ptr->addr = new_addr;
-    was_dirty = entry_ptr->is_dirty;
-    entry_ptr->is_dirty = TRUE;
 
-    H5C__INSERT_IN_INDEX(cache_ptr, entry_ptr, FAIL)
+    if ( ! ( entry_ptr->destroy_in_progress ) ) {
+
+        was_dirty = entry_ptr->is_dirty;
 
-    H5C__INSERT_ENTRY_IN_SLIST(cache_ptr, entry_ptr, FAIL)
+	if ( ! ( entry_ptr->flush_in_progress ) ) {
 
-    H5C__UPDATE_RP_FOR_RENAME(cache_ptr, entry_ptr, was_dirty, FAIL)
+            entry_ptr->is_dirty = TRUE;
+	}
+
+        H5C__INSERT_IN_INDEX(cache_ptr, entry_ptr, FAIL)
+
+	if ( ! ( entry_ptr->flush_in_progress ) ) {
+
+            H5C__INSERT_ENTRY_IN_SLIST(cache_ptr, entry_ptr, FAIL)
+
+#if H5C_DO_SANITY_CHECKS
+
+            if ( removed_entry_from_slist ) {
+
+		/* we just removed the entry from the slist.  Thus we 
+		 * must touch up cache_ptr->slist_len_increase and
+		 * cache_ptr->slist_size_increase to keep from skewing
+		 * the sanity checks.
+		 */
+		HDassert( cache_ptr->slist_len_increase > 1 );
+		HDassert( cache_ptr->slist_size_increase > entry_ptr->size );
+
+		cache_ptr->slist_len_increase -= 1;
+		cache_ptr->slist_size_increase -= entry_ptr->size;
+	    }
+
+#endif /* H5C_DO_SANITY_CHECKS */
+
+            H5C__UPDATE_RP_FOR_RENAME(cache_ptr, entry_ptr, was_dirty, FAIL)
+	}
+    }
 
     H5C__UPDATE_STATS_FOR_RENAME(cache_ptr, entry_ptr)
 
@@ -5773,6 +6135,9 @@ done:
  *		JRM -- 8/9/06
  *		More code supporting pinned entry related stats.
  *
+ *		JRM -- 8/23/06
+ *		Added code supporting new flush related statistics.
+ *
  *-------------------------------------------------------------------------
  */
 
@@ -5797,8 +6162,12 @@ H5C_stats(H5C_t * cache_ptr,
     int64_t     total_flushes = 0;
     int64_t     total_evictions = 0;
     int64_t     total_renames = 0;
+    int64_t     total_entry_flush_renames = 0;
+    int64_t     total_cache_flush_renames = 0;
     int64_t	total_size_increases = 0;
     int64_t	total_size_decreases = 0;
+    int64_t	total_entry_flush_size_changes = 0;
+    int64_t	total_cache_flush_size_changes = 0;
     int64_t	total_pins = 0;
     int64_t	total_unpins = 0;
     int64_t	total_dirty_pins = 0;
@@ -5839,8 +6208,16 @@ H5C_stats(H5C_t * cache_ptr,
         total_flushes           += cache_ptr->flushes[i];
         total_evictions         += cache_ptr->evictions[i];
         total_renames           += cache_ptr->renames[i];
+	total_entry_flush_renames
+				+= cache_ptr->entry_flush_renames[i];
+	total_cache_flush_renames
+				+= cache_ptr->cache_flush_renames[i];
         total_size_increases    += cache_ptr->size_increases[i];
         total_size_decreases    += cache_ptr->size_decreases[i];
+    	total_entry_flush_size_changes 
+				+= cache_ptr->entry_flush_size_changes[i];
+    	total_cache_flush_size_changes 
+				+= cache_ptr->cache_flush_size_changes[i];
 	total_pins              += cache_ptr->pins[i];
 	total_unpins            += cache_ptr->unpins[i];
 	total_dirty_pins        += cache_ptr->dirty_pins[i];
@@ -5981,11 +6358,22 @@ H5C_stats(H5C_t * cache_ptr,
               (long)total_pinned_insertions,
               (long)total_renames);
 
+    HDfprintf(stdout, 
+	      "%s  Total entry / cache flush renames  = %ld / %ld\n",
+              cache_ptr->prefix,
+              (long)total_entry_flush_renames,
+              (long)total_cache_flush_renames);
+
     HDfprintf(stdout, "%s  Total entry size incrs / decrs     = %ld / %ld\n",
               cache_ptr->prefix,
               (long)total_size_increases,
               (long)total_size_decreases);
 
+    HDfprintf(stdout, "%s  Ttl entry/cache flush size changes = %ld / %ld\n",
+              cache_ptr->prefix,
+              (long)total_entry_flush_size_changes,
+              (long)total_cache_flush_size_changes);
+
     HDfprintf(stdout,
 	      "%s  Total entry pins (dirty) / unpins  = %ld (%ld) / %ld\n",
               cache_ptr->prefix,
@@ -6058,12 +6446,25 @@ H5C_stats(H5C_t * cache_ptr,
                       (long)(cache_ptr->renames[i]));
 
             HDfprintf(stdout,
+                      "%s    entry / cache flush renames    = %ld / %ld\n",
+                      cache_ptr->prefix,
+                      (long)(cache_ptr->entry_flush_renames[i]),
+                      (long)(cache_ptr->cache_flush_renames[i]));
+
+            HDfprintf(stdout,
                       "%s    size increases / decreases     = %ld / %ld\n",
                       cache_ptr->prefix,
                       (long)(cache_ptr->size_increases[i]),
                       (long)(cache_ptr->size_decreases[i]));
 
             HDfprintf(stdout,
+                      "%s    entry/cache flush size changes = %ld / %ld\n",
+                      cache_ptr->prefix,
+                      (long)(cache_ptr->entry_flush_size_changes[i]),
+                      (long)(cache_ptr->cache_flush_size_changes[i]));
+
+
+            HDfprintf(stdout,
                       "%s    entry pins / unpins            = %ld / %ld\n",
                       cache_ptr->prefix,
                       (long)(cache_ptr->pins[i]),
@@ -6135,6 +6536,9 @@ done:
  *		JRM - 8/9/06 
  *		Further updates for pin related statistics.
  *
+ *		JRM 8/23/08
+ *		Added initialization code for new flush related statistics.
+ *
  *-------------------------------------------------------------------------
  */
 
@@ -6159,6 +6563,8 @@ H5C_stats__reset(H5C_t * cache_ptr)
         cache_ptr->flushes[i]			= 0;
         cache_ptr->evictions[i]	 		= 0;
         cache_ptr->renames[i]	 		= 0;
+        cache_ptr->entry_flush_renames[i]	= 0;
+        cache_ptr->cache_flush_renames[i]	= 0;
         cache_ptr->pins[i]	 		= 0;
         cache_ptr->unpins[i]	 		= 0;
         cache_ptr->dirty_pins[i]	 	= 0;
@@ -6166,6 +6572,8 @@ H5C_stats__reset(H5C_t * cache_ptr)
         cache_ptr->pinned_clears[i]	 	= 0;
         cache_ptr->size_increases[i] 		= 0;
         cache_ptr->size_decreases[i] 		= 0;
+	cache_ptr->entry_flush_size_changes[i]	= 0;
+	cache_ptr->cache_flush_size_changes[i]	= 0;
     }
 
     cache_ptr->total_ht_insertions		= 0;
@@ -7971,7 +8379,11 @@ done:
  *
  * Modifications:
  *
- *		None.
+ *		 To support the fractal heap, the cache must now deal with
+ *		 entries being dirtied, resized, and/or renamed inside
+ *		 flush callbacks.  Updated function to support this.
+ *
+ *		                                     -- JRM 8/27/06
  *
  *-------------------------------------------------------------------------
  */
@@ -7984,6 +8396,7 @@ H5C_flush_invalidate_cache(H5F_t *  f,
 {
     herr_t              status;
     herr_t		ret_value = SUCCEED;
+    hbool_t		done = FALSE;
     hbool_t		first_flush = TRUE;
     hbool_t		first_pass = TRUE;
     hbool_t		have_pinned_entries;
@@ -7991,13 +8404,14 @@ H5C_flush_invalidate_cache(H5F_t *  f,
     int32_t		i;
     int32_t		cur_pel_len;
     int32_t		old_pel_len;
+    int32_t		passes = 0;
     unsigned		cooked_flags;
     H5SL_node_t * 	node_ptr = NULL;
     H5C_cache_entry_t *	entry_ptr = NULL;
     H5C_cache_entry_t *	next_entry_ptr = NULL;
 #if H5C_DO_SANITY_CHECKS
-    int32_t		actual_slist_len = 0;
-    int32_t		initial_slist_len = 0;
+    int64_t		actual_slist_len = 0;
+    int64_t		initial_slist_len = 0;
     size_t              actual_slist_size = 0;
     size_t              initial_slist_size = 0;
 #endif /* H5C_DO_SANITY_CHECKS */
@@ -8026,15 +8440,51 @@ H5C_flush_invalidate_cache(H5F_t *  f,
         }
     }
 
+    /* The flush proceedure here is a bit strange.
+     *
+     * In the outer while loop we make at least one pass through the 
+     * cache, and then repeat until either all the pinned entries
+     * unpin themselves, or until the number of pinned entries stops
+     * declining.  In this later case, we scream and die.
+     *
+     * Since the fractal heap can dirty, resize, and/or rename entries
+     * in is flush callback, it is possible that the cache will still
+     * contain dirty entries at this point.  If so, we must make up to 
+     * H5C__MAX_PASSES_ON_FLUSH more passes through the skip list 
+     * to allow it to empty.  If is is not empty at this point, we again
+     * scream and die.
+     *
+     * Further, since clean entries can be dirtied, resized, and/or renamed 
+     * as the result of a flush call back (either the entries own, or that
+     * for some other cache entry), we can no longer promise to flush 
+     * the cache entries in increasing address order.
+     *
+     * Instead, we just do the best we can -- making a pass through
+     * the skip list, and then a pass through the "clean" entries, and 
+     * then repeating as needed.  Thus it is quite possible that an 
+     * entry will be evicted from the cache only to be re-loaded later
+     * in the flush process (From what Quincey tells me, the pin 
+     * mechanism makes this impossible, but even it it is true now, 
+     * we shouldn't count on it in the future.)
+     *
+     * The bottom line is that entries will probably be flushed in close
+     * to increasing address order, but there are no guarantees.
+     */
+
     cur_pel_len = cache_ptr->pel_len;
     old_pel_len = cache_ptr->pel_len;
 
-    while ( ( first_pass ) ||
-            ( ( cur_pel_len < old_pel_len ) && ( protected_entries == 0 ) ) )
+    while ( ! done )
     {
+        first_pass = FALSE;
+
 	have_pinned_entries = ( cur_pel_len > 0 );
 
-	/* first, try to flush-destroy any dirty entries */
+	/* first, try to flush-destroy any dirty entries.   Do this by
+	 * making a scan through the slist.  Note that new dirty entries 
+	 * may be created by the flush call backs.  Thus it is possible
+	 * that the slist will not be empty after we finish the scan.
+	 */ 
 
         if ( cache_ptr->slist_len == 0 ) {
 
@@ -8045,18 +8495,36 @@ H5C_flush_invalidate_cache(H5F_t *  f,
 
             node_ptr = H5SL_first(cache_ptr->slist_ptr);
 
+        }
 #if H5C_DO_SANITY_CHECKS
-            /* Depending on circumstances, H5C_flush_single_entry() will
-	     * remove dirty entries from the slist as it flushes them.
-	     * Thus for sanity checks we must make note of the initial
-	     * slist length and size before we do any flushes.
-             */
-            initial_slist_len = cache_ptr->slist_len;
-            initial_slist_size = cache_ptr->slist_size;
+        /* Depending on circumstances, H5C_flush_single_entry() will
+         * remove dirty entries from the slist as it flushes them.
+         * Thus for sanity checks we must make note of the initial
+         * slist length and size before we do any flushes.
+         */
+        initial_slist_len = cache_ptr->slist_len;
+        initial_slist_size = cache_ptr->slist_size;
+
+        /* There is also the possibility that entries will be
+         * dirtied, resized, and/or renamed as the result of
+         * calls to the flush callbacks.  We use the slist_len_increase
+         * and slist_size_increase increase fields in struct H5C_t
+         * to track these changes for purpose of sanity checking.
+         * To this end, we must zero these fields before we start
+         * the pass through the slist.
+         */
+        cache_ptr->slist_len_increase = 0;
+        cache_ptr->slist_size_increase = 0;
+
+	/* Finally, reset the actual_slist_len and actual_slist_size
+	 * fields to zero, as these fields are used to accumulate
+	 * the slist lenght and size that we see as we scan through
+	 * the slist.
+	 */
+	actual_slist_len = 0;
+	actual_slist_size = 0;
 #endif /* H5C_DO_SANITY_CHECKS */
 
-        }
-
         while ( node_ptr != NULL )
         {
 	    /* Note that we now remove nodes from the slist as we flush
@@ -8064,14 +8532,10 @@ H5C_flush_invalidate_cache(H5F_t *  f,
              * until we are done, and then destroying all nodes in
              * the slist.
              *
-             * While this optimization is still easy if everything works,
-             * the addition of pinned entries and multiple passes
-             * through the cache to allow entries to unpin themselves
-             * complicates error recover greatly.
-             *
-             * Given these complications, I've decided to ommit this
-	     * this optimization for now.  It can be re-implemented
-             * later if needed.
+             * While this optimization used to be easy, with the possibility
+	     * of new entries being added to the slist in the midst of the 
+	     * flush, we must keep the slist in cannonical form at all 
+	     * times.
              */
 
             entry_ptr = (H5C_cache_entry_t *)H5SL_item(node_ptr);
@@ -8085,6 +8549,16 @@ H5C_flush_invalidate_cache(H5F_t *  f,
             HDassert( entry_ptr->in_slist );
 
 #if H5C_DO_SANITY_CHECKS
+            /* update actual_slist_len & actual_slist_size before
+	     * the flush.  Note that the entry will be removed
+	     * from the slist after the flush, and thus may be
+	     * resized by the flush callback.  This is OK, as
+	     * we will catch the size delta in
+	     * cache_ptr->slist_size_increase.
+	     *
+	     * Note that we include pinned entries in this count, even
+	     * though we will not actually flush them.  
+	     */
             actual_slist_len++;
             actual_slist_size += entry_ptr->size;
 #endif /* H5C_DO_SANITY_CHECKS */
@@ -8103,8 +8577,11 @@ H5C_flush_invalidate_cache(H5F_t *  f,
                  * H5C_flush_single_entry() to destroy the entry
                  * as pinned entries can't be evicted.
                  */
-		if ( TRUE ) { /* insert test here */ /* JRM */
-
+		if ( TRUE ) { /* When we get to multithreaded cache,
+			       * we will need either locking code, and/or 
+			       * a test to see if the entry is in flushable
+			       * condition here.
+			       */
 
                     status = H5C_flush_single_entry(f,
                                                     primary_dxpl_id,
@@ -8114,12 +8591,13 @@ H5C_flush_invalidate_cache(H5F_t *  f,
                                                     entry_ptr->addr,
                                                     H5C__NO_FLAGS_SET,
                                                     &first_flush,
-                                                    TRUE);
+                                                    FALSE);
                     if ( status < 0 ) {
 
                         /* This shouldn't happen -- if it does, we are toast
                          * so just scream and die.
                          */
+
                         HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, \
                                     "dirty pinned entry flush failed.")
                     }
@@ -8141,6 +8619,7 @@ H5C_flush_invalidate_cache(H5F_t *  f,
                     /* This shouldn't happen -- if it does, we are toast so
                      * just scream and die.
                      */
+
                     HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, \
                                 "dirty entry flush destroy failed.")
                 }
@@ -8148,14 +8627,27 @@ H5C_flush_invalidate_cache(H5F_t *  f,
         } /* end while loop scanning skip list */
 
 #if H5C_DO_SANITY_CHECKS
-        HDassert( actual_slist_len == initial_slist_len );
-        HDassert( actual_slist_size == initial_slist_size );
+	/* It is possible that entries were added to the slist during
+	 * the scan, either before or after scan pointer.  The following
+	 * asserts take this into account.
+	 */
+
+        HDassert( (actual_slist_len + cache_ptr->slist_len) == 
+		  (initial_slist_len + cache_ptr->slist_len_increase) );
+        HDassert( (actual_slist_size + cache_ptr->slist_size) == 
+		  (initial_slist_size + cache_ptr->slist_size_increase) );
 #endif /* H5C_DO_SANITY_CHECKS */
 
         /* Since we are doing a destroy, we must make a pass through
          * the hash table and try to flush - destroy all entries that
-         * remain.  Note that all remaining entries entries must be
-         * clean, so this will not result in any writes to disk.
+         * remain.  
+	 *
+	 * It used to be that all entries remaining in the cache at 
+	 * this point had to be clean, but with the fractal heap mods
+	 * this may not be the case.  If so, we will flush entries out
+	 * of increasing address order.
+	 *
+	 * Writes to disk are possible here.
          */
         for ( i = 0; i < H5C__HASH_TABLE_LEN; i++ )
         {
@@ -8171,17 +8663,14 @@ H5C_flush_invalidate_cache(H5F_t *  f,
                     /* we have major problems -- but lets flush and destroy
                      * everything we can before we flag an error.
                      */
+	            protected_entries++;
 
                     if ( ! entry_ptr->in_slist ) {
 
-	                protected_entries++;
                         HDassert( !(entry_ptr->is_dirty) );
                     }
                 } else if ( ! ( entry_ptr->is_pinned ) ) {
 
-                    HDassert( !(entry_ptr->is_dirty) );
-                    HDassert( !(entry_ptr->in_slist) );
-
                     status = H5C_flush_single_entry(f,
                                                     primary_dxpl_id,
                                                     secondary_dxpl_id,
@@ -8197,8 +8686,9 @@ H5C_flush_invalidate_cache(H5F_t *  f,
                         /* This shouldn't happen -- if it does, we are toast so
                          * just scream and die.
                          */
+
                         HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, \
-                                    "Clean entry flush destroy failed.")
+                                    "Entry flush destroy failed.")
                     }
                 }
 	        /* We can't do anything if the entry is pinned.  The
@@ -8212,15 +8702,50 @@ H5C_flush_invalidate_cache(H5F_t *  f,
             } /* end while loop scanning hash table bin */
         } /* end for loop scanning hash table */
 
-        HDassert( protected_entries == cache_ptr->pl_len );
-
 	old_pel_len = cur_pel_len;
 	cur_pel_len = cache_ptr->pel_len;
 
-        first_pass = FALSE;
+	if ( ( cur_pel_len > 0 ) && ( cur_pel_len >= old_pel_len ) ) {
+
+	   /* The number of pinned entries is positive, and it is not
+	    * declining.  Scream and die.
+	    */
+
+            HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, \
+	                "Can't unpin all pinned entries 1.")
+
+        } else if ( ( cur_pel_len == 0 ) && ( old_pel_len == 0 ) ) {
+
+	    /* increment the pass count */
+	    passes++; 
+	}
+
+	if ( passes >= H5C__MAX_PASSES_ON_FLUSH ) {
+
+	    /* we have exceeded the maximum number of passes through the
+	     * cache to flush and destroy all entries.  Scream and die.
+	     */
+
+            HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, \
+	                "Maximum passes on flush exceeded.")
+	}
 
+	if ( cache_ptr->index_len <= 0 ) {
+
+	    done = TRUE;
+            HDassert( cache_ptr->index_size == 0 );
+	    HDassert( cache_ptr->slist_len == 0 );
+	    HDassert( cache_ptr->slist_size == 0 );
+	    HDassert( cache_ptr->pel_len == 0 );
+	    HDassert( cache_ptr->pel_size == 0 );
+	    HDassert( cache_ptr->pl_len == 0 );
+	    HDassert( cache_ptr->pl_size == 0 );
+	    HDassert( cache_ptr->LRU_list_len == 0 );
+	    HDassert( cache_ptr->LRU_list_size == 0 );
+        }
     } /* main while loop */
 
+
     HDassert( protected_entries <= cache_ptr->pl_len );
 
     if ( protected_entries > 0 ) {
@@ -8231,7 +8756,7 @@ H5C_flush_invalidate_cache(H5F_t *  f,
     } else if ( cur_pel_len > 0 ) {
 
         HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, \
-	            "Can't unpin all pinned entries.")
+	            "Can't unpin all pinned entries 2.")
 
     }
 
@@ -8313,6 +8838,17 @@ done:
  *		is not called if the H5C__FLUSH_CLEAR_ONLY_FLAG is set,
  *		as there is no write to file in this case.
  *
+ *		JRM -- 8/21/06
+ *		Added code maintaining the flush_in_progress and 
+ *		destroy_in_progress fields in H5C_cache_entry_t.  
+ *
+ *		Also added flush_flags parameter to the call to 
+ *		type_ptr->flush() so that the flush routine can report 
+ *		whether the entry has been resized or renamed.  Added 
+ *		code using the flush_flags variable to detect the case 
+ *		in which the target entry is resized during flush, and 
+ *		update the caches data structures accordingly.
+ *
  *-------------------------------------------------------------------------
  */
 static herr_t
@@ -8332,10 +8868,12 @@ H5C_flush_single_entry(H5F_t *		   f,
     herr_t		ret_value = SUCCEED;      /* Return value */
     herr_t		status;
     int			type_id;
+    unsigned		flush_flags = H5C_CALLBACK__NO_FLAGS_SET;
     H5C_cache_entry_t *	entry_ptr = NULL;
 
     FUNC_ENTER_NOAPI_NOINIT(H5C_flush_single_entry)
 
+
     HDassert( cache_ptr );
     HDassert( cache_ptr->magic == H5C__H5C_T_MAGIC );
     HDassert( cache_ptr->skip_file_checks || f );
@@ -8351,6 +8889,8 @@ H5C_flush_single_entry(H5F_t *		   f,
 #if H5C_DO_SANITY_CHECKS
     if ( entry_ptr != NULL ) {
 
+        HDassert( ! ( ( destroy ) && ( entry_ptr->is_pinned ) ) );
+
         if ( entry_ptr->in_slist ) {
 
             if ( ( ( entry_ptr->flush_marker ) && ( ! entry_ptr->is_dirty ) ) ||
@@ -8396,6 +8936,11 @@ H5C_flush_single_entry(H5F_t *		   f,
     {
         /* we have work to do */
 
+	/* We will set flush_in_progress back to FALSE at the end if the
+	 * entry still exists at that point.
+	 */
+	entry_ptr->flush_in_progress = TRUE;
+
 #ifdef H5_HAVE_PARALLEL
 #ifndef NDEBUG
 
@@ -8456,13 +9001,21 @@ H5C_flush_single_entry(H5F_t *		   f,
         /* Always remove the entry from the hash table on a destroy.  On a
          * flush with destroy, it is cheaper to discard the skip list all at
          * once rather than remove the entries one by one, so we only delete
-         * from the list if requested.
+         * from the slist only if requested.
          *
          * We must do deletions now as the callback routines will free the
          * entry if destroy is true.
+	 *
+	 * Note that it is possible that the entry will be renamed during
+	 * its call to flush.  This will upset H5C_rename_entry() if we 
+	 * don't tell it that it doesn't have to worry about updating the 
+	 * index and SLIST.  Use the destroy_in_progress field for this
+	 * purpose.
          */
         if ( destroy ) {
 
+            entry_ptr->destroy_in_progress = TRUE;
+
             H5C__DELETE_FROM_INDEX(cache_ptr, entry_ptr)
 
             if ( ( entry_ptr->in_slist ) &&
@@ -8606,14 +9159,15 @@ H5C_flush_single_entry(H5F_t *		   f,
             if ( *first_flush_ptr && entry_ptr->is_dirty ) {
 
                 status = (entry_ptr->type->flush)(f, primary_dxpl_id, destroy,
-                                                 entry_ptr->addr, entry_ptr);
+                                                 entry_ptr->addr, entry_ptr,
+						 &flush_flags);
                 *first_flush_ptr = FALSE;
 
             } else {
 
                 status = (entry_ptr->type->flush)(f, secondary_dxpl_id,
                                                  destroy, entry_ptr->addr,
-                                                 entry_ptr);
+                                                 entry_ptr, &flush_flags);
             }
 
             if ( status < 0 ) {
@@ -8621,6 +9175,43 @@ H5C_flush_single_entry(H5F_t *		   f,
                 HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, \
                             "unable to flush entry")
             }
+#ifdef H5_HAVE_PARALLEL
+            if ( flush_flags != H5C_CALLBACK__NO_FLAGS_SET ) {
+
+                /* In the parallel case, flush operations can
+		 * cause problems.  If they occur, scream and
+		 * die.
+		 *
+		 * At present, in the parallel case, the aux_ptr
+		 * will only be set if there is more than one 
+		 * process.  Thus we can use this to detect 
+		 * the parallel case.
+		 *
+		 * This works for now, but if we start using the 
+		 * aux_ptr for other purposes, we will have to 
+		 * change this test accordingly.
+		 *
+		 * NB: While this test detects entryies that attempt
+		 *     to resize or rename themselves during a flush
+		 *     in the parallel case, it will not detect an
+		 *     entry that dirties, resizes, and/or renames 
+		 *     other entries during its flush.
+		 *
+		 *     From what Quincey tells me, this test is 
+		 *     sufficient for now, as any flush routine that
+		 *     does the latter will also do the former.
+		 *
+		 *     If that ceases to be the case, further
+		 *     tests will be necessary.
+		 */
+		if ( cache_ptr->aux_ptr != NULL ) {
+
+                    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
+			        "Flush operation occured in the parallel case.")
+
+		}
+	    }
+#endif /* H5_HAVE_PARALLEL */
         }
 
         if ( ( ! destroy ) && ( entry_ptr->in_slist ) ) {
@@ -8628,11 +9219,79 @@ H5C_flush_single_entry(H5F_t *		   f,
             H5C__REMOVE_ENTRY_FROM_SLIST(cache_ptr, entry_ptr)
         }
 
-        if ( ! destroy ) {
+        if ( ! destroy ) { /* i.e. if the entry still exists */
 
             HDassert( !(entry_ptr->is_dirty) );
             HDassert( !(entry_ptr->flush_marker) );
             HDassert( !(entry_ptr->in_slist) );
+            HDassert( !(entry_ptr->is_protected) );
+
+	    if ( (flush_flags & H5C_CALLBACK__SIZE_CHANGED_FLAG) != 0 ) {
+
+		/* The entry size changed as a result of the flush.
+		 *
+		 * Most likely, the entry was compressed, and the 
+		 * new version is of a different size than the old.
+		 *
+		 * In any case, we must update entry and cache size
+		 * accordingly.
+		 */
+		size_t new_size;
+
+                if ( (entry_ptr->type->size)(f, (void *)entry_ptr, &new_size) 
+                     < 0 ) {
+
+                    HGOTO_ERROR(H5E_RESOURCE, H5E_CANTGETSIZE, FAIL, \
+                                "Can't get entry size after flush")
+                }
+
+		if ( new_size != entry_ptr->size ) {
+
+                    HDassert( entry_ptr->size < H5C_MAX_ENTRY_SIZE );
+
+                    /* update the hash table for the size change*/
+	            H5C__UPDATE_INDEX_FOR_SIZE_CHANGE((cache_ptr), \
+				                      (entry_ptr->size),\
+                                                      (new_size));
+
+		    /* The entry can't be protected since we just flushed it.
+		     * Thus we must update the replacement policy data 
+		     * structures for the size change.  The macro deals 
+		     * with the pinned case.
+		     */
+		    H5C__UPDATE_RP_FOR_SIZE_CHANGE(cache_ptr, entry_ptr, \
+				                   new_size)
+
+		    /* The entry can't be in the slist, so no need to update 
+		     * the slist for the size change.
+		     */
+
+		    /* update stats for the size change */
+		    H5C__UPDATE_STATS_FOR_ENTRY_SIZE_CHANGE(cache_ptr, \
+				                            entry_ptr, \
+							    new_size)
+
+		    /* finally, update the entry size proper */
+		    entry_ptr->size = new_size;
+		}
+	    }
+
+	    if ( (flush_flags & H5C_CALLBACK__RENAMED_FLAG) != 0 ) {
+
+		/* The entry was renamed as the result of the flush.
+		 *
+		 * Most likely, the entry was compressed, and the 
+		 * new version is larger than the old and thus had 
+		 * to be relocated.
+		 *
+		 * At preset, all processing for this case is 
+		 * handled elsewhere.  But lets keep the if statement 
+		 * around just in case.
+		 */
+
+	    }
+
+	    entry_ptr->flush_in_progress = FALSE;
         }
 
         if ( cache_ptr->log_flush ) {
@@ -8682,6 +9341,10 @@ done:
  *		the case, as our code will attempt to repair errors
  *		on load.
  *
+ *		JRM - 8/21/06
+ *		Added initialization for the new flush_in_progress and
+ *		destroy in progress fields.
+ *
  *-------------------------------------------------------------------------
  */
 
@@ -8695,7 +9358,7 @@ H5C_load_entry(H5F_t *             f,
 #ifndef NDEBUG
                hbool_t		   skip_file_checks)
 #else /* NDEBUG */
-               UNUSED hbool_t	   skip_file_checks)
+               hbool_t UNUSED	   skip_file_checks)
 #endif /* NDEBUG */
 {
     void *		thing = NULL;
@@ -8751,6 +9414,8 @@ H5C_load_entry(H5F_t *             f,
 #ifdef H5_HAVE_PARALLEL
     entry_ptr->clear_on_unprotect = FALSE;
 #endif /* H5_HAVE_PARALLEL */
+    entry_ptr->flush_in_progress = FALSE;
+    entry_ptr->destroy_in_progress = FALSE;
 
     if ( (type->size)(f, thing, &(entry_ptr->size)) < 0 ) {