/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * Copyright by The HDF Group.                                               *
 * All rights reserved.                                                      *
 *                                                                           *
 * This file is part of HDF5.  The full HDF5 copyright notice, including     *
 * terms governing use, modification, and redistribution, is contained in    *
 * the LICENSE file, which can be found at the root of the source code       *
 * distribution tree, or in https://www.hdfgroup.org/licenses.               *
 * If you do not have access to either file, you may request a copy from     *
 * help@hdfgroup.org.                                                        *
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

/*
 * Purpose:	This file contains declarations which are visible only within
 *		the H5C package.  Source files outside the H5C package should
 *		include H5Cprivate.h instead.
 */

#if !(defined H5C_FRIEND || defined H5C_MODULE)
#error "Do not include this file outside the H5C package!"
#endif

#ifndef H5Cpkg_H
#define H5Cpkg_H

/* Get package's private header */
#include "H5Cprivate.h"

/* Other private headers needed by this file */
#include "H5Clog.h"      /* Cache logging */
#include "H5SLprivate.h" /* Skip lists */

/**************************/
/* Package Private Macros */
/**************************/

/* 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 */

/* Initial allocated size of the "flush_dep_parent" array */
#define H5C_FLUSH_DEP_PARENT_INIT 8

/****************************************************************************
 *
 * We maintain doubly linked lists of instances of H5C_cache_entry_t for a
 * variety of reasons -- protected list, LRU list, and the clean and dirty
 * LRU lists at present.  The following macros support linking and unlinking
 * of instances of H5C_cache_entry_t by both their regular and auxiliary next
 * and previous pointers.
 *
 * The size and length fields are also maintained.
 *
 * Note that the relevant pair of prev and next pointers are presumed to be
 * NULL on entry in the insertion macros.
 *
 * Finally, observe that the sanity checking macros evaluate to the empty
 * string when H5C_DO_SANITY_CHECKS is false.  They also contain calls
 * to the HGOTO_ERROR macro, which may not be appropriate in all cases.
 * If so, we will need versions of the insertion and deletion macros which
 * do not reference the sanity checking macros.
 *
 ****************************************************************************/

#ifdef H5C_DO_SANITY_CHECKS

#define H5C__GEN_DLL_PRE_REMOVE_SC(entry_ptr, list_next, list_prev, head_ptr, tail_ptr, len, list_size,      \
                                   fail_val)                                                                 \
    do {                                                                                                     \
        if ((head_ptr) == NULL || (tail_ptr) == NULL || (entry_ptr) == NULL || (len) <= 0 ||                 \
            (list_size) < (entry_ptr)->size ||                                                               \
            ((entry_ptr)->list_prev == NULL && (head_ptr) != (entry_ptr)) ||                                 \
            ((entry_ptr)->list_next == NULL && (tail_ptr) != (entry_ptr)) ||                                 \
            ((len) == 1 &&                                                                                   \
             !((head_ptr) == (entry_ptr) && (tail_ptr) == (entry_ptr) && (entry_ptr)->list_next == NULL &&   \
               (entry_ptr)->list_prev == NULL && (list_size) == (entry_ptr)->size))) {                       \
            HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, (fail_val), "DLL pre remove SC failed");                      \
        }                                                                                                    \
    } while (0)

#define H5C__GEN_DLL_PRE_INSERT_SC(entry_ptr, list_next, list_prev, head_ptr, tail_ptr, len, list_size,      \
                                   fail_val)                                                                 \
    if ((entry_ptr) == NULL || (entry_ptr)->list_next != NULL || (entry_ptr)->list_prev != NULL ||           \
        (((head_ptr) == NULL || (tail_ptr) == NULL) && (head_ptr) != (tail_ptr)) ||                          \
        ((len) == 0 && ((list_size) > 0 || (head_ptr) != NULL || (tail_ptr) != NULL)) ||                     \
        ((len) == 1 &&                                                                                       \
         ((head_ptr) != (tail_ptr) || (head_ptr) == NULL || (head_ptr)->size != (list_size))) ||             \
        ((len) >= 1 && ((head_ptr) == NULL || (head_ptr)->list_prev != NULL || (tail_ptr) == NULL ||         \
                        (tail_ptr)->list_next != NULL))) {                                                   \
        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, (fail_val), "DLL pre insert SC failed");                          \
    }

#define H5C__GEN_DLL_PRE_SIZE_UPDATE_SC(dll_len, dll_size, old_size, new_size, fail_val)                     \
    if ((dll_len) <= 0 || (dll_size) <= 0 || (old_size) <= 0 || (old_size) > (dll_size) ||                   \
        (new_size) <= 0 || ((dll_len) == 1 && (old_size) != (dll_size))) {                                   \
        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, (fail_val), "DLL pre size update SC failed");                     \
    }

#define H5C__GEN_DLL_POST_SIZE_UPDATE_SC(dll_len, dll_size, old_size, new_size, fail_val)                    \
    if ((new_size) > (dll_size) || ((dll_len) == 1 && (new_size) != (dll_size))) {                           \
        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, (fail_val), "DLL post size update SC failed");                    \
    }
#else /* H5C_DO_SANITY_CHECKS */
#define H5C__GEN_DLL_PRE_REMOVE_SC(entry_ptr, list_next, list_prev, head_ptr, tail_ptr, len, list_size,      \
                                   fail_val)
#define H5C__GEN_DLL_PRE_INSERT_SC(entry_ptr, list_next, list_prev, head_ptr, tail_ptr, len, list_size,      \
                                   fail_val)
#define H5C__GEN_DLL_PRE_SIZE_UPDATE_SC(dll_len, dll_size, old_size, new_size, fail_val)
#define H5C__GEN_DLL_POST_SIZE_UPDATE_SC(dll_len, dll_size, old_size, new_size, fail_val)
#endif /* H5C_DO_SANITY_CHECKS */

#define H5C__GEN_DLL_APPEND(entry_ptr, list_next, list_prev, head_ptr, tail_ptr, len, list_size, fail_val)   \
    {                                                                                                        \
        H5C__GEN_DLL_PRE_INSERT_SC(entry_ptr, list_next, list_prev, head_ptr, tail_ptr, len, list_size,      \
                                   fail_val)                                                                 \
        if ((head_ptr) == NULL) {                                                                            \
            (head_ptr) = (entry_ptr);                                                                        \
            (tail_ptr) = (entry_ptr);                                                                        \
        }                                                                                                    \
        else {                                                                                               \
            (tail_ptr)->list_next  = (entry_ptr);                                                            \
            (entry_ptr)->list_prev = (tail_ptr);                                                             \
            (tail_ptr)             = (entry_ptr);                                                            \
        }                                                                                                    \
        (len)++;                                                                                             \
        (list_size) += (entry_ptr)->size;                                                                    \
    } /* H5C__GEN_DLL_APPEND() */

#define H5C__GEN_DLL_PREPEND(entry_ptr, list_next, list_prev, head_ptr, tail_ptr, len, list_size, fail_val)  \
    {                                                                                                        \
        H5C__GEN_DLL_PRE_INSERT_SC(entry_ptr, list_next, list_prev, head_ptr, tail_ptr, len, list_size,      \
                                   fail_val)                                                                 \
        if ((head_ptr) == NULL) {                                                                            \
            (head_ptr) = (entry_ptr);                                                                        \
            (tail_ptr) = (entry_ptr);                                                                        \
        }                                                                                                    \
        else {                                                                                               \
            (head_ptr)->list_prev  = (entry_ptr);                                                            \
            (entry_ptr)->list_next = (head_ptr);                                                             \
            (head_ptr)             = (entry_ptr);                                                            \
        }                                                                                                    \
        (len)++;                                                                                             \
        (list_size) += (entry_ptr)->size;                                                                    \
    } /* H5C__GEN_DLL_PREPEND() */

#define H5C__GEN_DLL_REMOVE(entry_ptr, list_next, list_prev, head_ptr, tail_ptr, len, list_size, fail_val)   \
    {                                                                                                        \
        H5C__GEN_DLL_PRE_REMOVE_SC(entry_ptr, list_next, list_prev, head_ptr, tail_ptr, len, list_size,      \
                                   fail_val);                                                                \
        if ((head_ptr) == (entry_ptr)) {                                                                     \
            (head_ptr) = (entry_ptr)->list_next;                                                             \
            if ((head_ptr) != NULL)                                                                          \
                (head_ptr)->list_prev = NULL;                                                                \
        }                                                                                                    \
        else                                                                                                 \
            (entry_ptr)->list_prev->list_next = (entry_ptr)->list_next;                                      \
        if ((tail_ptr) == (entry_ptr)) {                                                                     \
            (tail_ptr) = (entry_ptr)->list_prev;                                                             \
            if ((tail_ptr) != NULL)                                                                          \
                (tail_ptr)->list_next = NULL;                                                                \
        }                                                                                                    \
        else                                                                                                 \
            (entry_ptr)->list_next->list_prev = (entry_ptr)->list_prev;                                      \
        (entry_ptr)->list_next = NULL;                                                                       \
        (entry_ptr)->list_prev = NULL;                                                                       \
        (len)--;                                                                                             \
        (list_size) -= (entry_ptr)->size;                                                                    \
    } /* H5C__GEN_DLL_REMOVE() */

#define H5C__GEN_DLL_UPDATE_FOR_SIZE_CHANGE(dll_len, dll_size, old_size, new_size, fail_val)                 \
    {                                                                                                        \
        H5C__GEN_DLL_PRE_SIZE_UPDATE_SC(dll_len, dll_size, old_size, new_size, fail_val)                     \
        (dll_size) -= (old_size);                                                                            \
        (dll_size) += (new_size);                                                                            \
        H5C__GEN_DLL_POST_SIZE_UPDATE_SC(dll_len, dll_size, old_size, new_size, fail_val)                    \
    } /* H5C__GEN_DLL_UPDATE_FOR_SIZE_CHANGE() */

/* Macros that modify the LRU/protected/pinned lists */
#define H5C__DLL_APPEND(entry_ptr, head_ptr, tail_ptr, len, list_size, fail_val)                             \
    H5C__GEN_DLL_APPEND(entry_ptr, next, prev, head_ptr, tail_ptr, len, list_size, fail_val)
#define H5C__DLL_PREPEND(entry_ptr, head_ptr, tail_ptr, len, list_size, fail_val)                            \
    H5C__GEN_DLL_PREPEND(entry_ptr, next, prev, head_ptr, tail_ptr, len, list_size, fail_val)
#define H5C__DLL_REMOVE(entry_ptr, head_ptr, tail_ptr, len, list_size, fail_val)                             \
    H5C__GEN_DLL_REMOVE(entry_ptr, next, prev, head_ptr, tail_ptr, len, list_size, fail_val)
#define H5C__DLL_UPDATE_FOR_SIZE_CHANGE(dll_len, dll_size, old_size, new_size, fail_val)                     \
    H5C__GEN_DLL_UPDATE_FOR_SIZE_CHANGE(dll_len, dll_size, old_size, new_size, fail_val)

/* Macros that modify the "auxiliary" LRU list */
#define H5C__AUX_DLL_APPEND(entry_ptr, head_ptr, tail_ptr, len, list_size, fail_val)                         \
    H5C__GEN_DLL_APPEND(entry_ptr, aux_next, aux_prev, head_ptr, tail_ptr, len, list_size, fail_val)
#define H5C__AUX_DLL_PREPEND(entry_ptr, head_ptr, tail_ptr, len, list_size, fail_val)                        \
    H5C__GEN_DLL_PREPEND(entry_ptr, aux_next, aux_prev, head_ptr, tail_ptr, len, list_size, fail_val)
#define H5C__AUX_DLL_REMOVE(entry_ptr, head_ptr, tail_ptr, len, list_size, fail_val)                         \
    H5C__GEN_DLL_REMOVE(entry_ptr, aux_next, aux_prev, head_ptr, tail_ptr, len, list_size, fail_val)

/* Macros that modify the "index" list */
#define H5C__IL_DLL_APPEND(entry_ptr, head_ptr, tail_ptr, len, list_size, fail_val)                          \
    H5C__GEN_DLL_APPEND(entry_ptr, il_next, il_prev, head_ptr, tail_ptr, len, list_size, fail_val)
#define H5C__IL_DLL_REMOVE(entry_ptr, head_ptr, tail_ptr, len, list_size, fail_val)                          \
    H5C__GEN_DLL_REMOVE(entry_ptr, il_next, il_prev, head_ptr, tail_ptr, len, list_size, fail_val)

/***********************************************************************
 *
 * Stats collection macros
 *
 * The following macros must handle stats collection when this collection
 * is enabled, and evaluate to the empty string when it is not.
 *
 * The sole exception to this rule is
 * H5C__UPDATE_CACHE_HIT_RATE_STATS(), which is always active as
 * the cache hit rate stats are always collected and available.
 *
 ***********************************************************************/

#define H5C__UPDATE_CACHE_HIT_RATE_STATS(cache_ptr, hit)                                                     \
    do {                                                                                                     \
        (cache_ptr)->cache_accesses++;                                                                       \
        if (hit)                                                                                             \
            (cache_ptr)->cache_hits++;                                                                       \
    } while (0)

#if H5C_COLLECT_CACHE_STATS

#define H5C__UPDATE_MAX_INDEX_SIZE_STATS(cache_ptr)                                                          \
    do {                                                                                                     \
        if ((cache_ptr)->index_size > (cache_ptr)->max_index_size)                                           \
            (cache_ptr)->max_index_size = (cache_ptr)->index_size;                                           \
        if ((cache_ptr)->clean_index_size > (cache_ptr)->max_clean_index_size)                               \
            (cache_ptr)->max_clean_index_size = (cache_ptr)->clean_index_size;                               \
        if ((cache_ptr)->dirty_index_size > (cache_ptr)->max_dirty_index_size)                               \
            (cache_ptr)->max_dirty_index_size = (cache_ptr)->dirty_index_size;                               \
    } while (0)

#define H5C__UPDATE_STATS_FOR_DIRTY_PIN(cache_ptr, entry_ptr)                                                \
    do {                                                                                                     \
        (cache_ptr)->dirty_pins[(entry_ptr)->type->id]++;                                                    \
    } while (0)

#define H5C__UPDATE_STATS_FOR_UNPROTECT(cache_ptr)                                                           \
    do {                                                                                                     \
        if ((cache_ptr)->slist_len > (cache_ptr)->max_slist_len)                                             \
            (cache_ptr)->max_slist_len = (cache_ptr)->slist_len;                                             \
        if ((cache_ptr)->slist_size > (cache_ptr)->max_slist_size)                                           \
            (cache_ptr)->max_slist_size = (cache_ptr)->slist_size;                                           \
        if ((cache_ptr)->pel_len > (cache_ptr)->max_pel_len)                                                 \
            (cache_ptr)->max_pel_len = (cache_ptr)->pel_len;                                                 \
        if ((cache_ptr)->pel_size > (cache_ptr)->max_pel_size)                                               \
            (cache_ptr)->max_pel_size = (cache_ptr)->pel_size;                                               \
    } while (0)

#define H5C__UPDATE_STATS_FOR_MOVE(cache_ptr, entry_ptr)                                                     \
    do {                                                                                                     \
        if ((cache_ptr)->flush_in_progress)                                                                  \
            (cache_ptr)->cache_flush_moves[(entry_ptr)->type->id]++;                                         \
        if ((entry_ptr)->flush_in_progress)                                                                  \
            (cache_ptr)->entry_flush_moves[(entry_ptr)->type->id]++;                                         \
        (cache_ptr)->moves[(entry_ptr)->type->id]++;                                                         \
        (cache_ptr)->entries_relocated_counter++;                                                            \
    } while (0)

#define H5C__UPDATE_STATS_FOR_ENTRY_SIZE_CHANGE(cache_ptr, entry_ptr, new_size)                              \
    do {                                                                                                     \
        if ((cache_ptr)->flush_in_progress)                                                                  \
            (cache_ptr)->cache_flush_size_changes[(entry_ptr)->type->id]++;                                  \
        if ((entry_ptr)->flush_in_progress)                                                                  \
            (cache_ptr)->entry_flush_size_changes[(entry_ptr)->type->id]++;                                  \
        if ((entry_ptr)->size < (new_size)) {                                                                \
            (cache_ptr)->size_increases[(entry_ptr)->type->id]++;                                            \
            H5C__UPDATE_MAX_INDEX_SIZE_STATS(cache_ptr);                                                     \
            if ((cache_ptr)->slist_size > (cache_ptr)->max_slist_size)                                       \
                (cache_ptr)->max_slist_size = (cache_ptr)->slist_size;                                       \
            if ((cache_ptr)->pl_size > (cache_ptr)->max_pl_size)                                             \
                (cache_ptr)->max_pl_size = (cache_ptr)->pl_size;                                             \
        }                                                                                                    \
        else if ((entry_ptr)->size > (new_size)) {                                                           \
            (cache_ptr)->size_decreases[(entry_ptr)->type->id]++;                                            \
        }                                                                                                    \
    } while (0)

#define H5C__UPDATE_STATS_FOR_HT_INSERTION(cache_ptr)                                                        \
    do {                                                                                                     \
        (cache_ptr)->total_ht_insertions++;                                                                  \
    } while (0)

#define H5C__UPDATE_STATS_FOR_HT_DELETION(cache_ptr)                                                         \
    do {                                                                                                     \
        (cache_ptr)->total_ht_deletions++;                                                                   \
    } while (0)

#define H5C__UPDATE_STATS_FOR_HT_SEARCH(cache_ptr, success, depth)                                           \
    do {                                                                                                     \
        if (success) {                                                                                       \
            (cache_ptr)->successful_ht_searches++;                                                           \
            (cache_ptr)->total_successful_ht_search_depth += depth;                                          \
        }                                                                                                    \
        else {                                                                                               \
            (cache_ptr)->failed_ht_searches++;                                                               \
            (cache_ptr)->total_failed_ht_search_depth += depth;                                              \
        }                                                                                                    \
    } while (0)

#define H5C__UPDATE_STATS_FOR_UNPIN(cache_ptr, entry_ptr)                                                    \
    do {                                                                                                     \
        (cache_ptr)->unpins[(entry_ptr)->type->id]++;                                                        \
    } while (0)

#define H5C__UPDATE_STATS_FOR_PREFETCH(cache_ptr, dirty)                                                     \
    do {                                                                                                     \
        (cache_ptr)->prefetches++;                                                                           \
        if (dirty)                                                                                           \
            (cache_ptr)->dirty_prefetches++;                                                                 \
    } while (0)

#define H5C__UPDATE_STATS_FOR_PREFETCH_HIT(cache_ptr)                                                        \
    do {                                                                                                     \
        (cache_ptr)->prefetch_hits++;                                                                        \
    } while (0)

#define H5C__UPDATE_STATS_FOR_SLIST_SCAN_RESTART(cache_ptr)                                                  \
    do {                                                                                                     \
        (cache_ptr)->slist_scan_restarts++;                                                                  \
    } while (0)

#define H5C__UPDATE_STATS_FOR_LRU_SCAN_RESTART(cache_ptr)                                                    \
    do {                                                                                                     \
        (cache_ptr)->LRU_scan_restarts++;                                                                    \
    } while (0)

#define H5C__UPDATE_STATS_FOR_INDEX_SCAN_RESTART(cache_ptr)                                                  \
    do {                                                                                                     \
        (cache_ptr)->index_scan_restarts++;                                                                  \
    } while (0)

#if H5C_COLLECT_CACHE_ENTRY_STATS

#define H5C__RESET_CACHE_ENTRY_STATS(entry_ptr)                                                              \
    do {                                                                                                     \
        (entry_ptr)->accesses = 0;                                                                           \
        (entry_ptr)->clears   = 0;                                                                           \
        (entry_ptr)->flushes  = 0;                                                                           \
        (entry_ptr)->pins     = 0;                                                                           \
    } while (0)

#define H5C__UPDATE_STATS_FOR_CLEAR(cache_ptr, entry_ptr)                                                    \
    do {                                                                                                     \
        (cache_ptr)->clears[(entry_ptr)->type->id]++;                                                        \
        if ((entry_ptr)->is_pinned)                                                                          \
            (cache_ptr)->pinned_clears[(entry_ptr)->type->id]++;                                             \
        (entry_ptr)->clears++;                                                                               \
    } while (0)

#define H5C__UPDATE_STATS_FOR_FLUSH(cache_ptr, entry_ptr)                                                    \
    do {                                                                                                     \
        (cache_ptr)->flushes[(entry_ptr)->type->id]++;                                                       \
        if ((entry_ptr)->is_pinned)                                                                          \
            (cache_ptr)->pinned_flushes[(entry_ptr)->type->id]++;                                            \
        (entry_ptr)->flushes++;                                                                              \
    } while (0)

#define H5C__UPDATE_STATS_FOR_EVICTION(cache_ptr, entry_ptr, take_ownership)                                 \
    do {                                                                                                     \
        if (take_ownership)                                                                                  \
            (cache_ptr)->take_ownerships[(entry_ptr)->type->id]++;                                           \
        else                                                                                                 \
            (cache_ptr)->evictions[(entry_ptr)->type->id]++;                                                 \
        if ((entry_ptr)->accesses > (cache_ptr)->max_accesses[(entry_ptr)->type->id])                        \
            (cache_ptr)->max_accesses[(entry_ptr)->type->id] = (entry_ptr)->accesses;                        \
        if ((entry_ptr)->accesses < (cache_ptr)->min_accesses[(entry_ptr)->type->id])                        \
            (cache_ptr)->min_accesses[(entry_ptr)->type->id] = (entry_ptr)->accesses;                        \
        if ((entry_ptr)->clears > (cache_ptr)->max_clears[(entry_ptr)->type->id])                            \
            (cache_ptr)->max_clears[(entry_ptr)->type->id] = (entry_ptr)->clears;                            \
        if ((entry_ptr)->flushes > (cache_ptr)->max_flushes[(entry_ptr)->type->id])                          \
            (cache_ptr)->max_flushes[(entry_ptr)->type->id] = (entry_ptr)->flushes;                          \
        if ((entry_ptr)->size > (cache_ptr)->max_size[(entry_ptr)->type->id])                                \
            (cache_ptr)->max_size[(entry_ptr)->type->id] = (entry_ptr)->size;                                \
        if ((entry_ptr)->pins > (cache_ptr)->max_pins[(entry_ptr)->type->id])                                \
            (cache_ptr)->max_pins[(entry_ptr)->type->id] = (entry_ptr)->pins;                                \
    } while (0)

#define H5C__UPDATE_STATS_FOR_INSERTION(cache_ptr, entry_ptr)                                                \
    do {                                                                                                     \
        (cache_ptr)->insertions[(entry_ptr)->type->id]++;                                                    \
        if ((entry_ptr)->is_pinned) {                                                                        \
            (cache_ptr)->pinned_insertions[(entry_ptr)->type->id]++;                                         \
            (cache_ptr)->pins[(entry_ptr)->type->id]++;                                                      \
            (entry_ptr)->pins++;                                                                             \
            if ((cache_ptr)->pel_len > (cache_ptr)->max_pel_len)                                             \
                (cache_ptr)->max_pel_len = (cache_ptr)->pel_len;                                             \
            if ((cache_ptr)->pel_size > (cache_ptr)->max_pel_size)                                           \
                (cache_ptr)->max_pel_size = (cache_ptr)->pel_size;                                           \
        }                                                                                                    \
        if ((cache_ptr)->index_len > (cache_ptr)->max_index_len)                                             \
            (cache_ptr)->max_index_len = (cache_ptr)->index_len;                                             \
        H5C__UPDATE_MAX_INDEX_SIZE_STATS(cache_ptr);                                                         \
        if ((cache_ptr)->slist_len > (cache_ptr)->max_slist_len)                                             \
            (cache_ptr)->max_slist_len = (cache_ptr)->slist_len;                                             \
        if ((cache_ptr)->slist_size > (cache_ptr)->max_slist_size)                                           \
            (cache_ptr)->max_slist_size = (cache_ptr)->slist_size;                                           \
        if ((entry_ptr)->size > (cache_ptr)->max_size[(entry_ptr)->type->id])                                \
            (cache_ptr)->max_size[(entry_ptr)->type->id] = (entry_ptr)->size;                                \
        (cache_ptr)->entries_inserted_counter++;                                                             \
    } while (0)

#define H5C__UPDATE_STATS_FOR_PROTECT(cache_ptr, entry_ptr, hit)                                             \
    do {                                                                                                     \
        if (hit)                                                                                             \
            (cache_ptr)->hits[(entry_ptr)->type->id]++;                                                      \
        else                                                                                                 \
            (cache_ptr)->misses[(entry_ptr)->type->id]++;                                                    \
        if (!(entry_ptr)->is_read_only)                                                                      \
            (cache_ptr)->write_protects[(entry_ptr)->type->id]++;                                            \
        else {                                                                                               \
            (cache_ptr)->read_protects[(entry_ptr)->type->id]++;                                             \
            if ((entry_ptr)->ro_ref_count > (cache_ptr)->max_read_protects[(entry_ptr)->type->id])           \
                (cache_ptr)->max_read_protects[(entry_ptr)->type->id] = (entry_ptr)->ro_ref_count;           \
        }                                                                                                    \
        if ((cache_ptr)->index_len > (cache_ptr)->max_index_len)                                             \
            (cache_ptr)->max_index_len = (cache_ptr)->index_len;                                             \
        H5C__UPDATE_MAX_INDEX_SIZE_STATS(cache_ptr);                                                         \
        if ((cache_ptr)->pl_len > (cache_ptr)->max_pl_len)                                                   \
            (cache_ptr)->max_pl_len = (cache_ptr)->pl_len;                                                   \
        if ((cache_ptr)->pl_size > (cache_ptr)->max_pl_size)                                                 \
            (cache_ptr)->max_pl_size = (cache_ptr)->pl_size;                                                 \
        if ((entry_ptr)->size > (cache_ptr)->max_size[(entry_ptr)->type->id])                                \
            (cache_ptr)->max_size[(entry_ptr)->type->id] = (entry_ptr)->size;                                \
        (entry_ptr)->accesses++;                                                                             \
    } while (0)

#define H5C__UPDATE_STATS_FOR_PIN(cache_ptr, entry_ptr)                                                      \
    do {                                                                                                     \
        (cache_ptr)->pins[(entry_ptr)->type->id]++;                                                          \
        (entry_ptr)->pins++;                                                                                 \
        if ((cache_ptr)->pel_len > (cache_ptr)->max_pel_len)                                                 \
            (cache_ptr)->max_pel_len = (cache_ptr)->pel_len;                                                 \
        if ((cache_ptr)->pel_size > (cache_ptr)->max_pel_size)                                               \
            (cache_ptr)->max_pel_size = (cache_ptr)->pel_size;                                               \
    } while (0)

#else /* H5C_COLLECT_CACHE_ENTRY_STATS */

#define H5C__RESET_CACHE_ENTRY_STATS(entry_ptr)

#define H5C__UPDATE_STATS_FOR_CLEAR(cache_ptr, entry_ptr)                                                    \
    do {                                                                                                     \
        (cache_ptr)->clears[(entry_ptr)->type->id]++;                                                        \
        if ((entry_ptr)->is_pinned)                                                                          \
            (cache_ptr)->pinned_clears[(entry_ptr)->type->id]++;                                             \
    } while (0)

#define H5C__UPDATE_STATS_FOR_FLUSH(cache_ptr, entry_ptr)                                                    \
    do {                                                                                                     \
        (cache_ptr)->flushes[(entry_ptr)->type->id]++;                                                       \
        if ((entry_ptr)->is_pinned)                                                                          \
            (cache_ptr)->pinned_flushes[(entry_ptr)->type->id]++;                                            \
    } while (0)

#define H5C__UPDATE_STATS_FOR_EVICTION(cache_ptr, entry_ptr, take_ownership)                                 \
    do {                                                                                                     \
        if (take_ownership)                                                                                  \
            (cache_ptr)->take_ownerships[(entry_ptr)->type->id]++;                                           \
        else                                                                                                 \
            (cache_ptr)->evictions[(entry_ptr)->type->id]++;                                                 \
    } while (0)

#define H5C__UPDATE_STATS_FOR_INSERTION(cache_ptr, entry_ptr)                                                \
    do {                                                                                                     \
        (cache_ptr)->insertions[(entry_ptr)->type->id]++;                                                    \
        if ((entry_ptr)->is_pinned) {                                                                        \
            (cache_ptr)->pinned_insertions[(entry_ptr)->type->id]++;                                         \
            (cache_ptr)->pins[(entry_ptr)->type->id]++;                                                      \
            if ((cache_ptr)->pel_len > (cache_ptr)->max_pel_len)                                             \
                (cache_ptr)->max_pel_len = (cache_ptr)->pel_len;                                             \
            if ((cache_ptr)->pel_size > (cache_ptr)->max_pel_size)                                           \
                (cache_ptr)->max_pel_size = (cache_ptr)->pel_size;                                           \
        }                                                                                                    \
        if ((cache_ptr)->index_len > (cache_ptr)->max_index_len)                                             \
            (cache_ptr)->max_index_len = (cache_ptr)->index_len;                                             \
        H5C__UPDATE_MAX_INDEX_SIZE_STATS(cache_ptr)                                                          \
        if ((cache_ptr)->slist_len > (cache_ptr)->max_slist_len)                                             \
            (cache_ptr)->max_slist_len = (cache_ptr)->slist_len;                                             \
        if ((cache_ptr)->slist_size > (cache_ptr)->max_slist_size)                                           \
            (cache_ptr)->max_slist_size = (cache_ptr)->slist_size;                                           \
        (cache_ptr)->entries_inserted_counter++;                                                             \
    } while (0)

#define H5C__UPDATE_STATS_FOR_PROTECT(cache_ptr, entry_ptr, hit)                                             \
    do {                                                                                                     \
        if (hit)                                                                                             \
            (cache_ptr)->hits[(entry_ptr)->type->id]++;                                                      \
        else                                                                                                 \
            (cache_ptr)->misses[(entry_ptr)->type->id]++;                                                    \
        if (!(entry_ptr)->is_read_only)                                                                      \
            (cache_ptr)->write_protects[(entry_ptr)->type->id]++;                                            \
        else {                                                                                               \
            (cache_ptr)->read_protects[(entry_ptr)->type->id]++;                                             \
            if ((entry_ptr)->ro_ref_count > (cache_ptr)->max_read_protects[(entry_ptr)->type->id])           \
                (cache_ptr)->max_read_protects[(entry_ptr)->type->id] = (entry_ptr)->ro_ref_count;           \
        }                                                                                                    \
        if ((cache_ptr)->index_len > (cache_ptr)->max_index_len)                                             \
            (cache_ptr)->max_index_len = (cache_ptr)->index_len;                                             \
        H5C__UPDATE_MAX_INDEX_SIZE_STATS(cache_ptr)                                                          \
        if ((cache_ptr)->pl_len > (cache_ptr)->max_pl_len)                                                   \
            (cache_ptr)->max_pl_len = (cache_ptr)->pl_len;                                                   \
        if ((cache_ptr)->pl_size > (cache_ptr)->max_pl_size)                                                 \
            (cache_ptr)->max_pl_size = (cache_ptr)->pl_size;                                                 \
    } while (0)

#define H5C__UPDATE_STATS_FOR_PIN(cache_ptr, entry_ptr)                                                      \
    do {                                                                                                     \
        (cache_ptr)->pins[(entry_ptr)->type->id]++;                                                          \
        if ((cache_ptr)->pel_len > (cache_ptr)->max_pel_len)                                                 \
            (cache_ptr)->max_pel_len = (cache_ptr)->pel_len;                                                 \
        if ((cache_ptr)->pel_size > (cache_ptr)->max_pel_size)                                               \
            (cache_ptr)->max_pel_size = (cache_ptr)->pel_size;                                               \
    } while (0)

#endif /* H5C_COLLECT_CACHE_ENTRY_STATS */

#else /* H5C_COLLECT_CACHE_STATS */

#define H5C__RESET_CACHE_ENTRY_STATS(entry_ptr)                                                              \
    do {                                                                                                     \
    } while (0)
#define H5C__UPDATE_STATS_FOR_DIRTY_PIN(cache_ptr, entry_ptr)                                                \
    do {                                                                                                     \
    } while (0)
#define H5C__UPDATE_STATS_FOR_UNPROTECT(cache_ptr)                                                           \
    do {                                                                                                     \
    } while (0)
#define H5C__UPDATE_STATS_FOR_MOVE(cache_ptr, entry_ptr)                                                     \
    do {                                                                                                     \
    } while (0)
#define H5C__UPDATE_STATS_FOR_ENTRY_SIZE_CHANGE(cache_ptr, entry_ptr, new_size)                              \
    do {                                                                                                     \
    } while (0)
#define H5C__UPDATE_STATS_FOR_HT_INSERTION(cache_ptr)                                                        \
    do {                                                                                                     \
    } while (0)
#define H5C__UPDATE_STATS_FOR_HT_DELETION(cache_ptr)                                                         \
    do {                                                                                                     \
    } while (0)
#define H5C__UPDATE_STATS_FOR_HT_SEARCH(cache_ptr, success, depth)                                           \
    do {                                                                                                     \
    } while (0)
#define H5C__UPDATE_STATS_FOR_INSERTION(cache_ptr, entry_ptr)                                                \
    do {                                                                                                     \
    } while (0)
#define H5C__UPDATE_STATS_FOR_CLEAR(cache_ptr, entry_ptr)                                                    \
    do {                                                                                                     \
    } while (0)
#define H5C__UPDATE_STATS_FOR_FLUSH(cache_ptr, entry_ptr)                                                    \
    do {                                                                                                     \
    } while (0)
#define H5C__UPDATE_STATS_FOR_EVICTION(cache_ptr, entry_ptr, take_ownership)                                 \
    do {                                                                                                     \
    } while (0)
#define H5C__UPDATE_STATS_FOR_PROTECT(cache_ptr, entry_ptr, hit)                                             \
    do {                                                                                                     \
    } while (0)
#define H5C__UPDATE_STATS_FOR_PIN(cache_ptr, entry_ptr)                                                      \
    do {                                                                                                     \
    } while (0)
#define H5C__UPDATE_STATS_FOR_UNPIN(cache_ptr, entry_ptr)                                                    \
    do {                                                                                                     \
    } while (0)
#define H5C__UPDATE_STATS_FOR_PREFETCH(cache_ptr, dirty)                                                     \
    do {                                                                                                     \
    } while (0)
#define H5C__UPDATE_STATS_FOR_PREFETCH_HIT(cache_ptr)                                                        \
    do {                                                                                                     \
    } while (0)
#define H5C__UPDATE_STATS_FOR_SLIST_SCAN_RESTART(cache_ptr)                                                  \
    do {                                                                                                     \
    } while (0)
#define H5C__UPDATE_STATS_FOR_LRU_SCAN_RESTART(cache_ptr)                                                    \
    do {                                                                                                     \
    } while (0)
#define H5C__UPDATE_STATS_FOR_INDEX_SCAN_RESTART(cache_ptr)                                                  \
    do {                                                                                                     \
    } while (0)

#endif /* H5C_COLLECT_CACHE_STATS */

/***********************************************************************
 *
 * Hash table access and manipulation macros:
 *
 * The following macros handle searches, insertions, and deletion in
 * the hash table.
 *
 ***********************************************************************/

#define H5C__HASH_MASK   ((size_t)(H5C__HASH_TABLE_LEN - 1) << 3)
#define H5C__HASH_FCN(x) (int)((unsigned)((x) & H5C__HASH_MASK) >> 3)

#define H5C__POST_HT_SHIFT_TO_FRONT_SC_CMP(cache_ptr, entry_ptr, k)                                          \
    ((cache_ptr) == NULL || (cache_ptr)->index[k] != (entry_ptr) || (entry_ptr)->ht_prev != NULL)
#define H5C__PRE_HT_SEARCH_SC_CMP(cache_ptr, entry_addr)                                                     \
    ((cache_ptr) == NULL ||                                                                                  \
     (cache_ptr)->index_size != ((cache_ptr)->clean_index_size + (cache_ptr)->dirty_index_size) ||           \
     !H5_addr_defined(entry_addr) || H5C__HASH_FCN(entry_addr) < 0 ||                                        \
     H5C__HASH_FCN(entry_addr) >= H5C__HASH_TABLE_LEN)
#define H5C__POST_SUC_HT_SEARCH_SC_CMP(cache_ptr, entry_ptr, k)                                              \
    ((cache_ptr) == NULL || (cache_ptr)->index_len < 1 || (entry_ptr) == NULL ||                             \
     (cache_ptr)->index_size < (entry_ptr)->size ||                                                          \
     (cache_ptr)->index_size != ((cache_ptr)->clean_index_size + (cache_ptr)->dirty_index_size) ||           \
     (entry_ptr)->size <= 0 || (cache_ptr)->index[k] == NULL ||                                              \
     ((cache_ptr)->index[k] != (entry_ptr) && (entry_ptr)->ht_prev == NULL) ||                               \
     ((cache_ptr)->index[k] == (entry_ptr) && (entry_ptr)->ht_prev != NULL) ||                               \
     ((entry_ptr)->ht_prev != NULL && (entry_ptr)->ht_prev->ht_next != (entry_ptr)) ||                       \
     ((entry_ptr)->ht_next != NULL && (entry_ptr)->ht_next->ht_prev != (entry_ptr)))

#ifdef H5C_DO_SANITY_CHECKS

#define H5C__PRE_HT_INSERT_SC(cache_ptr, entry_ptr, fail_val)                                                \
    if ((cache_ptr) == NULL || (entry_ptr) == NULL || !H5_addr_defined((entry_ptr)->addr) ||                 \
        (entry_ptr)->ht_next != NULL || (entry_ptr)->ht_prev != NULL || (entry_ptr)->size <= 0 ||            \
        H5C__HASH_FCN((entry_ptr)->addr) < 0 || H5C__HASH_FCN((entry_ptr)->addr) >= H5C__HASH_TABLE_LEN ||   \
        (cache_ptr)->index_size != ((cache_ptr)->clean_index_size + (cache_ptr)->dirty_index_size) ||        \
        (cache_ptr)->index_size < (cache_ptr)->clean_index_size ||                                           \
        (cache_ptr)->index_size < (cache_ptr)->dirty_index_size ||                                           \
        (entry_ptr)->ring <= H5C_RING_UNDEFINED || (entry_ptr)->ring >= H5C_RING_NTYPES ||                   \
        (cache_ptr)->index_ring_len[(entry_ptr)->ring] > (cache_ptr)->index_len ||                           \
        (cache_ptr)->index_ring_size[(entry_ptr)->ring] > (cache_ptr)->index_size ||                         \
        (cache_ptr)->index_ring_size[(entry_ptr)->ring] !=                                                   \
            ((cache_ptr)->clean_index_ring_size[(entry_ptr)->ring] +                                         \
             (cache_ptr)->dirty_index_ring_size[(entry_ptr)->ring]) ||                                       \
        (cache_ptr)->index_len != (cache_ptr)->il_len || (cache_ptr)->index_size != (cache_ptr)->il_size) {  \
        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)                                               \
    if ((cache_ptr) == NULL ||                                                                               \
        (cache_ptr)->index_size != ((cache_ptr)->clean_index_size + (cache_ptr)->dirty_index_size) ||        \
        (cache_ptr)->index_size < (cache_ptr)->clean_index_size ||                                           \
        (cache_ptr)->index_size < (cache_ptr)->dirty_index_size ||                                           \
        (cache_ptr)->index_ring_len[(entry_ptr)->ring] == 0 ||                                               \
        (cache_ptr)->index_ring_len[(entry_ptr)->ring] > (cache_ptr)->index_len ||                           \
        (cache_ptr)->index_ring_size[(entry_ptr)->ring] > (cache_ptr)->index_size ||                         \
        (cache_ptr)->index_ring_size[(entry_ptr)->ring] !=                                                   \
            ((cache_ptr)->clean_index_ring_size[(entry_ptr)->ring] +                                         \
             (cache_ptr)->dirty_index_ring_size[(entry_ptr)->ring]) ||                                       \
        (cache_ptr)->index_len != (cache_ptr)->il_len || (cache_ptr)->index_size != (cache_ptr)->il_size) {  \
        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, fail_val, "post HT insert SC failed");                            \
    }

#define H5C__PRE_HT_REMOVE_SC(cache_ptr, entry_ptr, fail_val)                                                \
    if ((cache_ptr) == NULL || (cache_ptr)->index_len < 1 || (entry_ptr) == NULL ||                          \
        (cache_ptr)->index_size < (entry_ptr)->size || !H5_addr_defined((entry_ptr)->addr) ||                \
        (entry_ptr)->size <= 0 || H5C__HASH_FCN((entry_ptr)->addr) < 0 ||                                    \
        H5C__HASH_FCN((entry_ptr)->addr) >= H5C__HASH_TABLE_LEN ||                                           \
        (cache_ptr)->index[H5C__HASH_FCN((entry_ptr)->addr)] == NULL ||                                      \
        ((cache_ptr)->index[H5C__HASH_FCN((entry_ptr)->addr)] != (entry_ptr) &&                              \
         (entry_ptr)->ht_prev == NULL) ||                                                                    \
        ((cache_ptr)->index[H5C__HASH_FCN((entry_ptr)->addr)] == (entry_ptr) &&                              \
         (entry_ptr)->ht_prev != NULL) ||                                                                    \
        (cache_ptr)->index_size != ((cache_ptr)->clean_index_size + (cache_ptr)->dirty_index_size) ||        \
        (cache_ptr)->index_size < (cache_ptr)->clean_index_size ||                                           \
        (cache_ptr)->index_size < (cache_ptr)->dirty_index_size ||                                           \
        (entry_ptr)->ring <= H5C_RING_UNDEFINED || (entry_ptr)->ring >= H5C_RING_NTYPES ||                   \
        (cache_ptr)->index_ring_len[(entry_ptr)->ring] <= 0 ||                                               \
        (cache_ptr)->index_ring_len[(entry_ptr)->ring] > (cache_ptr)->index_len ||                           \
        (cache_ptr)->index_ring_size[(entry_ptr)->ring] < (entry_ptr)->size ||                               \
        (cache_ptr)->index_ring_size[(entry_ptr)->ring] > (cache_ptr)->index_size ||                         \
        (cache_ptr)->index_ring_size[(entry_ptr)->ring] !=                                                   \
            ((cache_ptr)->clean_index_ring_size[(entry_ptr)->ring] +                                         \
             (cache_ptr)->dirty_index_ring_size[(entry_ptr)->ring]) ||                                       \
        (cache_ptr)->index_len != (cache_ptr)->il_len || (cache_ptr)->index_size != (cache_ptr)->il_size) {  \
        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, (fail_val), "pre HT remove SC failed");                           \
    }

#define H5C__POST_HT_REMOVE_SC(cache_ptr, entry_ptr, fail_val)                                               \
    if ((cache_ptr) == NULL || (entry_ptr) == NULL || !H5_addr_defined((entry_ptr)->addr) ||                 \
        (entry_ptr)->size <= 0 || (entry_ptr)->ht_next != NULL || (entry_ptr)->ht_prev != NULL ||            \
        (cache_ptr)->index_size != ((cache_ptr)->clean_index_size + (cache_ptr)->dirty_index_size) ||        \
        (cache_ptr)->index_size < (cache_ptr)->clean_index_size ||                                           \
        (cache_ptr)->index_size < (cache_ptr)->dirty_index_size ||                                           \
        (cache_ptr)->index_ring_len[(entry_ptr)->ring] > (cache_ptr)->index_len ||                           \
        (cache_ptr)->index_ring_size[(entry_ptr)->ring] > (cache_ptr)->index_size ||                         \
        (cache_ptr)->index_ring_size[(entry_ptr)->ring] !=                                                   \
            ((cache_ptr)->clean_index_ring_size[(entry_ptr)->ring] +                                         \
             (cache_ptr)->dirty_index_ring_size[(entry_ptr)->ring]) ||                                       \
        (cache_ptr)->index_len != (cache_ptr)->il_len || (cache_ptr)->index_size != (cache_ptr)->il_size) {  \
        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, (fail_val), "post HT remove SC failed");                          \
    }

#define H5C__PRE_HT_SEARCH_SC(cache_ptr, entry_addr, fail_val)                                               \
    if (H5C__PRE_HT_SEARCH_SC_CMP(cache_ptr, entry_addr)) {                                                  \
        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, (fail_val), "pre HT search SC failed");                           \
    }

#define H5C__POST_SUC_HT_SEARCH_SC(cache_ptr, entry_ptr, k, fail_val)                                        \
    if (H5C__POST_SUC_HT_SEARCH_SC_CMP(cache_ptr, entry_ptr, k)) {                                           \
        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, (fail_val), "post successful HT search SC failed");               \
    }

#define H5C__POST_HT_SHIFT_TO_FRONT_SC(cache_ptr, entry_ptr, k, fail_val)                                    \
    if (H5C__POST_HT_SHIFT_TO_FRONT_SC_CMP(cache_ptr, entry_ptr, k)) {                                       \
        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, entry_ptr, was_clean, fail_val)      \
    if ((cache_ptr) == NULL || (cache_ptr)->index_len <= 0 || (cache_ptr)->index_size <= 0 ||                \
        (new_size) <= 0 || (old_size) > (cache_ptr)->index_size ||                                           \
        ((cache_ptr)->index_len == 1 && (cache_ptr)->index_size != (old_size)) ||                            \
        (cache_ptr)->index_size != ((cache_ptr)->clean_index_size + (cache_ptr)->dirty_index_size) ||        \
        (cache_ptr)->index_size < (cache_ptr)->clean_index_size ||                                           \
        (cache_ptr)->index_size < (cache_ptr)->dirty_index_size ||                                           \
        ((!(was_clean) || (cache_ptr)->clean_index_size < (old_size)) &&                                     \
         ((was_clean) || (cache_ptr)->dirty_index_size < (old_size))) ||                                     \
        (entry_ptr) == NULL || (entry_ptr)->ring <= H5C_RING_UNDEFINED ||                                    \
        (entry_ptr)->ring >= H5C_RING_NTYPES || (cache_ptr)->index_ring_len[(entry_ptr)->ring] <= 0 ||       \
        (cache_ptr)->index_ring_len[(entry_ptr)->ring] > (cache_ptr)->index_len ||                           \
        (cache_ptr)->index_ring_size[(entry_ptr)->ring] > (cache_ptr)->index_size ||                         \
        (cache_ptr)->index_ring_size[(entry_ptr)->ring] !=                                                   \
            ((cache_ptr)->clean_index_ring_size[(entry_ptr)->ring] +                                         \
             (cache_ptr)->dirty_index_ring_size[(entry_ptr)->ring]) ||                                       \
        (cache_ptr)->index_len != (cache_ptr)->il_len || (cache_ptr)->index_size != (cache_ptr)->il_size) {  \
        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, (fail_val), "pre HT entry size change SC failed");                \
    }

#define H5C__POST_HT_ENTRY_SIZE_CHANGE_SC(cache_ptr, old_size, new_size, entry_ptr, fail_val)                \
    if ((cache_ptr) == NULL || (cache_ptr)->index_len <= 0 || (cache_ptr)->index_size <= 0 ||                \
        (new_size) > (cache_ptr)->index_size ||                                                              \
        (cache_ptr)->index_size != ((cache_ptr)->clean_index_size + (cache_ptr)->dirty_index_size) ||        \
        (cache_ptr)->index_size < (cache_ptr)->clean_index_size ||                                           \
        (cache_ptr)->index_size < (cache_ptr)->dirty_index_size ||                                           \
        ((!((entry_ptr)->is_dirty) || (cache_ptr)->dirty_index_size < (new_size)) &&                         \
         ((entry_ptr)->is_dirty || (cache_ptr)->clean_index_size < (new_size))) ||                           \
        ((cache_ptr)->index_len == 1 && (cache_ptr)->index_size != (new_size)) ||                            \
        (cache_ptr)->index_ring_len[(entry_ptr)->ring] > (cache_ptr)->index_len ||                           \
        (cache_ptr)->index_ring_size[(entry_ptr)->ring] > (cache_ptr)->index_size ||                         \
        (cache_ptr)->index_ring_size[(entry_ptr)->ring] !=                                                   \
            ((cache_ptr)->clean_index_ring_size[(entry_ptr)->ring] +                                         \
             (cache_ptr)->dirty_index_ring_size[(entry_ptr)->ring]) ||                                       \
        (cache_ptr)->index_len != (cache_ptr)->il_len || (cache_ptr)->index_size != (cache_ptr)->il_size) {  \
        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, (fail_val), "post HT entry size change SC failed");               \
    }

#define H5C__PRE_HT_UPDATE_FOR_ENTRY_CLEAN_SC(cache_ptr, entry_ptr, fail_val)                                \
    if ((cache_ptr) == NULL || (cache_ptr)->index_len <= 0 || (entry_ptr) == NULL ||                         \
        (entry_ptr)->is_dirty != false || (cache_ptr)->index_size < (entry_ptr)->size ||                     \
        (cache_ptr)->dirty_index_size < (entry_ptr)->size ||                                                 \
        (cache_ptr)->index_size != ((cache_ptr)->clean_index_size + (cache_ptr)->dirty_index_size) ||        \
        (cache_ptr)->index_size < ((cache_ptr)->clean_index_size) ||                                         \
        (cache_ptr)->index_size < ((cache_ptr)->dirty_index_size) ||                                         \
        (entry_ptr)->ring <= H5C_RING_UNDEFINED || (entry_ptr)->ring >= H5C_RING_NTYPES ||                   \
        (cache_ptr)->index_ring_len[(entry_ptr)->ring] <= 0 ||                                               \
        (cache_ptr)->index_ring_len[(entry_ptr)->ring] > (cache_ptr)->index_len ||                           \
        (cache_ptr)->index_ring_size[(entry_ptr)->ring] > (cache_ptr)->index_size ||                         \
        (cache_ptr)->index_ring_size[(entry_ptr)->ring] !=                                                   \
            ((cache_ptr)->clean_index_ring_size[(entry_ptr)->ring] +                                         \
             (cache_ptr)->dirty_index_ring_size[(entry_ptr)->ring])) {                                       \
        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, (fail_val), "pre HT update for entry clean SC failed");           \
    }

#define H5C__PRE_HT_UPDATE_FOR_ENTRY_DIRTY_SC(cache_ptr, entry_ptr, fail_val)                                \
    if ((cache_ptr) == NULL || (cache_ptr)->index_len <= 0 || (entry_ptr) == NULL ||                         \
        (entry_ptr)->is_dirty != true || (cache_ptr)->index_size < (entry_ptr)->size ||                      \
        (cache_ptr)->clean_index_size < (entry_ptr)->size ||                                                 \
        (cache_ptr)->index_size != ((cache_ptr)->clean_index_size + (cache_ptr)->dirty_index_size) ||        \
        (cache_ptr)->index_size < (cache_ptr)->clean_index_size ||                                           \
        (cache_ptr)->index_size < (cache_ptr)->dirty_index_size ||                                           \
        (entry_ptr)->ring <= H5C_RING_UNDEFINED || (entry_ptr)->ring >= H5C_RING_NTYPES ||                   \
        (cache_ptr)->index_ring_len[(entry_ptr)->ring] <= 0 ||                                               \
        (cache_ptr)->index_ring_len[(entry_ptr)->ring] > (cache_ptr)->index_len ||                           \
        (cache_ptr)->index_ring_size[(entry_ptr)->ring] > (cache_ptr)->index_size ||                         \
        (cache_ptr)->index_ring_size[(entry_ptr)->ring] !=                                                   \
            ((cache_ptr)->clean_index_ring_size[(entry_ptr)->ring] +                                         \
             (cache_ptr)->dirty_index_ring_size[(entry_ptr)->ring])) {                                       \
        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, (fail_val), "pre HT update for entry dirty SC failed");           \
    }

#define H5C__POST_HT_UPDATE_FOR_ENTRY_CLEAN_SC(cache_ptr, entry_ptr, fail_val)                               \
    if ((cache_ptr)->index_size != ((cache_ptr)->clean_index_size + (cache_ptr)->dirty_index_size) ||        \
        (cache_ptr)->index_size < (cache_ptr)->clean_index_size ||                                           \
        (cache_ptr)->index_size < (cache_ptr)->dirty_index_size ||                                           \
        (cache_ptr)->index_ring_len[(entry_ptr)->ring] > (cache_ptr)->index_len ||                           \
        (cache_ptr)->index_ring_size[(entry_ptr)->ring] > (cache_ptr)->index_size ||                         \
        (cache_ptr)->index_ring_size[(entry_ptr)->ring] !=                                                   \
            ((cache_ptr)->clean_index_ring_size[(entry_ptr)->ring] +                                         \
             (cache_ptr)->dirty_index_ring_size[(entry_ptr)->ring])) {                                       \
        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, (fail_val), "post HT update for entry clean SC failed");          \
    }

#define H5C__POST_HT_UPDATE_FOR_ENTRY_DIRTY_SC(cache_ptr, entry_ptr, fail_val)                               \
    if ((cache_ptr)->index_size != ((cache_ptr)->clean_index_size + (cache_ptr)->dirty_index_size) ||        \
        (cache_ptr)->index_size < (cache_ptr)->clean_index_size ||                                           \
        (cache_ptr)->index_size < (cache_ptr)->dirty_index_size ||                                           \
        (cache_ptr)->index_ring_len[(entry_ptr)->ring] > (cache_ptr)->index_len ||                           \
        (cache_ptr)->index_ring_size[(entry_ptr)->ring] > (cache_ptr)->index_size ||                         \
        (cache_ptr)->index_ring_size[(entry_ptr)->ring] !=                                                   \
            ((cache_ptr)->clean_index_ring_size[(entry_ptr)->ring] +                                         \
             (cache_ptr)->dirty_index_ring_size[(entry_ptr)->ring])) {                                       \
        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, (fail_val), "post HT update for entry dirty SC failed");          \
    }

#else /* H5C_DO_SANITY_CHECKS */

#define H5C__PRE_HT_INSERT_SC(cache_ptr, entry_ptr, fail_val)
#define H5C__POST_HT_INSERT_SC(cache_ptr, entry_ptr, fail_val)
#define H5C__PRE_HT_REMOVE_SC(cache_ptr, entry_ptr, fail_val)
#define H5C__POST_HT_REMOVE_SC(cache_ptr, entry_ptr, fail_val)
#define H5C__PRE_HT_SEARCH_SC(cache_ptr, entry_addr, fail_val)
#define H5C__POST_SUC_HT_SEARCH_SC(cache_ptr, entry_ptr, k, fail_val)
#define H5C__POST_HT_SHIFT_TO_FRONT_SC(cache_ptr, entry_ptr, k, fail_val)
#define H5C__PRE_HT_UPDATE_FOR_ENTRY_CLEAN_SC(cache_ptr, entry_ptr, fail_val)
#define H5C__PRE_HT_UPDATE_FOR_ENTRY_DIRTY_SC(cache_ptr, entry_ptr, fail_val)
#define H5C__PRE_HT_ENTRY_SIZE_CHANGE_SC(cache_ptr, old_size, new_size, entry_ptr, was_clean, fail_val)
#define H5C__POST_HT_ENTRY_SIZE_CHANGE_SC(cache_ptr, old_size, new_size, entry_ptr, fail_val)
#define H5C__POST_HT_UPDATE_FOR_ENTRY_CLEAN_SC(cache_ptr, entry_ptr, fail_val)
#define H5C__POST_HT_UPDATE_FOR_ENTRY_DIRTY_SC(cache_ptr, entry_ptr, fail_val)

#endif /* H5C_DO_SANITY_CHECKS */

#define H5C__INSERT_IN_INDEX(cache_ptr, entry_ptr, fail_val)                                                 \
    do {                                                                                                     \
        int k;                                                                                               \
        H5C__PRE_HT_INSERT_SC(cache_ptr, entry_ptr, fail_val)                                                \
        k = H5C__HASH_FCN((entry_ptr)->addr);                                                                \
        if ((cache_ptr)->index[k] != NULL) {                                                                 \
            (entry_ptr)->ht_next          = (cache_ptr)->index[k];                                           \
            (entry_ptr)->ht_next->ht_prev = (entry_ptr);                                                     \
        }                                                                                                    \
        (cache_ptr)->index[k] = (entry_ptr);                                                                 \
        (cache_ptr)->index_len++;                                                                            \
        (cache_ptr)->index_size += (entry_ptr)->size;                                                        \
        (cache_ptr)->index_ring_len[(entry_ptr)->ring]++;                                                    \
        (cache_ptr)->index_ring_size[(entry_ptr)->ring] += (entry_ptr)->size;                                \
        if ((entry_ptr)->is_dirty) {                                                                         \
            (cache_ptr)->dirty_index_size += (entry_ptr)->size;                                              \
            (cache_ptr)->dirty_index_ring_size[(entry_ptr)->ring] += (entry_ptr)->size;                      \
        }                                                                                                    \
        else {                                                                                               \
            (cache_ptr)->clean_index_size += (entry_ptr)->size;                                              \
            (cache_ptr)->clean_index_ring_size[(entry_ptr)->ring] += (entry_ptr)->size;                      \
        }                                                                                                    \
        if ((entry_ptr)->flush_me_last) {                                                                    \
            (cache_ptr)->num_last_entries++;                                                                 \
            assert((cache_ptr)->num_last_entries <= 2);                                                      \
        }                                                                                                    \
        H5C__IL_DLL_APPEND((entry_ptr), (cache_ptr)->il_head, (cache_ptr)->il_tail, (cache_ptr)->il_len,     \
                           (cache_ptr)->il_size, fail_val);                                                  \
        H5C__UPDATE_STATS_FOR_HT_INSERTION(cache_ptr);                                                       \
        H5C__POST_HT_INSERT_SC(cache_ptr, entry_ptr, fail_val);                                              \
    } while (0)

#define H5C__DELETE_FROM_INDEX(cache_ptr, entry_ptr, fail_val)                                               \
    do {                                                                                                     \
        int k;                                                                                               \
        H5C__PRE_HT_REMOVE_SC(cache_ptr, entry_ptr, fail_val)                                                \
        k = H5C__HASH_FCN((entry_ptr)->addr);                                                                \
        if ((entry_ptr)->ht_next)                                                                            \
            (entry_ptr)->ht_next->ht_prev = (entry_ptr)->ht_prev;                                            \
        if ((entry_ptr)->ht_prev)                                                                            \
            (entry_ptr)->ht_prev->ht_next = (entry_ptr)->ht_next;                                            \
        if ((cache_ptr)->index[k] == (entry_ptr))                                                            \
            (cache_ptr)->index[k] = (entry_ptr)->ht_next;                                                    \
        (entry_ptr)->ht_next = NULL;                                                                         \
        (entry_ptr)->ht_prev = NULL;                                                                         \
        (cache_ptr)->index_len--;                                                                            \
        (cache_ptr)->index_size -= (entry_ptr)->size;                                                        \
        (cache_ptr)->index_ring_len[(entry_ptr)->ring]--;                                                    \
        (cache_ptr)->index_ring_size[(entry_ptr)->ring] -= (entry_ptr)->size;                                \
        if ((entry_ptr)->is_dirty) {                                                                         \
            (cache_ptr)->dirty_index_size -= (entry_ptr)->size;                                              \
            (cache_ptr)->dirty_index_ring_size[(entry_ptr)->ring] -= (entry_ptr)->size;                      \
        }                                                                                                    \
        else {                                                                                               \
            (cache_ptr)->clean_index_size -= (entry_ptr)->size;                                              \
            (cache_ptr)->clean_index_ring_size[(entry_ptr)->ring] -= (entry_ptr)->size;                      \
        }                                                                                                    \
        if ((entry_ptr)->flush_me_last) {                                                                    \
            (cache_ptr)->num_last_entries--;                                                                 \
            assert((cache_ptr)->num_last_entries <= 1);                                                      \
        }                                                                                                    \
        H5C__IL_DLL_REMOVE((entry_ptr), (cache_ptr)->il_head, (cache_ptr)->il_tail, (cache_ptr)->il_len,     \
                           (cache_ptr)->il_size, fail_val);                                                  \
        H5C__UPDATE_STATS_FOR_HT_DELETION(cache_ptr);                                                        \
        H5C__POST_HT_REMOVE_SC(cache_ptr, entry_ptr, fail_val);                                              \
    } while (0)

#define H5C__SEARCH_INDEX(cache_ptr, entry_addr, entry_ptr, fail_val)                                        \
    do {                                                                                                     \
        int k;                                                                                               \
        int depth = 0;                                                                                       \
        H5C__PRE_HT_SEARCH_SC(cache_ptr, entry_addr, fail_val);                                              \
        k           = H5C__HASH_FCN(entry_addr);                                                             \
        (entry_ptr) = (cache_ptr)->index[k];                                                                 \
        while (entry_ptr) {                                                                                  \
            if (H5_addr_eq(entry_addr, (entry_ptr)->addr)) {                                                 \
                H5C__POST_SUC_HT_SEARCH_SC(cache_ptr, entry_ptr, k, fail_val);                               \
                if ((entry_ptr) != (cache_ptr)->index[k]) {                                                  \
                    if ((entry_ptr)->ht_next)                                                                \
                        (entry_ptr)->ht_next->ht_prev = (entry_ptr)->ht_prev;                                \
                    assert((entry_ptr)->ht_prev != NULL);                                                    \
                    (entry_ptr)->ht_prev->ht_next  = (entry_ptr)->ht_next;                                   \
                    (cache_ptr)->index[k]->ht_prev = (entry_ptr);                                            \
                    (entry_ptr)->ht_next           = (cache_ptr)->index[k];                                  \
                    (entry_ptr)->ht_prev           = NULL;                                                   \
                    (cache_ptr)->index[k]          = (entry_ptr);                                            \
                    H5C__POST_HT_SHIFT_TO_FRONT_SC(cache_ptr, entry_ptr, k, fail_val);                       \
                }                                                                                            \
                break;                                                                                       \
            }                                                                                                \
            (entry_ptr) = (entry_ptr)->ht_next;                                                              \
            (depth)++;                                                                                       \
        }                                                                                                    \
        H5C__UPDATE_STATS_FOR_HT_SEARCH(cache_ptr, ((entry_ptr) != NULL), depth);                            \
    } while (0)

#define H5C__UPDATE_INDEX_FOR_ENTRY_CLEAN(cache_ptr, entry_ptr, fail_val)                                    \
    do {                                                                                                     \
        H5C__PRE_HT_UPDATE_FOR_ENTRY_CLEAN_SC(cache_ptr, entry_ptr, fail_val);                               \
        (cache_ptr)->dirty_index_size -= (entry_ptr)->size;                                                  \
        (cache_ptr)->dirty_index_ring_size[(entry_ptr)->ring] -= (entry_ptr)->size;                          \
        (cache_ptr)->clean_index_size += (entry_ptr)->size;                                                  \
        (cache_ptr)->clean_index_ring_size[(entry_ptr)->ring] += (entry_ptr)->size;                          \
        H5C__POST_HT_UPDATE_FOR_ENTRY_CLEAN_SC(cache_ptr, entry_ptr, fail_val);                              \
    } while (0)

#define H5C__UPDATE_INDEX_FOR_ENTRY_DIRTY(cache_ptr, entry_ptr, fail_val)                                    \
    do {                                                                                                     \
        H5C__PRE_HT_UPDATE_FOR_ENTRY_DIRTY_SC(cache_ptr, entry_ptr, fail_val);                               \
        (cache_ptr)->clean_index_size -= (entry_ptr)->size;                                                  \
        (cache_ptr)->clean_index_ring_size[(entry_ptr)->ring] -= (entry_ptr)->size;                          \
        (cache_ptr)->dirty_index_size += (entry_ptr)->size;                                                  \
        (cache_ptr)->dirty_index_ring_size[(entry_ptr)->ring] += (entry_ptr)->size;                          \
        H5C__POST_HT_UPDATE_FOR_ENTRY_DIRTY_SC(cache_ptr, entry_ptr, fail_val);                              \
    } while (0)

#define H5C__UPDATE_INDEX_FOR_SIZE_CHANGE(cache_ptr, old_size, new_size, entry_ptr, was_clean, fail_val)     \
    do {                                                                                                     \
        H5C__PRE_HT_ENTRY_SIZE_CHANGE_SC(cache_ptr, old_size, new_size, entry_ptr, was_clean, fail_val);     \
        (cache_ptr)->index_size -= (old_size);                                                               \
        (cache_ptr)->index_size += (new_size);                                                               \
        (cache_ptr)->index_ring_size[(entry_ptr)->ring] -= (old_size);                                       \
        (cache_ptr)->index_ring_size[(entry_ptr)->ring] += (new_size);                                       \
        if (was_clean) {                                                                                     \
            (cache_ptr)->clean_index_size -= (old_size);                                                     \
            (cache_ptr)->clean_index_ring_size[(entry_ptr)->ring] -= (old_size);                             \
        }                                                                                                    \
        else {                                                                                               \
            (cache_ptr)->dirty_index_size -= (old_size);                                                     \
            (cache_ptr)->dirty_index_ring_size[(entry_ptr)->ring] -= (old_size);                             \
        }                                                                                                    \
        if ((entry_ptr)->is_dirty) {                                                                         \
            (cache_ptr)->dirty_index_size += (new_size);                                                     \
            (cache_ptr)->dirty_index_ring_size[(entry_ptr)->ring] += (new_size);                             \
        }                                                                                                    \
        else {                                                                                               \
            (cache_ptr)->clean_index_size += (new_size);                                                     \
            (cache_ptr)->clean_index_ring_size[(entry_ptr)->ring] += (new_size);                             \
        }                                                                                                    \
        H5C__DLL_UPDATE_FOR_SIZE_CHANGE((cache_ptr)->il_len, (cache_ptr)->il_size, (old_size), (new_size),   \
                                        (fail_val));                                                         \
        H5C__POST_HT_ENTRY_SIZE_CHANGE_SC(cache_ptr, old_size, new_size, entry_ptr, fail_val);               \
    } while (0)

/**************************************************************************
 *
 * Skip list modification macros
 *
 **************************************************************************/

#ifdef H5C_DO_SLIST_SANITY_CHECKS

#define H5C__ENTRY_IN_SLIST(cache_ptr, entry_ptr) H5C__entry_in_skip_list((cache_ptr), (entry_ptr))

#else /* H5C_DO_SLIST_SANITY_CHECKS */

#define H5C__ENTRY_IN_SLIST(cache_ptr, entry_ptr) false

#endif /* H5C_DO_SLIST_SANITY_CHECKS */

#ifdef H5C_DO_SANITY_CHECKS

#define H5C__SLIST_INSERT_ENTRY_SC(cache_ptr, entry_ptr)                                                     \
    do {                                                                                                     \
        (cache_ptr)->slist_len_increase++;                                                                   \
        (cache_ptr)->slist_size_increase += (int64_t)((entry_ptr)->size);                                    \
    } while (0) /* H5C__SLIST_INSERT_ENTRY_SC() */
#define H5C__SLIST_REMOVE_ENTRY_SC(cache_ptr, entry_ptr)                                                     \
    do {                                                                                                     \
        (cache_ptr)->slist_len_increase--;                                                                   \
        (cache_ptr)->slist_size_increase -= (int64_t)((entry_ptr)->size);                                    \
    } while (0) /* H5C__SLIST_REMOVE_ENTRY_SC() */
#define H5C__SLIST_UPDATE_FOR_ENTRY_SIZE_CHANGE_SC(cache_ptr, old_size, new_size)                            \
    do {                                                                                                     \
        (cache_ptr)->slist_size_increase -= (int64_t)(old_size);                                             \
        (cache_ptr)->slist_size_increase += (int64_t)(new_size);                                             \
    } while (0) /* H5C__SLIST_UPDATE_FOR_ENTRY_SIZE_CHANGE_SC() */

#else /* H5C_DO_SANITY_CHECKS */

#define H5C__SLIST_INSERT_ENTRY_SC(cache_ptr, entry_ptr)
#define H5C__SLIST_REMOVE_ENTRY_SC(cache_ptr, entry_ptr)
#define H5C__SLIST_UPDATE_FOR_ENTRY_SIZE_CHANGE_SC(cache_ptr, old_size, new_size)

#endif /* H5C_DO_SANITY_CHECKS */

/*-------------------------------------------------------------------------
 *
 * Macro:       H5C__INSERT_ENTRY_IN_SLIST
 *
 * Purpose:     Insert a cache entry into a cache's skip list.  Updates
 *              the associated length and size fields.
 *
 * Note:        This macro is set up so that H5C_DO_SANITY_CHECKS and
 *              H5C_DO_SLIST_SANITY_CHECKS can be selected independently.
 *
 *-------------------------------------------------------------------------
 */

#define H5C__INSERT_ENTRY_IN_SLIST(cache_ptr, entry_ptr, fail_val)                                           \
    do {                                                                                                     \
        assert(cache_ptr);                                                                                   \
                                                                                                             \
        if ((cache_ptr)->slist_enabled) {                                                                    \
            assert(entry_ptr);                                                                               \
            assert((entry_ptr)->size > 0);                                                                   \
            assert(H5_addr_defined((entry_ptr)->addr));                                                      \
            assert(!(entry_ptr)->in_slist);                                                                  \
            assert(!H5C__ENTRY_IN_SLIST((cache_ptr), (entry_ptr)));                                          \
            assert((entry_ptr)->ring > H5C_RING_UNDEFINED);                                                  \
            assert((entry_ptr)->ring < H5C_RING_NTYPES);                                                     \
            assert((cache_ptr)->slist_ring_len[(entry_ptr)->ring] <= (cache_ptr)->slist_len);                \
            assert((cache_ptr)->slist_ring_size[(entry_ptr)->ring] <= (cache_ptr)->slist_size);              \
            assert((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;                          \
            H5C__SLIST_INSERT_ENTRY_SC(cache_ptr, entry_ptr);                                                \
                                                                                                             \
            assert((cache_ptr)->slist_len > 0);                                                              \
            assert((cache_ptr)->slist_size > 0);                                                             \
        }                                                                                                    \
        else { /* slist disabled */                                                                          \
            assert((cache_ptr)->slist_len == 0);                                                             \
            assert((cache_ptr)->slist_size == 0);                                                            \
        }                                                                                                    \
    } while (0) /* H5C__INSERT_ENTRY_IN_SLIST */

/*-------------------------------------------------------------------------
 *
 * Macro:       H5C__REMOVE_ENTRY_FROM_SLIST
 *
 * Purpose:     Insert a cache entry into a cache's skip list.  Updates
 *              the associated length and size fields.
 *
 *-------------------------------------------------------------------------
 */

#define H5C__REMOVE_ENTRY_FROM_SLIST(cache_ptr, entry_ptr, during_flush, fail_val)                           \
    do {                                                                                                     \
        assert(cache_ptr);                                                                                   \
                                                                                                             \
        if ((cache_ptr)->slist_enabled) {                                                                    \
            assert(entry_ptr);                                                                               \
            assert(!(entry_ptr)->is_read_only);                                                              \
            assert((entry_ptr)->ro_ref_count == 0);                                                          \
            assert((entry_ptr)->size > 0);                                                                   \
            assert((entry_ptr)->in_slist);                                                                   \
            assert((cache_ptr)->slist_ptr);                                                                  \
            assert((entry_ptr)->ring > H5C_RING_UNDEFINED);                                                  \
            assert((entry_ptr)->ring < H5C_RING_NTYPES);                                                     \
            assert((cache_ptr)->slist_ring_len[(entry_ptr)->ring] <= (cache_ptr)->slist_len);                \
            assert((cache_ptr)->slist_ring_size[(entry_ptr)->ring] <= (cache_ptr)->slist_size);              \
            assert((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_val), "can't delete entry from skip list");       \
                                                                                                             \
            assert((cache_ptr)->slist_len > 0);                                                              \
            if (!(during_flush))                                                                             \
                (cache_ptr)->slist_changed = true;                                                           \
            (cache_ptr)->slist_len--;                                                                        \
            assert((cache_ptr)->slist_size >= (entry_ptr)->size);                                            \
            (cache_ptr)->slist_size -= (entry_ptr)->size;                                                    \
            (cache_ptr)->slist_ring_len[(entry_ptr)->ring]--;                                                \
            assert((cache_ptr)->slist_ring_size[(entry_ptr)->ring] >= (entry_ptr)->size);                    \
            ((cache_ptr)->slist_ring_size[(entry_ptr)->ring]) -= (entry_ptr)->size;                          \
            H5C__SLIST_REMOVE_ENTRY_SC(cache_ptr, entry_ptr);                                                \
            (entry_ptr)->in_slist = false;                                                                   \
        }                                                                                                    \
        else { /* slist disabled */                                                                          \
            assert((cache_ptr)->slist_len == 0);                                                             \
            assert((cache_ptr)->slist_size == 0);                                                            \
        }                                                                                                    \
    } while (0) /* H5C__REMOVE_ENTRY_FROM_SLIST */

/*-------------------------------------------------------------------------
 *
 * Macro:       H5C__UPDATE_SLIST_FOR_SIZE_CHANGE
 *
 * Purpose:     Update cache_ptr->slist_size for a change in the size of
 *              and entry in the slist.
 *
 *-------------------------------------------------------------------------
 */

#define H5C__UPDATE_SLIST_FOR_SIZE_CHANGE(cache_ptr, old_size, new_size)                                     \
    do {                                                                                                     \
        assert(cache_ptr);                                                                                   \
                                                                                                             \
        if ((cache_ptr)->slist_enabled) {                                                                    \
            assert((old_size) > 0);                                                                          \
            assert((new_size) > 0);                                                                          \
            assert((old_size) <= (cache_ptr)->slist_size);                                                   \
            assert((cache_ptr)->slist_len > 0);                                                              \
            assert((cache_ptr)->slist_len > 1 || (cache_ptr)->slist_size == (old_size));                     \
            assert((entry_ptr)->ring > H5C_RING_UNDEFINED);                                                  \
            assert((entry_ptr)->ring < H5C_RING_NTYPES);                                                     \
            assert((cache_ptr)->slist_ring_len[(entry_ptr)->ring] <= (cache_ptr)->slist_len);                \
            assert((cache_ptr)->slist_ring_size[(entry_ptr)->ring] <= (cache_ptr)->slist_size);              \
                                                                                                             \
            (cache_ptr)->slist_size -= (old_size);                                                           \
            (cache_ptr)->slist_size += (new_size);                                                           \
                                                                                                             \
            assert((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);                                   \
                                                                                                             \
            H5C__SLIST_UPDATE_FOR_ENTRY_SIZE_CHANGE_SC(cache_ptr, old_size, new_size);                       \
                                                                                                             \
            assert((new_size) <= (cache_ptr)->slist_size);                                                   \
            assert((cache_ptr)->slist_len > 1 || (cache_ptr)->slist_size == (new_size));                     \
        }                                                                                                    \
        else { /* slist disabled */                                                                          \
            assert((cache_ptr)->slist_len == 0);                                                             \
            assert((cache_ptr)->slist_size == 0);                                                            \
        }                                                                                                    \
    } while (0) /* H5C__UPDATE_SLIST_FOR_SIZE_CHANGE */

/**************************************************************************
 *
 * Replacement policy update macros
 *
 **************************************************************************/

#if H5C_MAINTAIN_CLEAN_AND_DIRTY_LRU_LISTS

#define H5C__UPDATE_RP_FOR_EVICTION_CD_LRU(cache_ptr, entry_ptr, fail_val)                                   \
    do {                                                                                                     \
        /* If the entry is clean when it is evicted, it should be on the                                     \
         * clean LRU list, if it was dirty, it should be on the dirty LRU list.                              \
         * Remove it from the appropriate list according to the value of the                                 \
         * dirty flag.                                                                                       \
         */                                                                                                  \
        if ((entry_ptr)->is_dirty) {                                                                         \
            H5C__AUX_DLL_REMOVE((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 {                                                                                               \
            H5C__AUX_DLL_REMOVE((entry_ptr), (cache_ptr)->cLRU_head_ptr, (cache_ptr)->cLRU_tail_ptr,         \
                                (cache_ptr)->cLRU_list_len, (cache_ptr)->cLRU_list_size, (fail_val))         \
        }                                                                                                    \
    } while (0) /* H5C__UPDATE_RP_FOR_EVICTION_CD_LRU() */

#define H5C__UPDATE_RP_FOR_FLUSH_CD_LRU(cache_ptr, entry_ptr, fail_val)                                      \
    do {                                                                                                     \
        /* An entry being flushed or cleared, may not be dirty.  Use the                                     \
         * dirty flag to infer whether the entry is on the clean or dirty                                    \
         * LRU list, and remove it.  Then insert it at the head of the                                       \
         * clean LRU list.                                                                                   \
         *                                                                                                   \
         * The function presumes that a dirty entry will be either cleared                                   \
         * or flushed shortly, so it is OK if we put a dirty entry on the                                    \
         * clean LRU list.                                                                                   \
         */                                                                                                  \
        if ((entry_ptr)->is_dirty) {                                                                         \
            H5C__AUX_DLL_REMOVE((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 {                                                                                               \
            H5C__AUX_DLL_REMOVE((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))            \
    } while (0) /* H5C__UPDATE_RP_FOR_FLUSH_CD_LRU() */

#define H5C__UPDATE_RP_FOR_INSERT_APPEND_CD_LRU(cache_ptr, entry_ptr, fail_val)                              \
    do {                                                                                                     \
        /* Insert the entry at the _tail_ of the clean or dirty LRU list as                                  \
         * appropriate.                                                                                      \
         */                                                                                                  \
        if ((entry_ptr)->is_dirty) {                                                                         \
            H5C__AUX_DLL_APPEND((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 {                                                                                               \
            H5C__AUX_DLL_APPEND((entry_ptr), (cache_ptr)->cLRU_head_ptr, (cache_ptr)->cLRU_tail_ptr,         \
                                (cache_ptr)->cLRU_list_len, (cache_ptr)->cLRU_list_size, (fail_val));        \
        }                                                                                                    \
    } while (0) /* H5C__UPDATE_RP_FOR_INSERT_APPEND_CD_LRU() */

#define H5C__UPDATE_RP_FOR_INSERTION_CD_LRU(cache_ptr, entry_ptr, fail_val)                                  \
    do {                                                                                                     \
        /* Insert the entry at the head of the clean or dirty LRU list as                                    \
         * appropriate.                                                                                      \
         */                                                                                                  \
        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))        \
        }                                                                                                    \
        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))        \
        }                                                                                                    \
    } while (0) /* H5C__UPDATE_RP_FOR_INSERTION_CD_LRU() */

#define H5C__UPDATE_RP_FOR_PROTECT_CD_LRU(cache_ptr, entry_ptr, fail_val)                                    \
    {                                                                                                        \
        /* Remove the entry from the clean or dirty LRU list as appropriate */                               \
        if ((entry_ptr)->is_dirty) {                                                                         \
            H5C__AUX_DLL_REMOVE((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 {                                                                                               \
            H5C__AUX_DLL_REMOVE((entry_ptr), (cache_ptr)->cLRU_head_ptr, (cache_ptr)->cLRU_tail_ptr,         \
                                (cache_ptr)->cLRU_list_len, (cache_ptr)->cLRU_list_size, (fail_val))         \
        }                                                                                                    \
    }                                                                                                        \
    while (0) /* H5C__UPDATE_RP_FOR_PROTECT_CD_LRU() */

#define H5C__UPDATE_RP_FOR_MOVE_CD_LRU(cache_ptr, entry_ptr, was_dirty, fail_val)                            \
    do {                                                                                                     \
        /* Remove the entry from either the clean or dirty LRU list as                                       \
         * indicated by the was_dirty parameter                                                              \
         */                                                                                                  \
        if (was_dirty) {                                                                                     \
            H5C__AUX_DLL_REMOVE((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 {                                                                                               \
            H5C__AUX_DLL_REMOVE((entry_ptr), (cache_ptr)->cLRU_head_ptr, (cache_ptr)->cLRU_tail_ptr,         \
                                (cache_ptr)->cLRU_list_len, (cache_ptr)->cLRU_list_size, (fail_val));        \
        }                                                                                                    \
                                                                                                             \
        /* Insert the entry at the head of either the clean or dirty                                         \
         * LRU list as appropriate.                                                                          \
         */                                                                                                  \
        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));       \
        }                                                                                                    \
        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));       \
        }                                                                                                    \
    } while (0) /* H5C__UPDATE_RP_FOR_MOVE_CD_LRU() */

#define H5C__UPDATE_RP_FOR_SIZE_CHANGE_CD_LRU(cache_ptr, entry_ptr, new_size, fail_val)                      \
    do {                                                                                                     \
        /* Update the size of the clean or dirty LRU list as                                                 \
         * appropriate.                                                                                      \
         */                                                                                                  \
        if ((entry_ptr)->is_dirty) {                                                                         \
            H5C__DLL_UPDATE_FOR_SIZE_CHANGE((cache_ptr)->dLRU_list_len, (cache_ptr)->dLRU_list_size,         \
                                            (entry_ptr)->size, (new_size), (fail_val))                       \
        }                                                                                                    \
        else {                                                                                               \
            H5C__DLL_UPDATE_FOR_SIZE_CHANGE((cache_ptr)->cLRU_list_len, (cache_ptr)->cLRU_list_size,         \
                                            (entry_ptr)->size, (new_size), (fail_val))                       \
        }                                                                                                    \
    } while (0) /* H5C__UPDATE_RP_FOR_SIZE_CHANGE_CD_LRU() */

#define H5C__UPDATE_RP_FOR_UNPIN_CD_LRU(cache_ptr, entry_ptr, fail_val)                                      \
    do {                                                                                                     \
        /* Insert the entry at the head of either the clean                                                  \
         * or dirty LRU list as appropriate.                                                                 \
         */                                                                                                  \
        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))        \
        }                                                                                                    \
        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))        \
        }                                                                                                    \
    } while (0) /* H5C__UPDATE_RP_FOR_UNPIN_CD_LRU() */

#define H5C__UPDATE_RP_FOR_UNPROTECT_CD_LRU(cache_ptr, entry_ptr, fail_val)                                  \
    do {                                                                                                     \
        /* Insert the entry at the head of either the clean or                                               \
         * dirty LRU list as appropriate.                                                                    \
         */                                                                                                  \
        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))        \
        }                                                                                                    \
        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))        \
        }                                                                                                    \
    } while (0) /* H5C__UPDATE_RP_FOR_UNPROTECT_CD_LRU() */

#else /* H5C_MAINTAIN_CLEAN_AND_DIRTY_LRU_LISTS */

#define H5C__UPDATE_RP_FOR_EVICTION_CD_LRU(cache_ptr, entry_ptr, fail_val)
#define H5C__UPDATE_RP_FOR_FLUSH_CD_LRU(cache_ptr, entry_ptr, fail_val)
#define H5C__UPDATE_RP_FOR_INSERT_APPEND_CD_LRU(cache_ptr, entry_ptr, fail_val)
#define H5C__UPDATE_RP_FOR_INSERTION_CD_LRU(cache_ptr, entry_ptr, fail_val)
#define H5C__UPDATE_RP_FOR_PROTECT_CD_LRU(cache_ptr, entry_ptr, fail_val)
#define H5C__UPDATE_RP_FOR_MOVE_CD_LRU(cache_ptr, entry_ptr, was_dirty, fail_val)
#define H5C__UPDATE_RP_FOR_SIZE_CHANGE_CD_LRU(cache_ptr, entry_ptr, new_size, fail_val)
#define H5C__UPDATE_RP_FOR_UNPIN_CD_LRU(cache_ptr, entry_ptr, fail_val)
#define H5C__UPDATE_RP_FOR_UNPROTECT_CD_LRU(cache_ptr, entry_ptr, fail_val)

#endif /* H5C_MAINTAIN_CLEAN_AND_DIRTY_LRU_LISTS */

/*-------------------------------------------------------------------------
 *
 * Macro:       H5C__UPDATE_RP_FOR_EVICTION
 *
 * Purpose:     Update the replacement policy data structures for an
 *              eviction of the specified cache entry.
 *
 *-------------------------------------------------------------------------
 */

#define H5C__UPDATE_RP_FOR_EVICTION(cache_ptr, entry_ptr, fail_val)                                          \
    do {                                                                                                     \
        assert(cache_ptr);                                                                                   \
        assert(entry_ptr);                                                                                   \
        assert(!(entry_ptr)->is_protected);                                                                  \
        assert(!(entry_ptr)->is_read_only);                                                                  \
        assert((entry_ptr)->ro_ref_count == 0);                                                              \
        assert(!(entry_ptr)->is_pinned);                                                                     \
        assert((entry_ptr)->size > 0);                                                                       \
                                                                                                             \
        /* Remove the entry from the LRU list */                                                             \
        H5C__DLL_REMOVE((entry_ptr), (cache_ptr)->LRU_head_ptr, (cache_ptr)->LRU_tail_ptr,                   \
                        (cache_ptr)->LRU_list_len, (cache_ptr)->LRU_list_size, (fail_val))                   \
                                                                                                             \
        /* Remove the entry from the clean & dirty LRU lists, if enabled */                                  \
        H5C__UPDATE_RP_FOR_EVICTION_CD_LRU(cache_ptr, entry_ptr, fail_val);                                  \
    } while (0) /* H5C__UPDATE_RP_FOR_EVICTION */

/*-------------------------------------------------------------------------
 *
 * Macro:       H5C__UPDATE_RP_FOR_FLUSH
 *
 * Purpose:     Update the replacement policy data structures for a flush
 *              of the specified cache entry.
 *
 *-------------------------------------------------------------------------
 */

#define H5C__UPDATE_RP_FOR_FLUSH(cache_ptr, entry_ptr, fail_val)                                             \
    do {                                                                                                     \
        assert(cache_ptr);                                                                                   \
        assert(entry_ptr);                                                                                   \
        assert(!(entry_ptr)->is_protected);                                                                  \
        assert(!(entry_ptr)->is_read_only);                                                                  \
        assert((entry_ptr)->ro_ref_count == 0);                                                              \
        assert((entry_ptr)->size > 0);                                                                       \
                                                                                                             \
        if (!(entry_ptr)->is_pinned) {                                                                       \
            /* Remove the entry from its location in the LRU list                                            \
             * and re-insert it at the head of the list.                                                     \
             */                                                                                              \
            H5C__DLL_REMOVE((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))              \
                                                                                                             \
            /* Maintain the clean & dirty LRU lists, if enabled */                                           \
            H5C__UPDATE_RP_FOR_FLUSH_CD_LRU(cache_ptr, entry_ptr, fail_val);                                 \
        }                                                                                                    \
    } while (0) /* H5C__UPDATE_RP_FOR_FLUSH */

/*-------------------------------------------------------------------------
 *
 * Macro:       H5C__UPDATE_RP_FOR_INSERT_APPEND
 *
 * Purpose:     Update the replacement policy data structures for an
 *              insertion of the specified cache entry.
 *
 *              Unlike H5C__UPDATE_RP_FOR_INSERTION below, insert a non-pinned
 *              new entry as the LEAST recently used entry, not the
 *              most recently used.
 *
 *-------------------------------------------------------------------------
 */

#define H5C__UPDATE_RP_FOR_INSERT_APPEND(cache_ptr, entry_ptr, fail_val)                                     \
    do {                                                                                                     \
        assert(cache_ptr);                                                                                   \
        assert(entry_ptr);                                                                                   \
        assert(!(entry_ptr)->is_protected);                                                                  \
        assert(!(entry_ptr)->is_read_only);                                                                  \
        assert((entry_ptr)->ro_ref_count == 0);                                                              \
        assert((entry_ptr)->size > 0);                                                                       \
                                                                                                             \
        if ((entry_ptr)->is_pinned) {                                                                        \
            H5C__DLL_PREPEND((entry_ptr), (cache_ptr)->pel_head_ptr, (cache_ptr)->pel_tail_ptr,              \
                             (cache_ptr)->pel_len, (cache_ptr)->pel_size, (fail_val))                        \
        }                                                                                                    \
        else {                                                                                               \
            /* Insert the entry at the tail of the LRU list. */                                              \
            H5C__DLL_APPEND((entry_ptr), (cache_ptr)->LRU_head_ptr, (cache_ptr)->LRU_tail_ptr,               \
                            (cache_ptr)->LRU_list_len, (cache_ptr)->LRU_list_size, (fail_val))               \
                                                                                                             \
            /* Maintain the clean & dirty LRU lists, if enabled */                                           \
            H5C__UPDATE_RP_FOR_INSERT_APPEND_CD_LRU(cache_ptr, entry_ptr, fail_val);                         \
        }                                                                                                    \
    } while (0)

/*-------------------------------------------------------------------------
 *
 * Macro:       H5C__UPDATE_RP_FOR_INSERTION
 *
 * Purpose:     Update the replacement policy data structures for an
 *              insertion of the specified cache entry.
 *
 *-------------------------------------------------------------------------
 */

#define H5C__UPDATE_RP_FOR_INSERTION(cache_ptr, entry_ptr, fail_val)                                         \
    do {                                                                                                     \
        assert(cache_ptr);                                                                                   \
        assert(entry_ptr);                                                                                   \
        assert(!(entry_ptr)->is_protected);                                                                  \
        assert(!(entry_ptr)->is_read_only);                                                                  \
        assert((entry_ptr)->ro_ref_count == 0);                                                              \
        assert((entry_ptr)->size > 0);                                                                       \
                                                                                                             \
        if ((entry_ptr)->is_pinned) {                                                                        \
            H5C__DLL_PREPEND((entry_ptr), (cache_ptr)->pel_head_ptr, (cache_ptr)->pel_tail_ptr,              \
                             (cache_ptr)->pel_len, (cache_ptr)->pel_size, (fail_val))                        \
        }                                                                                                    \
        else {                                                                                               \
            /* 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))              \
                                                                                                             \
            /* Maintain the clean & dirty LRU lists, if enabled */                                           \
            H5C__UPDATE_RP_FOR_INSERTION_CD_LRU(cache_ptr, entry_ptr, fail_val);                             \
        }                                                                                                    \
    } while (0)

/*-------------------------------------------------------------------------
 *
 * Macro:       H5C__UPDATE_RP_FOR_PROTECT
 *
 * Purpose:     Update the replacement policy data structures for a
 *              protect of the specified cache entry.
 *
 *              To do this, unlink the specified entry from any data
 *              structures used by the replacement policy (or the pinned list,
 *              which is outside of the replacement policy), and add the
 *              entry to the protected list.
 *
 *-------------------------------------------------------------------------
 */

#define H5C__UPDATE_RP_FOR_PROTECT(cache_ptr, entry_ptr, fail_val)                                           \
    do {                                                                                                     \
        assert(cache_ptr);                                                                                   \
        assert(entry_ptr);                                                                                   \
        assert(!(entry_ptr)->is_protected);                                                                  \
        assert(!(entry_ptr)->is_read_only);                                                                  \
        assert((entry_ptr)->ro_ref_count == 0);                                                              \
        assert((entry_ptr)->size > 0);                                                                       \
                                                                                                             \
        if ((entry_ptr)->is_pinned) {                                                                        \
            H5C__DLL_REMOVE((entry_ptr), (cache_ptr)->pel_head_ptr, (cache_ptr)->pel_tail_ptr,               \
                            (cache_ptr)->pel_len, (cache_ptr)->pel_size, (fail_val))                         \
        }                                                                                                    \
        else {                                                                                               \
            /* Remove the entry from the LRU list. */                                                        \
            H5C__DLL_REMOVE((entry_ptr), (cache_ptr)->LRU_head_ptr, (cache_ptr)->LRU_tail_ptr,               \
                            (cache_ptr)->LRU_list_len, (cache_ptr)->LRU_list_size, (fail_val))               \
                                                                                                             \
            /* Maintain the clean & dirty LRU lists, if enabled */                                           \
            H5C__UPDATE_RP_FOR_PROTECT_CD_LRU(cache_ptr, entry_ptr, fail_val);                               \
        }                                                                                                    \
                                                                                                             \
        /* Regardless of whether the entry is pinned, add it to the protected                                \
         * list.                                                                                             \
         */                                                                                                  \
        H5C__DLL_APPEND((entry_ptr), (cache_ptr)->pl_head_ptr, (cache_ptr)->pl_tail_ptr,                     \
                        (cache_ptr)->pl_len, (cache_ptr)->pl_size, (fail_val))                               \
    } while (0) /* H5C__UPDATE_RP_FOR_PROTECT */

/*-------------------------------------------------------------------------
 *
 * Macro:       H5C__UPDATE_RP_FOR_MOVE
 *
 * Purpose:     Update the replacement policy data structures for a
 *              move of the specified cache entry.
 *
 *-------------------------------------------------------------------------
 */

#define H5C__UPDATE_RP_FOR_MOVE(cache_ptr, entry_ptr, was_dirty, fail_val)                                   \
    do {                                                                                                     \
        assert(cache_ptr);                                                                                   \
        assert(entry_ptr);                                                                                   \
        assert(!(entry_ptr)->is_read_only);                                                                  \
        assert((entry_ptr)->ro_ref_count == 0);                                                              \
        assert((entry_ptr)->size > 0);                                                                       \
                                                                                                             \
        if (!(entry_ptr)->is_pinned && !(entry_ptr)->is_protected) {                                         \
            /* Remove the entry from the LRU list, and re-insert it at the head.                             \
             */                                                                                              \
            H5C__DLL_REMOVE((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))              \
                                                                                                             \
            /* Maintain the clean & dirty LRU lists, if enabled */                                           \
            H5C__UPDATE_RP_FOR_MOVE_CD_LRU(cache_ptr, entry_ptr, was_dirty, fail_val);                       \
        }                                                                                                    \
    } while (0) /* H5C__UPDATE_RP_FOR_MOVE */

/*-------------------------------------------------------------------------
 *
 * Macro:       H5C__UPDATE_RP_FOR_SIZE_CHANGE
 *
 * Purpose:     Update the replacement policy data structures for a
 *              size change of the specified cache entry.
 *
 *              To do this, determine if the entry is pinned.  If it is,
 *              update the size of the pinned entry list.
 *
 *              If it isn't pinned, the entry must handled by the
 *              replacement policy.  Update the appropriate replacement
 *              policy data structures.
 *
 *              If the entry is accessed with collective operations for
 *              parallel I/O, update that list.
 *
 *-------------------------------------------------------------------------
 */

#ifdef H5_HAVE_PARALLEL

#define H5C__UPDATE_RP_FOR_SIZE_CHANGE_COLL(cache_ptr, entry_ptr, new_size, fail_val)                        \
    do {                                                                                                     \
        if ((entry_ptr)->coll_access) {                                                                      \
            H5C__DLL_UPDATE_FOR_SIZE_CHANGE((cache_ptr)->coll_list_len, (cache_ptr)->coll_list_size,         \
                                            (entry_ptr)->size, (new_size), (fail_val));                      \
        }                                                                                                    \
    } while (0) /* H5C__UPDATE_RP_FOR_SIZE_CHANGE_COLL() */

#else /* H5_HAVE_PARALLEL */

#define H5C__UPDATE_RP_FOR_SIZE_CHANGE_COLL(cache_ptr, entry_ptr, new_size, fail_val)

#endif /* H5_HAVE_PARALLEL */

#define H5C__UPDATE_RP_FOR_SIZE_CHANGE(cache_ptr, entry_ptr, new_size, fail_val)                             \
    do {                                                                                                     \
        assert(cache_ptr);                                                                                   \
        assert(entry_ptr);                                                                                   \
        assert(!(entry_ptr)->is_protected);                                                                  \
        assert(!(entry_ptr)->is_read_only);                                                                  \
        assert((entry_ptr)->ro_ref_count == 0);                                                              \
        assert((entry_ptr)->size > 0);                                                                       \
        assert(new_size > 0);                                                                                \
                                                                                                             \
        /* Maintain the collective access list, if enabled */                                                \
        H5C__UPDATE_RP_FOR_SIZE_CHANGE_COLL(cache_ptr, entry_ptr, new_size, fail_val);                       \
                                                                                                             \
        if ((entry_ptr)->is_pinned) {                                                                        \
            H5C__DLL_UPDATE_FOR_SIZE_CHANGE((cache_ptr)->pel_len, (cache_ptr)->pel_size, (entry_ptr)->size,  \
                                            (new_size), (fail_val))                                          \
        }                                                                                                    \
        else {                                                                                               \
            /* Update the size of the LRU list */                                                            \
            H5C__DLL_UPDATE_FOR_SIZE_CHANGE((cache_ptr)->LRU_list_len, (cache_ptr)->LRU_list_size,           \
                                            (entry_ptr)->size, (new_size), (fail_val))                       \
                                                                                                             \
            /* Maintain the clean & dirty LRU lists, if enabled */                                           \
            H5C__UPDATE_RP_FOR_SIZE_CHANGE_CD_LRU(cache_ptr, entry_ptr, new_size, fail_val);                 \
        }                                                                                                    \
    } while (0) /* H5C__UPDATE_RP_FOR_SIZE_CHANGE */

/*-------------------------------------------------------------------------
 *
 * Macro:       H5C__UPDATE_RP_FOR_UNPIN
 *
 * Purpose:     Update the replacement policy data structures for an
 *              unpin of the specified cache entry.
 *
 *              To do this, unlink the specified entry from the pinned
 *              entry list, and re-insert it in the data structures used
 *              by the current replacement policy.
 *
 *-------------------------------------------------------------------------
 */

#define H5C__UPDATE_RP_FOR_UNPIN(cache_ptr, entry_ptr, fail_val)                                             \
    do {                                                                                                     \
        assert(cache_ptr);                                                                                   \
        assert(entry_ptr);                                                                                   \
        assert(!(entry_ptr)->is_protected);                                                                  \
        assert(!(entry_ptr)->is_read_only);                                                                  \
        assert((entry_ptr)->ro_ref_count == 0);                                                              \
        assert((entry_ptr)->is_pinned);                                                                      \
        assert((entry_ptr)->size > 0);                                                                       \
                                                                                                             \
        /* Regardless of the replacement policy, remove the entry from the                                   \
         * pinned entry list.                                                                                \
         */                                                                                                  \
        H5C__DLL_REMOVE((entry_ptr), (cache_ptr)->pel_head_ptr, (cache_ptr)->pel_tail_ptr,                   \
                        (cache_ptr)->pel_len, (cache_ptr)->pel_size, (fail_val));                            \
                                                                                                             \
        /* 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));                 \
                                                                                                             \
        /* Maintain the clean & dirty LRU lists, if enabled */                                               \
        H5C__UPDATE_RP_FOR_UNPIN_CD_LRU(cache_ptr, entry_ptr, fail_val);                                     \
    } while (0) /* H5C__UPDATE_RP_FOR_UNPIN */

/*-------------------------------------------------------------------------
 *
 * Macro:       H5C__UPDATE_RP_FOR_UNPROTECT
 *
 * Purpose:     Update the replacement policy data structures for an
 *              unprotect of the specified cache entry.
 *
 *              To do this, unlink the specified entry from the protected
 *              list, and re-insert it in the data structures used by the
 *              current replacement policy.
 *
 *-------------------------------------------------------------------------
 */

#define H5C__UPDATE_RP_FOR_UNPROTECT(cache_ptr, entry_ptr, fail_val)                                         \
    do {                                                                                                     \
        assert(cache_ptr);                                                                                   \
        assert(entry_ptr);                                                                                   \
        assert((entry_ptr)->is_protected);                                                                   \
        assert((entry_ptr)->size > 0);                                                                       \
                                                                                                             \
        /* Regardless of the replacement policy, remove the entry from the                                   \
         * protected list.                                                                                   \
         */                                                                                                  \
        H5C__DLL_REMOVE((entry_ptr), (cache_ptr)->pl_head_ptr, (cache_ptr)->pl_tail_ptr,                     \
                        (cache_ptr)->pl_len, (cache_ptr)->pl_size, (fail_val))                               \
                                                                                                             \
        if ((entry_ptr)->is_pinned) {                                                                        \
            H5C__DLL_PREPEND((entry_ptr), (cache_ptr)->pel_head_ptr, (cache_ptr)->pel_tail_ptr,              \
                             (cache_ptr)->pel_len, (cache_ptr)->pel_size, (fail_val))                        \
        }                                                                                                    \
        else {                                                                                               \
            /* 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))              \
                                                                                                             \
            /* Maintain the clean & dirty LRU lists, if enabled */                                           \
            H5C__UPDATE_RP_FOR_UNPROTECT_CD_LRU(cache_ptr, entry_ptr, fail_val);                             \
        }                                                                                                    \
    } while (0) /* H5C__UPDATE_RP_FOR_UNPROTECT */

#ifdef H5_HAVE_PARALLEL

/* Macros that modify the "collective I/O" LRU list */
#define H5C__COLL_DLL_PREPEND(entry_ptr, head_ptr, tail_ptr, len, list_size, fail_val)                       \
    H5C__GEN_DLL_PREPEND(entry_ptr, coll_next, coll_prev, head_ptr, tail_ptr, len, list_size, fail_val)
#define H5C__COLL_DLL_REMOVE(entry_ptr, head_ptr, tail_ptr, len, list_size, fail_val)                        \
    H5C__GEN_DLL_REMOVE(entry_ptr, coll_next, coll_prev, head_ptr, tail_ptr, len, list_size, fail_val)

/*-------------------------------------------------------------------------
 *
 * Macro:       H5C__INSERT_IN_COLL_LIST
 *
 * Purpose:     Insert entry into collective entries list
 *
 *-------------------------------------------------------------------------
 */

#define H5C__INSERT_IN_COLL_LIST(cache_ptr, entry_ptr, fail_val)                                             \
    do {                                                                                                     \
        assert(cache_ptr);                                                                                   \
        assert(entry_ptr);                                                                                   \
                                                                                                             \
        /* Insert the entry at the head of the list. */                                                      \
        H5C__COLL_DLL_PREPEND((entry_ptr), (cache_ptr)->coll_head_ptr, (cache_ptr)->coll_tail_ptr,           \
                              (cache_ptr)->coll_list_len, (cache_ptr)->coll_list_size, (fail_val))           \
    } while (0) /* H5C__INSERT_IN_COLL_LIST */

/*-------------------------------------------------------------------------
 *
 * Macro:       H5C__REMOVE_FROM_COLL_LIST
 *
 * Purpose:     Remove entry from collective entries list
 *
 *-------------------------------------------------------------------------
 */

#define H5C__REMOVE_FROM_COLL_LIST(cache_ptr, entry_ptr, fail_val)                                           \
    do {                                                                                                     \
        assert(cache_ptr);                                                                                   \
        assert(entry_ptr);                                                                                   \
                                                                                                             \
        /* Remove the entry from the list. */                                                                \
        H5C__COLL_DLL_REMOVE((entry_ptr), (cache_ptr)->coll_head_ptr, (cache_ptr)->coll_tail_ptr,            \
                             (cache_ptr)->coll_list_len, (cache_ptr)->coll_list_size, (fail_val))            \
    } while (0) /* H5C__REMOVE_FROM_COLL_LIST */

/*-------------------------------------------------------------------------
 *
 * Macro:       H5C__MOVE_TO_TOP_IN_COLL_LIST
 *
 * Purpose:     Update entry position in collective entries list
 *
 *-------------------------------------------------------------------------
 */

#define H5C__MOVE_TO_TOP_IN_COLL_LIST(cache_ptr, entry_ptr, fail_val)                                        \
    do {                                                                                                     \
        assert(cache_ptr);                                                                                   \
        assert(entry_ptr);                                                                                   \
                                                                                                             \
        /* Remove entry and insert at the head of the list. */                                               \
        H5C__COLL_DLL_REMOVE((entry_ptr), (cache_ptr)->coll_head_ptr, (cache_ptr)->coll_tail_ptr,            \
                             (cache_ptr)->coll_list_len, (cache_ptr)->coll_list_size, (fail_val))            \
                                                                                                             \
        H5C__COLL_DLL_PREPEND((entry_ptr), (cache_ptr)->coll_head_ptr, (cache_ptr)->coll_tail_ptr,           \
                              (cache_ptr)->coll_list_len, (cache_ptr)->coll_list_size, (fail_val))           \
                                                                                                             \
    } while (0) /* H5C__MOVE_TO_TOP_IN_COLL_LIST */
#endif          /* H5_HAVE_PARALLEL */

/****************************/
/* Package Private Typedefs */
/****************************/

/****************************************************************************
 *
 * structure H5C_tag_info_t
 *
 * Structure about each set of tagged entries for an object in the file.
 *
 * Each H5C_tag_info_t struct corresponds to a particular object in the file.
 *
 * Each H5C_cache_entry struct in the linked list of entries for this tag
 *      also contains a pointer back to the H5C_tag_info_t struct for the
 *      overall object.
 *
 *
 * The fields of this structure are discussed individually below:
 *
 * tag:         Address (i.e. "tag") of the object header for all the entries
 *              corresponding to parts of that object.
 *
 * head:        Head of doubly-linked list of all entries belonging to the tag.
 *
 * entry_cnt:   Number of entries on linked list of entries for this tag.
 *
 * corked:      Boolean flag indicating whether entries for this object can be
 *              evicted.
 *
 * hh:          uthash hash table handle (must be last)
 *
 ****************************************************************************/
typedef struct H5C_tag_info_t {
    haddr_t            tag;       /* Tag (address) of the entries (must be first, for skiplist) */
    H5C_cache_entry_t *head;      /* Head of the list of entries for this tag */
    size_t             entry_cnt; /* Number of entries on list */
    bool               corked;    /* Whether this object is corked */

    /* Hash table fields */
    UT_hash_handle hh; /* Hash table handle (must be LAST) */
} H5C_tag_info_t;

/****************************************************************************
 *
 * structure H5C_t
 *
 * Structure for all information specific to an instance of the cache.
 *
 * While the cache was designed with multiple replacement policies in mind,
 * at present only a modified form of LRU is supported.
 *
 * The cache has a hash table in which all entries are stored.  Given the
 * advantages of flushing entries in increasing address order, a skip list
 * is used to track dirty entries.
 *
 * flush_in_progress: Boolean flag indicating whether a flush is in progress.
 *
 * log_info:    Information used by the cache logging functionality.
 *              Described in H5Clog.h.
 *
 * aux_ptr:    Pointer to void used to allow wrapper code to associate
 *        its data with an instance of H5C_t.  The H5C cache code
 *        sets this field to NULL, and otherwise leaves it alone.
 *
 * max_type_id:    Integer field containing the maximum type id number assigned
 *        to a type of entry in the cache.  All type ids from 0 to
 *        max_type_id inclusive must be defined.
 *
 * class_table_ptr: Pointer to an array of H5C_class_t of length
 *        max_type_id + 1.  Entry classes for the cache.
 *
 * max_cache_size:  Nominal maximum number of bytes that may be stored in the
 *        cache.  This value should be viewed as a soft limit, as the
 *        cache can exceed this value under the following circumstances:
 *
 *        a) All entries in the cache are protected, and the cache is
 *           asked to insert a new entry.  In this case the new entry
 *           will be created.  If this causes the cache to exceed
 *           max_cache_size, it will do so.  The cache will attempt
 *           to reduce its size as entries are unprotected.
 *
 *        b) When running in parallel mode, the cache may not be
 *           permitted to flush a dirty entry in response to a read.
 *           If there are no clean entries available to evict, the
 *           cache will exceed its maximum size.  Again the cache
 *           will attempt to reduce its size to the max_cache_size
 *           limit on the next cache write.
 *
 *        c) When an entry increases in size, the cache may exceed
 *           the max_cache_size limit until the next time the cache
 *           attempts to load or insert an entry.
 *
 *        d) When the evictions_enabled field is false (see below),
 *           the cache size will increase without limit until the
 *           field is set to true.
 *
 * min_clean_size: Nominal minimum number of clean bytes in the cache.
 *        The cache attempts to maintain this number of bytes of clean
 *        data so as to avoid case b) above.  Again, this is a soft limit.
 *
 * close_warning_received: Boolean flag indicating that a file closing
 *        warning has been received.
 *
 *
 * In addition to the callback functions required for each entry's class,
 * the cache requires the following callback functions for an instance of
 * the cache as a whole:
 *
 * check_write_permitted:  In certain applications, the cache may not
 *        be allowed to write to disk at certain time.  If specified,
 *        the check_write_permitted function is used to determine if
 *        a write is permissible at any given point in time.
 *
 *        If no such function is specified (i.e. this field is NULL),
 *        the cache uses the following write_permitted field to
 *        determine whether writes are permitted.
 *
 * write_permitted: If check_write_permitted is NULL, this boolean flag
 *        indicates whether writes are permitted.
 *
 * log_flush:    If provided, this function is called whenever a dirty
 *        entry is flushed to disk.
 *
 *
 * In cases where memory is plentiful, and performance is an issue, it may
 * be useful to disable all cache evictions, and thereby postpone metadata
 * writes.  The following field is used to implement this.
 *
 * evictions_enabled:  Boolean flag that is initialized to true.  When
 *         this flag is set to false, the metadata cache will not
 *         attempt to evict entries to make space for newly protected
 *         entries, and instead the will grow without limit.
 *
 *         Needless to say, this feature must be used with care.
 *
 *
 * The cache requires an index to facilitate searching for entries.  The
 * following fields support that index.
 *
 * We sometimes need to visit all entries in the cache, they are stored in
 * an index list.
 *
 * The index list is maintained by the same macros that maintain the
 * index, and must have the same length and size as the index proper.
 *
 * index_len:   Number of entries currently in the hash table used to index
 *        the cache.
 *
 * index_size:  Number of bytes of cache entries currently stored in the
 *        hash table used to index the cache.
 *
 *        This value should not be mistaken for footprint of the
 *        cache in memory.  The average cache entry is small, and
 *        the cache has a considerable overhead.  Multiplying the
 *        index_size by three should yield a conservative estimate
 *        of the cache's memory footprint.
 *
 * index_ring_len: Array of integer of length H5C_RING_NTYPES used to
 *        maintain a count of entries in the index by ring.  Note
 *        that the sum of all the cells in this array must equal
 *        the value stored in index_len above.
 *
 * index_ring_size: Array of size_t of length H5C_RING_NTYPES used to
 *        maintain the sum of the sizes of all entries in the index
 *        by ring.  Note that the sum of all cells in this array must
 *        equal the value stored in index_size above.
 *
 * clean_index_size: Number of bytes of clean entries currently stored in
 *        the hash table.  Note that the index_size field (above)
 *        is also the sum of the sizes of all entries in the cache.
 *        Thus we should have the invariant that clean_index_size +
 *        dirty_index_size = index_size.
 *
 *        WARNING:
 *           The value of the clean_index_size must not be mistaken for
 *           the current clean size of the cache.  Rather, the clean size
 *           of the cache is the current value of clean_index_size plus
 *           the amount of empty space (if any) in the cache.
 *
 * clean_index_ring_size: Array of size_t of length H5C_RING_NTYPES used to
 *        maintain the sum of the sizes of all clean entries in the
 *        index by ring.  Note that the sum of all cells in this array
 *        must equal the value stored in clean_index_size above.
 *
 * dirty_index_size: Number of bytes of dirty entries currently stored in
 *        the hash table.  Note that the index_size field (above)
 *        is also the sum of the sizes of all entries in the cache.
 *        Thus we should have the invariant that clean_index_size +
 *        dirty_index_size = index_size.
 *
 * dirty_index_ring_size: Array of size_t of length H5C_RING_NTYPES used to
 *        maintain the sum of the sizes of all dirty entries in the
 *        index by ring.  Note that the sum of all cells in this array
 *        must equal the value stored in dirty_index_size above.
 *
 * index: Array of pointers to H5C_cache_entry_t of size
 *        H5C__HASH_TABLE_LEN.  At present, this value is a power
 *        of two, not the usual prime number.
 *
 *        Hopefully the variable size of cache elements, the large
 *        hash table size, and the way in which HDF5 allocates space
 *        will combine to avoid problems with periodicity.  If so, we
 *        can use a trivial hash function (a bit-and and a 3 bit left
 *        shift) with some small savings.
 *
 *        If not, it will become evident in the statistics. Changing
 *        to the usual prime number length hash table will require
 *        changing the H5C__HASH_FCN macro and the deletion of the
 *        H5C__HASH_MASK #define.  No other changes should be required.
 *
 * il_len: Number of entries on the index list.
 *
 *        This must always be equal to index_len.  As such, this
 *        field is redundant.  However, the existing linked list
 *        management macros expect to maintain a length field, so
 *        this field exists primarily to avoid adding complexity to
 *        these macros.
 *
 * il_size: Number of bytes of cache entries currently stored in the
 *        index list.
 *
 *        This must always be equal to index_size.  As such, this
 *        field is redundant.  However, the existing linked list
 *        management macros expect to maintain a size field, so
 *        this field exists primarily to avoid adding complexity to
 *        these macros.
 *
 * il_head: Pointer to the head of the doubly linked list of entries in
 *        the index list.  Note that cache entries on this list are
 *        linked by their il_next and il_prev fields.
 *
 *        This field is NULL if the index is empty.
 *
 * il_tail: Pointer to the tail of the doubly linked list of entries in
 *        the index list.  Note that cache entries on this list are
 *        linked by their il_next and il_prev fields.
 *
 *        This field is NULL if the index is empty.
 *
 *
 * It is possible that an entry may be removed from the cache as the result
 * of the flush of a second entry.  In general, this causes little trouble,
 * but it is possible that the entry removed may be the next entry in the
 * scan of a list.  In this case, we must be able to detect the fact that the
 * entry has been removed, so that the scan doesn't attempt to proceed with
 * an entry that is no longer in the cache.
 *
 * The following fields are maintained to facilitate this.
 *
 * entries_removed_counter: Counter that is incremented each time an
 *        entry is removed from the cache by any means (eviction,
 *        expungement, or take ownership at this point in time).
 *        Functions that perform scans on lists may set this field
 *        to zero prior to calling H5C__flush_single_entry().
 *        Unexpected changes to the counter indicate that an entry
 *        was removed from the cache as a side effect of the flush.
 *
 * last_entry_removed_ptr: Pointer to the instance of H5C_cache_entry_t
 *        which contained the last entry to be removed from the cache,
 *        or NULL if there either is no such entry, or if a function
 *        performing a scan of a list has set this field to NULL prior
 *        to calling H5C__flush_single_entry().
 *
 *        WARNING!!! This field must NEVER be dereferenced.  It is
 *        maintained to allow functions that perform scans of lists
 *        to compare this pointer with their pointers to next, thus
 *        allowing them to avoid unnecessary restarts of scans if the
 *        pointers don't match, and if entries_removed_counter is one.
 *
 * entry_watched_for_removal:    Pointer to an instance of H5C_cache_entry_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.  (This functions similarly to a "dead man's switch")
 *
 *
 * When we flush the cache, we need to write entries out in increasing
 * address order.  An instance of a skip list is used to store dirty entries in
 * sorted order.
 *
 * The cost of maintaining the skip list is significant.  As it is only used
 * on flush and close, it is maintained only when needed.
 *
 * To do this, we add a flag to control maintenance 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 dirty entries in the skip list, and enable operations
 * on skip list by setting above control flag to true.
 *
 * In the case of a partial flush (i.e. flush tagged entries), we only
 * add tagged entries to the skip list, thus avoiding unnecessary scans
 * over the entire cache.
 *
 * 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.
 *
 * 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 skip list proceed as usual, and all dirty
 *        entries in the metadata cache must be listed in the skip list.
 *
 * slist_changed: Boolean flag used to indicate whether the contents of
 *        the skip list has changed since the last time this flag was
 *        reset.  This is used in the cache flush code to detect
 *        conditions in which pre-serialize or serialize callbacks
 *        have modified the skip list -- which obliges us to restart
 *        the scan of the skip list from the beginning.
 *
 * slist_len: Number of entries currently in the skip list. Used to
 *        maintain a sorted list of dirty entries in the cache.
 *
 * slist_size: Number of bytes of cache entries currently stored in the
 *        skip list used to maintain a sorted list of dirty entries in
 *        the cache.
 *
 * slist_ring_len: Array of integer of length H5C_RING_NTYPES used to
 *        maintain a count of entries in the skip list by ring.  Note
 *        that the sum of all the cells in this array must equal
 *        the value stored in slist_len above.
 *
 * slist_ring_size: Array of size_t of length H5C_RING_NTYPES used to
 *        maintain the sum of the sizes of all entries in the skip list
 *        by ring.  Note that the sum of all cells in this array must
 *        equal the value stored in slist_size above.
 *
 * slist_ptr: Pointer to the instance of H5SL_t used maintain a sorted
 *        list of dirty entries in the cache.  This sorted list has
 *        two uses:
 *
 *        a) It allows us to flush dirty entries in increasing address
 *           order, which results in significant savings.
 *
 *        b) It facilitates checking for adjacent dirty entries when
 *           attempting to evict entries from the cache.
 *
 * num_last_entries: The number of entries in the cache that can only be
 *        flushed after all other entries in the cache have been flushed.
 *
 *        Note: At this time, the this field will only be applied to
 *              two types of entries: the superblock and the file driver info
 *              message.  The code utilizing these flags is protected with
 *              asserts to enforce this.
 *
 * The cache must deal with the case in which entries may be dirtied, moved,
 * or have their sizes changed during a flush.  To allow sanity checks in this
 * situation, the following two fields have been added.  They are only
 * compiled in when H5C_DO_SANITY_CHECKS is true.
 *
 * slist_len_increase: Number of entries that have been added to the
 *        skip list since the last time this field was set to zero.
 *        Note that this value can be negative.
 *
 * slist_size_increase: Total size of all entries that have been added
 *         to the skip list since the last time this field was set to
 *         zero.  Note that this value can be negative.
 *
 * Cache entries belonging to a particular object are "tagged" with that
 * object's base object header address.
 *
 * The following fields are maintained to facilitate this.
 *
 * tag_list: A collection to track entries that belong to an object.
 *         Each H5C_tag_info_t struct on the tag list corresponds to a
 *         particular object in the file.  Tagged entries can be flushed
 *         or evicted as a group, or corked to prevent entries from being
 *         evicted from the cache.
 *
 *         "Global" entries, like the superblock and the file's freelist,
 *         as well as shared entries like global heaps and shared object
 *         header messages, are not tagged.
 *
 * ignore_tags: Boolean flag to disable tag validation during entry insertion.
 *
 * num_objs_corked: Unsigned integer field containing the number of objects
 *         that are "corked".  The "corked" status of an object is found by
 *         searching the "tag_list".  This field is added for optimization
 *         so that the skip list search on "tag_list" can be skipped if this
 *         field is zero, i.e. no "corked" objects.
 *
 * When a cache entry is protected, it must be removed from the LRU
 * list(s), as it cannot be either flushed or evicted until it is unprotected.
 * The following fields are used to implement the protected list (pl).
 *
 * pl_len: Number of entries currently residing on the protected list.
 *
 * pl_size: Number of bytes of cache entries currently residing on the
 *         protected list.
 *
 * pl_head_ptr: Pointer to the head of the doubly linked list of protected
 *         entries.  Note that cache entries on this list are linked
 *         by their next and prev fields.
 *
 *         This field is NULL if the list is empty.
 *
 * pl_tail_ptr: Pointer to the tail of the doubly linked list of protected
 *         entries.  Note that cache entries on this list are linked
 *         by their next and prev fields.
 *
 *         This field is NULL if the list is empty.
 *
 *
 * For very frequently used entries, the protect/unprotect overhead can
 * become burdensome.  To avoid this overhead, the cache allows entries to
 * be "pinned".  A pinned entry is similar to a protected entry, in the
 * sense that it cannot be evicted, and that the entry can be modified at
 * any time.
 *
 * Pinning an entry has the following implications:
 *
 *      1) A pinned entry cannot be evicted.  Thus unprotected pinned
 *         entries reside in the pinned entry list, instead of the LRU
 *         list(s) or other lists maintained by the current replacement
 *         policy code.
 *
 *      2) A pinned entry can be accessed or modified at any time.
 *         This places an additional burden on the associated pre-serialize
 *         and serialize callbacks, which must ensure the entry is in
 *         a consistent state before creating an image of it.
 *
 *      3) A pinned entry can be marked as dirty (and possibly
 *         change size) while it is unprotected.
 *
 *      4) The flush-destroy code must allow pinned entries to
 *         be unpinned (and possibly unprotected) during the flush.
 *
 * Since pinned entries cannot be evicted, they must be kept on a pinned
 * entry list (pel), instead of being entrusted to the replacement policy
 * code.
 *
 * Maintaining the pinned entry list requires the following fields:
 *
 * pel_len: Number of entries currently residing on the pinned entry list.
 *
 * pel_size: Number of bytes of cache entries currently residing on
 *         the pinned entry list.
 *
 * pel_head_ptr: Pointer to the head of the doubly linked list of pinned
 *         but not protected entries.  Note that cache entries on
 *         this list are linked by their next and prev fields.
 *
 *         This field is NULL if the list is empty.
 *
 * pel_tail_ptr: Pointer to the tail of the doubly linked list of pinned
 *         but not protected entries.  Note that cache entries on
 *         this list are linked by their next and prev fields.
 *
 *         This field is NULL if the list is empty.
 *
 *
 * The cache must have a replacement policy, and the fields supporting this
 * policy must be accessible from this structure.
 *
 * Fields supporting the modified LRU policy:
 *
 * When operating in parallel mode, we must ensure that a read does not
 * cause a write.  If it does, the process will hang, as the write will
 * be collective and the other processes will not know to participate.
 *
 * To deal with this issue, the usual LRU policy has been modified by adding
 * clean and dirty LRU lists to the usual LRU list.  In general, these
 * lists only exist in parallel builds.
 *
 * The clean LRU list is simply the regular LRU list with all dirty cache
 * entries removed.
 *
 * Similarly, the dirty LRU list is the regular LRU list with all the clean
 * cache entries removed.
 *
 * When reading in parallel mode, we evict from the clean LRU list only.
 * This implies that we must try to ensure that the clean LRU list is
 * reasonably well stocked at all times.  We attempt to do this by trying
 * to flush enough entries on each write to keep the cLRU_list_size >=
 * min_clean_size.
 *
 * Even if we start with a completely clean cache, a sequence of protects
 * without unprotects can empty the clean LRU list.  In this case, the
 * cache must grow temporarily.  At the next sync point, we will attempt to
 * evict enough entries to reduce index_size to less than max_cache_size.
 * While this will usually be possible, all bets are off if enough entries
 * are protected.
 *
 * Discussions of the individual fields used by the modified LRU replacement
 * policy follow:
 *
 * LRU_list_len:  Number of cache entries currently on the LRU list.
 *
 *              The LRU_list_len + pl_len + pel_len must always
 *              equal index_len.
 *
 * LRU_list_size:  Number of bytes of cache entries currently residing on the
 *              LRU list.
 *
 *              The LRU_list_size + pl_size + pel_size must always
 *              equal index_size.
 *
 * LRU_head_ptr:  Pointer to the head of the doubly linked LRU list.  Cache
 *              entries on this list are linked by their next and prev fields.
 *
 *              This field is NULL if the list is empty.
 *
 * LRU_tail_ptr:  Pointer to the tail of the doubly linked LRU list.  Cache
 *              entries on this list are linked by their next and prev fields.
 *
 *              This field is NULL if the list is empty.
 *
 * cLRU_list_len: Number of cache entries currently on the clean LRU list.
 *
 *              The cLRU_list_len + dLRU_list_len must always
 *              equal LRU_list_len.
 *
 * cLRU_list_size:  Number of bytes of cache entries currently residing on
 *              the clean LRU list.
 *
 *              The cLRU_list_size + dLRU_list_size must always
 *              equal LRU_list_size.
 *
 * cLRU_head_ptr:  Pointer to the head of the doubly linked clean LRU list.
 *              Cache entries on this list are linked by their aux_next and
 *              aux_prev fields.
 *
 *              This field is NULL if the list is empty.
 *
 * cLRU_tail_ptr:  Pointer to the tail of the doubly linked clean LRU list.
 *              Cache entries on this list are linked by their aux_next and
 *              aux_prev fields.
 *
 *              This field is NULL if the list is empty.
 *
 * dLRU_list_len: Number of cache entries currently on the dirty LRU list.
 *
 *              The cLRU_list_len + dLRU_list_len must always
 *              equal LRU_list_len.
 *
 * dLRU_list_size:  Number of cache entries currently on the dirty LRU list.
 *
 *              The cLRU_list_len + dLRU_list_len must always
 *              equal LRU_list_len.
 *
 * dLRU_head_ptr:  Pointer to the head of the doubly linked dirty LRU list.
 *              Cache entries on this list are linked by their aux_next and
 *              aux_prev fields.
 *
 *              This field is NULL if the list is empty.
 *
 * dLRU_tail_ptr:  Pointer to the tail of the doubly linked dirty LRU list.
 *              Cache entries on this list are linked by their aux_next and
 *              aux_prev fields.
 *
 *              This field is NULL if the list is empty.
 *
 *
 * Automatic cache size adjustment:
 *
 * While the default cache size is adequate for many cases, there are
 * cases where the default is too small.  Ideally, the user should
 * adjust the cache size as required.  However, this is not possible in all
 * cases, so the cache has automatic cache size adjustment code.
 *
 * The configuration for the automatic cache size adjustment is stored in
 * the structure described below:
 *
 * size_increase_possible:  Depending on the configuration data given
 *        in the resize_ctl field, it may or may not be possible to
 *        increase the size of the cache.  Rather than test for all the
 *        ways this can happen, we simply set this flag when we receive
 *        a new configuration.
 *
 * flash_size_increase_possible: Depending on the configuration data given
 *        in the resize_ctl field, it may or may not be possible for a
 *        flash size increase to occur.  We set this flag whenever we
 *        receive a new configuration so as to avoid repeated calculations.
 *
 * flash_size_increase_threshold: If a flash cache size increase is possible,
 *        this field is used to store the minimum size of a new entry or size
 *        increase needed to trigger a flash cache size increase.  Note that
 *        this field must be updated whenever the size of the cache is changed.
 *
 * size_decrease_possible:  Depending on the configuration data given in the
 *        resize_ctl field, it may or may not be possible to decrease the
 *        size of the cache.  Rather than test for all the ways this can
 *        happen, we simply set this flag when we receive a new configuration.
 *
 * resize_enabled:  This is another convenience flag which is set whenever
 *        a new set of values for resize_ctl are provided.  Very simply:
 *
 *        resize_enabled = size_increase_possible || size_decrease_possible;
 *
 * cache_full: Boolean flag used to keep track of whether the cache is
 *        full, so we can refrain from increasing the size of a
 *        cache which hasn't used up the space allotted to it.
 *
 *        The field is initialized to false, and then set to true
 *        whenever we attempt to make space in the cache.
 *
 * size_decreased:  Boolean flag set to true whenever the maximum cache
 *        size is decreased.  The flag triggers a call to
 *        H5C__make_space_in_cache() on the next call to H5C_protect().
 *
 * resize_in_progress: As the metadata cache has become re-entrant, it is
 *        possible that a protect may trigger a call to
 *        H5C__auto_adjust_cache_size(), which may trigger a flush,
 *        which may trigger a protect, which will result in another
 *        call to H5C__auto_adjust_cache_size().
 *
 *        The resize_in_progress boolean flag is used to detect this,
 *        and to prevent the infinite recursion that would otherwise
 *        occur.
 *
 * msic_in_progress: As the metadata cache has become re-entrant, and as
 *        the free space manager code has become more tightly integrated
 *        with the metadata cache, it is possible that a call to
 *        H5C_insert_entry() may trigger a call to H5C_make_space_in_cache(),
 *        which, via H5C__flush_single_entry() and client callbacks, may
 *        trigger an infinite regression of calls to H5C_make_space_in_cache().
 *
 *        The msic_in_progress boolean flag is used to detect this,
 *        and prevent the infinite regression that would otherwise occur.
 *
 * resize_ctl: Instance of H5C_auto_size_ctl_t containing configuration
 *         data for automatic cache resizing.
 *
 * epoch_markers_active:  Integer field containing the number of epoch
 *        markers currently in use in the LRU list.  This value
 *        must be in the range [0, H5C__MAX_EPOCH_MARKERS - 1].
 *
 * epoch_marker_active:  Array of boolean of length H5C__MAX_EPOCH_MARKERS.
 *        This array is used to track which epoch markers are currently
 *        in use.
 *
 * epoch_marker_ringbuf:  Array of int of length H5C__MAX_EPOCH_MARKERS + 1.
 *
 *        To manage the epoch marker cache entries, it is necessary
 *        to track their order in the LRU list.  This is done with
 *        epoch_marker_ringbuf.  When markers are inserted at the
 *        head of the LRU list, the index of the marker in the
 *        epoch_markers array is inserted at the tail of the ring
 *        buffer.  When it becomes the epoch_marker_active'th marker
 *        in the LRU list, it will have worked its way to the head
 *        of the ring buffer as well.  This allows us to remove it
 *        without scanning the LRU list if such is required.
 *
 * epoch_marker_ringbuf_first: Integer field containing the index of the
 *        first entry in the ring buffer.
 *
 * epoch_marker_ringbuf_last: Integer field containing the index of the
 *        last entry in the ring buffer.
 *
 * epoch_marker_ringbuf_size: Integer field containing the number of entries
 *        in the ring buffer.
 *
 * epoch_markers:  Array of instances of H5C_cache_entry_t of length
 *        H5C__MAX_EPOCH_MARKERS.  The entries are used as markers in the
 *        LRU list to identify cache entries that haven't been accessed for
 *        some (small) specified number of epochs.  These entries (if any)
 *        can then be evicted and the cache size reduced -- ideally without
 *        evicting any of the current working set.  Needless to say, the epoch
 *        length and the number of epochs before an unused entry must be
 *        chosen so that all, or almost all, the working set will be accessed
 *        before the limit.
 *
 *        Epoch markers only appear in the LRU list, never in the index or
 *        skip list.  While they are of type H5C__EPOCH_MARKER_TYPE, and have
 *        associated class functions, these functions should never be called.
 *
 *        The addr fields of these instances of H5C_cache_entry_t are set to
 *        the index of the instance in the epoch_markers array, the size is
 *        set to 0, and the type field points to the constant structure
 *        epoch_marker_class defined in H5Cepoch.c.  The next and prev fields
 *        are used as usual to link the entry into the LRU list.
 *
 *        All other fields are unused.
 *
 *
 * Cache hit rate collection fields:
 *
 * We supply the current cache hit rate on request, so we must keep a
 * simple cache hit rate computation regardless of whether statistics
 * collection is enabled.  The following fields support this capability.
 *
 * cache_hits: Number of cache hits since the last time the cache hit rate
 *        statistics were reset.  Note that when automatic cache re-sizing
 *        is enabled, this field will be reset every automatic resize epoch.
 *
 * cache_accesses: Number of times the cache has been accessed while
 *        since the last since the last time the cache hit rate statistics
 *        were reset.  Note that when automatic cache re-sizing is enabled,
 *        this field will be reset every automatic resize epoch.
 *
 *
 * Metadata cache image management related fields.
 *
 * image_ctl: Instance of H5C_cache_image_ctl_t containing configuration
 *        data for generation of a cache image on file close.
 *
 * serialization_in_progress: Boolean field that is set to true iff
 *        the cache is in the process of being serialized.  This field is
 *        needed to support the H5C_serialization_in_progress() call, which
 *        is in turn required for sanity checks in some cache clients.
 *
 * load_image: Boolean flag indicating that the metadata cache image
 *        superblock extension message exists and should be read, and the
 *        image block read and decoded on the next call to H5C_protect().
 *
 * image_loaded: Boolean flag indicating that the metadata cache has
 *        loaded the metadata cache image as directed by the
 *        cache image superblock extension message.
 *
 * delete_image: Boolean flag indicating whether the metadata cache image
 *        superblock message should be deleted and the cache image
 *        file space freed after they have been read and decoded.
 *
 *        This flag should be set to true iff the file is opened
 *        R/W and there is a cache image to be read.
 *
 * image_addr: The base address of the on-disk metadata cache image, or
 *        HADDR_UNDEF if that value is undefined.  Note that this field
 *        is used both in the construction and write, and the read and
 *        decode of metadata cache image blocks.
 *
 * image_len: The size of the on disk metadata cache image, or zero if that
 *        value is undefined.  Note that this field is used both in the
 *        construction and write, and the read and decode of metadata cache
 *        image blocks.
 *
 * image_data_len:  The number of bytes of data in the on disk metadata
 *        cache image, or zero if that value is undefined.
 *
 *        In most cases, this value is the same as the image_len
 *        above.  It exists to allow for metadata cache image blocks
 *        that are larger than the actual image.  Thus in all
 *        cases image_data_len <= image_len.
 *
 * To create the metadata cache image, we must first serialize all the
 * entries in the metadata cache.  This is done by a scan of the index.
 * As entries must be serialized in increasing flush dependency height
 * order, we scan the index repeatedly, once for each flush dependency
 * height in increasing order.
 *
 * This operation is complicated by the fact that entries other than the
 * target may be inserted, loaded, relocated, or removed from the cache
 * (either by eviction or the take ownership flag) as the result of a
 * pre_serialize or serialize callback.  While entry removals are not
 * a problem for the scan of the index, insertions, loads, and relocations
 * are.  Hence the entries loaded, inserted, and relocated counters
 * listed below have been implemented to allow these conditions to be
 * detected and dealt with by restarting the scan.
 *
 * The serialization operation is further complicated by the fact that
 * the flush dependency height of a given entry may increase (as the
 * result of an entry load or insert) or decrease (as the result of an
 * entry removal -- via either eviction or the take ownership flag).  The
 * entry_fd_height_change_counter field is maintained to allow detection
 * of this condition, and a restart of the scan when it occurs.
 *
 * Note that all these new fields would work just as well as booleans.
 *
 * entries_loaded_counter: Number of entries loaded into the cache
 *        since the last time this field was reset.
 *
 * entries_inserted_counter: Number of entries inserted into the cache
 *        since the last time this field was reset.
 *
 * entries relocated_counter: Number of entries whose base address has
 *        been changed since the last time this field was reset.
 *
 * entry_fd_height_change_counter: Number of entries whose flush dependency
 *        height has changed since the last time this field was reset.
 *
 * The following fields are used assemble the cache image prior to
 * writing it to disk.
 *
 * num_entries_in_image: Unsigned integer field containing the number of
 *        entries to be copied into the metadata cache image.  Note that
 *        this value will be less than the number of entries in the cache,
 *        and the superblock and its related entries are not written to the
 *        metadata cache image.
 *
 * image_entries: Pointer to a dynamically allocated array of instance of
 *        H5C_image_entry_t of length num_entries_in_image, or NULL
 *        if that array does not exist.  This array is used to
 *        assemble entry data to be included in the image, and to
 *        sort them by flush dependency height and LRU rank.
 *
 * image_buffer: Pointer to the dynamically allocated buffer of length
 *        image_len in which the metadata cache image is assembled,
 *        or NULL if that buffer does not exist.
 *
 *
 * Free Space Manager Related fields:
 *
 * The free space managers for the file must be informed when we are about to
 * close or flush the file so that they order themselves accordingly.  This
 * used to be done much later in the close process, but with cache image and
 * page buffering, this is no longer viable, as we must finalize the on
 * disk image of all metadata much sooner.
 *
 * This is handled by the H5MF_settle_raw_data_fsm() and
 * H5MF_settle_meta_data_fsm() routines.  As these calls are expensive,
 * the following fields are used to track whether the target free space
 * managers are clean.
 *
 * They are also used in sanity checking, as once a free space manager is
 * settled, it should not become unsettled (i.e. be asked to allocate or
 * free file space) either ever (in the case of a file close) or until the
 * flush is complete.
 *
 * rdfsm_settled:  Boolean flag indicating whether the raw data free space
 *        manager is settled -- i.e. whether the correct space has
 *        been allocated for it in the file.
 *
 *        Note that the name of this field is deceptive.  In the
 *        multi file case, the flag applies to all free space
 *        managers that are not involved in allocating space for
 *        free space manager metadata.
 *
 * mdfsm_settled:  Boolean flag indicating whether the meta data free space
 *        manager is settled -- i.e. whether the correct space has
 *        been allocated for it in the file.
 *
 *        Note that the name of this field is deceptive.  In the
 *        multi-file case, the flag applies only to free space
 *        managers that are involved in allocating space for free
 *        space managers.
 *
 *
 * Statistics collection fields:
 *
 * When enabled, these fields are used to collect statistics as described
 * below.  The first set are collected only when H5C_COLLECT_CACHE_STATS
 * is true.
 *
 * hits: Array to record the number of times an entry with type id
 *        equal to the array index has been in cache when requested in
 *        the current epoch.
 *
 * misses: Array to record the number of times an entry with type id
 *        equal to the array index has not been in cache when
 *        requested in the current epoch.
 *
 * write_protects: Array to record the number of times an entry with
 *         type id equal to the array index has been write protected
 *         in the current epoch.
 *
 *         Observe that (hits + misses) = (write_protects + read_protects).
 *
 * read_protects: Array to record the number of times an entry with
 *         type id equal to the array index has been read protected in
 *         the current epoch.
 *
 *         Observe that (hits + misses) = (write_protects + read_protects).
 *
 * max_read_protects: Array to maximum number of simultaneous read
 *         protects on any entry with type id equal to the array index
 *         in the current epoch.
 *
 * insertions: Array to record the number of times an entry with type
 *        id equal to the array index has been inserted into the
 *        cache in the current epoch.
 *
 * pinned_insertions: Array to record the number of times an entry
 *         with type id equal to the array index has been inserted
 *         pinned into the cache in the current epoch.
 *
 * clears: Array to record the number of times a dirty entry with type
 *        id equal to the array index has been cleared in the current epoch.
 *
 * flushes: Array to record the number of times an entry with type id
 *        equal to the array index has been written to disk in the
 *        current epoch.
 *
 * evictions: Array to record the number of times an entry with type id
 *        equal to the array index has been evicted from the cache in
 *        the current epoch.
 *
 * take_ownerships: Array to record the number of times an entry with
 *        type id equal to the array index has been removed from the
 *        cache via the H5C__TAKE_OWNERSHIP_FLAG in the current epoch.
 *
 * moves: Array to record the number of times an entry with type
 *        id equal to the array index has been moved in the current epoch.
 *
 * entry_flush_moves: Array to record the number of times an entry
 *         with type id equal to the array index has been moved
 *         during its pre-serialize callback in the current epoch.
 *
 * cache_flush_moves: Array to record the number of times an entry
 *         with type id equal to the array index has been moved
 *         during a cache flush in the current epoch.
 *
 * pins: Array to record the number of times an entry with type
 *        id equal to the array index has been pinned in the current epoch.
 *
 * unpins: Array to record the number of times an entry with type
 *        id equal to the array index has been unpinned in the current epoch.
 *
 * dirty_pins: Array to record the number of times an entry with type
 *        id equal to the array index has been marked dirty while pinned
 *        in the current epoch.
 *
 * pinned_flushes: Array to record the number of times an entry
 *         with type id equal to the array index has been flushed while
 *         pinned in the current epoch.
 *
 * pinned_clears: Array to record the number of times an entry
 *         with type id equal to the array index has been cleared while
 *         pinned in the current epoch.
 *
 * size_increases: Array to record the number of times an entry
 *        with type id equal to the array index has increased in
 *        size in the current epoch.
 *
 * size_decreases: Array to record the number of times an entry
 *        with type id equal to the array index has decreased in
 *        size in the current epoch.
 *
 * entry_flush_size_changes: Array to record the number of times an entry
 *        with type id equal to the array index has changed size while in
 *        its pre-serialize callback.
 *
 * cache_flush_size_changes: Array to record the number of times an entry
 *        with type id equal to the array index has changed size during a
 *        cache flush
 *
 * total_ht_insertions: Number of times entries have been inserted into the
 *        hash table in the current epoch.
 *
 * total_ht_deletions: Number of times entries have been deleted from the
 *        hash table in the current epoch.
 *
 * successful_ht_searches: The total number of successful searches of the
 *        hash table in the current epoch.
 *
 * total_successful_ht_search_depth: The total number of entries other than
 *        the targets examined in successful searches of the hash table in
 *        the current epoch.
 *
 * failed_ht_searches: The total number of unsuccessful searches of the hash
 *        table in the current epoch.
 *
 * total_failed_ht_search_depth: The total number of entries examined in
 *        unsuccessful searches of the hash table in the current epoch.
 *
 * max_index_len: Largest value attained by the index_len field in the
 *        current epoch.
 *
 * max_index_size: Largest value attained by the index_size field in the
 *        current epoch.
 *
 * max_clean_index_size: Largest value attained by the clean_index_size field
 *         in the current epoch.
 *
 * max_dirty_index_size: Largest value attained by the dirty_index_size field
 *         in the current epoch.
 *
 * max_slist_len: Largest value attained by the slist_len field in the
 *        current epoch.
 *
 * max_slist_size: Largest value attained by the slist_size field in the
 *        current epoch.
 *
 * max_pl_len:  Largest value attained by the pl_len field in the
 *        current epoch.
 *
 * max_pl_size: Largest value attained by the pl_size field in the
 *        current epoch.
 *
 * max_pel_len: Largest value attained by the pel_len field in the
 *        current epoch.
 *
 * max_pel_size: Largest value attained by the pel_size field in the
 *        current epoch.
 *
 * calls_to_msic: Total number of calls to H5C__make_space_in_cache
 *
 * total_entries_skipped_in_msic: Number of clean entries skipped while
 *        enforcing the min_clean_fraction in H5C__make_space_in_cache().
 *
 * total_dirty_pf_entries_skipped_in_msic: Number of dirty prefetched entries
 *        skipped in H5C__make_space_in_cache().  Note that this can
 *        only occur when a file is opened R/O with a cache image
 *        containing dirty entries.
 *
 * total_entries_scanned_in_msic: Number of clean entries skipped while
 *        enforcing the min_clean_fraction in H5C__make_space_in_cache().
 *
 * max_entries_skipped_in_msic: Maximum number of clean entries skipped
 *        in any one call to H5C__make_space_in_cache().
 *
 * max_dirty_pf_entries_skipped_in_msic: Maximum number of dirty prefetched
 *        entries skipped in any one call to H5C__make_space_in_cache().
 *        Note that this can only occur when the file is opened
 *        R/O with a cache image containing dirty entries.
 *
 * max_entries_scanned_in_msic: Maximum number of entries scanned over
 *        in any one call to H5C__make_space_in_cache().
 *
 * entries_scanned_to_make_space: Number of entries scanned only when looking
 *        for entries to evict in order to make space in cache.
 *
 *
 * The following fields track statistics on cache images.
 *
 * images_created:  The number of cache images created since the last
 *        time statistics were reset.
 *
 *        At present, this field must always be either 0 or 1.
 *        Further, since cache images are only created at file
 *        close, this field should only be set at that time.
 *
 * images_read: The number of cache images read from file.  Note that
 *        reading an image is different from loading it -- reading the
 *        image means just that, while loading the image refers to decoding
 *        it and loading it into the metadata cache.
 *
 *        In the serial case, image_read should always equal images_loaded.
 *        However, in the parallel case, the image should only be read by
 *        process 0.  All other processes should receive the cache image via
 *        a broadcast from process 0.
 *
 * images_loaded:  The number of cache images loaded since the last time
 *        statistics were reset.
 *
 *        At present, this field must always be either 0 or 1.
 *        Further, since cache images are only loaded at the
 *        time of the first protect or on file close, this value
 *        should only change on those events.
 *
 * last_image_size:  Size of the most recently loaded metadata cache image
 *        loaded into the cache, or zero if no image has been loaded.
 *
 *        At present, at most one cache image can be loaded into
 *        the metadata cache for any given file, and this image
 *        will be loaded either on the first protect, or on file
 *        close if no entry is protected before then.
 *
 *
 * Fields for tracking prefetched entries.  Note that flushes and evictions
 * of prefetched entries are tracked in the flushes and evictions arrays
 * discussed above.
 *
 * prefetches: Number of prefetched entries that are loaded to the cache.
 *
 * dirty_prefetches: Number of dirty prefetched entries that are loaded
 *        into the cache.
 *
 * prefetch_hits: Number of prefetched entries that are actually used.
 *
 *
 * Entries may move, load, dirty, and delete other entries in their
 * pre_serialize and serialize callbacks, there is code to restart scans of
 * lists so as to avoid improper behavior if the next entry in the list is
 * the target of one on these operations.
 *
 * The following fields are use to count such occurrences.  They are used
 * both in tests (to verify that the scan has been restarted), and to
 * obtain estimates of how frequently these restarts occur.
 *
 * slist_scan_restarts: Number of times a scan of the skip list (that contains
 *        calls to H5C__flush_single_entry()) has been restarted to
 *        avoid potential issues with change of status of the next
 *        entry in the scan.
 *
 * LRU_scan_restarts: Number of times a scan of the LRU list (that contains
 *        calls to H5C__flush_single_entry()) has been restarted to
 *        avoid potential issues with change of status of the next
 *        entry in the scan.
 *
 * index_scan_restarts: Number of times a scan of the index has been
 *        restarted to avoid potential issues with load, insertion
 *        or change in flush dependency height of an entry other
 *        than the target entry as the result of call(s) to the
 *        pre_serialize or serialize callbacks.
 *
 *        Note that at present, this condition can only be triggered
 *        by a call to H5C_serialize_single_entry().
 *
 * The remaining stats are collected only when both H5C_COLLECT_CACHE_STATS
 * and H5C_COLLECT_CACHE_ENTRY_STATS are true.
 *
 * max_accesses: Array to record the maximum number of times any single
 *        entry with type id equal to the array index has been
 *        accessed in the current epoch.
 *
 * min_accesses: Array to record the minimum number of times any single
 *        entry with type id equal to the array index has been
 *        accessed in the current epoch.
 *
 * max_clears: Array to record the maximum number of times any single
 *        entry with type id equal to the array index has been cleared
 *        in the current epoch.
 *
 * max_flushes: Array to record the maximum number of times any single
 *        entry with type id equal to the array index has been
 *        flushed in the current epoch.
 *
 * max_size: Array to record the maximum size of any single entry
 *        with type id equal to the array index that has resided in
 *        the cache in the current epoch.
 *
 * max_pins: Array to record the maximum number of times that any single
 *        entry with type id equal to the array index that has been
 *        marked as pinned in the cache in the current epoch.
 *
 *
 * Fields supporting testing:
 *
 * prefix: Array of char used to prefix debugging output.  The field is
 *        intended to allow marking of output of with the processes mpi rank.
 *
 * get_entry_ptr_from_addr_counter: Counter used to track the number of
 *        times the H5C_get_entry_ptr_from_addr() function has been
 *        called successfully.  This field is only defined when
 *        NDEBUG is not #defined.
 *
 ****************************************************************************/
struct H5C_t {
    bool                       flush_in_progress;
    H5C_log_info_t            *log_info;
    void                      *aux_ptr;
    int32_t                    max_type_id;
    const H5C_class_t *const  *class_table_ptr;
    size_t                     max_cache_size;
    size_t                     min_clean_size;
    H5C_write_permitted_func_t check_write_permitted;
    bool                       write_permitted;
    H5C_log_flush_func_t       log_flush;
    bool                       evictions_enabled;
    bool                       close_warning_received;

    /* 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];
    size_t             index_ring_size[H5C_RING_NTYPES];
    size_t             clean_index_size;
    size_t             clean_index_ring_size[H5C_RING_NTYPES];
    size_t             dirty_index_size;
    size_t             dirty_index_ring_size[H5C_RING_NTYPES];
    H5C_cache_entry_t *index[H5C__HASH_TABLE_LEN];
    uint32_t           il_len;
    size_t             il_size;
    H5C_cache_entry_t *il_head;
    H5C_cache_entry_t *il_tail;

    /* Fields to detect entries removed during scans */
    int64_t            entries_removed_counter;
    H5C_cache_entry_t *last_entry_removed_ptr;
    H5C_cache_entry_t *entry_watched_for_removal;

    /* Fields for maintaining list of in-order entries, for flushing */
    bool     slist_enabled;
    bool     slist_changed;
    uint32_t slist_len;
    size_t   slist_size;
    uint32_t slist_ring_len[H5C_RING_NTYPES];
    size_t   slist_ring_size[H5C_RING_NTYPES];
    H5SL_t  *slist_ptr;
    uint32_t num_last_entries;
#ifdef H5C_DO_SANITY_CHECKS
    int32_t slist_len_increase;
    int64_t slist_size_increase;
#endif /* H5C_DO_SANITY_CHECKS */

    /* Fields for maintaining list of tagged entries */
    H5C_tag_info_t *tag_list;
    bool            ignore_tags;
    uint32_t        num_objs_corked;

    /* Fields for tracking protected entries */
    uint32_t           pl_len;
    size_t             pl_size;
    H5C_cache_entry_t *pl_head_ptr;
    H5C_cache_entry_t *pl_tail_ptr;

    /* Fields for tracking pinned entries */
    uint32_t           pel_len;
    size_t             pel_size;
    H5C_cache_entry_t *pel_head_ptr;
    H5C_cache_entry_t *pel_tail_ptr;

    /* Fields for complete LRU list of entries */
    uint32_t           LRU_list_len;
    size_t             LRU_list_size;
    H5C_cache_entry_t *LRU_head_ptr;
    H5C_cache_entry_t *LRU_tail_ptr;

#if H5C_MAINTAIN_CLEAN_AND_DIRTY_LRU_LISTS
    /* Fields for clean LRU list of entries */
    uint32_t           cLRU_list_len;
    size_t             cLRU_list_size;
    H5C_cache_entry_t *cLRU_head_ptr;
    H5C_cache_entry_t *cLRU_tail_ptr;

    /* Fields for dirty LRU list of entries */
    uint32_t           dLRU_list_len;
    size_t             dLRU_list_size;
    H5C_cache_entry_t *dLRU_head_ptr;
    H5C_cache_entry_t *dLRU_tail_ptr;
#endif /* H5C_MAINTAIN_CLEAN_AND_DIRTY_LRU_LISTS */

#ifdef H5_HAVE_PARALLEL
    /* Fields for collective metadata reads */
    uint32_t           coll_list_len;
    size_t             coll_list_size;
    H5C_cache_entry_t *coll_head_ptr;
    H5C_cache_entry_t *coll_tail_ptr;

    /* Fields for collective metadata writes */
    H5SL_t *coll_write_list;
#endif /* H5_HAVE_PARALLEL */

    /* Fields for automatic cache size adjustment */
    bool                size_increase_possible;
    bool                flash_size_increase_possible;
    size_t              flash_size_increase_threshold;
    bool                size_decrease_possible;
    bool                resize_enabled;
    bool                cache_full;
    bool                size_decreased;
    bool                resize_in_progress;
    bool                msic_in_progress;
    H5C_auto_size_ctl_t resize_ctl;

    /* Fields for epoch markers used in automatic cache size adjustment */
    int32_t           epoch_markers_active;
    bool              epoch_marker_active[H5C__MAX_EPOCH_MARKERS];
    int32_t           epoch_marker_ringbuf[H5C__MAX_EPOCH_MARKERS + 1];
    int32_t           epoch_marker_ringbuf_first;
    int32_t           epoch_marker_ringbuf_last;
    int32_t           epoch_marker_ringbuf_size;
    H5C_cache_entry_t epoch_markers[H5C__MAX_EPOCH_MARKERS];

    /* Fields for cache hit rate collection */
    int64_t cache_hits;
    int64_t cache_accesses;

    /* fields supporting generation of a cache image on file close */
    H5C_cache_image_ctl_t image_ctl;
    bool                  serialization_in_progress;
    bool                  load_image;
    bool                  image_loaded;
    bool                  delete_image;
    haddr_t               image_addr;
    hsize_t               image_len;
    hsize_t               image_data_len;
    int64_t               entries_loaded_counter;
    int64_t               entries_inserted_counter;
    int64_t               entries_relocated_counter;
    int64_t               entry_fd_height_change_counter;
    uint32_t              num_entries_in_image;
    H5C_image_entry_t    *image_entries;
    void                 *image_buffer;

    /* Free Space Manager Related fields */
    bool rdfsm_settled;
    bool mdfsm_settled;

#if H5C_COLLECT_CACHE_STATS
    /* stats fields */
    int64_t hits[H5C__MAX_NUM_TYPE_IDS + 1];
    int64_t misses[H5C__MAX_NUM_TYPE_IDS + 1];
    int64_t write_protects[H5C__MAX_NUM_TYPE_IDS + 1];
    int64_t read_protects[H5C__MAX_NUM_TYPE_IDS + 1];
    int32_t max_read_protects[H5C__MAX_NUM_TYPE_IDS + 1];
    int64_t insertions[H5C__MAX_NUM_TYPE_IDS + 1];
    int64_t pinned_insertions[H5C__MAX_NUM_TYPE_IDS + 1];
    int64_t clears[H5C__MAX_NUM_TYPE_IDS + 1];
    int64_t flushes[H5C__MAX_NUM_TYPE_IDS + 1];
    int64_t evictions[H5C__MAX_NUM_TYPE_IDS + 1];
    int64_t take_ownerships[H5C__MAX_NUM_TYPE_IDS + 1];
    int64_t moves[H5C__MAX_NUM_TYPE_IDS + 1];
    int64_t entry_flush_moves[H5C__MAX_NUM_TYPE_IDS + 1];
    int64_t cache_flush_moves[H5C__MAX_NUM_TYPE_IDS + 1];
    int64_t pins[H5C__MAX_NUM_TYPE_IDS + 1];
    int64_t unpins[H5C__MAX_NUM_TYPE_IDS + 1];
    int64_t dirty_pins[H5C__MAX_NUM_TYPE_IDS + 1];
    int64_t pinned_flushes[H5C__MAX_NUM_TYPE_IDS + 1];
    int64_t pinned_clears[H5C__MAX_NUM_TYPE_IDS + 1];
    int64_t size_increases[H5C__MAX_NUM_TYPE_IDS + 1];
    int64_t size_decreases[H5C__MAX_NUM_TYPE_IDS + 1];
    int64_t entry_flush_size_changes[H5C__MAX_NUM_TYPE_IDS + 1];
    int64_t cache_flush_size_changes[H5C__MAX_NUM_TYPE_IDS + 1];

    /* Fields for hash table operations */
    int64_t  total_ht_insertions;
    int64_t  total_ht_deletions;
    int64_t  successful_ht_searches;
    int64_t  total_successful_ht_search_depth;
    int64_t  failed_ht_searches;
    int64_t  total_failed_ht_search_depth;
    uint32_t max_index_len;
    size_t   max_index_size;
    size_t   max_clean_index_size;
    size_t   max_dirty_index_size;

    /* Fields for in-order skip list */
    uint32_t max_slist_len;
    size_t   max_slist_size;

    /* Fields for protected entry list */
    uint32_t max_pl_len;
    size_t   max_pl_size;

    /* Fields for pinned entry list */
    uint32_t max_pel_len;
    size_t   max_pel_size;

    /* Fields for tracking 'make space in cache' (msic) operations */
    int64_t calls_to_msic;
    int64_t total_entries_skipped_in_msic;
    int64_t total_dirty_pf_entries_skipped_in_msic;
    int64_t total_entries_scanned_in_msic;
    int32_t max_entries_skipped_in_msic;
    int32_t max_dirty_pf_entries_skipped_in_msic;
    int32_t max_entries_scanned_in_msic;
    int64_t entries_scanned_to_make_space;

    /* Fields for tracking skip list scan restarts */
    int64_t slist_scan_restarts;
    int64_t LRU_scan_restarts;
    int64_t index_scan_restarts;

    /* Fields for tracking cache image operations */
    int32_t images_created;
    int32_t images_read;
    int32_t images_loaded;
    hsize_t last_image_size;

    /* Fields for tracking prefetched entries */
    int64_t prefetches;
    int64_t dirty_prefetches;
    int64_t prefetch_hits;

#if H5C_COLLECT_CACHE_ENTRY_STATS
    int32_t max_accesses[H5C__MAX_NUM_TYPE_IDS + 1];
    int32_t min_accesses[H5C__MAX_NUM_TYPE_IDS + 1];
    int32_t max_clears[H5C__MAX_NUM_TYPE_IDS + 1];
    int32_t max_flushes[H5C__MAX_NUM_TYPE_IDS + 1];
    size_t  max_size[H5C__MAX_NUM_TYPE_IDS + 1];
    int32_t max_pins[H5C__MAX_NUM_TYPE_IDS + 1];
#endif /* H5C_COLLECT_CACHE_ENTRY_STATS */
#endif /* H5C_COLLECT_CACHE_STATS */

    char prefix[H5C__PREFIX_LEN];

#ifndef NDEBUG
    int64_t get_entry_ptr_from_addr_counter;
#endif

}; /* H5C_t */

/* Define typedef for tagged cache entry iteration callbacks */
typedef int (*H5C_tag_iter_cb_t)(H5C_cache_entry_t *entry, void *ctx);

/*****************************/
/* Package Private Variables */
/*****************************/

/******************************/
/* Package Private Prototypes */
/******************************/
H5_DLL herr_t H5C__prep_image_for_file_close(H5F_t *f, bool *image_generated);

/* General routines */
H5_DLL herr_t H5C__auto_adjust_cache_size(H5F_t *f, bool write_permitted);
H5_DLL herr_t H5C__autoadjust__ageout__remove_all_markers(H5C_t *cache_ptr);
H5_DLL herr_t H5C__autoadjust__ageout__remove_excess_markers(H5C_t *cache_ptr);
H5_DLL herr_t H5C__flash_increase_cache_size(H5C_t *cache_ptr, size_t old_entry_size, size_t new_entry_size);
H5_DLL herr_t H5C__flush_invalidate_cache(H5F_t *f, unsigned flags);
H5_DLL herr_t H5C__flush_ring(H5F_t *f, H5C_ring_t ring, unsigned flags);
H5_DLL herr_t H5C__flush_single_entry(H5F_t *f, H5C_cache_entry_t *entry_ptr, unsigned flags);
H5_DLL herr_t H5C__generate_cache_image(H5F_t *f, H5C_t *cache_ptr);
H5_DLL herr_t H5C__load_cache_image(H5F_t *f);
H5_DLL herr_t H5C__make_space_in_cache(H5F_t *f, size_t space_needed, bool write_permitted);
H5_DLL herr_t H5C__serialize_cache(H5F_t *f);
H5_DLL herr_t H5C__serialize_single_entry(H5F_t *f, H5C_t *cache_ptr, H5C_cache_entry_t *entry_ptr);
H5_DLL herr_t H5C__iter_tagged_entries(H5C_t *cache, haddr_t tag, bool match_global, H5C_tag_iter_cb_t cb,
                                       void *cb_ctx);

/* Routines for operating on entry tags */
H5_DLL herr_t H5C__tag_entry(H5C_t *cache_ptr, H5C_cache_entry_t *entry_ptr);
H5_DLL herr_t H5C__untag_entry(H5C_t *cache, H5C_cache_entry_t *entry);

/* Routines for operating on cache images */
H5_DLL herr_t H5C__get_cache_image_config(const H5C_t *cache_ptr, H5C_cache_image_ctl_t *config_ptr);
H5_DLL herr_t H5C__image_stats(H5C_t *cache_ptr, bool print_header);

/* Debugging routines */
#ifdef H5C_DO_SLIST_SANITY_CHECKS
H5_DLL bool H5C__entry_in_skip_list(H5C_t *cache_ptr, H5C_cache_entry_t *target_ptr);
#endif
#ifdef H5C_DO_EXTREME_SANITY_CHECKS
H5_DLL herr_t H5C__validate_lru_list(H5C_t *cache_ptr);
H5_DLL herr_t H5C__validate_pinned_entry_list(H5C_t *cache_ptr);
H5_DLL herr_t H5C__validate_protected_entry_list(H5C_t *cache_ptr);
#endif /* H5C_DO_EXTREME_SANITY_CHECKS */

/* Testing functions */
#ifdef H5C_TESTING
H5_DLL herr_t H5C__verify_cork_tag_test(hid_t fid, H5O_token_t tag_token, bool status);
#endif /* H5C_TESTING */

#endif /* H5Cpkg_H */
