Align with incoming page buffering changes: minor cleanups, centralize removing

entries from collective metadata read list

1 files changed, 35 insertions, 30 deletions

diff --git a/src/H5C.c b/src/H5C.c
index 805b4f5..8b43c77 100644
--- a/src/H5C.c
+++ b/src/H5C.c
@@ -925,12 +925,6 @@ H5C_expunge_entry(H5F_t *f, hid_t dxpl_id, const H5C_class_t *type,
         HGOTO_ERROR(H5E_CACHE, H5E_CANTEXPUNGE, FAIL, "Target entry is protected")
     if(entry_ptr->is_pinned)
         HGOTO_ERROR(H5E_CACHE, H5E_CANTEXPUNGE, FAIL, "Target entry is pinned")
-#ifdef H5_HAVE_PARALLEL
-    if(entry_ptr->coll_access) {
-        entry_ptr->coll_access = FALSE;
-        H5C__REMOVE_FROM_COLL_LIST(cache_ptr, entry_ptr, FAIL)
-    } /* end if */
-#endif /* H5_HAVE_PARALLEL */
 
     /* If we get this far, call H5C__flush_single_entry() with the
      * H5C__FLUSH_INVALIDATE_FLAG and the H5C__FLUSH_CLEAR_ONLY_FLAG.
@@ -1465,10 +1459,15 @@ H5C_insert_entry(H5F_t *             f,
     entry_ptr->prefetched			= FALSE;
     entry_ptr->prefetch_type_id			= 0;
     entry_ptr->age				= 0;
+    entry_ptr->prefetched_dirty                 = FALSE;
 #ifndef NDEBUG  /* debugging field */
     entry_ptr->serialization_count		= 0;
 #endif /* NDEBUG */
 
+    entry_ptr->tl_next  = NULL;
+    entry_ptr->tl_prev  = NULL;
+    entry_ptr->tag_info = NULL;
+
     /* Apply tag to newly inserted entry */
     if(H5C__tag_entry(cache_ptr, entry_ptr, dxpl_id) < 0)
         HGOTO_ERROR(H5E_CACHE, H5E_CANTTAG, FAIL, "Cannot tag metadata entry")
@@ -2437,7 +2436,7 @@ H5C_protect(H5F_t *		f,
            marked as collective, and is clean, it is possible that
            other processes will not have it in its cache and will
            expect a bcast of the entry from process 0. So process 0
-           will bcast the entry to all other ranks. Ranks that do have
+           will bcast the entry to all other ranks. Ranks that _do_ have
            the entry in their cache still have to participate in the
            bcast. */
 #ifdef H5_HAVE_PARALLEL
@@ -6033,10 +6032,6 @@ H5C__flush_single_entry(H5F_t *f, hid_t dxpl_id, H5C_cache_entry_t *entry_ptr,
     else
         destroy_entry = destroy;
 
-#ifdef H5_HAVE_PARALLEL
-    HDassert(FALSE == entry_ptr->coll_access);
-#endif
-
     /* we will write the entry to disk if it exists, is dirty, and if the
      * clear only flag is not set.
      */
@@ -6232,9 +6227,11 @@ H5C__flush_single_entry(H5F_t *f, hid_t dxpl_id, H5C_cache_entry_t *entry_ptr,
          *
          * 2) Delete it from the skip list if requested.
          *
-         * 3) Update the replacement policy for eviction
+         * 3) Delete it from the collective read access list.
          *
-         * 4) Remove it from the tag list for this object
+         * 4) Update the replacement policy for eviction
+         *
+         * 5) Remove it from the tag list for this object
          *
          * Finally, if the destroy_entry flag is set, discard the 
          * entry.
@@ -6244,6 +6241,14 @@ H5C__flush_single_entry(H5F_t *f, hid_t dxpl_id, H5C_cache_entry_t *entry_ptr,
         if(entry_ptr->in_slist && del_from_slist_on_destroy)
             H5C__REMOVE_ENTRY_FROM_SLIST(cache_ptr, entry_ptr, during_flush)
 
+#ifdef H5_HAVE_PARALLEL
+        /* Check for collective read access flag */
+        if(entry_ptr->coll_access) {
+            entry_ptr->coll_access = FALSE;
+            H5C__REMOVE_FROM_COLL_LIST(cache_ptr, entry_ptr, FAIL)
+        } /* end if */
+#endif /* H5_HAVE_PARALLEL */
+
         H5C__UPDATE_RP_FOR_EVICTION(cache_ptr, entry_ptr, FAIL)
 
         /* Remove entry from tag list */
@@ -6290,7 +6295,8 @@ H5C__flush_single_entry(H5F_t *f, hid_t dxpl_id, H5C_cache_entry_t *entry_ptr,
                 HGOTO_ERROR(H5E_CACHE, H5E_CANTNOTIFY, FAIL, "can't notify client about entry dirty flag cleared")
 
             /* Propagate the clean flag up the flush dependency chain if appropriate */
-            HDassert(entry_ptr->flush_dep_ndirty_children == 0);
+            if(entry_ptr->flush_dep_ndirty_children != 0)
+                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")
@@ -6826,6 +6832,10 @@ H5C_load_entry(H5F_t *              f,
     entry->serialization_count          = 0;
 #endif /* NDEBUG */
 
+    entry->tl_next  = NULL;
+    entry->tl_prev  = NULL;
+    entry->tag_info = NULL;
+
     H5C__RESET_CACHE_ENTRY_STATS(entry);
 
     ret_value = thing;
@@ -6864,13 +6874,6 @@ done:
  *		Thus the function simply does its best, returning success
  *		unless an error is encountered.
  *
- *		The primary_dxpl_id and secondary_dxpl_id parameters
- *		specify the dxpl_ids used on the first write occasioned
- *		by the call (primary_dxpl_id), and on all subsequent
- *		writes (secondary_dxpl_id).  This is useful in the metadata
- *		cache, but may not be needed elsewhere.  If so, just use the
- *		same dxpl_id for both parameters.
- *
  *		Observe that this function cannot occasion a read.
  *
  * Return:      Non-negative on success/Negative on failure.
@@ -6980,13 +6983,6 @@ H5C__make_space_in_cache(H5F_t *f, hid_t dxpl_id, size_t space_needed,
                     cache_ptr->entries_removed_counter = 0;
                     cache_ptr->last_entry_removed_ptr  = NULL;
 
-#ifdef H5_HAVE_PARALLEL
-                    if(TRUE == entry_ptr->coll_access) {
-                        entry_ptr->coll_access = FALSE;
-                        H5C__REMOVE_FROM_COLL_LIST(cache_ptr, entry_ptr, FAIL)
-                    } /* end if */
-#endif
-
                     if(H5C__flush_single_entry(f, dxpl_id, entry_ptr, H5C__NO_FLAGS_SET) < 0)
                         HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "unable to flush entry")
 
@@ -8723,12 +8719,21 @@ H5C_remove_entry(void *_entry)
     /* Update the cache internal data structures as appropriate for a destroy.
      * Specifically:
      *	1) Delete it from the index
-     *	2) Update the replacement policy for eviction
-     *	3) Remove it from the tag list for this object
+     *	2) Delete it from the collective read access list
+     *	3) Update the replacement policy for eviction
+     *	4) Remove it from the tag list for this object
      */
 
     H5C__DELETE_FROM_INDEX(cache, entry, FAIL)
 
+#ifdef H5_HAVE_PARALLEL
+    /* Check for collective read access flag */
+    if(entry->coll_access) {
+        entry->coll_access = FALSE;
+        H5C__REMOVE_FROM_COLL_LIST(cache, entry, FAIL)
+    } /* end if */
+#endif /* H5_HAVE_PARALLEL */
+
     H5C__UPDATE_RP_FOR_EVICTION(cache, entry, FAIL)
 
     /* Remove entry from tag list */