Merge pull request #316 in HDFFV/hdf5 from merge_page_buffering_05 to develop

* commit 'cf932610999de00867c0a0bb3a08ee3bbf39a158':
  Correct issues from pull request reviews.
  Corrected version of 4b5e05c084f93c35dae946c2c9e814d565a613b0:     Fix some more signed -> unsigned value issues with cache data structures,     also misc. style cleanups.  All to align w/incoming page_buffering changes.
  Revert "Fix some more signed -> unsigned value issues with cache data structures, also"

9 files changed, 148 insertions, 148 deletions

diff --git a/src/H5ACmpio.c b/src/H5ACmpio.c
index cccb3bd..945aaba 100644
--- a/src/H5ACmpio.c
+++ b/src/H5ACmpio.c
@@ -81,7 +81,7 @@ typedef struct H5AC_addr_list_ud_t
 {
     H5AC_aux_t    * aux_ptr;        /* 'Auxiliary' parallel cache info */
     haddr_t       * addr_buf_ptr;   /* Array to store addresses */
-    int             i;              /* Counter for position in array */
+    unsigned        u;              /* Counter for position in array */
 } H5AC_addr_list_ud_t;
 
 
@@ -310,13 +310,13 @@ H5AC__broadcast_candidate_list(H5AC_t *cache_ptr, unsigned *num_entries_ptr,
      * receivers can set up buffers to receive them.  If there aren't
      * any, we are done.
      */
-    num_entries = H5SL_count(aux_ptr->candidate_slist_ptr);
+    num_entries = (unsigned)H5SL_count(aux_ptr->candidate_slist_ptr);
     if(MPI_SUCCESS != (mpi_result = MPI_Bcast(&num_entries, 1, MPI_UNSIGNED, 0, aux_ptr->mpi_comm)))
         HMPI_GOTO_ERROR(FAIL, "MPI_Bcast failed", mpi_result)
 
     if(num_entries > 0) {
-        size_t		buf_size = 0;
-        unsigned        chk_num_entries = 0;
+        size_t		 buf_size = 0;
+        unsigned	 chk_num_entries = 0;
 
         /* convert the candidate list into the format we
          * are used to receiving from process 0, and also load it 
@@ -378,8 +378,8 @@ H5AC__broadcast_clean_list_cb(void *_item, void H5_ATTR_UNUSED *_key,
 
     /* Store the entry's address in the buffer */
     addr = slist_entry_ptr->addr;
-    udata->addr_buf_ptr[udata->i] = addr;
-    udata->i++;
+    udata->addr_buf_ptr[udata->u] = addr;
+    udata->u++;
 
     /* now release the entry */
     slist_entry_ptr = H5FL_FREE(H5AC_slist_entry_t, slist_entry_ptr);
@@ -437,7 +437,7 @@ H5AC__broadcast_clean_list(H5AC_t * cache_ptr)
      * receives can set up a buffer to receive them.  If there aren't
      * any, we are done.
      */
-    num_entries = H5SL_count(aux_ptr->c_slist_ptr);
+    num_entries = (unsigned)H5SL_count(aux_ptr->c_slist_ptr);
     if(MPI_SUCCESS != (mpi_result = MPI_Bcast(&num_entries, 1, MPI_UNSIGNED, 0, aux_ptr->mpi_comm)))
         HMPI_GOTO_ERROR(FAIL, "MPI_Bcast failed", mpi_result)
 
@@ -453,7 +453,7 @@ H5AC__broadcast_clean_list(H5AC_t * cache_ptr)
         /* Set up user data for callback */
         udata.aux_ptr = aux_ptr;
         udata.addr_buf_ptr = addr_buf_ptr;
-        udata.i = 0;
+        udata.u = 0;
 
         /* Free all the clean list entries, building the address list in the callback */
         /* (Callback also removes the matching entries from the dirtied list) */
@@ -568,8 +568,8 @@ H5AC__copy_candidate_list_to_buffer_cb(void *_item, void H5_ATTR_UNUSED *_key,
     HDassert(udata);
 
     /* Store the entry's address in the buffer */
-    udata->addr_buf_ptr[udata->i] = slist_entry_ptr->addr;
-    udata->i++;
+    udata->addr_buf_ptr[udata->u] = slist_entry_ptr->addr;
+    udata->u++;
 
     /* now release the entry */
     slist_entry_ptr = H5FL_FREE(H5AC_slist_entry_t, slist_entry_ptr);
@@ -635,7 +635,7 @@ H5AC__copy_candidate_list_to_buffer(const H5AC_t *cache_ptr, unsigned *num_entri
     HDassert(haddr_buf_ptr_ptr != NULL);
     HDassert(*haddr_buf_ptr_ptr == NULL);
 
-    num_entries = (int)H5SL_count(aux_ptr->candidate_slist_ptr);
+    num_entries = (unsigned)H5SL_count(aux_ptr->candidate_slist_ptr);
 
     /* allocate a buffer(s) to store the list of candidate entry 
      * base addresses in 
@@ -647,7 +647,7 @@ H5AC__copy_candidate_list_to_buffer(const H5AC_t *cache_ptr, unsigned *num_entri
     /* Set up user data for callback */
     udata.aux_ptr = aux_ptr;
     udata.addr_buf_ptr = haddr_buf_ptr;
-    udata.i = 0;
+    udata.u = 0;
 
     /* Free all the candidate list entries, building the address list in the callback */
     if(H5SL_free(aux_ptr->candidate_slist_ptr, H5AC__copy_candidate_list_to_buffer_cb, &udata) < 0)
@@ -1543,7 +1543,7 @@ H5AC__receive_and_apply_clean_list(H5F_t *f, hid_t dxpl_id)
 
     if(num_entries > 0)
         /* mark the indicated entries as clean */
-        if(H5C_mark_entries_as_clean(f, dxpl_id, (int32_t)num_entries, haddr_buf_ptr) < 0)
+        if(H5C_mark_entries_as_clean(f, dxpl_id, num_entries, haddr_buf_ptr) < 0)
             HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Can't mark entries clean.")
 
     /* if it is defined, call the sync point done callback.  Note
diff --git a/src/H5C.c b/src/H5C.c
index 4601d35..fe97f05 100644
--- a/src/H5C.c
+++ b/src/H5C.c
@@ -1470,6 +1470,11 @@ H5C_insert_entry(H5F_t *             f,
     entry_ptr->aux_next = NULL;
     entry_ptr->aux_prev = NULL;
 
+#ifdef H5_HAVE_PARALLEL
+    entry_ptr->coll_next = NULL;
+    entry_ptr->coll_prev = NULL;
+#endif /* H5_HAVE_PARALLEL */
+
     /* initialize cache image related fields */
     entry_ptr->include_in_image 		= FALSE;
     entry_ptr->lru_rank         		= 0;
@@ -1486,11 +1491,6 @@ H5C_insert_entry(H5F_t *             f,
     entry_ptr->serialization_count		= 0;
 #endif /* NDEBUG */
 
-#ifdef H5_HAVE_PARALLEL
-    entry_ptr->coll_next = NULL;
-    entry_ptr->coll_prev = NULL;
-#endif /* H5_HAVE_PARALLEL */
-
     /* 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")
diff --git a/src/H5Cdbg.c b/src/H5Cdbg.c
index 3dbe86c..205567f 100644
--- a/src/H5Cdbg.c
+++ b/src/H5Cdbg.c
@@ -655,7 +655,7 @@ H5C_stats(H5C_t * cache_ptr,
               cache_ptr->prefix,
               cache_ptr->images_created,
               cache_ptr->images_loaded,
-              (long long)cache_ptr->last_image_size);
+              cache_ptr->last_image_size);
 
     HDfprintf(stdout,
 	      "%s  prefetches / dirty prefetches      = %lld / %lld\n",
@@ -905,7 +905,7 @@ H5C_stats__reset(H5C_t H5_ATTR_UNUSED * cache_ptr)
 
     cache_ptr->images_created           = 0;
     cache_ptr->images_loaded            = 0;
-    cache_ptr->last_image_size          = (size_t)0;
+    cache_ptr->last_image_size          = (hsize_t)0;
 
     cache_ptr->prefetches               = 0;
     cache_ptr->dirty_prefetches			= 0;
diff --git a/src/H5Cmpio.c b/src/H5Cmpio.c
index 7df8093..8f8b5c6 100644
--- a/src/H5Cmpio.c
+++ b/src/H5Cmpio.c
@@ -180,19 +180,19 @@ H5C_apply_candidate_list(H5F_t * f,
     int                 i;
     int			m;
     int			n;
-    int			first_entry_to_flush;
-    int			last_entry_to_flush;
-    int			entries_to_clear = 0;
-    int			entries_to_flush = 0;
-    int			entries_to_flush_or_clear_last = 0;
-    int			entries_to_flush_collectively = 0;
-    int			entries_cleared = 0;
-    int			entries_flushed = 0;
-    int			entries_delayed = 0;
-    int			entries_flushed_or_cleared_last = 0;
-    int			entries_flushed_collectively = 0;
-    int			entries_examined = 0;
-    int			initial_list_len;
+    unsigned		first_entry_to_flush;
+    unsigned		last_entry_to_flush;
+    unsigned		entries_to_clear = 0;
+    unsigned		entries_to_flush = 0;
+    unsigned		entries_to_flush_or_clear_last = 0;
+    unsigned		entries_to_flush_collectively = 0;
+    unsigned		entries_cleared = 0;
+    unsigned		entries_flushed = 0;
+    unsigned		entries_delayed = 0;
+    unsigned		entries_flushed_or_cleared_last = 0;
+    unsigned		entries_flushed_collectively = 0;
+    unsigned		entries_examined = 0;
+    unsigned		initial_list_len;
     int               * candidate_assignment_table = NULL;
     haddr_t		addr;
     H5C_cache_entry_t *	clear_ptr = NULL;
@@ -206,8 +206,8 @@ H5C_apply_candidate_list(H5F_t * f,
 #if H5C_APPLY_CANDIDATE_LIST__DEBUG
     char		tbl_buf[1024];
 #endif /* H5C_APPLY_CANDIDATE_LIST__DEBUG */
-    unsigned            u;                      /* Local index variable */
-    herr_t              ret_value = SUCCEED;    /* Return value */
+    unsigned            u;
+    herr_t              ret_value = SUCCEED;      /* Return value */
 
     FUNC_ENTER_NOAPI(FAIL)
 
@@ -297,7 +297,7 @@ H5C_apply_candidate_list(H5F_t * f,
     sprintf(&(tbl_buf[HDstrlen(tbl_buf)]), "\n");
     HDfprintf(stdout, "%s", tbl_buf);
 
-    HDfprintf(stdout, "%s:%d: flush entries [%d, %d].\n", 
+    HDfprintf(stdout, "%s:%d: flush entries [%u, %u].\n", 
               FUNC, mpi_rank, first_entry_to_flush, last_entry_to_flush);
 
     HDfprintf(stdout, "%s:%d: marking entries.\n", FUNC, mpi_rank);
@@ -329,26 +329,26 @@ H5C_apply_candidate_list(H5F_t * f,
              * issue, we should be able to work around this. 
              */
             HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Listed entry is protected?!?!?")
-            /* Determine whether the entry is to be cleared or flushed,
-             * and mark it accordingly.  We will scan the protected and 
-             * pinned list shortly, and clear or flush according to these
-             * markings.  
-             */
-            if(i >= first_entry_to_flush && i <= last_entry_to_flush) {
-                entries_to_flush++;
-                entry_ptr->flush_immediately = TRUE;
-            } /* end if */
-            else {
-                entries_to_clear++;
-                entry_ptr->clear_on_unprotect = TRUE;
-            } /* end else */
 
-        /* Entries marked as collectively accessed and are in the
-         * candidate list to clear from the cache have to be
-         * removed from the coll list. This is OK since the
-         * candidate list is collective and uniform across all
-         * ranks. 
+        /* Determine whether the entry is to be cleared or flushed,
+         * and mark it accordingly.  We will scan the protected and 
+         * pinned list shortly, and clear or flush according to these
+         * markings.  
          */
+        if(u >= first_entry_to_flush && u <= last_entry_to_flush) {
+            entries_to_flush++;
+            entry_ptr->flush_immediately = TRUE;
+        } /* end if */
+        else {
+            entries_to_clear++;
+            entry_ptr->clear_on_unprotect = TRUE;
+        } /* end else */
+
+        /* Entries marked as collectively accessed and are in the
+           candidate list to clear from the cache have to be
+           removed from the coll list. This is OK since the
+           candidate list is collective and uniform across all
+           ranks. */
         if(entry_ptr->coll_access) {
             entry_ptr->coll_access = FALSE;
             H5C__REMOVE_FROM_COLL_LIST(cache_ptr, entry_ptr, FAIL)
@@ -356,9 +356,9 @@ H5C_apply_candidate_list(H5F_t * f,
     } /* end for */
 
 #if H5C_APPLY_CANDIDATE_LIST__DEBUG
-    HDfprintf(stdout, "%s:%d: num candidates/to clear/to flush = %u/%d/%d.\n", 
-              FUNC, mpi_rank, num_candidates, (int)entries_to_clear,
-              (int)entries_to_flush);
+    HDfprintf(stdout, "%s:%d: num candidates/to clear/to flush = %u/%u/%u.\n", 
+              FUNC, mpi_rank, num_candidates, entries_to_clear,
+              entries_to_flush);
 #endif /* H5C_APPLY_CANDIDATE_LIST__DEBUG */
 
     /* We have now marked all the entries on the candidate list for 
@@ -557,7 +557,7 @@ H5C_apply_candidate_list(H5F_t * f,
     } /* end while */
 
 #if H5C_APPLY_CANDIDATE_LIST__DEBUG
-    HDfprintf(stdout, "%s:%d: entries examined/cleared/flushed = %d/%d/%d.\n",
+    HDfprintf(stdout, "%s:%d: entries examined/cleared/flushed = %u/%u/%u.\n",
               FUNC, mpi_rank, entries_examined,
               entries_cleared, entries_flushed);
 #endif /* H5C_APPLY_CANDIDATE_LIST__DEBUG */
@@ -684,7 +684,7 @@ H5C_apply_candidate_list(H5F_t * f,
 
 #if H5C_APPLY_CANDIDATE_LIST__DEBUG
     HDfprintf(stdout,
-              "%s:%d: pel entries examined/cleared/flushed = %d/%d/%d.\n",
+              "%s:%d: pel entries examined/cleared/flushed = %u/%u/%u.\n",
               FUNC, mpi_rank, entries_examined,
               entries_cleared, entries_flushed);
     HDfprintf(stdout, "%s:%d: done.\n", FUNC, mpi_rank);
@@ -745,7 +745,7 @@ H5C_apply_candidate_list(H5F_t * f,
            (entries_cleared != entries_to_clear) ||
            (entries_flushed_or_cleared_last != entries_to_flush_or_clear_last) ||
            (entries_flushed_collectively != entries_to_flush_collectively))
-        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "entry count mismatch.")
+        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "entry count mismatch")
 
 done:
     if(candidate_assignment_table != NULL)
@@ -806,7 +806,7 @@ H5C_construct_candidate_list__clean_cache(H5C_t * cache_ptr)
 
     if(space_needed > 0) { /* we have work to do */
         H5C_cache_entry_t *entry_ptr;
-        unsigned nominated_entries_count = 0;
+        int     nominated_entries_count = 0;
         size_t  nominated_entries_size = 0;
         haddr_t	nominated_addr;
 
@@ -992,23 +992,23 @@ done:
 herr_t
 H5C_mark_entries_as_clean(H5F_t *  f,
                           hid_t     dxpl_id,
-                          int32_t   ce_array_len,
+                          unsigned  ce_array_len,
                           haddr_t * ce_array_ptr)
 {
     H5C_t *             cache_ptr;
-    int			entries_cleared;
+    unsigned		entries_cleared;
     unsigned		entries_examined;
-    int                 i;
     unsigned		initial_list_len;
     haddr_t		addr;
 #if H5C_DO_SANITY_CHECKS
-    int			pinned_entries_marked = 0;
-    int			protected_entries_marked = 0;
-    int			other_entries_marked = 0;
+    unsigned		pinned_entries_marked = 0;
+    unsigned		protected_entries_marked = 0;
+    unsigned		other_entries_marked = 0;
     haddr_t		last_addr;
 #endif /* H5C_DO_SANITY_CHECKS */
     H5C_cache_entry_t *	clear_ptr = NULL;
     H5C_cache_entry_t *	entry_ptr = NULL;
+    unsigned            u;
     herr_t		ret_value = SUCCEED;      /* Return value */
 
     FUNC_ENTER_NOAPI(FAIL)
@@ -1029,11 +1029,11 @@ H5C_mark_entries_as_clean(H5F_t *  f,
         HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on entry")
 #endif /* H5C_DO_EXTREME_SANITY_CHECKS */
 
-    for(i = 0; i < ce_array_len; i++) {
-        addr = ce_array_ptr[i];
+    for(u = 0; u < ce_array_len; u++) {
+        addr = ce_array_ptr[u];
 
 #if H5C_DO_SANITY_CHECKS
-        if(i == 0)
+        if(u == 0)
             last_addr = addr;
         else {
             if(last_addr == addr)
@@ -1057,17 +1057,17 @@ H5C_mark_entries_as_clean(H5F_t *  f,
         if(entry_ptr == NULL) {
 #if H5C_DO_SANITY_CHECKS
 	    HDfprintf(stdout,
-                  "H5C_mark_entries_as_clean: entry[%d] = %ld not in cache.\n",
-                      (int)i,
-                      (long)addr);
+                  "H5C_mark_entries_as_clean: entry[%u] = %a not in cache.\n",
+                      u,
+                      addr);
 #endif /* H5C_DO_SANITY_CHECKS */
             HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Listed entry not in cache?!?!?")
         } /* end if */
         else if(!entry_ptr->is_dirty) {
 #if H5C_DO_SANITY_CHECKS
 	    HDfprintf(stdout,
-                      "H5C_mark_entries_as_clean: entry %ld is not dirty!?!\n",
-                      (long)addr);
+                      "H5C_mark_entries_as_clean: entry %a is not dirty!?!\n",
+                      addr);
 #endif /* H5C_DO_SANITY_CHECKS */
             HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Listed entry not dirty?!?!?")
         } /* end else-if */
@@ -1178,17 +1178,17 @@ H5C_mark_entries_as_clean(H5F_t *  f,
               ( (ce_array_len - entries_cleared) <= cache_ptr->pl_len ) );
 
 #if H5C_DO_SANITY_CHECKS
-    i = 0;
+    u = 0;
     entry_ptr = cache_ptr->pl_head_ptr;
     while ( entry_ptr != NULL )
     {
         if ( entry_ptr->clear_on_unprotect ) {
 
-            i++;
+            u++;
         }
         entry_ptr = entry_ptr->next;
     }
-    HDassert( (entries_cleared + i) == ce_array_len );
+    HDassert( (entries_cleared + u) == ce_array_len );
 #endif /* H5C_DO_SANITY_CHECKS */
 
 done:
diff --git a/src/H5Cpkg.h b/src/H5Cpkg.h
index e72c81f..26e932f 100644
--- a/src/H5Cpkg.h
+++ b/src/H5Cpkg.h
@@ -374,7 +374,6 @@ if ( ( (entry_ptr) == NULL ) ||                                                \
      ( ( ( (hd_ptr) == NULL ) || ( (tail_ptr) == NULL ) ) &&                   \
        ( (hd_ptr) != (tail_ptr) )                                              \
      ) ||                                                                      \
-     ( (len) < 0 ) ||                                                          \
      ( ( (len) == 1 ) &&                                                       \
        ( ( (hd_ptr) != (tail_ptr) ) || ( (Size) <= 0 ) ||                      \
          ( (hd_ptr) == NULL ) || ( (hd_ptr)->size != (Size) )                  \
@@ -482,7 +481,7 @@ if ( ( (hd_ptr) == NULL ) ||                                                  \
        )                                                                      \
      )                                                                        \
    ) {                                                                        \
-    HDassert(0 && "il DLL pre remove SC failed"); \
+    HDassert(0 && "il DLL pre remove SC failed");                             \
     HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, (fv), "il DLL pre remove SC failed")   \
 }
 
@@ -504,7 +503,7 @@ if ( ( (entry_ptr) == NULL ) ||                                               \
        )                                                                      \
      )                                                                        \
    ) {                                                                        \
-    HDassert(0 && "IL DLL pre insert SC failed"); \
+    HDassert(0 && "IL DLL pre insert SC failed");                             \
     HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, (fv), "IL DLL pre insert SC failed")   \
 }
 
@@ -1008,7 +1007,7 @@ if ( ( (cache_ptr) == NULL ) ||                                         \
      ( (cache_ptr)->index_len != (cache_ptr)->il_len ) ||               \
      ( (cache_ptr)->index_size != (cache_ptr)->il_size ) ) {            \
     HDassert(FALSE);                                                    \
-    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, fail_val, "pre HT insert SC failed") \
+    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, fail_val, "Pre HT insert SC failed") \
 }
 
 #define H5C__POST_HT_INSERT_SC(cache_ptr, entry_ptr, fail_val)          \
@@ -1030,7 +1029,7 @@ if ( ( (cache_ptr) == NULL ) ||                                         \
      ( (cache_ptr)->index_len != (cache_ptr)->il_len ) ||               \
      ( (cache_ptr)->index_size != (cache_ptr)->il_size) ) {             \
     HDassert(FALSE);                                                    \
-    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, fail_val, "post HT insert SC failed") \
+    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, fail_val, "Post HT insert SC failed") \
 }
 
 #define H5C__PRE_HT_REMOVE_SC(cache_ptr, entry_ptr)                     \
@@ -1071,7 +1070,7 @@ if ( ( (cache_ptr) == NULL ) ||                                         \
      ( (cache_ptr)->index_len != (cache_ptr)->il_len ) ||               \
      ( (cache_ptr)->index_size != (cache_ptr)->il_size ) ) {            \
     HDassert(FALSE);                                                    \
-    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "pre HT remove SC failed") \
+    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Pre HT remove SC failed") \
 }
 
 #define H5C__POST_HT_REMOVE_SC(cache_ptr, entry_ptr)                     \
@@ -1097,7 +1096,7 @@ if ( ( (cache_ptr) == NULL ) ||                                          \
      ( (cache_ptr)->index_len != (cache_ptr)->il_len ) ||                \
      ( (cache_ptr)->index_size != (cache_ptr)->il_size ) ) {             \
     HDassert(FALSE);                                                     \
-    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "post HT remove SC failed") \
+    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Post HT remove SC failed") \
 }
 
 /* (Keep in sync w/H5C_TEST__PRE_HT_SEARCH_SC macro in test/cache_common.h -QAK) */
@@ -1109,7 +1108,7 @@ if ( ( (cache_ptr) == NULL ) ||                                             \
      ( ! H5F_addr_defined(Addr) ) ||                                        \
      ( H5C__HASH_FCN(Addr) < 0 ) ||                                         \
      ( H5C__HASH_FCN(Addr) >= H5C__HASH_TABLE_LEN ) ) {                     \
-    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, fail_val, "pre HT search SC failed") \
+    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, fail_val, "Pre HT search SC failed") \
 }
 
 /* (Keep in sync w/H5C_TEST__POST_SUC_HT_SEARCH_SC macro in test/cache_common.h -QAK) */
@@ -1131,7 +1130,7 @@ if ( ( (cache_ptr) == NULL ) ||                                             \
        ( (entry_ptr)->ht_prev->ht_next != (entry_ptr) ) ) ||                \
      ( ( (entry_ptr)->ht_next != NULL ) &&                                  \
        ( (entry_ptr)->ht_next->ht_prev != (entry_ptr) ) ) ) {               \
-    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, fail_val, "post successful HT search SC failed") \
+    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, fail_val, "Post successful HT search SC failed") \
 }
 
 /* (Keep in sync w/H5C_TEST__POST_HT_SHIFT_TO_FRONT macro in test/cache_common.h -QAK) */
@@ -1139,7 +1138,7 @@ if ( ( (cache_ptr) == NULL ) ||                                             \
 if ( ( (cache_ptr) == NULL ) ||                                        \
      ( ((cache_ptr)->index)[k] != (entry_ptr) ) ||                     \
      ( (entry_ptr)->ht_prev != NULL ) ) {                              \
-    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, fail_val, "post HT shift to front SC failed") \
+    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, fail_val, "Post HT shift to front SC failed") \
 }
 
 #define H5C__PRE_HT_ENTRY_SIZE_CHANGE_SC(cache_ptr, old_size, new_size, \
@@ -1174,7 +1173,7 @@ if ( ( (cache_ptr) == NULL ) ||                                         \
      ( (cache_ptr)->index_len != (cache_ptr)->il_len ) ||               \
      ( (cache_ptr)->index_size != (cache_ptr)->il_size ) ) {            \
     HDassert(FALSE);                                                    \
-    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "pre HT entry size change SC failed") \
+    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Pre HT entry size change SC failed") \
 }
 
 #define H5C__POST_HT_ENTRY_SIZE_CHANGE_SC(cache_ptr, old_size, new_size,  \
@@ -1204,7 +1203,7 @@ if ( ( (cache_ptr) == NULL ) ||                                           \
      ( (cache_ptr)->index_len != (cache_ptr)->il_len ) ||                 \
      ( (cache_ptr)->index_size != (cache_ptr)->il_size ) ) {              \
     HDassert(FALSE);                                                      \
-    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "post HT entry size change SC failed") \
+    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Post HT entry size change SC failed") \
 }
 
 #define H5C__PRE_HT_UPDATE_FOR_ENTRY_CLEAN_SC(cache_ptr, entry_ptr)           \
@@ -1231,7 +1230,7 @@ if (                                                                          \
       ((cache_ptr)->clean_index_ring_size[(entry_ptr)->ring] +                \
        (cache_ptr)->dirty_index_ring_size[(entry_ptr)->ring]) ) ) {           \
     HDassert(FALSE);                                                          \
-    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "pre HT update for entry clean SC failed") \
+    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Pre HT update for entry clean SC failed") \
 }
 
 #define H5C__PRE_HT_UPDATE_FOR_ENTRY_DIRTY_SC(cache_ptr, entry_ptr)           \
@@ -1258,7 +1257,7 @@ if (                                                                          \
       ((cache_ptr)->clean_index_ring_size[(entry_ptr)->ring] +                \
        (cache_ptr)->dirty_index_ring_size[(entry_ptr)->ring]) ) ) {           \
     HDassert(FALSE);                                                          \
-    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "pre HT update for entry dirty SC failed") \
+    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Pre HT update for entry dirty SC failed") \
 }
 
 #define H5C__POST_HT_UPDATE_FOR_ENTRY_CLEAN_SC(cache_ptr, entry_ptr)        \
@@ -1274,7 +1273,7 @@ if ( ( (cache_ptr)->index_size !=                                           \
        ((cache_ptr)->clean_index_ring_size[(entry_ptr)->ring] +             \
         (cache_ptr)->dirty_index_ring_size[(entry_ptr)->ring]) ) ) {        \
     HDassert(FALSE);                                                        \
-    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "post HT update for entry clean SC failed") \
+    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Post HT update for entry clean SC failed") \
 }
 
 #define H5C__POST_HT_UPDATE_FOR_ENTRY_DIRTY_SC(cache_ptr, entry_ptr)        \
@@ -1290,7 +1289,7 @@ if ( ( (cache_ptr)->index_size !=                                           \
        ((cache_ptr)->clean_index_ring_size[(entry_ptr)->ring] +             \
         (cache_ptr)->dirty_index_ring_size[(entry_ptr)->ring]) ) ) {        \
     HDassert(FALSE);                                                        \
-    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "post HT update for entry dirty SC failed") \
+    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Post HT update for entry dirty SC failed") \
 }
 
 #else /* H5C_DO_SANITY_CHECKS */
@@ -1591,7 +1590,7 @@ if ( ( (cache_ptr)->index_size !=                                           \
               (cache_ptr)->slist_size );                                       \
                                                                                \
     if(H5SL_insert((cache_ptr)->slist_ptr, entry_ptr, &(entry_ptr)->addr) < 0) \
-        HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, (fail_val), "Can't insert entry in skip list") \
+        HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, (fail_val), "can't insert entry in skip list") \
                                                                                \
     (entry_ptr)->in_slist = TRUE;                                              \
     (cache_ptr)->slist_changed = TRUE;                                         \
@@ -1626,8 +1625,7 @@ if ( ( (cache_ptr)->index_size !=                                           \
               (cache_ptr)->slist_size );                                       \
                                                                                \
     if(H5SL_insert((cache_ptr)->slist_ptr, entry_ptr, &(entry_ptr)->addr) < 0) \
-        HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, (fail_val),                       \
-                    "Can't insert entry in skip list")                         \
+        HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, (fail_val), "can't insert entry in skip list") \
                                                                                \
     (entry_ptr)->in_slist = TRUE;                                              \
     (cache_ptr)->slist_changed = TRUE;                                         \
@@ -1716,8 +1714,7 @@ if ( ( (cache_ptr)->index_size !=                                           \
                                                                             \
     if ( H5SL_remove((cache_ptr)->slist_ptr, &(entry_ptr)->addr)            \
              != (entry_ptr) )                                               \
-        HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, FAIL,                          \
-                    "Can't delete entry from skip list.")                   \
+        HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, FAIL, "can't delete entry from skip list") \
                                                                             \
     HDassert( (cache_ptr)->slist_len > 0 );                                 \
     if(!(during_flush))                                                     \
@@ -2954,39 +2951,39 @@ if ( ( (cache_ptr)->index_size !=                                           \
                     (cache_ptr)->pel_tail_ptr, (cache_ptr)->pel_len,   \
                     (cache_ptr)->pel_size, (fail_val))                 \
                                                                        \
-        /* modified LRU specific code */                               \
+    /* modified LRU specific code */                                   \
                                                                        \
-        /* insert the entry at the head of the LRU list. */            \
+    /* insert the entry at the head of the LRU list. */                \
                                                                        \
-        H5C__DLL_PREPEND((entry_ptr), (cache_ptr)->LRU_head_ptr,       \
-                         (cache_ptr)->LRU_tail_ptr,                    \
-                         (cache_ptr)->LRU_list_len,                    \
-                         (cache_ptr)->LRU_list_size, (fail_val))       \
+    H5C__DLL_PREPEND((entry_ptr), (cache_ptr)->LRU_head_ptr,           \
+                     (cache_ptr)->LRU_tail_ptr,                        \
+                     (cache_ptr)->LRU_list_len,                        \
+                     (cache_ptr)->LRU_list_size, (fail_val))           \
                                                                        \
-        /* Similarly, insert the entry at the head of either the clean \
-         * or dirty LRU list as appropriate.                           \
-         */                                                            \
+    /* Similarly, insert the entry at the head of either the clean     \
+     * or dirty LRU list as appropriate.                               \
+     */                                                                \
                                                                        \
-        if ( (entry_ptr)->is_dirty ) {                                 \
+    if ( (entry_ptr)->is_dirty ) {                                     \
                                                                        \
-            H5C__AUX_DLL_PREPEND((entry_ptr),                          \
-			          (cache_ptr)->dLRU_head_ptr,          \
-                                  (cache_ptr)->dLRU_tail_ptr,          \
-                                  (cache_ptr)->dLRU_list_len,          \
-                                  (cache_ptr)->dLRU_list_size,         \
-			          (fail_val))                          \
+        H5C__AUX_DLL_PREPEND((entry_ptr),                              \
+                              (cache_ptr)->dLRU_head_ptr,              \
+                              (cache_ptr)->dLRU_tail_ptr,              \
+                              (cache_ptr)->dLRU_list_len,              \
+                              (cache_ptr)->dLRU_list_size,             \
+                              (fail_val))                              \
                                                                        \
-        } else {                                                       \
+    } else {                                                           \
                                                                        \
-            H5C__AUX_DLL_PREPEND((entry_ptr),                          \
-			          (cache_ptr)->cLRU_head_ptr,          \
-                                  (cache_ptr)->cLRU_tail_ptr,          \
-                                  (cache_ptr)->cLRU_list_len,          \
-                                  (cache_ptr)->cLRU_list_size,         \
-			          (fail_val))                          \
-         }                                                             \
+        H5C__AUX_DLL_PREPEND((entry_ptr),                              \
+                              (cache_ptr)->cLRU_head_ptr,              \
+                              (cache_ptr)->cLRU_tail_ptr,              \
+                              (cache_ptr)->cLRU_list_len,              \
+                              (cache_ptr)->cLRU_list_size,             \
+                              (fail_val))                              \
+     }                                                                 \
                                                                        \
-        /* End modified LRU specific code. */                          \
+    /* End modified LRU specific code. */                              \
                                                                        \
 } /* H5C__UPDATE_RP_FOR_UNPIN */
 
@@ -3181,22 +3178,22 @@ if ( ( (hd_ptr) == NULL ) ||                                                   \
      ( (len) <= 0 ) ||                                                         \
      ( (Size) < (entry_ptr)->size ) ||                                         \
      ( ( (Size) == (entry_ptr)->size ) && ( ! ( (len) == 1 ) ) ) ||            \
-     ( ( (entry_ptr)->coll_prev == NULL ) && ( (hd_ptr) != (entry_ptr) ) ) ||   \
+     ( ( (entry_ptr)->coll_prev == NULL ) && ( (hd_ptr) != (entry_ptr) ) ) ||  \
      ( ( (entry_ptr)->coll_next == NULL ) && ( (tail_ptr) != (entry_ptr) ) ) || \
      ( ( (len) == 1 ) &&                                                       \
        ( ! ( ( (hd_ptr) == (entry_ptr) ) && ( (tail_ptr) == (entry_ptr) ) &&   \
-             ( (entry_ptr)->coll_next == NULL ) &&                              \
-             ( (entry_ptr)->coll_prev == NULL ) &&                              \
+             ( (entry_ptr)->coll_next == NULL ) &&                             \
+             ( (entry_ptr)->coll_prev == NULL ) &&                             \
              ( (Size) == (entry_ptr)->size )                                   \
            )                                                                   \
        )                                                                       \
      )                                                                         \
    ) {                                                                         \
-    HDassert(0 && "coll DLL pre remove SC failed");                       \
-    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, (fv), "coll DLL pre remove SC failed")   \
+    HDassert(0 && "coll DLL pre remove SC failed");                            \
+    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, (fv), "coll DLL pre remove SC failed")  \
 }
 
-#define H5C__COLL_DLL_SC(head_ptr, tail_ptr, len, Size, fv)                  \
+#define H5C__COLL_DLL_SC(head_ptr, tail_ptr, len, Size, fv)                 \
 if ( ( ( ( (head_ptr) == NULL ) || ( (tail_ptr) == NULL ) ) &&              \
        ( (head_ptr) != (tail_ptr) )                                         \
      ) ||                                                                   \
@@ -3208,36 +3205,35 @@ if ( ( ( ( (head_ptr) == NULL ) || ( (tail_ptr) == NULL ) ) &&              \
        )                                                                    \
      ) ||                                                                   \
      ( ( (len) >= 1 ) &&                                                    \
-       ( ( (head_ptr) == NULL ) || ( (head_ptr)->coll_prev != NULL ) ||      \
-         ( (tail_ptr) == NULL ) || ( (tail_ptr)->coll_next != NULL )         \
+       ( ( (head_ptr) == NULL ) || ( (head_ptr)->coll_prev != NULL ) ||     \
+         ( (tail_ptr) == NULL ) || ( (tail_ptr)->coll_next != NULL )        \
        )                                                                    \
      )                                                                      \
    ) {                                                                      \
-    HDassert(0 && "COLL DLL sanity check failed");                      \
+    HDassert(0 && "COLL DLL sanity check failed");                          \
     HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, (fv), "COLL DLL sanity check failed") \
 }
 
 #define H5C__COLL_DLL_PRE_INSERT_SC(entry_ptr, hd_ptr, tail_ptr, len, Size, fv) \
 if ( ( (entry_ptr) == NULL ) ||                                                \
-     ( (entry_ptr)->coll_next != NULL ) ||                                      \
-     ( (entry_ptr)->coll_prev != NULL ) ||                                      \
+     ( (entry_ptr)->coll_next != NULL ) ||                                     \
+     ( (entry_ptr)->coll_prev != NULL ) ||                                     \
      ( ( ( (hd_ptr) == NULL ) || ( (tail_ptr) == NULL ) ) &&                   \
        ( (hd_ptr) != (tail_ptr) )                                              \
      ) ||                                                                      \
-     ( (len) < 0 ) ||                                                          \
      ( ( (len) == 1 ) &&                                                       \
        ( ( (hd_ptr) != (tail_ptr) ) || ( (Size) <= 0 ) ||                      \
          ( (hd_ptr) == NULL ) || ( (hd_ptr)->size != (Size) )                  \
        )                                                                       \
      ) ||                                                                      \
      ( ( (len) >= 1 ) &&                                                       \
-       ( ( (hd_ptr) == NULL ) || ( (hd_ptr)->coll_prev != NULL ) ||             \
-         ( (tail_ptr) == NULL ) || ( (tail_ptr)->coll_next != NULL )            \
+       ( ( (hd_ptr) == NULL ) || ( (hd_ptr)->coll_prev != NULL ) ||            \
+         ( (tail_ptr) == NULL ) || ( (tail_ptr)->coll_next != NULL )           \
        )                                                                       \
      )                                                                         \
    ) {                                                                         \
-    HDassert(0 && "COLL DLL pre insert SC failed");                     \
-    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, (fv), "COLL DLL pre insert SC failed")   \
+    HDassert(0 && "COLL DLL pre insert SC failed");                            \
+    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, (fv), "COLL DLL pre insert SC failed")  \
 }
 
 #else /* H5C_DO_SANITY_CHECKS */
diff --git a/src/H5Cprivate.h b/src/H5Cprivate.h
index 9696cc0..30a7745 100644
--- a/src/H5Cprivate.h
+++ b/src/H5Cprivate.h
@@ -1661,8 +1661,8 @@ typedef struct H5C_cache_entry_t {
  *						JRM - 8/5/15
  *
  * magic:	Unsigned 32 bit integer that must always be set to
- *              H5C_IMAGE_ENTRY_T_MAGIC when the entry is valid.
- *              The field must be set to H5C_IMAGE_ENTRY_T_BAD_MAGIC
+ *              H5C__IMAGE_ENTRY_T_MAGIC when the entry is valid.
+ *              The field must be set to H5C__IMAGE__ENTRY_T_BAD_MAGIC
  *              just before the entry is freed.
  *
  * addr:	Base address of the cache entry on disk.
@@ -2284,7 +2284,7 @@ H5_DLL herr_t H5C_apply_candidate_list(H5F_t *f, hid_t dxpl_id,
 H5_DLL herr_t H5C_construct_candidate_list__clean_cache(H5C_t *cache_ptr);
 H5_DLL herr_t H5C_construct_candidate_list__min_clean(H5C_t *cache_ptr);
 H5_DLL herr_t H5C_clear_coll_entries(H5C_t * cache_ptr, hbool_t partial);
-H5_DLL herr_t H5C_mark_entries_as_clean(H5F_t *f, hid_t dxpl_id, int32_t ce_array_len,
+H5_DLL herr_t H5C_mark_entries_as_clean(H5F_t *f, hid_t dxpl_id, unsigned ce_array_len,
     haddr_t *ce_array_ptr);
 #endif /* H5_HAVE_PARALLEL */
 
diff --git a/test/cache_api.c b/test/cache_api.c
index 6c43796..710e38f 100644
--- a/test/cache_api.c
+++ b/test/cache_api.c
@@ -2314,7 +2314,7 @@ main(void)
         nerrs += 1;
     }
 
-    if(invalid_configs )
+    if(invalid_configs)
         HDfree(invalid_configs);
 
     if(nerrs > 0)
diff --git a/test/links.c b/test/links.c
index 3364c7e..3aff68b 100644
--- a/test/links.c
+++ b/test/links.c
@@ -22,7 +22,7 @@
 
 /*
  * This file needs to access private information from the H5FD package.
- * This file also needs to access the file driver testing code.
+ * This file also needs to access the group testing code.
  */
 #define H5FD_FRIEND		/*suppress error about including H5FDpkg	  */
 #define H5FD_TESTING
diff --git a/testpar/t_cache.c b/testpar/t_cache.c
index bfa4c8f..0e69557 100644
--- a/testpar/t_cache.c
+++ b/testpar/t_cache.c
@@ -4334,7 +4334,8 @@ setup_cache_for_test(hid_t * fid_ptr,
  *
  *****************************************************************************/
 static void
-verify_writes(unsigned num_writes, haddr_t *written_entries_tbl)
+verify_writes(unsigned num_writes,
+	      haddr_t * written_entries_tbl)
 {
     const hbool_t report = FALSE;
     hbool_t proceed = TRUE;
@@ -4360,10 +4361,13 @@ verify_writes(unsigned num_writes, haddr_t *written_entries_tbl)
         }
     }
 
-    if(proceed)
+    if ( proceed ) {
+
         proceed = verify_total_writes(num_writes);
+    }
 
-    while(proceed && u < num_writes) {
+    while ( ( proceed ) && ( u < num_writes ) ) 
+    {
         proceed = verify_entry_writes(written_entries_tbl[u], 1);
         u++;
     }