[svn-r30118] Sync with trunk.

1 files changed, 780 insertions, 1071 deletions

diff --git a/src/H5C.c b/src/H5C.c
index e1ac8f2..66e3e25 100644
--- a/src/H5C.c
+++ b/src/H5C.c
@@ -166,6 +166,10 @@ static herr_t H5C_make_space_in_cache(H5F_t * f,
        	                              size_t  space_needed,
                                       hbool_t write_permitted);
 
+static herr_t H5C__mark_flush_dep_dirty(H5C_cache_entry_t * entry);
+
+static herr_t H5C__mark_flush_dep_clean(H5C_cache_entry_t * entry);
+
 static herr_t H5C__generate_image(const H5F_t *f, H5C_t * cache_ptr, H5C_cache_entry_t *entry_ptr, 
                                   hid_t dxpl_id, int64_t *entry_size_change_ptr);
 
@@ -180,6 +184,11 @@ static herr_t H5C_validate_pinned_entry_list(H5C_t * cache_ptr);
 static herr_t H5C_validate_protected_entry_list(H5C_t * cache_ptr);
 #endif /* H5C_DO_EXTREME_SANITY_CHECKS */
 
+#ifndef NDEBUG
+static void H5C__assert_flush_dep_nocycle(const H5C_cache_entry_t * entry,
+                                          const H5C_cache_entry_t * base_entry);
+#endif /* NDEBUG */
+
 #if 0 /* debugging routines */
 herr_t H5C_dump_cache(H5C_t * cache_ptr, const char *  cache_name);
 herr_t H5C_dump_cache_skip_list(H5C_t * cache_ptr, char * calling_fcn);
@@ -206,6 +215,9 @@ hbool_t H5_PKG_INIT_VAR = FALSE;
 /* Declare a free list to manage the H5C_t struct */
 H5FL_DEFINE_STATIC(H5C_t);
 
+/* Declare a free list to manage flush dependency arrays */
+H5FL_BLK_DEFINE_STATIC(parent);
+
 /* Declare extern free list to manage the H5C_collective_write_t struct */
 H5FL_EXTERN(H5C_collective_write_t);
 
@@ -443,10 +455,6 @@ H5C_create(size_t		      max_cache_size,
 
     cache_ptr->prefix[0]			= '\0';  /* empty string */
 
-#ifndef NDEBUG
-    cache_ptr->get_entry_ptr_from_addr_counter	= 0;  
-#endif /* NDEBUG */
-
     /* Set return value */
     ret_value = cache_ptr;
 
@@ -738,23 +746,6 @@ H5C_dest(H5F_t * f, hid_t dxpl_id)
         cache_ptr->cork_list_ptr = NULL;
     } /* end if */
 
-    /* Only display count of number of calls to H5C_get_entry_ptr_from_add()
-     * if NDEBUG is undefined, and H5C_DO_SANITY_CHECKS is defined.  Need 
-     * this as the print statement will upset windows, and we frequently
-     * run debug builds there.
-     *
-     * Note that the count is still kept whenever NDEBUG is undefined, and
-     * is reasonably accessible via debugger.
-     */
-#ifndef NDEBUG 
-#if H5C_DO_SANITY_CHECKS
-    if ( cache_ptr->get_entry_ptr_from_addr_counter > 0 )
-        HDfprintf(stdout, 
-		  "*** %ld calls to H5C_get_entry_ptr_from_add(). ***\n",
-		  cache_ptr->get_entry_ptr_from_addr_counter);
-#endif /* H5C_DO_SANITY_CHECKS */
-#endif /* NDEBUG */
-
 #ifndef NDEBUG
     cache_ptr->magic = 0;
 #endif /* NDEBUG */
@@ -1243,7 +1234,6 @@ H5C_insert_entry(H5F_t *             f,
     size_t		empty_space;
     H5C_cache_entry_t  *entry_ptr;
     H5C_cache_entry_t  *test_entry_ptr;
-    unsigned            u;                      /* Local index variable */
     herr_t		ret_value = SUCCEED;    /* Return value */
 
     FUNC_ENTER_NOAPI(FAIL)
@@ -1366,9 +1356,10 @@ H5C_insert_entry(H5F_t *             f,
 
     /* Initialize flush dependency height fields */
     entry_ptr->flush_dep_parent = NULL;
-    for(u = 0; u < H5C__NUM_FLUSH_DEP_HEIGHTS; u++)
-        entry_ptr->child_flush_dep_height_rc[u] = 0;
-    entry_ptr->flush_dep_height = 0;
+    entry_ptr->flush_dep_nparents = 0;
+    entry_ptr->flush_dep_parent_nalloc = 0;
+    entry_ptr->flush_dep_nchildren = 0;
+    entry_ptr->flush_dep_ndirty_children = 0;
 
     entry_ptr->ht_next = NULL;
     entry_ptr->ht_prev = NULL;
@@ -1585,31 +1576,32 @@ H5C_mark_entry_dirty(void *thing)
         entry_ptr->dirtied = TRUE;
 
     } else if ( entry_ptr->is_pinned ) {
-        hbool_t		was_pinned_unprotected_and_clean;
+        hbool_t		was_clean;
 
-	was_pinned_unprotected_and_clean = ! ( entry_ptr->is_dirty );
+	was_clean = !entry_ptr->is_dirty;
 
         /* mark the entry as dirty if it isn't already */
         entry_ptr->is_dirty = TRUE;
 	entry_ptr->image_up_to_date = FALSE;
 
-	if ( was_pinned_unprotected_and_clean ) {
-
-	    H5C__UPDATE_INDEX_FOR_ENTRY_DIRTY(cache_ptr, entry_ptr);
-	}
+        /* Propagate the dirty flag up the flush dependency chain if appropriate */
+        if(was_clean) {
+            H5C__UPDATE_INDEX_FOR_ENTRY_DIRTY(cache_ptr, entry_ptr);
 
-        if ( ! (entry_ptr->in_slist) ) {
+            if(entry_ptr->flush_dep_nparents > 0)
+                if(H5C__mark_flush_dep_dirty(entry_ptr) < 0)
+                    HGOTO_ERROR(H5E_CACHE, H5E_CANTMARKDIRTY, FAIL, "Can't propagate flush dep dirty flag")
+        } /* end if */
 
+        if(!entry_ptr->in_slist) {
             H5C__INSERT_ENTRY_IN_SLIST(cache_ptr, entry_ptr, FAIL)
         }
 
         H5C__UPDATE_STATS_FOR_DIRTY_PIN(cache_ptr, entry_ptr)
 
-    } else {
-
-        HGOTO_ERROR(H5E_CACHE, H5E_CANTMARKDIRTY, FAIL, \
-                    "Entry is neither pinned nor protected??")
-    }
+    } /* end if */
+    else
+        HGOTO_ERROR(H5E_CACHE, H5E_CANTMARKDIRTY, FAIL, "Entry is neither pinned nor protected??")
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
@@ -1638,9 +1630,6 @@ H5C_move_entry(H5C_t *	     cache_ptr,
 {
     H5C_cache_entry_t *	entry_ptr = NULL;
     H5C_cache_entry_t *	test_entry_ptr = NULL;
-#if H5C_MAINTAIN_CLEAN_AND_DIRTY_LRU_LISTS
-    hbool_t			was_dirty;
-#endif /* H5C_MAINTAIN_CLEAN_AND_DIRTY_LRU_LISTS */
 #if H5C_DO_SANITY_CHECKS
     hbool_t			removed_entry_from_slist = FALSE;
 #endif /* H5C_DO_SANITY_CHECKS */
@@ -1735,24 +1724,29 @@ H5C_move_entry(H5C_t *	     cache_ptr,
 
     entry_ptr->addr = new_addr;
 
-    if ( ! ( entry_ptr->destroy_in_progress ) ) {
+    if(!entry_ptr->destroy_in_progress) {
+        hbool_t		was_dirty;
 
-#if H5C_MAINTAIN_CLEAN_AND_DIRTY_LRU_LISTS
         was_dirty = entry_ptr->is_dirty;
-#endif /* H5C_MAINTAIN_CLEAN_AND_DIRTY_LRU_LISTS */
+	entry_ptr->is_dirty = TRUE;
 
-        entry_ptr->is_dirty = TRUE;
-        /* This shouldn't be needed, but it keeps the test code happy */
+	/* This shouldn't be needed, but it keeps the test code happy */
         entry_ptr->image_up_to_date = FALSE;
 
+        /* Propagate the dirty flag up the flush dependency chain if
+         * appropriate */
+        if(!entry_ptr->flush_in_progress) {
+            if(!was_dirty && entry_ptr->flush_dep_nparents > 0)
+                if(H5C__mark_flush_dep_dirty(entry_ptr) < 0)
+                    HGOTO_ERROR(H5E_CACHE, H5E_CANTMARKDIRTY, FAIL, "Can't propagate flush dep dirty flag")
+        } /* end if */
+
         H5C__INSERT_IN_INDEX(cache_ptr, entry_ptr, FAIL)
 
         H5C__INSERT_ENTRY_IN_SLIST(cache_ptr, entry_ptr, FAIL)
 
 #if H5C_DO_SANITY_CHECKS
-
-        if ( removed_entry_from_slist ) {
-
+        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
@@ -1760,21 +1754,18 @@ H5C_move_entry(H5C_t *	     cache_ptr,
 	     */
 	    cache_ptr->slist_len_increase -= 1;
 	    cache_ptr->slist_size_increase -= (int64_t)(entry_ptr->size);
-        }
-
+        } /* end if */
 #endif /* H5C_DO_SANITY_CHECKS */
 
-	if ( ! ( entry_ptr->flush_in_progress ) ) {
-
+	if(!entry_ptr->flush_in_progress) {
             /* skip the update if a flush is in progress */
             H5C__UPDATE_RP_FOR_MOVE(cache_ptr, entry_ptr, was_dirty, FAIL)
         }
-    }
+    } /* end if */
 
     H5C__UPDATE_STATS_FOR_MOVE(cache_ptr, entry_ptr)
 
 done:
-
 #if H5C_DO_EXTREME_SANITY_CHECKS
     if ( ( H5C_validate_protected_entry_list(cache_ptr) < 0 ) ||
          ( H5C_validate_pinned_entry_list(cache_ptr) < 0 ) ||
@@ -1786,7 +1777,6 @@ done:
 #endif /* H5C_DO_EXTREME_SANITY_CHECKS */
 
     FUNC_LEAVE_NOAPI(ret_value)
-
 } /* H5C_move_entry() */
 
 
@@ -1842,16 +1832,21 @@ H5C_resize_entry(void *thing, size_t new_size)
         hbool_t		was_clean;
 
         /* make note of whether the entry was clean to begin with */
-        was_clean = ! ( entry_ptr->is_dirty );
+        was_clean = !entry_ptr->is_dirty;
 
         /* mark the entry as dirty if it isn't already */
         entry_ptr->is_dirty = TRUE;
         entry_ptr->image_up_to_date = FALSE;
 
         /* Release the current image */
-        if( entry_ptr->image_ptr )
+        if(entry_ptr->image_ptr)
             entry_ptr->image_ptr = H5MM_xfree(entry_ptr->image_ptr);
 
+        /* Propagate the dirty flag up the flush dependency chain if appropriate */
+        if(was_clean && entry_ptr->flush_dep_nparents > 0)
+            if(H5C__mark_flush_dep_dirty(entry_ptr) < 0)
+                HGOTO_ERROR(H5E_CACHE, H5E_CANTMARKDIRTY, FAIL, "Can't propagate flush dep dirty flag")
+
         /* do a flash cache size increase if appropriate */
         if ( cache_ptr->flash_size_increase_possible ) {
 
@@ -4119,9 +4114,25 @@ H5C_unprotect(H5F_t *		  f,
 	entry_ptr->image_up_to_date = !entry_ptr->is_dirty;
 #endif /* JRM */
 
-        /* Update index for newly dirtied entry */
-        if(was_clean && entry_ptr->is_dirty)
-	    H5C__UPDATE_INDEX_FOR_ENTRY_DIRTY(cache_ptr, entry_ptr)
+        /* Check for newly dirtied entry */
+        if(was_clean && entry_ptr->is_dirty) {
+            /* Propagate the flush dep dirty flag up the flush dependency chain
+             * if appropriate */
+            if(entry_ptr->flush_dep_nparents > 0)
+                if(H5C__mark_flush_dep_dirty(entry_ptr) < 0)
+                    HGOTO_ERROR(H5E_CACHE, H5E_CANTMARKDIRTY, FAIL, "Can't propagate flush dep dirty flag")
+
+            /* Update index for newly dirtied entry */
+            H5C__UPDATE_INDEX_FOR_ENTRY_DIRTY(cache_ptr, entry_ptr)
+        } /* end if */ 
+        /* Check for newly clean entry */
+        else if(!was_clean && !entry_ptr->is_dirty) {
+            /* Propagate the flush dep clean flag up the flush dependency chain
+             * if appropriate */
+            if(entry_ptr->flush_dep_nparents > 0)
+                if(H5C__mark_flush_dep_clean(entry_ptr) < 0)
+                    HGOTO_ERROR(H5E_CACHE, H5E_CANTMARKDIRTY, FAIL, "Can't propagate flush dep dirty flag")
+        } /* end else-if */
 
         /* Pin or unpin the entry as requested. */
         if(pin_entry) {
@@ -4455,103 +4466,6 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5C_adjust_flush_dependency_rc()
- *
- * Purpose:	"Atomicly" adjust flush dependency ref. counts for an entry,
- *              as a result of a flush dependency child's height changing.
- *
- * Note:	Entry will remain in flush dependency relationship with its
- *              child entry (i.e. it's not going to get unpinned as a result
- *              of this change), but change could trickle upward, if this
- *              entry's height changes and it has a flush dependency parent.
- *
- * Return:      Non-negative on success/Negative on failure
- *
- * Programmer:  Quincey Koziol
- *              3/05/09
- *
- *-------------------------------------------------------------------------
- */
-static void
-H5C_adjust_flush_dependency_rc(H5C_cache_entry_t * cache_entry,
-    unsigned old_child_height, unsigned new_child_height)
-{
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
-
-    /* Sanity checks */
-    HDassert(cache_entry);
-    HDassert(cache_entry->is_pinned);
-    HDassert(cache_entry->flush_dep_height > 0);
-    HDassert(cache_entry->flush_dep_height < H5C__NUM_FLUSH_DEP_HEIGHTS);
-    HDassert(cache_entry->child_flush_dep_height_rc[old_child_height] > 0);
-    HDassert(old_child_height < H5C__NUM_FLUSH_DEP_HEIGHTS);
-    HDassert(old_child_height != new_child_height);
-    HDassert(new_child_height < H5C__NUM_FLUSH_DEP_HEIGHTS);
-
-    /* Adjust ref. counts for entry's flush dependency children heights */
-    cache_entry->child_flush_dep_height_rc[new_child_height]++;
-    cache_entry->child_flush_dep_height_rc[old_child_height]--;
-
-    /* Check for flush dependency height of entry increasing */
-    if((new_child_height + 1) > cache_entry->flush_dep_height) {
-
-        /* Check if entry has _its_ own parent flush dependency entry */
-        if(NULL != cache_entry->flush_dep_parent) {
-            /* Adjust flush dependency ref. counts on entry's parent */
-            H5C_adjust_flush_dependency_rc(cache_entry->flush_dep_parent, cache_entry->flush_dep_height, new_child_height + 1);
-        } /* end if */
-
-        /* Set new flush dependency height of entry */
-        cache_entry->flush_dep_height = new_child_height + 1;
-    } /* end if */
-    else {
-        /* Check for child's flush dep. height decreasing and ref. count of
-         *      old child height going to zero, it could mean the parent's
-         *      flush dependency height dropped.
-         */
-        if((new_child_height < old_child_height)
-                && ((old_child_height + 1) == cache_entry->flush_dep_height)
-                && (0 == cache_entry->child_flush_dep_height_rc[old_child_height])) {
-            int i;                      /* Local index variable */
-
-            /* Re-scan child flush dependency height ref. counts to determine
-             *  this entry's height.
-             */
-#ifndef NDEBUG
-            for(i = (H5C__NUM_FLUSH_DEP_HEIGHTS - 1); i > (int)new_child_height; i--)
-                HDassert(0 == cache_entry->child_flush_dep_height_rc[i]);
-#endif /* NDEBUG */
-            for(i = (int)new_child_height; i >= 0; i--)
-                /* Check for child flush dependencies of this height */
-                if(cache_entry->child_flush_dep_height_rc[i] > 0)
-                    break;
-
-            /* Sanity checks */
-            HDassert((unsigned)(i + 1) < cache_entry->flush_dep_height);
-
-            /* Check if entry has _its_ own parent flush dependency entry */
-            if(NULL != cache_entry->flush_dep_parent) {
-                /* Adjust flush dependency ref. counts on entry's parent */
-                H5C_adjust_flush_dependency_rc(cache_entry->flush_dep_parent, cache_entry->flush_dep_height, (unsigned)(i + 1));
-            } /* end if */
-
-            /* Set new flush dependency height of entry */
-            cache_entry->flush_dep_height = (unsigned)(i + 1);
-        } /* end if */
-    } /* end else */
-
-
-    /* Post-conditions, for successful operation */
-    HDassert(cache_entry->is_pinned);
-    HDassert(cache_entry->flush_dep_height > 0);
-    HDassert(cache_entry->flush_dep_height <= H5C__NUM_FLUSH_DEP_HEIGHTS);
-    HDassert(cache_entry->child_flush_dep_height_rc[new_child_height] > 0);
-
-    FUNC_LEAVE_NOAPI_VOID
-} /* H5C_adjust_flush_dependency_rc() */
-
-
-/*-------------------------------------------------------------------------
  * Function:    H5C_create_flush_dependency()
  *
  * Purpose:	Initiates a parent<->child entry flush dependency.  The parent
@@ -4563,11 +4477,6 @@ H5C_adjust_flush_dependency_rc(H5C_cache_entry_t * cache_entry,
  *              currently used to implement Single-Writer/Multiple-Reader (SWMR)
  *              I/O access for data structures in the file).
  *
- *              Each child entry can have only one parent entry, but parent
- *              entries can have >1 child entries.  The flush dependency
- *              height of a parent entry is one greater than the max. flush
- *              dependency height of its children.
- *
  *              Creating a flush dependency between two entries will also pin
  *              the parent entry.
  *
@@ -4584,9 +4493,6 @@ H5C_create_flush_dependency(void * parent_thing, void * child_thing)
     H5C_t             * cache_ptr;
     H5C_cache_entry_t *	parent_entry = (H5C_cache_entry_t *)parent_thing;   /* Ptr to parent thing's entry */
     H5C_cache_entry_t * child_entry = (H5C_cache_entry_t *)child_thing;    /* Ptr to child thing's entry */
-#ifndef NDEBUG
-    unsigned prev_flush_dep_height = parent_entry->flush_dep_height; /* Previous flush height for parent entry */
-#endif /* NDEBUG */
     herr_t ret_value = SUCCEED;         /* Return value */
 
     FUNC_ENTER_NOAPI(FAIL)
@@ -4594,45 +4500,34 @@ H5C_create_flush_dependency(void * parent_thing, void * child_thing)
     /* Sanity checks */
     HDassert(parent_entry);
     HDassert(parent_entry->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
-    HDassert(parent_entry->flush_dep_height <= H5C__NUM_FLUSH_DEP_HEIGHTS);
     HDassert(H5F_addr_defined(parent_entry->addr));
     HDassert(child_entry);
     HDassert(child_entry->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
     HDassert(H5F_addr_defined(child_entry->addr));
-    HDassert(child_entry->flush_dep_height <= H5C__NUM_FLUSH_DEP_HEIGHTS);
     cache_ptr = parent_entry->cache_ptr;
-    HDassert(parent_entry->ring == child_entry->ring);
     HDassert(cache_ptr);
     HDassert(cache_ptr->magic == H5C__H5C_T_MAGIC);
     HDassert(cache_ptr == child_entry->cache_ptr);
+#ifndef NDEBUG
+    /* Make sure the parent is not already a parent */
+    {
+        unsigned u;
+
+        for(u = 0; u < child_entry->flush_dep_nparents; u++)
+            HDassert(child_entry->flush_dep_parent[u] != parent_entry);
+    } /* end block */
+#endif /* NDEBUG */
 
     /* More sanity checks */
     if(child_entry == parent_entry)
         HGOTO_ERROR(H5E_CACHE, H5E_CANTDEPEND, FAIL, "Child entry flush dependency parent can't be itself")
     if(!(parent_entry->is_protected || parent_entry->is_pinned))
         HGOTO_ERROR(H5E_CACHE, H5E_CANTDEPEND, FAIL, "Parent entry isn't pinned or protected")
-    if(NULL != child_entry->flush_dep_parent)
-        HGOTO_ERROR(H5E_CACHE, H5E_CANTDEPEND, FAIL, "Child entry already has flush dependency parent")
-    {
-        H5C_cache_entry_t *tmp_entry = parent_entry;  /* Temporary cache entry in flush dependency chain */
-        unsigned tmp_flush_height = 0;          /* Different in heights of parent entry */
-
-        /* Find the top entry in the flush dependency list */
-        while(NULL != tmp_entry->flush_dep_parent) {
-            tmp_flush_height++;
-            tmp_entry = tmp_entry->flush_dep_parent;
-        } /* end while */
-
-        /* Check if we will make the dependency chain too long */
-        if((tmp_flush_height + child_entry->flush_dep_height + 1)
-                > H5C__NUM_FLUSH_DEP_HEIGHTS)
-        HGOTO_ERROR(H5E_CACHE, H5E_CANTDEPEND, FAIL, "Combined flush dependency height too large")
-    }
 
     /* Check for parent not pinned */
     if(!parent_entry->is_pinned) {
         /* Sanity check */
-        HDassert(parent_entry->flush_dep_height == 0);
+        HDassert(parent_entry->flush_dep_nchildren == 0);
         HDassert(!parent_entry->pinned_from_client);
         HDassert(!parent_entry->pinned_from_cache);
 
@@ -4644,33 +4539,50 @@ H5C_create_flush_dependency(void * parent_thing, void * child_thing)
     /* Mark the entry as pinned from the cache's action (possibly redundantly) */
     parent_entry->pinned_from_cache = TRUE;
 
-    /* Increment ref. count for parent's flush dependency children heights */
-    parent_entry->child_flush_dep_height_rc[child_entry->flush_dep_height]++;
+    /* Check if we need to resize the child's parent array */
+    if(child_entry->flush_dep_nparents >= child_entry->flush_dep_parent_nalloc) {
+        if(child_entry->flush_dep_parent_nalloc == 0) {
+            /* Array does not exist yet, allocate it */
+            HDassert(!child_entry->flush_dep_parent);
 
-    /* Check for increasing parent flush dependency height */
-    if((child_entry->flush_dep_height + 1) > parent_entry->flush_dep_height) {
-
-        /* Check if parent entry has _its_ own parent flush dependency entry */
-        if(NULL != parent_entry->flush_dep_parent) {
-            /* Adjust flush dependency ref. counts on parent entry's parent */
-            H5C_adjust_flush_dependency_rc(parent_entry->flush_dep_parent, parent_entry->flush_dep_height, (child_entry->flush_dep_height + 1));
+            if(NULL == (child_entry->flush_dep_parent = (H5C_cache_entry_t **)H5FL_BLK_MALLOC(parent, H5C_FLUSH_DEP_PARENT_INIT * sizeof(H5C_cache_entry_t *))))
+                HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for flush dependency parent list")
+            child_entry->flush_dep_parent_nalloc = H5C_FLUSH_DEP_PARENT_INIT;
         } /* end if */
+        else {
+            /* Resize existing array */
+            HDassert(child_entry->flush_dep_parent);
 
-        /* Increase flush dependency height of parent entry */
-        parent_entry->flush_dep_height = child_entry->flush_dep_height + 1;
+            if(NULL == (child_entry->flush_dep_parent = (H5C_cache_entry_t **)H5FL_BLK_REALLOC(parent, child_entry->flush_dep_parent, 2 * child_entry->flush_dep_parent_nalloc * sizeof(H5C_cache_entry_t *))))
+                HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for flush dependency parent list")
+            child_entry->flush_dep_parent_nalloc *= 2;
+        } /* end else */
     } /* end if */
 
-    /* Set parent for child entry */
-    child_entry->flush_dep_parent = parent_entry;
+    /* Add the dependency to the child's parent array */
+    child_entry->flush_dep_parent[child_entry->flush_dep_nparents] = parent_entry;
+    child_entry->flush_dep_nparents++;
+
+    /* Increment parent's number of children */
+    parent_entry->flush_dep_nchildren++;
+
+    /* Adjust the number of dirty children */
+    if(child_entry->is_dirty) {
+        /* Sanity check */
+        HDassert(parent_entry->flush_dep_ndirty_children < parent_entry->flush_dep_nchildren);
 
+        parent_entry->flush_dep_ndirty_children++;
+    } /* end if */
 
     /* Post-conditions, for successful operation */
     HDassert(parent_entry->is_pinned);
-    HDassert(parent_entry->flush_dep_height > 0);
-    HDassert(parent_entry->flush_dep_height < H5C__NUM_FLUSH_DEP_HEIGHTS);
-    HDassert(prev_flush_dep_height <= parent_entry->flush_dep_height);
-    HDassert(parent_entry->child_flush_dep_height_rc[child_entry->flush_dep_height] > 0);
-    HDassert(NULL != child_entry->flush_dep_parent);
+    HDassert(parent_entry->flush_dep_nchildren > 0);
+    HDassert(child_entry->flush_dep_parent);
+    HDassert(child_entry->flush_dep_nparents > 0);
+    HDassert(child_entry->flush_dep_parent_nalloc > 0);
+#ifndef NDEBUG
+    H5C__assert_flush_dep_nocycle(parent_entry, child_entry);
+#endif /* NDEBUG */
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
@@ -4681,9 +4593,7 @@ done:
  * Function:    H5C_destroy_flush_dependency()
  *
  * Purpose:	Terminates a parent<-> child entry flush dependency.  The
- *              parent entry must be pinned and have a positive flush
- *              dependency height (which could go to zero as a result of
- *              this operation).
+ *              parent entry must be pinned.
  *
  * Return:      Non-negative on success/Negative on failure
  *
@@ -4698,9 +4608,7 @@ H5C_destroy_flush_dependency(void *parent_thing, void * child_thing)
     H5C_t             * cache_ptr;
     H5C_cache_entry_t *	parent_entry = (H5C_cache_entry_t *)parent_thing; /* Ptr to parent entry */
     H5C_cache_entry_t *	child_entry = (H5C_cache_entry_t *)child_thing; /* Ptr to child entry */
-#ifndef NDEBUG
-    unsigned prev_flush_dep_height = parent_entry->flush_dep_height; /* Previous flush height for parent entry */
-#endif /* NDEBUG */
+    unsigned            u;                      /* Local index variable */
     herr_t              ret_value = SUCCEED;    /* Return value */
 
     FUNC_ENTER_NOAPI(FAIL)
@@ -4709,9 +4617,7 @@ H5C_destroy_flush_dependency(void *parent_thing, void * child_thing)
     HDassert(parent_entry);
     HDassert(parent_entry->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
     HDassert(H5F_addr_defined(parent_entry->addr));
-    HDassert(parent_entry->flush_dep_height <= H5C__NUM_FLUSH_DEP_HEIGHTS);
     HDassert(child_entry);
-    HDassert(child_entry->flush_dep_parent != child_entry);
     HDassert(child_entry->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
     HDassert(H5F_addr_defined(child_entry->addr));
     cache_ptr = parent_entry->cache_ptr;
@@ -4722,78 +4628,70 @@ H5C_destroy_flush_dependency(void *parent_thing, void * child_thing)
     /* Usage checks */
     if(!parent_entry->is_pinned)
         HGOTO_ERROR(H5E_CACHE, H5E_CANTUNDEPEND, FAIL, "Parent entry isn't pinned")
-    if(0 == parent_entry->flush_dep_height)
-        HGOTO_ERROR(H5E_CACHE, H5E_CANTUNDEPEND, FAIL, "Parent entry isn't a flush dependency parent")
     if(NULL == child_entry->flush_dep_parent)
-        HGOTO_ERROR(H5E_CACHE, H5E_CANTUNDEPEND, FAIL, "Child entry doesn't have a flush dependency parent")
-    if(0 == parent_entry->child_flush_dep_height_rc[child_entry->flush_dep_height])
-        HGOTO_ERROR(H5E_CACHE, H5E_CANTUNDEPEND, FAIL, "Parent entry flush dependency ref. count has no child entries of this height")
-    if(child_entry->flush_dep_parent != parent_entry)
-        HGOTO_ERROR(H5E_CACHE, H5E_CANTUNDEPEND, FAIL, "Parent entry isn't flush dependency parent for child entry")
-
-    /* Decrement the ref. count for flush dependency height of children for parent entry */
-    parent_entry->child_flush_dep_height_rc[child_entry->flush_dep_height]--;
-
-    /* Check for flush dependency ref. count at this height going to zero and
-     *  parent entry flush dependency height dropping
-     */
-    if(((child_entry->flush_dep_height + 1) == parent_entry->flush_dep_height) &&
-            0 == parent_entry->child_flush_dep_height_rc[child_entry->flush_dep_height]) {
-        int i;             /* Local index variable */
-
-        /* Reverse scan for new flush dependency height of parent */
-#ifndef NDEBUG
-        for(i = (H5C__NUM_FLUSH_DEP_HEIGHTS - 1); i > (int)child_entry->flush_dep_height; i--)
-            HDassert(0 == parent_entry->child_flush_dep_height_rc[i]);
-#endif /* NDEBUG */
-        for(i = (int)child_entry->flush_dep_height; i >= 0; i--)
-            /* Check for child flush dependencies of this height */
-            if(parent_entry->child_flush_dep_height_rc[i] > 0)
-                break;
-
+        HGOTO_ERROR(H5E_CACHE, H5E_CANTUNDEPEND, FAIL, "Child entry doesn't have a flush dependency parent array")
+    if(0 == parent_entry->flush_dep_nchildren)
+        HGOTO_ERROR(H5E_CACHE, H5E_CANTUNDEPEND, FAIL, "Parent entry flush dependency ref. count has no child dependencies")
+
+    /* Search for parent in child's parent array.  This is a linear search
+     * because we do not expect large numbers of parents.  If this changes, we
+     * may wish to change the parent array to a skip list */
+    for(u = 0; u < child_entry->flush_dep_nparents; u++)
+        if(child_entry->flush_dep_parent[u] == parent_entry)
+            break;
+    if(u == child_entry->flush_dep_nparents)
+        HGOTO_ERROR(H5E_CACHE, H5E_CANTUNDEPEND, FAIL, "Parent entry isn't a flush dependency parent for child entry")
+
+    /* Remove parent entry from child's parent array */
+    if(u < (child_entry->flush_dep_nparents - 1))
+        HDmemmove(&child_entry->flush_dep_parent[u],
+                &child_entry->flush_dep_parent[u + 1],
+                (child_entry->flush_dep_nparents - u - 1) * sizeof(child_entry->flush_dep_parent[0]));
+    child_entry->flush_dep_nparents--;
+
+    /* Adjust parent entry's nchildren and unpin parent if it goes to zero */
+    parent_entry->flush_dep_nchildren--;
+    if(0 == parent_entry->flush_dep_nchildren) {
         /* Sanity check */
-        HDassert((unsigned)(i + 1) < parent_entry->flush_dep_height);
+        HDassert(parent_entry->pinned_from_cache);
 
-        /* Check if parent entry is a child in another flush dependency relationship */
-        if(NULL != parent_entry->flush_dep_parent) {
-            /* Change flush dependency ref. counts of parent's parent */
-            H5C_adjust_flush_dependency_rc(parent_entry->flush_dep_parent, parent_entry->flush_dep_height, (unsigned)(i + 1));
-        } /* end if */
+        /* Check if we should unpin parent entry now */
+        if(!parent_entry->pinned_from_client) {
+            /* Update the replacement policy if the entry is not protected */
+            if(!parent_entry->is_protected)
+                H5C__UPDATE_RP_FOR_UNPIN(cache_ptr, parent_entry, FAIL)
 
-        /* Increase flush dependency height of parent entry */
-        parent_entry->flush_dep_height = (unsigned)(i + 1);
+            /* Unpin the entry now */
+            parent_entry->is_pinned = FALSE;
 
-        /* Check for height of parent dropping to zero (i.e. no longer a
-         *  parent of _any_ child flush dependencies).
-         */
-        if(0 == parent_entry->flush_dep_height) {
-            /* Sanity check */
-            HDassert(parent_entry->pinned_from_cache);
-
-            /* Check if we should unpin parent entry now */
-            if(!parent_entry->pinned_from_client) {
-                /* Update the replacement policy if the entry is not protected */
-                if(!parent_entry->is_protected)
-                    H5C__UPDATE_RP_FOR_UNPIN(cache_ptr, parent_entry, FAIL)
+            /* Update the stats for an unpin operation */
+            H5C__UPDATE_STATS_FOR_UNPIN(cache_ptr, parent_entry)
+        } /* end if */
 
-                /* Unpin the entry now */
-                parent_entry->is_pinned = FALSE;
+        /* Mark the entry as unpinned from the cache's action */
+        parent_entry->pinned_from_cache = FALSE;
+    } /* end if */
 
-                /* Update the stats for an unpin operation */
-                H5C__UPDATE_STATS_FOR_UNPIN(cache_ptr, parent_entry)
-            } /* end if */
+    /* Adjust parent entry's ndirty_children */
+    if(child_entry->is_dirty) {
+        /* Sanity check */
+        HDassert(parent_entry->flush_dep_ndirty_children > 0);
 
-            /* Mark the entry as unpinned from the cache's action */
-            parent_entry->pinned_from_cache = FALSE;
-        } /* end if */
+        parent_entry->flush_dep_ndirty_children--;
     } /* end if */
 
-    /* Reset parent of child entry */
-    child_entry->flush_dep_parent = NULL;
-
-    /* Post-conditions, for successful operation */
-    HDassert(prev_flush_dep_height >= parent_entry->flush_dep_height);
-    HDassert(NULL == child_entry->flush_dep_parent);
+    /* Shrink or free the parent array if apporpriate */
+    if(child_entry->flush_dep_nparents == 0) {
+        child_entry->flush_dep_parent = (H5C_cache_entry_t **)H5FL_BLK_FREE(parent, child_entry->flush_dep_parent);
+        child_entry->flush_dep_parent_nalloc = 0;
+    } /* end if */
+    else if(child_entry->flush_dep_parent_nalloc > H5C_FLUSH_DEP_PARENT_INIT
+            && child_entry->flush_dep_nparents
+            <= (child_entry->flush_dep_parent_nalloc / 4)) {
+        if(NULL == (child_entry->flush_dep_parent = (H5C_cache_entry_t **)H5FL_BLK_REALLOC(parent, child_entry->flush_dep_parent, (child_entry->flush_dep_parent_nalloc / 4) * sizeof(H5C_cache_entry_t *))))
+            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for flush dependency parent list")
+        child_entry->flush_dep_parent_nalloc /= 4;
+    } /* end if */
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
@@ -6208,8 +6106,8 @@ H5C_flush_invalidate_ring(const H5F_t * f, hid_t dxpl_id, H5C_ring_t ring,
     int32_t		i;
     int32_t		cur_ring_pel_len;
     int32_t		old_ring_pel_len;
-    int32_t		passes = 0;
     unsigned		cooked_flags;
+    unsigned		evict_flags;
     H5SL_node_t * 	node_ptr = NULL;
     H5C_cache_entry_t *	entry_ptr = NULL;
     H5C_cache_entry_t *	next_entry_ptr = NULL;
@@ -6239,10 +6137,9 @@ H5C_flush_invalidate_ring(const H5F_t * f, hid_t dxpl_id, H5C_ring_t ring,
     HDassert(cache_ptr->epoch_markers_active == 0);
 
     /* Filter out the flags that are not relevant to the flush/invalidate.
-     * At present, only the H5C__FLUSH_CLEAR_ONLY_FLAG is kept.
      */
     cooked_flags = flags & H5C__FLUSH_CLEAR_ONLY_FLAG;
-
+    evict_flags = flags & H5C__EVICT_ALLOW_LAST_PINS_FLAG;
 
     /* The flush proceedure here is a bit strange.
      *
@@ -6253,10 +6150,8 @@ H5C_flush_invalidate_ring(const H5F_t * f, hid_t dxpl_id, H5C_ring_t ring,
      *
      * Since the fractal heap can dirty, resize, and/or move 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.
+     * contain dirty entries at this point.  If so, we must make more
+     * passes through the skip list to allow it to empty.
      *
      * Further, since clean entries can be dirtied, resized, and/or moved
      * as the result of a flush call back (either the entries own, or that
@@ -6289,402 +6184,353 @@ H5C_flush_invalidate_ring(const H5F_t * f, hid_t dxpl_id, H5C_ring_t ring,
 
     old_ring_pel_len = cur_ring_pel_len;
     while(cache_ptr->index_ring_len[ring] > 0) {
-        unsigned curr_flush_dep_height = 0;
-        unsigned flush_dep_passes = 0;
-
-        /* Loop over all flush dependency heights of entries */
-        while((curr_flush_dep_height <= H5C__NUM_FLUSH_DEP_HEIGHTS) &&
-                (cache_ptr->index_ring_len[ring] > 0) &&
-                (flush_dep_passes < H5C__MAX_PASSES_ON_FLUSH)) {
-            hbool_t flushed_during_dep_loop = FALSE;
-
-            /* 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.
-             */
+        /* 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 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;
-
-            /* There is also the possibility that entries will be
-             * dirtied, resized, moved, and/or removed from the cache
-             * 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;
+        /* 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, moved, and/or removed from the cache
+         * 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 flushed_slist_len and flushed_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.
-             */
-            flushed_slist_len = 0;
-            flushed_slist_size = 0;
+        /* Finally, reset the flushed_slist_len and flushed_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.
+         */
+        flushed_slist_len = 0;
+        flushed_slist_size = 0;
 #endif /* H5C_DO_SANITY_CHECKS */
 
-            /* set the cache_ptr->slist_change_in_pre_serialize and
-             * cache_ptr->slist_change_in_serialize to false.
-             *
-             * These flags are set to TRUE by H5C__flush_single_entry if the
-             * slist is modified by a pre_serialize or serialize call 
-             * respectively.
-             *
-             * H5C_flush_invalidate_cache() uses these flags to detect any 
-             * modifications to the slist that might corrupt the scan of 
-             * the slist -- and restart the scan in this event.
-             */
-            cache_ptr->slist_change_in_pre_serialize = FALSE;
-            cache_ptr->slist_change_in_serialize = FALSE;
-
-            /* this done, start the scan of the slist */
-            restart_slist_scan = TRUE;
-            while(restart_slist_scan || (node_ptr != NULL)) {
-                if(restart_slist_scan) {
-                    restart_slist_scan = FALSE;
-
-                    /* Start at beginning of skip list */
-                    node_ptr = H5SL_first(cache_ptr->slist_ptr);
-                    if(node_ptr == NULL)
-                        /* the slist is empty -- break out of inner loop */
-                        break;
-
-                    /* Get cache entry for this node */
-                    next_entry_ptr = (H5C_cache_entry_t *)H5SL_item(node_ptr);
-                    if(NULL == next_entry_ptr)
-                        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "next_entry_ptr == NULL ?!?!")
-
-                    HDassert(next_entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
-                    HDassert(next_entry_ptr->is_dirty);
-                    HDassert(next_entry_ptr->in_slist);
-                    HDassert(next_entry_ptr->ring >= ring);
-                } /* end if */
+        /* set the cache_ptr->slist_change_in_pre_serialize and
+         * cache_ptr->slist_change_in_serialize to false.
+         *
+         * These flags are set to TRUE by H5C__flush_single_entry if the
+         * slist is modified by a pre_serialize or serialize call 
+         * respectively.
+         *
+         * H5C_flush_invalidate_cache() uses these flags to detect any 
+         * modifications to the slist that might corrupt the scan of 
+         * the slist -- and restart the scan in this event.
+         */
+        cache_ptr->slist_change_in_pre_serialize = FALSE;
+        cache_ptr->slist_change_in_serialize = FALSE;
+
+        /* this done, start the scan of the slist */
+        restart_slist_scan = TRUE;
+        while(restart_slist_scan || (node_ptr != NULL)) {
+            if(restart_slist_scan) {
+                restart_slist_scan = FALSE;
+
+                /* Start at beginning of skip list */
+                node_ptr = H5SL_first(cache_ptr->slist_ptr);
+                if(node_ptr == NULL)
+                    /* the slist is empty -- break out of inner loop */
+                    break;
 
-                entry_ptr = next_entry_ptr;
+                /* Get cache entry for this node */
+                next_entry_ptr = (H5C_cache_entry_t *)H5SL_item(node_ptr);
+                if(NULL == next_entry_ptr)
+                    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "next_entry_ptr == NULL ?!?!")
 
-                /* It is possible that entries will be dirtied, resized, 
-                 * flushed, or removed from the cache via the take ownership
-                 * flag as the result of pre_serialize or serialized callbacks. 
-                 * 
-                 * This in turn can corrupt the scan through the slist.
-                 *
-                 * We test for slist modifications in the pre_serialize 
-                 * and serialize callbacks, and restart the scan of the 
-                 * slist if we find them.  However, best we do some extra
-                 * sanity checking just in case.
-                 */
-                HDassert(entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
-                HDassert(entry_ptr->in_slist);
-                HDassert(entry_ptr->is_dirty);
-                HDassert(entry_ptr->ring >= ring);
+                HDassert(next_entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
+                HDassert(next_entry_ptr->is_dirty);
+                HDassert(next_entry_ptr->in_slist);
+                HDassert(next_entry_ptr->ring >= ring);
+            } /* end if */
 
-                /* increment node pointer now, before we delete its target
-                 * from the slist.
-                 */
-                node_ptr = H5SL_next(node_ptr);
-                if(node_ptr != NULL) {
-                    next_entry_ptr = (H5C_cache_entry_t *)H5SL_item(node_ptr);
-                    if(NULL == next_entry_ptr)
-                        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "next_entry_ptr == NULL ?!?!")
-                    HDassert(next_entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
-                    HDassert(next_entry_ptr->is_dirty);
-                    HDassert(next_entry_ptr->in_slist);
-                    HDassert(next_entry_ptr->ring >= ring);
-                    HDassert(entry_ptr != next_entry_ptr);
-                } /* end if */
-                else
-                    next_entry_ptr = NULL;
+            entry_ptr = next_entry_ptr;
 
-                /* Note that we now remove nodes from the slist as we flush
-                 * the associated entries, instead of leaving them there
-                 * until we are done, and then destroying all nodes in
-                 * the slist.
-                 *
-                 * 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.
-                 */
-                HDassert(entry_ptr != NULL);
-                HDassert(entry_ptr->in_slist);
+            /* It is possible that entries will be dirtied, resized, 
+             * flushed, or removed from the cache via the take ownership
+             * flag as the result of pre_serialize or serialized callbacks. 
+             * 
+             * This in turn can corrupt the scan through the slist.
+             *
+             * We test for slist modifications in the pre_serialize 
+             * and serialize callbacks, and restart the scan of the 
+             * slist if we find them.  However, best we do some extra
+             * sanity checking just in case.
+             */
+            HDassert(entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
+            HDassert(entry_ptr->in_slist);
+            HDassert(entry_ptr->is_dirty);
+            HDassert(entry_ptr->ring >= ring);
 
-                if(((!entry_ptr->flush_me_last) ||
-                        ((entry_ptr->flush_me_last) &&
-                            (cache_ptr->num_last_entries >= cache_ptr->slist_len))) &&
-                        (entry_ptr->ring == ring)) {
-                    if(entry_ptr->is_protected) {
-                        /* we have major problems -- but lets flush
-                         * everything we can before we flag an error.
-                         */
-                        protected_entries++;
-                    } else if(entry_ptr->is_pinned) {
+            /* increment node pointer now, before we delete its target
+             * from the slist.
+             */
+            node_ptr = H5SL_next(node_ptr);
+            if(node_ptr != NULL) {
+                next_entry_ptr = (H5C_cache_entry_t *)H5SL_item(node_ptr);
+                if(NULL == next_entry_ptr)
+                    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "next_entry_ptr == NULL ?!?!")
+                HDassert(next_entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
+                HDassert(next_entry_ptr->is_dirty);
+                HDassert(next_entry_ptr->in_slist);
+                HDassert(next_entry_ptr->ring >= ring);
+                HDassert(entry_ptr != next_entry_ptr);
+            } /* end if */
+            else
+                next_entry_ptr = NULL;
+
+            /* Note that we now remove nodes from the slist as we flush
+             * the associated entries, instead of leaving them there
+             * until we are done, and then destroying all nodes in
+             * the slist.
+             *
+             * 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.
+             */
+            HDassert(entry_ptr != NULL);
+            HDassert(entry_ptr->in_slist);
+
+            if(((!entry_ptr->flush_me_last) ||
+                    ((entry_ptr->flush_me_last) &&
+                        (cache_ptr->num_last_entries >= cache_ptr->slist_len))) &&
+                    (entry_ptr->flush_dep_nchildren == 0) &&
+                    (entry_ptr->ring == ring)) {
+                if(entry_ptr->is_protected) {
+                    /* we have major problems -- but lets flush
+                     * everything we can before we flag an error.
+                     */
+                    protected_entries++;
+                } else if(entry_ptr->is_pinned) {
 
-                        /* Test to see if we are can flush the entry now.
-                         * If we can, go ahead and flush, but don't tell
-                         * H5C__flush_single_entry() to destroy the entry
-                         * as pinned entries can't be evicted.
-                         */
-                        if(entry_ptr->flush_dep_height == curr_flush_dep_height) {
 #if H5C_DO_SANITY_CHECKS
-                            /* update flushed_slist_len & flushed_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.
-                             *
-                             */
-                            flushed_slist_len++;
-                            flushed_slist_size += (int64_t)entry_ptr->size;
-		            entry_size_change = 0;
+                    /* update flushed_slist_len & flushed_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.
+                     *
+                     */
+                    flushed_slist_len++;
+                    flushed_slist_size += (int64_t)entry_ptr->size;
+                    entry_size_change = 0;
 #endif /* H5C_DO_SANITY_CHECKS */
 
-                            if(H5C__flush_single_entry(f, dxpl_id, entry_ptr, H5C__NO_FLAGS_SET, entry_size_change_ptr, NULL) < 0)
-                                HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "dirty pinned entry flush failed.")
+                    if(H5C__flush_single_entry(f, dxpl_id, entry_ptr, H5C__NO_FLAGS_SET, entry_size_change_ptr, NULL) < 0)
+                        HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "dirty pinned entry flush failed.")
 #if H5C_DO_SANITY_CHECKS
-                            /* entry size may have changed during the flush.
-                             * Update flushed_slist_size to account for this.
-                             */
-                            flushed_slist_size += entry_size_change;
+                    /* entry size may have changed during the flush.
+                     * Update flushed_slist_size to account for this.
+                     */
+                    flushed_slist_size += entry_size_change;
 #endif /* H5C_DO_SANITY_CHECKS */
 
-                            flushed_during_dep_loop = TRUE;
-                            if((cache_ptr->slist_change_in_serialize) ||
-                                    (cache_ptr->slist_change_in_pre_serialize)) {
-                                /* The slist has been modified by something
-                                 * other than the simple removal of the
-                                 * of the flushed entry after the flush.
-                                 *
-                                 * This has the potential to corrupt the
-                                 * scan through the slist, so restart it.
-                                 */
-                                restart_slist_scan = TRUE;
-                                cache_ptr->slist_change_in_pre_serialize = FALSE;
-                                cache_ptr->slist_change_in_serialize = FALSE;
-				H5C__UPDATE_STATS_FOR_SLIST_SCAN_RESTART(cache_ptr);
-                            } /* end if */
-                        } /* end if */
-                        else if(entry_ptr->flush_dep_height < curr_flush_dep_height)
-                            /* This shouldn't happen -- if it does, just scream and die.  */
-                            HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "dirty entry below current flush dep. height.")
+                    if((cache_ptr->slist_change_in_serialize) ||
+                            (cache_ptr->slist_change_in_pre_serialize)) {
+                        /* The slist has been modified by something
+                         * other than the simple removal of the
+                         * of the flushed entry after the flush.
+                         *
+                         * This has the potential to corrupt the
+                         * scan through the slist, so restart it.
+                         */
+                        restart_slist_scan = TRUE;
+                        cache_ptr->slist_change_in_pre_serialize = FALSE;
+                        cache_ptr->slist_change_in_serialize = FALSE;
+                        H5C__UPDATE_STATS_FOR_SLIST_SCAN_RESTART(cache_ptr);
                     } /* end if */
-                    else {
-                        if(entry_ptr->flush_dep_height == curr_flush_dep_height) {
+                } /* end if */
+                else {
 #if H5C_DO_SANITY_CHECKS
-                            /* update flushed_slist_len & flushed_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.
-                             *
-                             */
-                            flushed_slist_len++;
-                            flushed_slist_size += (int64_t)entry_ptr->size;
-		            entry_size_change = 0;
+                    /* update flushed_slist_len & flushed_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.
+                     *
+                     */
+                    flushed_slist_len++;
+                    flushed_slist_size += (int64_t)entry_ptr->size;
+                    entry_size_change = 0;
 #endif /* H5C_DO_SANITY_CHECKS */
 
-                            if(H5C__flush_single_entry(f, dxpl_id, entry_ptr, 
-                                        (cooked_flags | H5C__FLUSH_INVALIDATE_FLAG | H5C__DEL_FROM_SLIST_ON_DESTROY_FLAG), 
-                                        entry_size_change_ptr, NULL) < 0)
-                                HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "dirty entry flush destroy failed.")
+                    if(H5C__flush_single_entry(f, dxpl_id, entry_ptr, 
+                                (cooked_flags | H5C__FLUSH_INVALIDATE_FLAG | H5C__DEL_FROM_SLIST_ON_DESTROY_FLAG), 
+                                entry_size_change_ptr, NULL) < 0)
+                        HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "dirty entry flush destroy failed.")
 #if H5C_DO_SANITY_CHECKS
-                            /* entry size may have changed during the flush.
-                             * Update flushed_slist_size to account for this.
-                             */
-                            flushed_slist_size += entry_size_change;
+                    /* entry size may have changed during the flush.
+                     * Update flushed_slist_size to account for this.
+                     */
+                    flushed_slist_size += entry_size_change;
 #endif /* H5C_DO_SANITY_CHECKS */
 
-                            flushed_during_dep_loop = TRUE;
-
-                            if((cache_ptr->slist_change_in_serialize) ||
-                                    (cache_ptr->slist_change_in_pre_serialize)) {
-                                /* The slist has been modified by something
-                                 * other than the simple removal of the
-                                 * of the flushed entry after the flush.
-                                 *
-                                 * This has the potential to corrupt the
-                                 * scan through the slist, so restart it.
-                                 */
-                                restart_slist_scan = TRUE;
-                                cache_ptr->slist_change_in_pre_serialize = FALSE;
-                                cache_ptr->slist_change_in_serialize = FALSE;
-				H5C__UPDATE_STATS_FOR_SLIST_SCAN_RESTART(cache_ptr)
-                            } /* end if */
-                        } /* end if */
-                        else if(entry_ptr->flush_dep_height < curr_flush_dep_height)
-                            /* This shouldn't happen -- if it does, just scream and die.  */
-                            HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "dirty entry below current flush dep. height.")
-                    } /* end else */
-                } /* end if */
-            } /* end while loop scanning skip list */
+                    if((cache_ptr->slist_change_in_serialize) ||
+                            (cache_ptr->slist_change_in_pre_serialize)) {
+                        /* The slist has been modified by something
+                         * other than the simple removal of the
+                         * of the flushed entry after the flush.
+                         *
+                         * This has the potential to corrupt the
+                         * scan through the slist, so restart it.
+                         */
+                        restart_slist_scan = TRUE;
+                        cache_ptr->slist_change_in_pre_serialize = FALSE;
+                        cache_ptr->slist_change_in_serialize = FALSE;
+                        H5C__UPDATE_STATS_FOR_SLIST_SCAN_RESTART(cache_ptr)
+                    } /* end if */
+                } /* end else */
+            } /* end if */
+        } /* end while loop scanning skip list */
 
 #if H5C_DO_SANITY_CHECKS
-            /* 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.
-             *
-             * Don't bother with the sanity checks if node_ptr != NULL, as
-             * in this case we broke out of the loop because it got changed
-             * out from under us.
-             */
+        /* 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.
+         *
+         * Don't bother with the sanity checks if node_ptr != NULL, as
+         * in this case we broke out of the loop because it got changed
+         * out from under us.
+         */
 
-            if(node_ptr == NULL) {
-                HDassert((flushed_slist_len + cache_ptr->slist_len) ==
-                        (initial_slist_len + cache_ptr->slist_len_increase));
-                HDassert((flushed_slist_size + (int64_t)cache_ptr->slist_size) ==
-                        ((int64_t)initial_slist_size + cache_ptr->slist_size_increase));
-            } /* end if */
+        if(node_ptr == NULL) {
+            HDassert((flushed_slist_len + cache_ptr->slist_len) ==
+                    (initial_slist_len + cache_ptr->slist_len_increase));
+            HDassert((flushed_slist_size + (int64_t)cache_ptr->slist_size) ==
+                    ((int64_t)initial_slist_size + cache_ptr->slist_size_increase));
+        } /* end if */
 #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.
-             *
-             * 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++) {
-                next_entry_ptr = cache_ptr->index[i];
-
-                while(next_entry_ptr != NULL) {
-                    entry_ptr = next_entry_ptr;
-                    HDassert(entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
-                    HDassert(entry_ptr->ring >= ring);
-
-                    next_entry_ptr = entry_ptr->ht_next;
-                    HDassert((next_entry_ptr == NULL) ||
-                            (next_entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC));
-
-                    if(((!entry_ptr->flush_me_last) ||
-                           ((entry_ptr->flush_me_last) &&
-                                (cache_ptr->num_last_entries >= cache_ptr->slist_len))) &&
-                           (entry_ptr->ring == ring)) {
-
-                        if(entry_ptr->is_protected) {
-                            /* we have major problems -- but lets flush and 
-                             * destroy everything we can before we flag an 
-                             * error.
-                             */
-                            protected_entries++;
-                            if(!entry_ptr->in_slist)
-                                HDassert(!(entry_ptr->is_dirty));
-                        } else if(!(entry_ptr->is_pinned)) {
+        /* Since we are doing a destroy, we must make a pass through
+         * the hash table and try to flush - destroy all entries that
+         * 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++) {
+            next_entry_ptr = cache_ptr->index[i];
 
-                            /* Test to see if we are can flush the entry now.
-                             * If we can, go ahead and flush.
+            while(next_entry_ptr != NULL) {
+                entry_ptr = next_entry_ptr;
+                HDassert(entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
+                HDassert(entry_ptr->ring >= ring);
+
+                next_entry_ptr = entry_ptr->ht_next;
+                HDassert((next_entry_ptr == NULL) ||
+                        (next_entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC));
+
+                if(((!entry_ptr->flush_me_last) ||
+                       ((entry_ptr->flush_me_last) &&
+                            (cache_ptr->num_last_entries >= cache_ptr->slist_len))) &&
+                       (entry_ptr->flush_dep_nchildren == 0) &&
+                       (entry_ptr->ring == ring)) {
+
+                    if(entry_ptr->is_protected) {
+                        /* we have major problems -- but lets flush and 
+                         * destroy everything we can before we flag an 
+                         * error.
+                         */
+                        protected_entries++;
+                        if(!entry_ptr->in_slist)
+                            HDassert(!(entry_ptr->is_dirty));
+                    } else if(!(entry_ptr->is_pinned)) {
+
+                        /* if *entry_ptr is dirty, it is possible 
+                         * that one or more other entries may be 
+                         * either removed from the cache, loaded 
+                         * into the cache, or moved to a new location
+                         * in the file as a side effect of the flush.
+                         *
+                         * If this happens, and one of the target 
+                         * entries happens to be the next entry in 
+                         * the hash bucket, we could find ourselves 
+                         * either find ourselves either scanning a 
+                         * non-existant entry, scanning through a 
+                         * different bucket, or skipping an entry.
+                         *
+                         * Neither of these are good, so restart the 
+                         * the scan at the head of the hash bucket 
+                         * after the flush if *entry_ptr was dirty,
+                         * on the off chance that the next entry was
+                         * a target.
+                         *
+                         * This is not as inefficient at it might seem,
+                         * as hash buckets typically have at most two
+                         * or three entries.
+                         */
+                        hbool_t entry_was_dirty;
+
+                        entry_was_dirty = entry_ptr->is_dirty;
+
+                        if(H5C__flush_single_entry(f, dxpl_id, entry_ptr, 
+                                (cooked_flags | H5C__FLUSH_INVALIDATE_FLAG | H5C__DEL_FROM_SLIST_ON_DESTROY_FLAG), 
+                                NULL, NULL) < 0)
+                            HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "Entry flush destroy failed.")
+
+                        if(entry_was_dirty) {
+                            /* update stats for hash bucket scan
+                             * restart here.
+                             *                   -- JRM 
                              */
-                            if(entry_ptr->flush_dep_height == curr_flush_dep_height) {
-				/* if *entry_ptr is dirty, it is possible 
-                                 * that one or more other entries may be 
-                                 * either removed from the cache, loaded 
-                                 * into the cache, or moved to a new location
-                                 * in the file as a side effect of the flush.
-                                 *
-                                 * If this happens, and one of the target 
-                                 * entries happens to be the next entry in 
-                                 * the hash bucket, we could find ourselves 
-				 * either find ourselves either scanning a 
-                                 * non-existant entry, scanning through a 
-                                 * different bucket, or skipping an entry.
-                                 *
-                                 * Neither of these are good, so restart the 
-                                 * the scan at the head of the hash bucket 
-                                 * after the flush if *entry_ptr was dirty,
-                                 * on the off chance that the next entry was
-                                 * a target.
-                                 *
-                                 * This is not as inefficient at it might seem,
-                                 * as hash buckets typically have at most two
-                                 * or three entries.
-                                 */
-                                hbool_t entry_was_dirty;
-
-                                entry_was_dirty = entry_ptr->is_dirty;
-
-                                if(H5C__flush_single_entry(f, dxpl_id, entry_ptr, 
-                                        (cooked_flags | H5C__FLUSH_INVALIDATE_FLAG | H5C__DEL_FROM_SLIST_ON_DESTROY_FLAG), 
-                                        NULL, NULL) < 0)
-                                    HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "Entry flush destroy failed.")
-
-				if(entry_was_dirty) {
-                                    /* update stats for hash bucket scan
-                                     * restart here.
-                                     *                   -- JRM 
-                                     */
-                                    next_entry_ptr = cache_ptr->index[i];
-				    H5C__UPDATE_STATS_FOR_HASH_BUCKET_SCAN_RESTART(cache_ptr)
-                                } /* end if */
-
-                                flushed_during_dep_loop = TRUE;
-                            } /* end if */
-                            else if(entry_ptr->flush_dep_height < curr_flush_dep_height)
-                                /* This shouldn't happen -- if it does, just scream and die.  */
-                                HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "dirty entry below current flush dep. height.")
+                            next_entry_ptr = cache_ptr->index[i];
+                            H5C__UPDATE_STATS_FOR_HASH_BUCKET_SCAN_RESTART(cache_ptr)
                         } /* end if */
                     } /* end if */
-                    /* We can't do anything if the entry is pinned.  The
-                     * hope is that the entry will be unpinned as the
-                     * result of destroys of entries that reference it.
-                     *
-                     * We detect this by noting the change in the number
-                     * of pinned entries from pass to pass.  If it stops
-                     * shrinking before it hits zero, we scream and die.
-                     */
-                    /* if the serialize function on the entry we last evicted
-                     * loaded an entry into cache (as Quincey has promised me
-                     * it never will), and if the cache was full, it is
-                     * possible that *next_entry_ptr was flushed or evicted.
-                     *
-                     * Test to see if this happened here.  Note that if this
-                     * test is triggred, we are accessing a deallocated piece
-                     * of dynamically allocated memory, so we just scream and
-                     * die.
-                     *
-                     * Update: The code to restart the scan after flushes
-                     *         of dirty entries should make it impossible 
-                     *         to satisfy the following test.  Leave it in
-                     *         in case I am wrong.
-                     *                                    -- JRM
-                     */
-                    if((next_entry_ptr != NULL) && (next_entry_ptr->magic != H5C__H5C_CACHE_ENTRY_T_MAGIC))
-                        /* Something horrible has happened to
-                         * *next_entry_ptr -- scream and die.
-                         */
-                        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "next_entry_ptr->magic is invalid?!?!?.")
-                } /* end while loop scanning hash table bin */
-            } /* end for loop scanning hash table */
-
-            /* Check for incrementing flush dependency height */
-            if(flushed_during_dep_loop) {
-                /* If we flushed an entry at this flush dependency height
-                 *  start over at the bottom level of the flush dependencies
-                 */
-                curr_flush_dep_height = 0;
-
-                /* Make certain we don't get stuck in an infinite loop */
-                flush_dep_passes++;
-            } /* end if */
-            else
-                curr_flush_dep_height++;
+                } /* end if */
 
-        } /* end while loop over flush dependency heights */
+                /* We can't do anything if the entry is pinned.  The
+                 * hope is that the entry will be unpinned as the
+                 * result of destroys of entries that reference it.
+                 *
+                 * We detect this by noting the change in the number
+                 * of pinned entries from pass to pass.  If it stops
+                 * shrinking before it hits zero, we scream and die.
+                 */
+                /* if the serialize function on the entry we last evicted
+                 * loaded an entry into cache (as Quincey has promised me
+                 * it never will), and if the cache was full, it is
+                 * possible that *next_entry_ptr was flushed or evicted.
+                 *
+                 * Test to see if this happened here.  Note that if this
+                 * test is triggred, we are accessing a deallocated piece
+                 * of dynamically allocated memory, so we just scream and
+                 * die.
+                 *
+                 * Update: The code to restart the scan after flushes
+                 *         of dirty entries should make it impossible 
+                 *         to satisfy the following test.  Leave it in
+                 *         in case I am wrong.
+                 *                                    -- JRM
+                 */
+                if((next_entry_ptr != NULL) && (next_entry_ptr->magic != H5C__H5C_CACHE_ENTRY_T_MAGIC))
+                    /* Something horrible has happened to
+                     * *next_entry_ptr -- scream and die.
+                     */
+                    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "next_entry_ptr->magic is invalid?!?!?.")
+            } /* end while loop scanning hash table bin */
+        } /* end for loop scanning hash table */
 
 	old_ring_pel_len = cur_ring_pel_len;
         entry_ptr = cache_ptr->pel_head_ptr;
@@ -6700,20 +6546,19 @@ H5C_flush_invalidate_ring(const H5F_t * f, hid_t dxpl_id, H5C_ring_t ring,
         } /* end while */
 
 	if((cur_ring_pel_len > 0) && (cur_ring_pel_len >= old_ring_pel_len)) {
+            /* Don't error if allowed to have pinned entries remaining */
+	    if(evict_flags)
+                HGOTO_DONE(TRUE)
+
 	   /* The number of pinned entries in the ring is positive, and 
             * it is not declining.  Scream and die.
 	    */
             HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "Pinned entry count not decreasing, cur_ring_pel_len = %d, old_ring_pel_len = %d, ring = %d", (int)cur_ring_pel_len, (int)old_ring_pel_len, (int)ring)
-        } else if((cur_ring_pel_len == 0) && (old_ring_pel_len == 0)) {
-	    /* increment the pass count */
-	    passes++;
-	}
+        } /* end if */
 
-	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.")
+        HDassert(protected_entries == cache_ptr->pl_len);
+        if((protected_entries > 0) && (protected_entries == cache_ptr->index_len))
+            HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "Only protected entries left in cache, protected_entries = %d", (int)protected_entries)
     } /* main while loop */
 
     /* Invariants, after destroying all entries in the ring */
@@ -6767,12 +6612,12 @@ herr_t
 H5C_flush_ring(H5F_t *f, hid_t dxpl_id, H5C_ring_t ring,  unsigned flags)
 {
     H5C_t * cache_ptr = f->shared->cache;
+    hbool_t		destroy;
     hbool_t		flushed_entries_last_pass;
     hbool_t		flush_marked_entries;
     hbool_t		ignore_protected;
     hbool_t		tried_to_flush_protected_entry = FALSE;
     hbool_t		restart_slist_scan;
-    int32_t		passes = 0;
     int32_t		protected_entries = 0;
     H5SL_node_t * 	node_ptr = NULL;
     H5C_cache_entry_t *	entry_ptr = NULL;
@@ -6807,6 +6652,7 @@ H5C_flush_ring(H5F_t *f, hid_t dxpl_id, H5C_ring_t ring,  unsigned flags)
 #endif /* H5C_DO_EXTREME_SANITY_CHECKS */
 
     ignore_protected = ( (flags & H5C__FLUSH_IGNORE_PROTECTED_FLAG) != 0 );
+    destroy = ( (flags & H5C__FLUSH_INVALIDATE_FLAG) != 0 );
     flush_marked_entries = ( (flags & H5C__FLUSH_MARKED_ENTRIES_FLAG) != 0 );
 
     if(!flush_marked_entries)
@@ -6834,264 +6680,182 @@ H5C_flush_ring(H5F_t *f, hid_t dxpl_id, H5C_ring_t ring,  unsigned flags)
     cache_ptr->slist_change_in_pre_serialize = FALSE;
     cache_ptr->slist_change_in_serialize = FALSE;
 
-    while((passes < H5C__MAX_PASSES_ON_FLUSH) &&
-            (cache_ptr->slist_ring_len[ring] > 0) &&
+    while((cache_ptr->slist_ring_len[ring] > 0) &&
 	    (protected_entries == 0)  &&
 	    (flushed_entries_last_pass)) {
-        unsigned curr_flush_dep_height = 0;
-        unsigned flush_dep_passes = 0;
-
         flushed_entries_last_pass = FALSE;
 
-        /* Loop over all flush dependency heights of entries */
-        while((curr_flush_dep_height <= H5C__NUM_FLUSH_DEP_HEIGHTS) &&
-                (cache_ptr->slist_ring_len[ring] > 0) &&
-                (flush_dep_passes < H5C__MAX_PASSES_ON_FLUSH)) {
-            hbool_t flushed_during_dep_loop = FALSE;
-
 #if H5C_DO_SANITY_CHECKS
-            /* 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 serialize callback can cause entries
-             * to be dirtied, resized, and/or moved.  Also, the 
-             * pre_serialize callback can result in an entry being 
-             * removed from the cache via the take ownership flag.
-             *
-             * 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;
+        /* 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 serialize callback can cause entries
+         * to be dirtied, resized, and/or moved.  Also, the 
+         * pre_serialize callback can result in an entry being 
+         * removed from the cache via the take ownership flag.
+         *
+         * 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;
 
-            /* 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, flushed, or removed
-             * from the cache via the take ownership flag  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;
+        /* 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, flushed, or removed
+         * from the cache via the take ownership flag  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.
-             */
+        /* 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 */
 
-            restart_slist_scan = TRUE;
-
-            while((restart_slist_scan ) || (node_ptr != NULL)) {
-                if(restart_slist_scan) {
-                    restart_slist_scan = FALSE;
+        restart_slist_scan = TRUE;
 
-                    /* Start at beginning of skip list */
-                    node_ptr = H5SL_first(cache_ptr->slist_ptr);
+        while((restart_slist_scan ) || (node_ptr != NULL)) {
+            if(restart_slist_scan) {
+                restart_slist_scan = FALSE;
 
-                    if(node_ptr == NULL)
-                        /* the slist is empty -- break out of inner loop */
-	                break;
+                /* Start at beginning of skip list */
+                node_ptr = H5SL_first(cache_ptr->slist_ptr);
 
-                    /* Get cache entry for this node */
-                    next_entry_ptr = (H5C_cache_entry_t *)H5SL_item(node_ptr);
+                if(node_ptr == NULL)
+                    /* the slist is empty -- break out of inner loop */
+                    break;
 
-                    if(NULL == next_entry_ptr)
-                        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "next_entry_ptr == NULL ?!?!")
+                /* Get cache entry for this node */
+                next_entry_ptr = (H5C_cache_entry_t *)H5SL_item(node_ptr);
 
-                    HDassert(next_entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
-                    HDassert(next_entry_ptr->is_dirty);
-                    HDassert(next_entry_ptr->in_slist);
-                } /* end if */
-                    
-                entry_ptr = next_entry_ptr;
+                if(NULL == next_entry_ptr)
+                    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "next_entry_ptr == NULL ?!?!")
 
-                /* With the advent of the fractal heap, the free space
-                 * manager, and the version 3 cache, it is possible
-                 * that the pre-serialize or serialize callback will 
-                 * dirty, resize, or take ownership of other entries 
-                 * in the cache.  
-                 *
-                 * To deal with this, I have inserted code to detect any
-                 * change in the skip list not directly under the control
-                 * of this function.  If such modifications are detected,
-                 * we must re-start the scan of the skip list to avoid 
-                 * the possibility that the target of the next_entry_ptr
-                 * may have been flushed or deleted from the cache.
-                 *
-                 * To verify that all such possibilities have been dealt
-                 * with, we do a bit of extra sanity checking on 
-                 * entry_ptr.
-                 */
-                HDassert(entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
-                HDassert(entry_ptr->in_slist);
-                HDassert(entry_ptr->is_dirty);
-                if(!flush_marked_entries || entry_ptr->flush_marker)
-                    HDassert(entry_ptr->ring >= ring);
+                HDassert(next_entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
+                HDassert(next_entry_ptr->is_dirty);
+                HDassert(next_entry_ptr->in_slist);
+            } /* end if */
+                
+            entry_ptr = next_entry_ptr;
+
+            /* With the advent of the fractal heap, the free space
+             * manager, and the version 3 cache, it is possible
+             * that the pre-serialize or serialize callback will 
+             * dirty, resize, or take ownership of other entries 
+             * in the cache.  
+             *
+             * To deal with this, I have inserted code to detect any
+             * change in the skip list not directly under the control
+             * of this function.  If such modifications are detected,
+             * we must re-start the scan of the skip list to avoid 
+             * the possibility that the target of the next_entry_ptr
+             * may have been flushed or deleted from the cache.
+             *
+             * To verify that all such possibilities have been dealt
+             * with, we do a bit of extra sanity checking on 
+             * entry_ptr.
+             */
+            HDassert(entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
+            HDassert(entry_ptr->in_slist);
+            HDassert(entry_ptr->is_dirty);
+            if(!flush_marked_entries || entry_ptr->flush_marker)
+                HDassert(entry_ptr->ring >= ring);
 
-                /* increment node pointer now, before we delete its target
-                 * from the slist.
-                 */
-                node_ptr = H5SL_next(node_ptr);
-                if(node_ptr != NULL) {
-                    next_entry_ptr = (H5C_cache_entry_t *)H5SL_item(node_ptr);
-                    if(NULL == next_entry_ptr)
-                        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "next_entry_ptr == NULL ?!?!")
-
-                    HDassert(next_entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
-                    HDassert(next_entry_ptr->is_dirty);
-                    HDassert(next_entry_ptr->in_slist);
-                    if(!flush_marked_entries || next_entry_ptr->flush_marker)
-                        HDassert(next_entry_ptr->ring >= ring);
-                    HDassert(entry_ptr != next_entry_ptr);
-                } /* end if */
-                else
-                    next_entry_ptr = NULL;
+            /* increment node pointer now, before we delete its target
+             * from the slist.
+             */
+            node_ptr = H5SL_next(node_ptr);
+            if(node_ptr != NULL) {
+                next_entry_ptr = (H5C_cache_entry_t *)H5SL_item(node_ptr);
+                if(NULL == next_entry_ptr)
+                    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "next_entry_ptr == NULL ?!?!")
+
+                HDassert(next_entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
+                HDassert(next_entry_ptr->is_dirty);
+                HDassert(next_entry_ptr->in_slist);
+                if(!flush_marked_entries || next_entry_ptr->flush_marker)
+                    HDassert(next_entry_ptr->ring >= ring);
 
-                HDassert(entry_ptr != NULL);
-                HDassert(entry_ptr->in_slist);
+                HDassert(entry_ptr != next_entry_ptr);
+            } /* end if */
+            else
+                next_entry_ptr = NULL;
 
-                if(((!flush_marked_entries) || (entry_ptr->flush_marker)) &&
-                        ((!entry_ptr->flush_me_last) ||
-                           ((entry_ptr->flush_me_last) &&
-                             (cache_ptr->num_last_entries >= cache_ptr->slist_len))) &&
-                         (entry_ptr->ring == ring)) {
-                    if(entry_ptr->is_protected) {
-                        /* 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++;
-                    } /* end if */
-                    else if(entry_ptr->is_pinned) {
+            HDassert(entry_ptr != NULL);
+            HDassert(entry_ptr->in_slist);
 
-                        /* Test to see if we are can flush the entry now.
-                         * If we can, go ahead and flush.  Note that we
-                         * aren't trying to do a destroy here, so that
-                         * is not an issue.
-                         */
-                        if(entry_ptr->flush_dep_height == curr_flush_dep_height) {
+            if(((!flush_marked_entries) || (entry_ptr->flush_marker)) &&
+                    ((!entry_ptr->flush_me_last) ||
+                       (entry_ptr->flush_me_last &&
+                         ((cache_ptr->num_last_entries >= cache_ptr->slist_len) ||
+                           (flush_marked_entries && entry_ptr->flush_marker)))) &&
+                       ( ( entry_ptr->flush_dep_nchildren == 0 ) ||
+                         ( ( ! destroy ) &&
+                           ( entry_ptr->flush_dep_ndirty_children == 0 ) ) ) &&
+                     (entry_ptr->ring == ring)) {
+                if(entry_ptr->is_protected) {
+                    /* 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++;
+                } /* end if */
+                else {
 #if H5C_DO_SANITY_CHECKS
-                            flushed_entries_count++;
-                            flushed_entries_size += (int64_t)entry_ptr->size;
-                            entry_size_change = 0;
+                    flushed_entries_count++;
+                    flushed_entries_size += (int64_t)entry_ptr->size;
+                    entry_size_change = 0;
 #endif /* H5C_DO_SANITY_CHECKS */
-
-                            if(H5C__flush_single_entry(f, dxpl_id, entry_ptr, flags, entry_size_change_ptr, NULL) < 0)
-                                HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "dirty pinned entry flush failed.")
+                    if(H5C__flush_single_entry(f, dxpl_id, entry_ptr, flags, entry_size_change_ptr, NULL) < 0)
+                        HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "Can't flush entry.")
 
 #if H5C_DO_SANITY_CHECKS
-                            /* it is possible that the entry size changed
-                             * during flush -- update flushed_entries_size
-                             * to account for this.
-                             */
-                            flushed_entries_size += entry_size_change;
+                    /* it is possible that the entry size changed
+                     * during flush -- update flushed_entries_size
+                     * to account for this.
+                     */
+                    flushed_entries_size += entry_size_change;
 #endif /* H5C_DO_SANITY_CHECKS */
 
-                            flushed_during_dep_loop = TRUE;
-
-                            if((cache_ptr->slist_change_in_serialize) ||
-                                    (cache_ptr->slist_change_in_pre_serialize)) {
-                                /* The slist has been modified by something
-                                 * other than the simple removal of the 
-                                 * of the flushed entry after the flush.
-                                 * 
-                                 * This has the potential to corrupt the
-                                 * scan through the slist, so restart it.
-                                 */
-                                restart_slist_scan = TRUE;
-                                cache_ptr->slist_change_in_pre_serialize = FALSE;
-                                cache_ptr->slist_change_in_serialize = FALSE;
-
-				H5C__UPDATE_STATS_FOR_SLIST_SCAN_RESTART(cache_ptr)
-                            } /* end if */
-                        } /* end if */
-                        else if(entry_ptr->flush_dep_height < curr_flush_dep_height)
-                            /* This shouldn't happen -- if it does, just scream and die. */
-                            HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "dirty entry below current flush dep. height.")
-                    } /* end else-if */
-                    else {
-                        /* Test to see if we are can flush the entry now.
-                         * If we can, go ahead and flush.  Note that we
-                         * aren't trying to do a destroy here, so that
-                         * is not an issue.
+                    if((cache_ptr->slist_change_in_serialize) ||
+                            (cache_ptr->slist_change_in_pre_serialize)) {
+                        /* The slist has been modified by something
+                         * other than the simple removal of the 
+                         * of the flushed entry after the flush.
+                         * 
+                         * This has the potential to corrupt the
+                         * scan through the slist, so restart it.
                          */
-                        if(entry_ptr->flush_dep_height == curr_flush_dep_height) {
-#if H5C_DO_SANITY_CHECKS
-                            flushed_entries_count++;
-                            flushed_entries_size += (int64_t)entry_ptr->size;
-                            entry_size_change = 0;
-#endif /* H5C_DO_SANITY_CHECKS */
-                            if(H5C__flush_single_entry(f, dxpl_id, entry_ptr, flags, entry_size_change_ptr, NULL) < 0)
-                                HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "Can't flush entry.")
-
-#if H5C_DO_SANITY_CHECKS
-                            /* it is possible that the entry size changed
-                             * during flush -- update flushed_entries_size
-                             * to account for this.
-                             */
-                            flushed_entries_size += entry_size_change;
-#endif /* H5C_DO_SANITY_CHECKS */
-
-                            flushed_during_dep_loop = TRUE;
-
-                            if((cache_ptr->slist_change_in_serialize) ||
-                                    (cache_ptr->slist_change_in_pre_serialize)) {
-                                /* The slist has been modified by something
-                                 * other than the simple removal of the 
-                                 * of the flushed entry after the flush.
-                                 * 
-                                 * This has the potential to corrupt the
-                                 * scan through the slist, so restart it.
-                                 */
-                                restart_slist_scan = TRUE;
-                                cache_ptr->slist_change_in_pre_serialize = FALSE;
-                                cache_ptr->slist_change_in_serialize = FALSE;
-
-                                H5C__UPDATE_STATS_FOR_SLIST_SCAN_RESTART(cache_ptr)
-                            } /* end if */
-                        } /* end if */
-                        else if(entry_ptr->flush_dep_height < curr_flush_dep_height)
-                            /* This shouldn't happen -- if it does, just scream and die. */
-                            HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "dirty entry below current flush dep. height.")
-                    } /* end else */
-                } /* end if */
-            } /* while ( ( restart_slist_scan ) || ( node_ptr != NULL ) ) */
-
-            /* Check for incrementing flush dependency height */
-            if(flushed_during_dep_loop) {
-
-                /* If we flushed an entry at this flush dependency height
-                 *  start over at the bottom level of the flush dependencies
-                 */
-                curr_flush_dep_height = 0;
+                        restart_slist_scan = TRUE;
+                        cache_ptr->slist_change_in_pre_serialize = FALSE;
+                        cache_ptr->slist_change_in_serialize = FALSE;
 
-                /* Make certain we don't get stuck in an infinite loop */
-                flush_dep_passes++;
+                        H5C__UPDATE_STATS_FOR_SLIST_SCAN_RESTART(cache_ptr)
+                    } /* end if */
 
-                /* Set flag for outer loop */
-                flushed_entries_last_pass = TRUE;
+                    flushed_entries_last_pass = TRUE;
+                } /* end else */
             } /* end if */
-            else
-                curr_flush_dep_height++;
-        } /* while ( curr_flush_dep_height <= H5C__NUM_FLUSH_DEP_HEIGHTS) */
-
-        passes++;
+        } /* while ( ( restart_slist_scan ) || ( node_ptr != NULL ) ) */
 
 #if H5C_DO_SANITY_CHECKS
         /* Verify that the slist size and length are as expected. */
@@ -7108,9 +6872,6 @@ H5C_flush_ring(H5F_t *f, hid_t dxpl_id, H5C_ring_t ring,  unsigned flags)
     if(((cache_ptr->pl_len > 0) && (!ignore_protected)) || (tried_to_flush_protected_entry))
         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_ring_len[ring] == 0);
@@ -7442,6 +7203,10 @@ H5C__flush_single_entry(const H5F_t *f, hid_t dxpl_id, H5C_cache_entry_t *entry_
             H5C__REMOVE_ENTRY_FROM_SLIST(cache_ptr, entry_ptr)
 
         H5C__UPDATE_RP_FOR_EVICTION(cache_ptr, entry_ptr, FAIL)
+
+	/* verify that the entry is no longer part of any flush dependencies */
+        HDassert(entry_ptr->flush_dep_nparents == 0);
+	HDassert(entry_ptr->flush_dep_nchildren == 0);
     }
     else {
         HDassert(clear_only || write_entry);
@@ -7471,6 +7236,16 @@ H5C__flush_single_entry(const H5F_t *f, hid_t dxpl_id, H5C_cache_entry_t *entry_
 
         if(entry_ptr->type->clear && (entry_ptr->type->clear)(f, (void *)entry_ptr, FALSE) < 0)
             HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "unable to clear entry")
+
+	/* Propagate the clean flag up the flush dependency chain if
+         * appropriate */
+        if(was_dirty) {
+	    HDassert(entry_ptr->flush_dep_ndirty_children == 0);
+
+	    if(entry_ptr->flush_dep_nparents > 0)
+		if(H5C__mark_flush_dep_clean(entry_ptr) < 0)
+		    HGOTO_ERROR(H5E_CACHE, H5E_CANTMARKDIRTY, FAIL, "Can't propagate flush dep clean flag")
+	} /* end if */
     }
 
     /* reset the flush_in progress flag */
@@ -7646,7 +7421,6 @@ H5C_load_entry(H5F_t *              f,
     void *      thing = NULL;           /* Pointer to thing loaded                  */
     H5C_cache_entry_t *entry = NULL;    /* Alias for thing loaded, as cache entry   */
     size_t      len;                    /* Size of image in file                    */
-    unsigned    u;                      /* Local index variable                     */
 #ifdef H5_HAVE_PARALLEL
     int         mpi_rank = 0;           /* MPI process rank                         */
     MPI_Comm    comm = MPI_COMM_NULL;   /* File MPI Communicator                    */
@@ -7986,9 +7760,10 @@ H5C_load_entry(H5F_t *              f,
 
     /* Initialize flush dependency height fields */
     entry->flush_dep_parent     = NULL;
-    for(u = 0; u < H5C__NUM_FLUSH_DEP_HEIGHTS; u++)
-        entry->child_flush_dep_height_rc[u] = 0;
-    entry->flush_dep_height = 0;
+    entry->flush_dep_nparents   = 0;
+    entry->flush_dep_parent_nalloc = 0;
+    entry->flush_dep_nchildren  = 0;
+    entry->flush_dep_ndirty_children = 0;
     entry->ht_next              = NULL;
     entry->ht_prev              = NULL;
 
@@ -8834,188 +8609,6 @@ H5C_entry_in_skip_list(H5C_t * cache_ptr, H5C_cache_entry_t *target_ptr)
 
 /*-------------------------------------------------------------------------
  *
- * Function:    H5C_get_entry_ptr_from_addr()
- *
- * Purpose:     Debugging function that attempts to look up an entry in the 
- *		cache by its file address, and if found, returns a pointer 
- *		to the entry in *entry_ptr_ptr.  If the entry is not in the 
- *		cache, *entry_ptr_ptr is set to NULL.
- *
- *		WARNING: This call should be used only in debugging  
- *			 routines, and it should be avoided when 
- *			 possible.
- *
- *			 Further, if we ever multi-thread the cache, 
- *			 this routine will have to be either discarded 
- *			 or heavily re-worked.
- *
- *			 Finally, keep in mind that the entry whose 
- *			 pointer is obtained in this fashion may not 
- *			 be in a stable state.  
- *
- *		Note that this function is only defined if NDEBUG
- *		is not defined.
- *
- *		As heavy use of this function is almost certainly a 
- *		bad idea, the metadata cache tracks the number of 
- *		successful calls to this function, and (if 
- *              H5C_DO_SANITY_CHECKS is defined) displays any 
- *		non-zero count on cache shutdown.
- *
- * Return:      FAIL if error is detected, SUCCEED otherwise.
- *
- * Programmer:  John Mainzer, 5/30/14
- *
- * Changes:
- *
- *		None.
- *
- *-------------------------------------------------------------------------
- */
-#ifndef NDEBUG
-herr_t
-H5C_get_entry_ptr_from_addr(const H5F_t *f,
-                            haddr_t   addr,
-			    void ** entry_ptr_ptr)
-{
-    H5C_t             * cache_ptr;
-    H5C_cache_entry_t * entry_ptr = NULL;
-    herr_t              ret_value = SUCCEED;      /* Return value */
-
-    FUNC_ENTER_NOAPI(FAIL)
-
-    HDassert( f );
-    HDassert( f->shared );
-
-    cache_ptr = f->shared->cache;
-
-    HDassert( cache_ptr != NULL );
-    HDassert( cache_ptr->magic == H5C__H5C_T_MAGIC );
-    HDassert( H5F_addr_defined(addr) );
-    HDassert( entry_ptr_ptr != NULL );
-
-    /* this test duplicates two of the above asserts, but we need an
-     * invocation of HGOTO_ERROR to keep the compiler happy.
-     */
-    if ( ( cache_ptr == NULL ) || ( cache_ptr->magic != H5C__H5C_T_MAGIC ) ) {
-
-        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Bad cache_ptr on entry.")
-    }
-
-    H5C__SEARCH_INDEX(cache_ptr, addr, entry_ptr, FAIL)
-
-    if ( entry_ptr == NULL ) {
-
-        /* the entry doesn't exist in the cache -- report this
-         * and quit.
-         */
-        *entry_ptr_ptr = NULL;
-
-    } else {
-
-        *entry_ptr_ptr = entry_ptr;
-
-	/* increment call counter */
-	(cache_ptr->get_entry_ptr_from_addr_counter)++;
-    }
-
-done:
-
-    FUNC_LEAVE_NOAPI(ret_value)
-
-} /* H5C_get_entry_ptr_from_addr() */
-
-#endif /* NDEBUG */
-
-
-/*-------------------------------------------------------------------------
- *
- * Function:    H5C_verify_entry_type()
- *
- * Purpose:     Debugging function that attempts to look up an entry in the 
- *		cache by its file address, and if found, test to see if its
- *		type field contains the expted value.
- *
- *		If the specified entry is in cache, *in_cache_ptr is set
- *		to TRUE, and *type_ok_ptr is set to TRUE or FALSE
- *		depending on whether the entries type field matches the 
- *		expected_type parameter
- *
- *		If the target entry is not in cache, *in_cache_ptr is 
- *		set to FALSE, and *type_ok_ptr is undefined.
- *
- *		Note that this function is only defined if NDEBUG
- *		is not defined.
- *
- * Return:      FAIL if error is detected, SUCCEED otherwise.
- *
- * Programmer:  John Mainzer, 5/30/14
- *
- * Changes:
- *
- *		None.
- *
- *-------------------------------------------------------------------------
- */
-#ifndef NDEBUG
-herr_t
-H5C_verify_entry_type(const H5F_t *f,
-                      haddr_t   addr,
-                      const H5C_class_t * expected_type,
-                      hbool_t * in_cache_ptr,
-                      hbool_t * type_ok_ptr)
-{
-    H5C_t             * cache_ptr;
-    H5C_cache_entry_t * entry_ptr = NULL;
-    herr_t              ret_value = SUCCEED;      /* Return value */
-
-    FUNC_ENTER_NOAPI(FAIL)
-
-    HDassert( f );
-    HDassert( f->shared );
-
-    cache_ptr = f->shared->cache;
-
-    HDassert( cache_ptr != NULL );
-    HDassert( cache_ptr->magic == H5C__H5C_T_MAGIC );
-    HDassert( H5F_addr_defined(addr) );
-    HDassert( in_cache_ptr != NULL );
-    HDassert( type_ok_ptr != NULL );
-
-    /* this test duplicates two of the above asserts, but we need an
-     * invocation of HGOTO_ERROR to keep the compiler happy.
-     */
-    if ( ( cache_ptr == NULL ) || ( cache_ptr->magic != H5C__H5C_T_MAGIC ) ) {
-
-        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Bad cache_ptr on entry.")
-    }
-
-    H5C__SEARCH_INDEX(cache_ptr, addr, entry_ptr, FAIL)
-
-    if ( entry_ptr == NULL ) {
-
-        /* the entry doesn't exist in the cache -- report this
-         * and quit.
-         */
-        *in_cache_ptr = FALSE;
-
-    } else {
-
-        *in_cache_ptr = TRUE;
-	*type_ok_ptr = (expected_type == entry_ptr->type);
-    }
-
-done:
-
-    FUNC_LEAVE_NOAPI(ret_value)
-
-} /* H5C_verify_entry_type() */
-
-#endif /* NDEBUG */
-
-
-/*-------------------------------------------------------------------------
- *
  * Function:    H5C__flush_marked_entries
  *
  * Purpose:     Flushes all marked entries in the cache.
@@ -9145,6 +8738,122 @@ done:
 
 
 /*-------------------------------------------------------------------------
+ * Function:    H5C__mark_flush_dep_dirty()
+ *
+ * Purpose:     Recursively propagate the flush_dep_ndirty_children flag
+ *              up the dependency chain in response to entry either
+ *              becoming dirty or having its flush_dep_ndirty_children
+ *              increased from 0.
+ *
+ * Return:      Non-negative on success/Negative on failure
+ *
+ * Programmer:  Neil Fortner
+ *              11/13/12
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5C__mark_flush_dep_dirty(H5C_cache_entry_t * entry)
+{
+    unsigned u;                         /* Local index variable */
+
+    FUNC_ENTER_STATIC_NOERR
+
+    /* Sanity checks */
+    HDassert(entry);
+
+    /* Iterate over the parent entries, if any */
+    for(u = 0; u < entry->flush_dep_nparents; u++) {
+	/* Sanity check */
+	HDassert(entry->flush_dep_parent[u]->flush_dep_ndirty_children < entry->flush_dep_parent[u]->flush_dep_nchildren);
+
+	/* Adjust the parent's number of dirty children */
+	entry->flush_dep_parent[u]->flush_dep_ndirty_children++;
+    } /* end for */
+
+    FUNC_LEAVE_NOAPI(SUCCEED)
+} /* H5C__mark_flush_dep_dirty() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:    H5C__mark_flush_dep_clean()
+ *
+ * Purpose:     Recursively propagate the flush_dep_ndirty_children flag
+ *              up the dependency chain in response to entry either
+ *              becoming clean or having its flush_dep_ndirty_children
+ *              reduced to 0.
+ *
+ * Return:      Non-negative on success/Negative on failure
+ *
+ * Programmer:  Neil Fortner
+ *              11/13/12
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5C__mark_flush_dep_clean(H5C_cache_entry_t * entry)
+{
+    unsigned u;                         /* Local index variable */
+
+    FUNC_ENTER_STATIC_NOERR
+
+    /* Sanity checks */
+    HDassert(entry);
+
+    /* Iterate over the parent entries, if any */
+    for(u = 0; u < entry->flush_dep_nparents; u++) {
+	/* Sanity check */
+	HDassert(entry->flush_dep_parent[u]->flush_dep_ndirty_children > 0);
+
+	/* Adjust the parent's number of dirty children */
+	entry->flush_dep_parent[u]->flush_dep_ndirty_children--;
+    } /* end for */
+
+    FUNC_LEAVE_NOAPI(SUCCEED)
+} /* H5C__mark_flush_dep_clean() */
+
+#ifndef NDEBUG
+
+/*-------------------------------------------------------------------------
+ * Function:    H5C__assert_flush_dep_nocycle()
+ *
+ * Purpose:     Assert recursively that base_entry is not the same as
+ *              entry, and perform the same assertion on all of entry's
+ *              flush dependency parents.  This is used to detect cycles
+ *              created by flush dependencies.
+ *
+ * Return:      void
+ *
+ * Programmer:  Neil Fortner
+ *              12/10/12
+ *
+ *-------------------------------------------------------------------------
+ */
+static void
+H5C__assert_flush_dep_nocycle(const H5C_cache_entry_t * entry,
+    const H5C_cache_entry_t * base_entry)
+{
+    unsigned u;                         /* Local index variable */
+
+    FUNC_ENTER_STATIC_NOERR
+
+    /* Sanity checks */
+    HDassert(entry);
+    HDassert(base_entry);
+
+    /* Make sure the entries are not the same */
+    HDassert(base_entry != entry);
+
+    /* Iterate over entry's parents (if any) */
+    for(u = 0; u < entry->flush_dep_nparents; u++)
+	H5C__assert_flush_dep_nocycle(entry->flush_dep_parent[u], base_entry);
+
+    FUNC_LEAVE_NOAPI_VOID
+} /* H5C__assert_flush_dep_nocycle() */
+#endif /* NDEBUG */
+
+
+/*-------------------------------------------------------------------------
  * Function:    H5C__generate_image
  *
  * Purpose:     Serialize an entry and generate its image.