When flushing, the metadata cache attempts to flush entries in increasing

address order.  To facilitate this, the metadata cache needs a list of
of dirty entries in increasing address order.  This is implemented via a
skip list of all dirty entries in the cache.

To date this skip list has been maintained at all times.

However, profiling indicates that we can avoid significant overhead by
constructing the skip list of dirty entries just before a flush, taking
it down afterwareds, and not maintaining it during normal operation.

This commit implements this optimization for both serial and parallel.

Tested serial and parallel, debug and production on charis and jelly.

1 files changed, 317 insertions, 154 deletions

diff --git a/src/H5Cpkg.h b/src/H5Cpkg.h
index 8712af5..ac761f6 100644
--- a/src/H5Cpkg.h
+++ b/src/H5Cpkg.h
@@ -47,13 +47,22 @@
 /* Number of epoch markers active */
 #define H5C__MAX_EPOCH_MARKERS                  10
 
+
 /* Cache configuration settings */
 #define H5C__HASH_TABLE_LEN     (64 * 1024) /* must be a power of 2 */
 #define H5C__H5C_T_MAGIC	0x005CAC0E
 
+
 /* Initial allocated size of the "flush_dep_parent" array */
 #define H5C_FLUSH_DEP_PARENT_INIT 8
 
+
+/* Set to TRUE to enable the slist optimization.  If this field is TRUE,
+ * the slist is disabled whenever a flush is not in progress.
+ */
+#define H5C__SLIST_OPT_ENABLED                  TRUE
+
+
 /****************************************************************************
  *
  * We maintain doubly linked lists of instances of H5C_cache_entry_t for a
@@ -1568,49 +1577,82 @@ if ( ( (cache_ptr)->index_size !=                                           \
  *		Added code to maintain the cache_ptr->slist_ring_len
  *		and cache_ptr->slist_ring_size arrays.
  *
+ *              JRM -- 4/29/20
+ *              Reworked macro to support the slist_enabled field 
+ *              of H5C_t.  If slist_enabled == TRUE, the macro 
+ *              functions as before.  Otherwise, the macro is a no-op,
+ *              and the slist must be empty.
+ *
  *-------------------------------------------------------------------------
  */
 
+/* NOTE:  The H5C__INSERT_ENTRY_IN_SLIST() macro is set up so that 
+ *        
+ *            H5C_DO_SANITY_CHECKS 
+ *
+ *        and 
+ *
+ *            H5C_DO_SLIST_SANITY_CHECKS 
+ *
+ *        can be selected independantly.  This is easy to miss as the 
+ *        two #defines are easy to confuse.
+ */
+
 #if H5C_DO_SLIST_SANITY_CHECKS
+
 #define ENTRY_IN_SLIST(cache_ptr, entry_ptr) \
     H5C_entry_in_skip_list((cache_ptr), (entry_ptr))
+
 #else /* H5C_DO_SLIST_SANITY_CHECKS */
+
 #define ENTRY_IN_SLIST(cache_ptr, entry_ptr) FALSE
+
 #endif /* H5C_DO_SLIST_SANITY_CHECKS */
 
+
 #if H5C_DO_SANITY_CHECKS
 
 #define H5C__INSERT_ENTRY_IN_SLIST(cache_ptr, entry_ptr, fail_val)             \
 {                                                                              \
     HDassert( (cache_ptr) );                                                   \
     HDassert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                        \
-    HDassert( (entry_ptr) );                                                   \
-    HDassert( (entry_ptr)->size > 0 );                                         \
-    HDassert( H5F_addr_defined((entry_ptr)->addr) );                           \
-    HDassert( !((entry_ptr)->in_slist) );                                      \
-    HDassert( !ENTRY_IN_SLIST((cache_ptr), (entry_ptr)) );                     \
-    HDassert( (entry_ptr)->ring > H5C_RING_UNDEFINED );                        \
-    HDassert( (entry_ptr)->ring < H5C_RING_NTYPES );                           \
-    HDassert( (cache_ptr)->slist_ring_len[(entry_ptr)->ring] <=                \
-              (cache_ptr)->slist_len );                                        \
-    HDassert( (cache_ptr)->slist_ring_size[(entry_ptr)->ring] <=               \
-              (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") \
+    if ( (cache_ptr)->slist_enabled ) {                                        \
+                                                                               \
+        HDassert( (entry_ptr) );                                               \
+        HDassert( (entry_ptr)->size > 0 );                                     \
+        HDassert( H5F_addr_defined((entry_ptr)->addr) );                       \
+        HDassert( !((entry_ptr)->in_slist) );                                  \
+        HDassert( ! ENTRY_IN_SLIST((cache_ptr), (entry_ptr)) );                \
+        HDassert( (entry_ptr)->ring > H5C_RING_UNDEFINED );                    \
+        HDassert( (entry_ptr)->ring < H5C_RING_NTYPES );                       \
+        HDassert( (cache_ptr)->slist_ring_len[(entry_ptr)->ring] <=            \
+                  (cache_ptr)->slist_len );                                    \
+        HDassert( (cache_ptr)->slist_ring_size[(entry_ptr)->ring] <=           \
+                  (cache_ptr)->slist_size );                                   \
                                                                                \
-    (entry_ptr)->in_slist = TRUE;                                              \
-    (cache_ptr)->slist_changed = TRUE;                                         \
-    (cache_ptr)->slist_len++;                                                  \
-    (cache_ptr)->slist_size += (entry_ptr)->size;                              \
-    ((cache_ptr)->slist_ring_len[(entry_ptr)->ring])++;                        \
-    ((cache_ptr)->slist_ring_size[(entry_ptr)->ring]) += (entry_ptr)->size;    \
-    (cache_ptr)->slist_len_increase++;                                         \
-    (cache_ptr)->slist_size_increase += (int64_t)((entry_ptr)->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")                     \
                                                                                \
-    HDassert( (cache_ptr)->slist_len > 0 );                                    \
-    HDassert( (cache_ptr)->slist_size > 0 );                                   \
+        (entry_ptr)->in_slist = TRUE;                                          \
+        (cache_ptr)->slist_changed = TRUE;                                     \
+        (cache_ptr)->slist_len++;                                              \
+        (cache_ptr)->slist_size += (entry_ptr)->size;                          \
+        ((cache_ptr)->slist_ring_len[(entry_ptr)->ring])++;                    \
+        ((cache_ptr)->slist_ring_size[(entry_ptr)->ring]) += (entry_ptr)->size;\
+        (cache_ptr)->slist_len_increase++;                                     \
+        (cache_ptr)->slist_size_increase += (int64_t)((entry_ptr)->size);      \
                                                                                \
+        HDassert( (cache_ptr)->slist_len > 0 );                                \
+        HDassert( (cache_ptr)->slist_size > 0 );                               \
+                                                                               \
+    } else { /* slist disabled */                                              \
+                                                                               \
+        HDassert( (cache_ptr)->slist_len == 0 );                               \
+        HDassert( (cache_ptr)->slist_size == 0 );                              \
+    }                                                                          \
 } /* H5C__INSERT_ENTRY_IN_SLIST */
 
 #else /* H5C_DO_SANITY_CHECKS */
@@ -1619,31 +1661,42 @@ if ( ( (cache_ptr)->index_size !=                                           \
 {                                                                              \
     HDassert( (cache_ptr) );                                                   \
     HDassert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                        \
-    HDassert( (entry_ptr) );                                                   \
-    HDassert( (entry_ptr)->size > 0 );                                         \
-    HDassert( H5F_addr_defined((entry_ptr)->addr) );                           \
-    HDassert( !((entry_ptr)->in_slist) );                                      \
-    HDassert( !ENTRY_IN_SLIST((cache_ptr), (entry_ptr)) );                     \
-    HDassert( (entry_ptr)->ring > H5C_RING_UNDEFINED );                        \
-    HDassert( (entry_ptr)->ring < H5C_RING_NTYPES );                           \
-    HDassert( (cache_ptr)->slist_ring_len[(entry_ptr)->ring] <=                \
-              (cache_ptr)->slist_len );                                        \
-    HDassert( (cache_ptr)->slist_ring_size[(entry_ptr)->ring] <=               \
-              (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") \
+    if ( (cache_ptr)->slist_enabled ) {                                        \
+                                                                               \
+        HDassert( (entry_ptr) );                                               \
+        HDassert( (entry_ptr)->size > 0 );                                     \
+        HDassert( ! ENTRY_IN_SLIST((cache_ptr), (entry_ptr)) );                \
+        HDassert( H5F_addr_defined((entry_ptr)->addr) );                       \
+        HDassert( !((entry_ptr)->in_slist) );                                  \
+        HDassert( (entry_ptr)->ring > H5C_RING_UNDEFINED );                    \
+        HDassert( (entry_ptr)->ring < H5C_RING_NTYPES );                       \
+        HDassert( (cache_ptr)->slist_ring_len[(entry_ptr)->ring] <=            \
+                  (cache_ptr)->slist_len );                                    \
+        HDassert( (cache_ptr)->slist_ring_size[(entry_ptr)->ring] <=           \
+                  (cache_ptr)->slist_size );                                   \
+        HDassert( (cache_ptr)->slist_ptr );                                    \
+                                                                               \
+        if ( H5SL_insert((cache_ptr)->slist_ptr, entry_ptr,                    \
+                         &((entry_ptr)->addr)) < 0)                            \
+            HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, (fail_val),                   \
+                        "can't insert entry in skip list")                     \
                                                                                \
-    (entry_ptr)->in_slist = TRUE;                                              \
-    (cache_ptr)->slist_changed = TRUE;                                         \
-    (cache_ptr)->slist_len++;                                                  \
-    (cache_ptr)->slist_size += (entry_ptr)->size;                              \
-    ((cache_ptr)->slist_ring_len[(entry_ptr)->ring])++;                        \
-    ((cache_ptr)->slist_ring_size[(entry_ptr)->ring]) += (entry_ptr)->size;    \
+        (entry_ptr)->in_slist = TRUE;                                          \
+        (cache_ptr)->slist_changed = TRUE;                                     \
+        (cache_ptr)->slist_len++;                                              \
+        (cache_ptr)->slist_size += (entry_ptr)->size;                          \
+        ((cache_ptr)->slist_ring_len[(entry_ptr)->ring])++;                    \
+        ((cache_ptr)->slist_ring_size[(entry_ptr)->ring]) += (entry_ptr)->size;\
                                                                                \
-    HDassert( (cache_ptr)->slist_len > 0 );                                    \
-    HDassert( (cache_ptr)->slist_size > 0 );                                   \
+        HDassert( (cache_ptr)->slist_len > 0 );                                \
+        HDassert( (cache_ptr)->slist_size > 0 );                               \
                                                                                \
+    } else { /* slist disabled */                                              \
+                                                                               \
+        HDassert( (cache_ptr)->slist_len == 0 );                               \
+        HDassert( (cache_ptr)->slist_size == 0 );                              \
+    }                                                                          \
 } /* H5C__INSERT_ENTRY_IN_SLIST */
 
 #endif /* H5C_DO_SANITY_CHECKS */
@@ -1661,80 +1714,129 @@ if ( ( (cache_ptr)->index_size !=                                           \
  *
  * Programmer:  John Mainzer, 5/10/04
  *
+ * Modifications:
+ *
+ *              JRM -- 7/21/04
+ *              Updated function for the addition of the hash table.
+ *
+ *              JRM - 7/27/04
+ *              Converted from the function H5C_remove_entry_from_tree()
+ *              to the macro H5C__REMOVE_ENTRY_FROM_TREE in the hopes of
+ *              wringing a little more performance out of the cache.
+ *
+ *              QAK -- 11/27/04
+ *              Switched over to using skip list routines.
+ *
+ *              JRM -- 3/28/07
+ *              Updated sanity checks for the new is_read_only and
+ *              ro_ref_count fields in H5C_cache_entry_t.
+ *
+ *              JRM -- 12/13/14
+ *              Added code to set cache_ptr->slist_changed to TRUE
+ *              when an entry is removed from the slist.
+ *
+ *              JRM -- 4/29/20
+ *              Reworked macro to support the slist_enabled field 
+ *              of H5C_t.  If slist_enabled == TRUE, the macro 
+ *              functions as before.  Otherwise, the macro is a no-op,
+ *              and the slist must be empty.
+ *
  *-------------------------------------------------------------------------
  */
 
 #if H5C_DO_SANITY_CHECKS
-#define H5C__REMOVE_ENTRY_FROM_SLIST(cache_ptr, entry_ptr, during_flush)    \
-{                                                                           \
-    HDassert( (cache_ptr) );                                                \
-    HDassert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                     \
-    HDassert( (entry_ptr) );                                                \
-    HDassert( !((entry_ptr)->is_read_only) );                               \
-    HDassert( ((entry_ptr)->ro_ref_count) == 0 );                           \
-    HDassert( (entry_ptr)->size > 0 );                                      \
-    HDassert( (entry_ptr)->in_slist );                                      \
-    HDassert( (cache_ptr)->slist_ptr );                                     \
-    HDassert( (entry_ptr)->ring > H5C_RING_UNDEFINED );                     \
-    HDassert( (entry_ptr)->ring < H5C_RING_NTYPES );                        \
-    HDassert( (cache_ptr)->slist_ring_len[(entry_ptr)->ring] <=             \
-              (cache_ptr)->slist_len );                                     \
-    HDassert( (cache_ptr)->slist_ring_size[(entry_ptr)->ring] <=            \
-              (cache_ptr)->slist_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") \
-                                                                            \
-    HDassert( (cache_ptr)->slist_len > 0 );                                 \
-    if(!(during_flush))                                                     \
-        (cache_ptr)->slist_changed = TRUE;                                  \
-    (cache_ptr)->slist_len--;                                               \
-    HDassert( (cache_ptr)->slist_size >= (entry_ptr)->size );               \
-    (cache_ptr)->slist_size -= (entry_ptr)->size;                           \
-    ((cache_ptr)->slist_ring_len[(entry_ptr)->ring])--;                     \
-    HDassert( (cache_ptr)->slist_ring_size[(entry_ptr->ring)] >=            \
-              (entry_ptr)->size );                                          \
-    ((cache_ptr)->slist_ring_size[(entry_ptr)->ring]) -= (entry_ptr)->size; \
-    (cache_ptr)->slist_len_increase--;                                      \
-    (cache_ptr)->slist_size_increase -= (int64_t)((entry_ptr)->size);       \
-    (entry_ptr)->in_slist = FALSE;                                          \
+#define H5C__REMOVE_ENTRY_FROM_SLIST(cache_ptr, entry_ptr, during_flush)       \
+{                                                                              \
+    HDassert( (cache_ptr) );                                                   \
+    HDassert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                        \
+                                                                               \
+    if ( (cache_ptr)->slist_enabled ) {                                        \
+                                                                               \
+        HDassert( (entry_ptr) );                                               \
+        HDassert( !((entry_ptr)->is_read_only) );                              \
+        HDassert( ((entry_ptr)->ro_ref_count) == 0 );                          \
+        HDassert( (entry_ptr)->size > 0 );                                     \
+        HDassert( (entry_ptr)->in_slist );                                     \
+        HDassert( (cache_ptr)->slist_ptr );                                    \
+        HDassert( (entry_ptr)->ring > H5C_RING_UNDEFINED );                    \
+        HDassert( (entry_ptr)->ring < H5C_RING_NTYPES );                       \
+        HDassert( (cache_ptr)->slist_ring_len[(entry_ptr)->ring] <=            \
+                  (cache_ptr)->slist_len );                                    \
+        HDassert( (cache_ptr)->slist_ring_size[(entry_ptr)->ring] <=           \
+                  (cache_ptr)->slist_size );                                   \
+        HDassert( (cache_ptr)->slist_size >= (entry_ptr)->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")                   \
+                                                                               \
+        HDassert( (cache_ptr)->slist_len > 0 );                                \
+        if(!(during_flush))                                                    \
+            (cache_ptr)->slist_changed = TRUE;                                 \
+        (cache_ptr)->slist_len--;                                              \
+        HDassert( (cache_ptr)->slist_size >= (entry_ptr)->size );              \
+        (cache_ptr)->slist_size -= (entry_ptr)->size;                          \
+        ((cache_ptr)->slist_ring_len[(entry_ptr)->ring])--;                    \
+        HDassert( (cache_ptr)->slist_ring_size[(entry_ptr->ring)] >=           \
+                  (entry_ptr)->size );                                         \
+        ((cache_ptr)->slist_ring_size[(entry_ptr)->ring]) -= (entry_ptr)->size;\
+        (cache_ptr)->slist_len_increase--;                                     \
+        (cache_ptr)->slist_size_increase -= (int64_t)((entry_ptr)->size);      \
+        (entry_ptr)->in_slist = FALSE;                                         \
+                                                                               \
+    } else { /* slist disabled */                                              \
+                                                                               \
+        HDassert( (cache_ptr)->slist_len == 0 );                               \
+        HDassert( (cache_ptr)->slist_size == 0 );                               \
+    }                                                                          \
 } /* H5C__REMOVE_ENTRY_FROM_SLIST */
 
 #else /* H5C_DO_SANITY_CHECKS */
 
-#define H5C__REMOVE_ENTRY_FROM_SLIST(cache_ptr, entry_ptr, during_flush)    \
-{                                                                           \
-    HDassert( (cache_ptr) );                                                \
-    HDassert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                     \
-    HDassert( (entry_ptr) );                                                \
-    HDassert( !((entry_ptr)->is_read_only) );                               \
-    HDassert( ((entry_ptr)->ro_ref_count) == 0 );                           \
-    HDassert( (entry_ptr)->in_slist );                                      \
-    HDassert( (cache_ptr)->slist_ptr );                                     \
-    HDassert( (entry_ptr)->ring > H5C_RING_UNDEFINED );                     \
-    HDassert( (entry_ptr)->ring < H5C_RING_NTYPES );                        \
-    HDassert( (cache_ptr)->slist_ring_len[(entry_ptr)->ring] <=             \
-              (cache_ptr)->slist_len );                                     \
-    HDassert( (cache_ptr)->slist_ring_size[(entry_ptr)->ring] <=            \
-              (cache_ptr)->slist_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") \
-                                                                            \
-    HDassert( (cache_ptr)->slist_len > 0 );                                 \
-    if(!(during_flush))                                                     \
-        (cache_ptr)->slist_changed = TRUE;                                  \
-    (cache_ptr)->slist_len--;                                               \
-    HDassert( (cache_ptr)->slist_size >= (entry_ptr)->size );               \
-    (cache_ptr)->slist_size -= (entry_ptr)->size;                           \
-    ((cache_ptr)->slist_ring_len[(entry_ptr)->ring])--;                     \
-    HDassert( (cache_ptr)->slist_ring_size[(entry_ptr->ring)] >=            \
-              (entry_ptr)->size );                                          \
-    ((cache_ptr)->slist_ring_size[(entry_ptr)->ring]) -= (entry_ptr)->size; \
-    (entry_ptr)->in_slist = FALSE;                                          \
+#define H5C__REMOVE_ENTRY_FROM_SLIST(cache_ptr, entry_ptr, during_flush)       \
+{                                                                              \
+    HDassert( (cache_ptr) );                                                   \
+    HDassert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                        \
+                                                                               \
+    if ( (cache_ptr)->slist_enabled ) {                                        \
+                                                                               \
+        HDassert( (entry_ptr) );                                               \
+        HDassert( !((entry_ptr)->is_read_only) );                              \
+        HDassert( ((entry_ptr)->ro_ref_count) == 0 );                          \
+        HDassert( (entry_ptr)->in_slist );                                     \
+        HDassert( (cache_ptr)->slist_ptr );                                    \
+        HDassert( (entry_ptr)->ring > H5C_RING_UNDEFINED );                    \
+        HDassert( (entry_ptr)->ring < H5C_RING_NTYPES );                       \
+        HDassert( (cache_ptr)->slist_ring_len[(entry_ptr)->ring] <=            \
+                  (cache_ptr)->slist_len );                                    \
+        HDassert( (cache_ptr)->slist_ring_size[(entry_ptr)->ring] <=           \
+                  (cache_ptr)->slist_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")                   \
+                                                                               \
+        HDassert( (cache_ptr)->slist_len > 0 );                                \
+        if(!(during_flush))                                                    \
+            (cache_ptr)->slist_changed = TRUE;                                 \
+        (cache_ptr)->slist_len--;                                              \
+        HDassert( (cache_ptr)->slist_size >= (entry_ptr)->size );              \
+        (cache_ptr)->slist_size -= (entry_ptr)->size;                          \
+        ((cache_ptr)->slist_ring_len[(entry_ptr)->ring])--;                    \
+        HDassert( (cache_ptr)->slist_ring_size[(entry_ptr->ring)] >=           \
+                  (entry_ptr)->size );                                         \
+        ((cache_ptr)->slist_ring_size[(entry_ptr)->ring]) -= (entry_ptr)->size;\
+        (entry_ptr)->in_slist = FALSE;                                         \
+                                                                               \
+    } else { /* slist disabled */                                              \
+                                                                               \
+        HDassert( (cache_ptr)->slist_len == 0 );                               \
+        HDassert( (cache_ptr)->slist_size == 0 );                              \
+    }                                                                          \
 } /* H5C__REMOVE_ENTRY_FROM_SLIST */
+
 #endif /* H5C_DO_SANITY_CHECKS */
 
 
@@ -1770,6 +1872,12 @@ if ( ( (cache_ptr)->index_size !=                                           \
  *		Added code to maintain the cache_ptr->slist_ring_len
  *		and cache_ptr->slist_ring_size arrays.
  *
+ *              JRM -- 4/29/20
+ *              Reworked macro to support the slist_enabled field 
+ *              of H5C_t.  If slist_enabled == TRUE, the macro 
+ *              functions as before.  Otherwise, the macro is a no-op,
+ *              and the slist must be empty.
+ *
  *-------------------------------------------------------------------------
  */
 
@@ -1779,32 +1887,43 @@ if ( ( (cache_ptr)->index_size !=                                           \
 {                                                                             \
     HDassert( (cache_ptr) );                                                  \
     HDassert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                       \
-    HDassert( (old_size) > 0 );                                               \
-    HDassert( (new_size) > 0 );                                               \
-    HDassert( (old_size) <= (cache_ptr)->slist_size );                        \
-    HDassert( (cache_ptr)->slist_len > 0 );                                   \
-    HDassert( ((cache_ptr)->slist_len > 1) ||                                 \
-              ( (cache_ptr)->slist_size == (old_size) ) );                    \
-    HDassert( (entry_ptr)->ring > H5C_RING_UNDEFINED );                       \
-    HDassert( (entry_ptr)->ring < H5C_RING_NTYPES );                          \
-    HDassert( (cache_ptr)->slist_ring_len[(entry_ptr)->ring] <=               \
-              (cache_ptr)->slist_len );                                       \
-    HDassert( (cache_ptr)->slist_ring_size[(entry_ptr)->ring] <=              \
-              (cache_ptr)->slist_size );                                      \
                                                                               \
-    (cache_ptr)->slist_size -= (old_size);                                    \
-    (cache_ptr)->slist_size += (new_size);                                    \
+    if ( (cache_ptr)->slist_enabled ) {                                       \
+                                                                              \
+        HDassert( (old_size) > 0 );                                           \
+        HDassert( (new_size) > 0 );                                           \
+        HDassert( (old_size) <= (cache_ptr)->slist_size );                    \
+        HDassert( (cache_ptr)->slist_len > 0 );                               \
+        HDassert( ((cache_ptr)->slist_len > 1) ||                             \
+                  ( (cache_ptr)->slist_size == (old_size) ) );                \
+        HDassert( (entry_ptr)->ring > H5C_RING_UNDEFINED );                   \
+        HDassert( (entry_ptr)->ring < H5C_RING_NTYPES );                      \
+        HDassert( (cache_ptr)->slist_ring_len[(entry_ptr)->ring] <=           \
+                  (cache_ptr)->slist_len );                                   \
+        HDassert( (cache_ptr)->slist_ring_size[(entry_ptr)->ring] <=          \
+                  (cache_ptr)->slist_size );                                  \
+                                                                              \
+        (cache_ptr)->slist_size -= (old_size);                                \
+        (cache_ptr)->slist_size += (new_size);                                \
+                                                                              \
+        HDassert( (cache_ptr)->slist_ring_size[(entry_ptr->ring)]             \
+                  >= (old_size) );                                            \
                                                                               \
-    HDassert( (cache_ptr)->slist_ring_size[(entry_ptr->ring)] >=(old_size) ); \
-    ((cache_ptr)->slist_ring_size[(entry_ptr)->ring]) -= (old_size);          \
-    ((cache_ptr)->slist_ring_size[(entry_ptr)->ring]) += (new_size);          \
+        ((cache_ptr)->slist_ring_size[(entry_ptr)->ring]) -= (old_size);      \
+        ((cache_ptr)->slist_ring_size[(entry_ptr)->ring]) += (new_size);      \
                                                                               \
-    (cache_ptr)->slist_size_increase -= (int64_t)(old_size);                  \
-    (cache_ptr)->slist_size_increase += (int64_t)(new_size);                  \
+        (cache_ptr)->slist_size_increase -= (int64_t)(old_size);              \
+        (cache_ptr)->slist_size_increase += (int64_t)(new_size);              \
                                                                               \
-    HDassert( (new_size) <= (cache_ptr)->slist_size );                        \
-    HDassert( ( (cache_ptr)->slist_len > 1 ) ||                               \
-              ( (cache_ptr)->slist_size == (new_size) ) );                    \
+        HDassert( (new_size) <= (cache_ptr)->slist_size );                    \
+        HDassert( ( (cache_ptr)->slist_len > 1 ) ||                           \
+                  ( (cache_ptr)->slist_size == (new_size) ) );                \
+                                                                              \
+    } else { /* slist disabled */                                             \
+                                                                              \
+        HDassert( (cache_ptr)->slist_len == 0 );                              \
+        HDassert( (cache_ptr)->slist_size == 0 );                             \
+    }                                                                         \
 } /* H5C__UPDATE_SLIST_FOR_SIZE_CHANGE */
 
 #else /* H5C_DO_SANITY_CHECKS */
@@ -1813,29 +1932,39 @@ if ( ( (cache_ptr)->index_size !=                                           \
 {                                                                             \
     HDassert( (cache_ptr) );                                                  \
     HDassert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                       \
-    HDassert( (old_size) > 0 );                                               \
-    HDassert( (new_size) > 0 );                                               \
-    HDassert( (old_size) <= (cache_ptr)->slist_size );                        \
-    HDassert( (cache_ptr)->slist_len > 0 );                                   \
-    HDassert( ((cache_ptr)->slist_len > 1) ||                                 \
-              ( (cache_ptr)->slist_size == (old_size) ) );                    \
-    HDassert( (entry_ptr)->ring > H5C_RING_UNDEFINED );                       \
-    HDassert( (entry_ptr)->ring < H5C_RING_NTYPES );                          \
-    HDassert( (cache_ptr)->slist_ring_len[(entry_ptr)->ring] <=               \
-              (cache_ptr)->slist_len );                                       \
-    HDassert( (cache_ptr)->slist_ring_size[(entry_ptr)->ring] <=              \
-              (cache_ptr)->slist_size );                                      \
                                                                               \
-    (cache_ptr)->slist_size -= (old_size);                                    \
-    (cache_ptr)->slist_size += (new_size);                                    \
+    if ( (cache_ptr)->slist_enabled ) {                                       \
+                                                                              \
+        HDassert( (old_size) > 0 );                                           \
+        HDassert( (new_size) > 0 );                                           \
+        HDassert( (old_size) <= (cache_ptr)->slist_size );                    \
+        HDassert( (cache_ptr)->slist_len > 0 );                               \
+        HDassert( ((cache_ptr)->slist_len > 1) ||                             \
+                  ( (cache_ptr)->slist_size == (old_size) ) );                \
+        HDassert( (entry_ptr)->ring > H5C_RING_UNDEFINED );                   \
+        HDassert( (entry_ptr)->ring < H5C_RING_NTYPES );                      \
+        HDassert( (cache_ptr)->slist_ring_len[(entry_ptr)->ring] <=           \
+                  (cache_ptr)->slist_len );                                   \
+        HDassert( (cache_ptr)->slist_ring_size[(entry_ptr)->ring] <=          \
+                  (cache_ptr)->slist_size );                                  \
+                                                                              \
+        (cache_ptr)->slist_size -= (old_size);                                \
+        (cache_ptr)->slist_size += (new_size);                                \
+                                                                              \
+        HDassert( (cache_ptr)->slist_ring_size[(entry_ptr->ring)] >=          \
+                  (old_size) );                                               \
+        ((cache_ptr)->slist_ring_size[(entry_ptr)->ring]) -= (old_size);      \
+        ((cache_ptr)->slist_ring_size[(entry_ptr)->ring]) += (new_size);      \
                                                                               \
-    HDassert( (cache_ptr)->slist_ring_size[(entry_ptr->ring)] >=(old_size) ); \
-    ((cache_ptr)->slist_ring_size[(entry_ptr)->ring]) -= (old_size);          \
-    ((cache_ptr)->slist_ring_size[(entry_ptr)->ring]) += (new_size);          \
+        HDassert( (new_size) <= (cache_ptr)->slist_size );                    \
+        HDassert( ( (cache_ptr)->slist_len > 1 ) ||                           \
+                  ( (cache_ptr)->slist_size == (new_size) ) );                \
                                                                               \
-    HDassert( (new_size) <= (cache_ptr)->slist_size );                        \
-    HDassert( ( (cache_ptr)->slist_len > 1 ) ||                               \
-              ( (cache_ptr)->slist_size == (new_size) ) );                    \
+    } else { /* slist disabled */                                             \
+                                                                              \
+        HDassert( (cache_ptr)->slist_len == 0 );                              \
+        HDassert( (cache_ptr)->slist_size == 0 );                             \
+    }                                                                         \
 } /* H5C__UPDATE_SLIST_FOR_SIZE_CHANGE */
 
 #endif /* H5C_DO_SANITY_CHECKS */
@@ -3726,7 +3855,8 @@ typedef struct H5C_tag_info_t {
  *		which contains the 'next' entry for an iteration.  Removing
  *              this entry must trigger a rescan of the iteration, so each
  *              entry removed from the cache is compared against this pointer
- *              and the pointer is reset to NULL if the watched entry is removed.
+ *              and the pointer is reset to NULL if the watched entry is 
+ *              removed.
  *              (This functions similarly to a "dead man's switch")
  *
  *
@@ -3740,6 +3870,36 @@ typedef struct H5C_tag_info_t {
  * are flushed. (this has been changed -- dirty entries are now removed from
  * the skip list as they are flushed.  JRM - 10/25/05)
  *
+ * Update 4/21/20: 
+ *
+ * Profiling indicates that the cost of maintaining the skip list is 
+ * significant.  As it is only used on flush and close, maintaining it
+ * only when needed is an obvious optimization.
+ *
+ * To do this, we add a flag to control maintenanace of the skip list.
+ * This flag is initially set to FALSE, which disables all operations 
+ * on the skip list.
+ *
+ * At the beginning of either flush or close, we scan the index list,
+ * insert all dirtly entries in the skip list, and enable operations
+ * on skip list by setting above control flag to true.
+ *
+ * At the end of a complete flush, we verify that the skip list is empty,
+ * and set the control flag back to false, so as to avoid skip list 
+ * maintenance overhead until the next flush or close.  
+ *
+ * In the case of a partial flush (i.e. flush marked entries), we remove
+ * all remaining entries from the skip list, and then set the control flag
+ * back to false -- again avoiding skip list maintenance overhead until 
+ * the next flush or close.
+ *
+ * slist_enabled: Boolean flag used to control operation of the skip
+ *              list.  If this filed is FALSE, operations on the 
+ *              slist are no-ops, and the slist must be empty.  If
+ *              it is TRUE, operations on the slist proceed as usual,
+ *              and all dirty entries in the metadata cache must be
+ *              listed in the slist.
+ *
  * slist_changed: Boolean flag used to indicate whether the contents of
  *		the slist has changed since the last time this flag was
  *		reset.  This is used in the cache flush code to detect
@@ -4649,6 +4809,7 @@ typedef struct H5C_tag_info_t {
  *              NDEBUG is not #defined.
  *
  ****************************************************************************/
+
 struct H5C_t {
     uint32_t			magic;
     hbool_t			flush_in_progress;
@@ -4664,7 +4825,7 @@ struct H5C_t {
     hbool_t			evictions_enabled;
     hbool_t			close_warning_received;
 
-    /* Fields for maintaining [hash table] index of entries */
+    /* Fields for maintaining the [hash table] index of entries */
     uint32_t                    index_len;
     size_t                      index_size;
     uint32_t			index_ring_len[H5C_RING_NTYPES];
@@ -4685,6 +4846,7 @@ struct H5C_t {
     H5C_cache_entry_t *		entry_watched_for_removal;
 
     /* Fields for maintaining list of in-order entries, for flushing */
+    hbool_t                     slist_enabled;
     hbool_t			slist_changed;
     uint32_t                    slist_len;
     size_t                      slist_size;
@@ -4882,7 +5044,8 @@ struct H5C_t {
 #ifndef NDEBUG
     int64_t                     get_entry_ptr_from_addr_counter;
 #endif /* NDEBUG */
-};
+
+}; /* H5C_t */
 
 /* Define typedef for tagged cache entry iteration callbacks */
 typedef int (*H5C_tag_iter_cb_t)(H5C_cache_entry_t *entry, void *ctx);