Omnibus checkin for several relatively minor modifications:

1) Added code test/page_buffer.c to verify that page buffering is
   disabled in parallel builds.

2) Added code to test/cache_image.c to verify correct interaction
   between evict on close and cache image -- in particular management
   of a file containing a cache image containing dirty metadata that
   has been opened R/O.  Also fix for the bug exposed.

3) Added code to testpar/t_cache_image.c to verify expected procedure
   for reading cache images, and also supporting stats collection code
   needed for the test.

4) Repair of an overactive sanity check in H5C__reconstruct_cache_contents().

5) Other minor tidies in passing.

Tested serial and parallel, debug and production on Jelly.

1 files changed, 42 insertions, 5 deletions

diff --git a/src/H5Ctag.c b/src/H5Ctag.c
index a9bcca1..0170ce9 100644
--- a/src/H5Ctag.c
+++ b/src/H5Ctag.c
@@ -58,8 +58,18 @@
 typedef struct {
     H5F_t * f;                          /* File pointer for evicting entry */
     hid_t dxpl_id;                      /* DXPL for evicting entry */
-    hbool_t evicted_entries_last_pass;  /* Flag to indicate that an entry was evicted when iterating over cache */
-    hbool_t pinned_entries_need_evicted;        /* Flag to indicate that a pinned entry was attempted to be evicted */
+    hbool_t evicted_entries_last_pass;  /* Flag to indicate that an entry 
+                                         * was evicted when iterating over 
+                                         * cache 
+                                         */
+    hbool_t pinned_entries_need_evicted;/* Flag to indicate that a pinned 
+                                         * entry was attempted to be evicted 
+                                         */
+    hbool_t skipped_pf_dirty_entries;   /* Flag indicating that one or more 
+                                         * entries marked prefetched_dirty
+                                         * were encountered and not 
+                                         * evicted.
+                                         */
 } H5C_tag_iter_evict_ctx_t;
 
 /* Typedef for tagged entry iterator callback context - expunge tag type metadata */
@@ -470,7 +480,9 @@ H5C__evict_tagged_entries_cb(H5C_cache_entry_t *entry, void *_ctx)
         if(H5C__flush_single_entry(ctx->f, ctx->dxpl_id, entry, H5C__FLUSH_INVALIDATE_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG | H5C__DEL_FROM_SLIST_ON_DESTROY_FLAG) < 0)
             HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, H5_ITER_ERROR, "Entry eviction failed.")
         ctx->evicted_entries_last_pass = TRUE;
-    } /* end else */
+    } else {
+        ctx->skipped_pf_dirty_entries = TRUE;
+    }
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
@@ -516,6 +528,7 @@ H5C_evict_tagged_entries(H5F_t * f, hid_t dxpl_id, haddr_t tag, hbool_t match_gl
         /* Reset pinned/evicted tracking flags */
         ctx.pinned_entries_need_evicted = FALSE;
         ctx.evicted_entries_last_pass = FALSE;
+        ctx.skipped_pf_dirty_entries = FALSE;
 
         /* Iterate through entries in the cache */
         if(H5C__iter_tagged_entries(cache, tag, match_global, H5C__evict_tagged_entries_cb, &ctx) < 0)
@@ -524,8 +537,32 @@ H5C_evict_tagged_entries(H5F_t * f, hid_t dxpl_id, haddr_t tag, hbool_t match_gl
         /* Keep doing this until we have stopped evicted entries */
     } while(TRUE == ctx.evicted_entries_last_pass);
 
-    /* Fail if we have finished evicting entries and pinned entries still need evicted */
-    if(ctx.pinned_entries_need_evicted)
+    /* In most cases, fail if we have finished evicting entries and pinned 
+     * entries still need evicted 
+     *
+     * However, things can get strange if the file was opened R/O and 
+     * the file contains a cache image and the cache image contains dirty 
+     * entries.  
+     *
+     * Since the file was opened read only, dirty entries in the cache 
+     * image were marked as clean when they were inserted into the metadata
+     * cache.  This is necessary, as if they are marked dirty, the metadata
+     * cache will attempt to write them on file close, which is frowned 
+     * upon when the file is opened R/O.
+     *
+     * On the other hand, such entries (marked prefetched_dirty) must not 
+     * be evicted, as should the cache be asked to re-load them, the cache
+     * will attempt to read them from the file, and at best load an outdated
+     * version.
+     * 
+     * To avoid this, H5C__evict_tagged_entries_cb has been modified to 
+     * skip such entries.  However, by doing so, it may prevent pinned 
+     * entries from becoming unpinned.
+     *
+     * Thus we must ignore ctx.pinned_entries_need_evicted if 
+     * ctx.skipped_pf_dirty_entries is TRUE.
+     */
+    if((!ctx.skipped_pf_dirty_entries) && (ctx.pinned_entries_need_evicted))
         HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "Pinned entries still need evicted?!")
 
 done: