/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 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 COPYING 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. */ /* clang-format off */ /* Maintain current format by disabling format for this file */ #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 maintenanace of the skip list. * This flag is initially set to false, which disables all operations * on the skip list. * * At the beginning of either flush or close, we scan the index list, * insert all dirtly entries in the skip list, and enable operations * on skip list by setting above control flag to true. * * At the end of a complete flush, we verify that the skip list is empty, * and set the control flag back to false, so as to avoid skip list * maintenance overhead until the next flush or close. * * In the case of a partial flush (i.e. flush marked entries), we remove * all remaining entries from the skip list, and then set the control flag * back to false -- again avoiding skip list maintenance overhead until * the next flush or close. * * slist_enabled: Boolean flag used to control operation of the skip * list. If this filed is false, operations on the slist are * no-ops, and the slist must be empty. If it is true, * operations on the 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 */ /* clang-format on */