HDF5  1.12.0
Data Structures | Macros | Typedefs | Functions
H5Cpkg.h File Reference
#include "H5Cprivate.h"
#include "H5Clog.h"
#include "H5SLprivate.h"

Go to the source code of this file.

Data Structures

struct  H5C_tag_info_t
 
struct  H5C_t
 

Macros

#define H5C__MAX_EPOCH_MARKERS   10
 
#define H5C__HASH_TABLE_LEN   (64 * 1024) /* must be a power of 2 */
 
#define H5C__H5C_T_MAGIC   0x005CAC0E
 
#define H5C_FLUSH_DEP_PARENT_INIT   8
 
#define H5C__DLL_PRE_REMOVE_SC(entry_ptr, head_ptr, tail_ptr, len, Size, fv)
 
#define H5C__DLL_SC(head_ptr, tail_ptr, len, Size, fv)
 
#define H5C__DLL_PRE_INSERT_SC(entry_ptr, head_ptr, tail_ptr, len, Size, fv)
 
#define H5C__DLL_PRE_SIZE_UPDATE_SC(dll_len, dll_size, old_size, new_size)
 
#define H5C__DLL_POST_SIZE_UPDATE_SC(dll_len, dll_size, old_size, new_size)
 
#define H5C__DLL_APPEND(entry_ptr, head_ptr, tail_ptr, len, Size, fail_val)
 
#define H5C__DLL_PREPEND(entry_ptr, head_ptr, tail_ptr, len, Size, fail_val)
 
#define H5C__DLL_REMOVE(entry_ptr, head_ptr, tail_ptr, len, Size, fail_val)
 
#define H5C__DLL_UPDATE_FOR_SIZE_CHANGE(dll_len, dll_size, old_size, new_size)
 
#define H5C__AUX_DLL_PRE_REMOVE_SC(entry_ptr, hd_ptr, tail_ptr, len, Size, fv)
 
#define H5C__AUX_DLL_SC(head_ptr, tail_ptr, len, Size, fv)
 
#define H5C__AUX_DLL_PRE_INSERT_SC(entry_ptr, hd_ptr, tail_ptr, len, Size, fv)
 
#define H5C__AUX_DLL_APPEND(entry_ptr, head_ptr, tail_ptr, len, Size, fail_val)
 
#define H5C__AUX_DLL_PREPEND(entry_ptr, head_ptr, tail_ptr, len, Size, fv)
 
#define H5C__AUX_DLL_REMOVE(entry_ptr, head_ptr, tail_ptr, len, Size, fv)
 
#define H5C__IL_DLL_PRE_REMOVE_SC(entry_ptr, hd_ptr, tail_ptr, len, Size, fv)
 
#define H5C__IL_DLL_PRE_INSERT_SC(entry_ptr, hd_ptr, tail_ptr, len, Size, fv)
 
#define H5C__IL_DLL_SC(head_ptr, tail_ptr, len, Size, fv)
 
#define H5C__IL_DLL_APPEND(entry_ptr, head_ptr, tail_ptr, len, Size, fail_val)
 
#define H5C__IL_DLL_REMOVE(entry_ptr, head_ptr, tail_ptr, len, Size, fv)
 
#define H5C__UPDATE_CACHE_HIT_RATE_STATS(cache_ptr, hit)
 
#define H5C__UPDATE_MAX_INDEX_SIZE_STATS(cache_ptr)
 
#define H5C__UPDATE_STATS_FOR_DIRTY_PIN(cache_ptr, entry_ptr)   (((cache_ptr)->dirty_pins)[(entry_ptr)->type->id])++;
 
#define H5C__UPDATE_STATS_FOR_UNPROTECT(cache_ptr)
 
#define H5C__UPDATE_STATS_FOR_MOVE(cache_ptr, entry_ptr)
 
#define H5C__UPDATE_STATS_FOR_ENTRY_SIZE_CHANGE(cache_ptr, entry_ptr, new_size)
 
#define H5C__UPDATE_STATS_FOR_HT_INSERTION(cache_ptr)   (cache_ptr)->total_ht_insertions++;
 
#define H5C__UPDATE_STATS_FOR_HT_DELETION(cache_ptr)   (cache_ptr)->total_ht_deletions++;
 
#define H5C__UPDATE_STATS_FOR_HT_SEARCH(cache_ptr, success, depth)
 
#define H5C__UPDATE_STATS_FOR_UNPIN(cache_ptr, entry_ptr)   ((cache_ptr)->unpins)[(entry_ptr)->type->id]++;
 
#define H5C__UPDATE_STATS_FOR_SLIST_SCAN_RESTART(cache_ptr)   ((cache_ptr)->slist_scan_restarts)++;
 
#define H5C__UPDATE_STATS_FOR_LRU_SCAN_RESTART(cache_ptr)   ((cache_ptr)->LRU_scan_restarts)++;
 
#define H5C__UPDATE_STATS_FOR_INDEX_SCAN_RESTART(cache_ptr)   ((cache_ptr)->index_scan_restarts)++;
 
#define H5C__UPDATE_STATS_FOR_CACHE_IMAGE_CREATE(cache_ptr)
 
#define H5C__UPDATE_STATS_FOR_CACHE_IMAGE_READ(cache_ptr)
 
#define H5C__UPDATE_STATS_FOR_CACHE_IMAGE_LOAD(cache_ptr)
 
#define H5C__UPDATE_STATS_FOR_PREFETCH(cache_ptr, dirty)
 
#define H5C__UPDATE_STATS_FOR_PREFETCH_HIT(cache_ptr)
 
#define H5C__RESET_CACHE_ENTRY_STATS(entry_ptr)
 
#define H5C__UPDATE_STATS_FOR_CLEAR(cache_ptr, entry_ptr)
 
#define H5C__UPDATE_STATS_FOR_FLUSH(cache_ptr, entry_ptr)
 
#define H5C__UPDATE_STATS_FOR_EVICTION(cache_ptr, entry_ptr, take_ownership)
 
#define H5C__UPDATE_STATS_FOR_INSERTION(cache_ptr, entry_ptr)
 
#define H5C__UPDATE_STATS_FOR_PROTECT(cache_ptr, entry_ptr, hit)
 
#define H5C__UPDATE_STATS_FOR_PIN(cache_ptr, entry_ptr)
 
#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__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)
 
#define H5C__POST_HT_REMOVE_SC(cache_ptr, entry_ptr)
 
#define H5C__PRE_HT_SEARCH_SC(cache_ptr, Addr, fail_val)
 
#define H5C__POST_SUC_HT_SEARCH_SC(cache_ptr, entry_ptr, k, fail_val)
 
#define H5C__POST_HT_SHIFT_TO_FRONT(cache_ptr, entry_ptr, k, fail_val)
 
#define H5C__PRE_HT_ENTRY_SIZE_CHANGE_SC(cache_ptr, old_size, new_size, entry_ptr, was_clean)
 
#define H5C__POST_HT_ENTRY_SIZE_CHANGE_SC(cache_ptr, old_size, new_size, entry_ptr)
 
#define H5C__PRE_HT_UPDATE_FOR_ENTRY_CLEAN_SC(cache_ptr, entry_ptr)
 
#define H5C__PRE_HT_UPDATE_FOR_ENTRY_DIRTY_SC(cache_ptr, entry_ptr)
 
#define H5C__POST_HT_UPDATE_FOR_ENTRY_CLEAN_SC(cache_ptr, entry_ptr)
 
#define H5C__POST_HT_UPDATE_FOR_ENTRY_DIRTY_SC(cache_ptr, entry_ptr)
 
#define H5C__INSERT_IN_INDEX(cache_ptr, entry_ptr, fail_val)
 
#define H5C__DELETE_FROM_INDEX(cache_ptr, entry_ptr, fail_val)
 
#define H5C__SEARCH_INDEX(cache_ptr, Addr, entry_ptr, fail_val)
 
#define H5C__SEARCH_INDEX_NO_STATS(cache_ptr, Addr, entry_ptr, fail_val)
 
#define H5C__UPDATE_INDEX_FOR_ENTRY_CLEAN(cache_ptr, entry_ptr)
 
#define H5C__UPDATE_INDEX_FOR_ENTRY_DIRTY(cache_ptr, entry_ptr)
 
#define H5C__UPDATE_INDEX_FOR_SIZE_CHANGE(cache_ptr, old_size, new_size, entry_ptr, was_clean)
 
#define ENTRY_IN_SLIST(cache_ptr, entry_ptr)   FALSE
 
#define H5C__INSERT_ENTRY_IN_SLIST(cache_ptr, entry_ptr, fail_val)
 
#define H5C__REMOVE_ENTRY_FROM_SLIST(cache_ptr, entry_ptr, during_flush)
 
#define H5C__UPDATE_SLIST_FOR_SIZE_CHANGE(cache_ptr, old_size, new_size)
 
#define H5C__FAKE_RP_FOR_MOST_RECENT_ACCESS(cache_ptr, entry_ptr, fail_val)
 
#define H5C__UPDATE_RP_FOR_EVICTION(cache_ptr, entry_ptr, fail_val)
 
#define H5C__UPDATE_RP_FOR_FLUSH(cache_ptr, entry_ptr, fail_val)
 
#define H5C__UPDATE_RP_FOR_INSERT_APPEND(cache_ptr, entry_ptr, fail_val)
 
#define H5C__UPDATE_RP_FOR_INSERTION(cache_ptr, entry_ptr, fail_val)
 
#define H5C__UPDATE_RP_FOR_PROTECT(cache_ptr, entry_ptr, fail_val)
 
#define H5C__UPDATE_RP_FOR_MOVE(cache_ptr, entry_ptr, was_dirty, fail_val)
 
#define H5C__UPDATE_RP_FOR_SIZE_CHANGE(cache_ptr, entry_ptr, new_size)
 
#define H5C__UPDATE_RP_FOR_UNPIN(cache_ptr, entry_ptr, fail_val)
 
#define H5C__UPDATE_RP_FOR_UNPROTECT(cache_ptr, entry_ptr, fail_val)
 

Typedefs

typedef struct H5C_tag_info_t H5C_tag_info_t
 
typedef int(* H5C_tag_iter_cb_t) (H5C_cache_entry_t *entry, void *ctx)
 

Functions

H5_DLL herr_t H5C__prep_image_for_file_close (H5F_t *f, hbool_t *image_generated)
 
H5_DLL herr_t H5C__deserialize_prefetched_entry (H5F_t *f, H5C_t *cache_ptr, H5C_cache_entry_t **entry_ptr_ptr, const H5C_class_t *type, haddr_t addr, void *udata)
 
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__mark_flush_dep_serialized (H5C_cache_entry_t *entry_ptr)
 
H5_DLL herr_t H5C__mark_flush_dep_unserialized (H5C_cache_entry_t *entry_ptr)
 
H5_DLL herr_t H5C__make_space_in_cache (H5F_t *f, size_t space_needed, hbool_t write_permitted)
 
H5_DLL herr_t H5C__flush_marked_entries (H5F_t *f)
 
H5_DLL herr_t H5C__generate_image (H5F_t *f, H5C_t *cache_ptr, H5C_cache_entry_t *entry_ptr)
 
H5_DLL herr_t H5C__serialize_cache (H5F_t *f)
 
H5_DLL herr_t H5C__iter_tagged_entries (H5C_t *cache, haddr_t tag, hbool_t match_global, H5C_tag_iter_cb_t cb, void *cb_ctx)
 
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)
 

Macro Definition Documentation

◆ ENTRY_IN_SLIST

#define ENTRY_IN_SLIST (   cache_ptr,
  entry_ptr 
)    FALSE

◆ H5C__AUX_DLL_APPEND

#define H5C__AUX_DLL_APPEND (   entry_ptr,
  head_ptr,
  tail_ptr,
  len,
  Size,
  fail_val 
)
Value:
{ \
H5C__AUX_DLL_PRE_INSERT_SC(entry_ptr, head_ptr, tail_ptr, len, Size, \
fail_val) \
if ( (head_ptr) == NULL ) \
{ \
(head_ptr) = (entry_ptr); \
(tail_ptr) = (entry_ptr); \
} \
else \
{ \
(tail_ptr)->aux_next = (entry_ptr); \
(entry_ptr)->aux_prev = (tail_ptr); \
(tail_ptr) = (entry_ptr); \
} \
(len)++; \
(Size) += entry_ptr->size; \
} /* H5C__AUX_DLL_APPEND() */

◆ H5C__AUX_DLL_PRE_INSERT_SC

#define H5C__AUX_DLL_PRE_INSERT_SC (   entry_ptr,
  hd_ptr,
  tail_ptr,
  len,
  Size,
  fv 
)
Value:
if ( ( (entry_ptr) == NULL ) || \
( (entry_ptr)->aux_next != NULL ) || \
( (entry_ptr)->aux_prev != NULL ) || \
( ( ( (hd_ptr) == NULL ) || ( (tail_ptr) == NULL ) ) && \
( (hd_ptr) != (tail_ptr) ) \
) || \
( ( (len) == 1 ) && \
( ( (hd_ptr) != (tail_ptr) ) || ( (Size) <= 0 ) || \
( (hd_ptr) == NULL ) || ( (hd_ptr)->size != (Size) ) \
) \
) || \
( ( (len) >= 1 ) && \
( ( (hd_ptr) == NULL ) || ( (hd_ptr)->aux_prev != NULL ) || \
( (tail_ptr) == NULL ) || ( (tail_ptr)->aux_next != NULL ) \
) \
) \
) { \
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, (fv), "AUX DLL pre insert SC failed") \
}

◆ H5C__AUX_DLL_PRE_REMOVE_SC

#define H5C__AUX_DLL_PRE_REMOVE_SC (   entry_ptr,
  hd_ptr,
  tail_ptr,
  len,
  Size,
  fv 
)
Value:
if ( ( (hd_ptr) == NULL ) || \
( (tail_ptr) == NULL ) || \
( (entry_ptr) == NULL ) || \
( (len) <= 0 ) || \
( (Size) < (entry_ptr)->size ) || \
( ( (Size) == (entry_ptr)->size ) && ( ! ( (len) == 1 ) ) ) || \
( ( (entry_ptr)->aux_prev == NULL ) && ( (hd_ptr) != (entry_ptr) ) ) || \
( ( (entry_ptr)->aux_next == NULL ) && ( (tail_ptr) != (entry_ptr) ) ) || \
( ( (len) == 1 ) && \
( ! ( ( (hd_ptr) == (entry_ptr) ) && ( (tail_ptr) == (entry_ptr) ) && \
( (entry_ptr)->aux_next == NULL ) && \
( (entry_ptr)->aux_prev == NULL ) && \
( (Size) == (entry_ptr)->size ) \
) \
) \
) \
) { \
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, (fv), "aux DLL pre remove SC failed") \
}

◆ H5C__AUX_DLL_PREPEND

#define H5C__AUX_DLL_PREPEND (   entry_ptr,
  head_ptr,
  tail_ptr,
  len,
  Size,
  fv 
)
Value:
{ \
H5C__AUX_DLL_PRE_INSERT_SC(entry_ptr, head_ptr, tail_ptr, len, Size, fv) \
if ( (head_ptr) == NULL ) \
{ \
(head_ptr) = (entry_ptr); \
(tail_ptr) = (entry_ptr); \
} \
else \
{ \
(head_ptr)->aux_prev = (entry_ptr); \
(entry_ptr)->aux_next = (head_ptr); \
(head_ptr) = (entry_ptr); \
} \
(len)++; \
(Size) += entry_ptr->size; \
} /* H5C__AUX_DLL_PREPEND() */

◆ H5C__AUX_DLL_REMOVE

#define H5C__AUX_DLL_REMOVE (   entry_ptr,
  head_ptr,
  tail_ptr,
  len,
  Size,
  fv 
)
Value:
{ \
H5C__AUX_DLL_PRE_REMOVE_SC(entry_ptr, head_ptr, tail_ptr, len, Size, fv) \
{ \
if ( (head_ptr) == (entry_ptr) ) \
{ \
(head_ptr) = (entry_ptr)->aux_next; \
if ( (head_ptr) != NULL ) \
(head_ptr)->aux_prev = NULL; \
} \
else \
(entry_ptr)->aux_prev->aux_next = (entry_ptr)->aux_next; \
if ( (tail_ptr) == (entry_ptr) ) \
{ \
(tail_ptr) = (entry_ptr)->aux_prev; \
if ( (tail_ptr) != NULL ) \
(tail_ptr)->aux_next = NULL; \
} \
else \
(entry_ptr)->aux_next->aux_prev = (entry_ptr)->aux_prev; \
entry_ptr->aux_next = NULL; \
entry_ptr->aux_prev = NULL; \
(len)--; \
(Size) -= entry_ptr->size; \
} \
} /* H5C__AUX_DLL_REMOVE() */

◆ H5C__AUX_DLL_SC

#define H5C__AUX_DLL_SC (   head_ptr,
  tail_ptr,
  len,
  Size,
  fv 
)
Value:
if ( ( ( ( (head_ptr) == NULL ) || ( (tail_ptr) == NULL ) ) && \
( (head_ptr) != (tail_ptr) ) \
) || \
( (len) < 0 ) || \
( (Size) < 0 ) || \
( ( (len) == 1 ) && \
( ( (head_ptr) != (tail_ptr) ) || ( (Size) <= 0 ) || \
( (head_ptr) == NULL ) || ( (head_ptr)->size != (Size) ) \
) \
) || \
( ( (len) >= 1 ) && \
( ( (head_ptr) == NULL ) || ( (head_ptr)->aux_prev != NULL ) || \
( (tail_ptr) == NULL ) || ( (tail_ptr)->aux_next != NULL ) \
) \
) \
) { \
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, (fv), "AUX DLL sanity check failed") \
}

◆ H5C__DELETE_FROM_INDEX

#define H5C__DELETE_FROM_INDEX (   cache_ptr,
  entry_ptr,
  fail_val 
)

◆ H5C__DLL_APPEND

#define H5C__DLL_APPEND (   entry_ptr,
  head_ptr,
  tail_ptr,
  len,
  Size,
  fail_val 
)
Value:
{ \
H5C__DLL_PRE_INSERT_SC(entry_ptr, head_ptr, tail_ptr, len, Size, \
fail_val) \
if ( (head_ptr) == NULL ) \
{ \
(head_ptr) = (entry_ptr); \
(tail_ptr) = (entry_ptr); \
} \
else \
{ \
(tail_ptr)->next = (entry_ptr); \
(entry_ptr)->prev = (tail_ptr); \
(tail_ptr) = (entry_ptr); \
} \
(len)++; \
(Size) += (entry_ptr)->size; \
} /* H5C__DLL_APPEND() */

◆ H5C__DLL_POST_SIZE_UPDATE_SC

#define H5C__DLL_POST_SIZE_UPDATE_SC (   dll_len,
  dll_size,
  old_size,
  new_size 
)
Value:
if ( ( (new_size) > (dll_size) ) || \
( ( (dll_len) == 1 ) && ( (new_size) != (dll_size) ) ) ) { \
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "DLL post size update SC failed") \
}

◆ H5C__DLL_PRE_INSERT_SC

#define H5C__DLL_PRE_INSERT_SC (   entry_ptr,
  head_ptr,
  tail_ptr,
  len,
  Size,
  fv 
)
Value:
if ( ( (entry_ptr) == NULL ) || \
( (entry_ptr)->next != NULL ) || \
( (entry_ptr)->prev != NULL ) || \
( ( ( (head_ptr) == NULL ) || ( (tail_ptr) == NULL ) ) && \
( (head_ptr) != (tail_ptr) ) \
) || \
( ( (len) == 1 ) && \
( ( (head_ptr) != (tail_ptr) ) || \
( (head_ptr) == NULL ) || ( (head_ptr)->size != (Size) ) \
) \
) || \
( ( (len) >= 1 ) && \
( ( (head_ptr) == NULL ) || ( (head_ptr)->prev != NULL ) || \
( (tail_ptr) == NULL ) || ( (tail_ptr)->next != NULL ) \
) \
) \
) { \
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, (fv), "DLL pre insert SC failed") \
}

◆ H5C__DLL_PRE_REMOVE_SC

#define H5C__DLL_PRE_REMOVE_SC (   entry_ptr,
  head_ptr,
  tail_ptr,
  len,
  Size,
  fv 
)
Value:
if ( ( (head_ptr) == NULL ) || \
( (tail_ptr) == NULL ) || \
( (entry_ptr) == NULL ) || \
( (len) <= 0 ) || \
( (Size) < (entry_ptr)->size ) || \
( ( (entry_ptr)->prev == NULL ) && ( (head_ptr) != (entry_ptr) ) ) || \
( ( (entry_ptr)->next == NULL ) && ( (tail_ptr) != (entry_ptr) ) ) || \
( ( (len) == 1 ) && \
( ! ( ( (head_ptr) == (entry_ptr) ) && \
( (tail_ptr) == (entry_ptr) ) && \
( (entry_ptr)->next == NULL ) && \
( (entry_ptr)->prev == NULL ) && \
( (Size) == (entry_ptr)->size ) \
) \
) \
) \
) { \
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, (fv), "DLL pre remove SC failed") \
}

◆ H5C__DLL_PRE_SIZE_UPDATE_SC

#define H5C__DLL_PRE_SIZE_UPDATE_SC (   dll_len,
  dll_size,
  old_size,
  new_size 
)
Value:
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, "DLL pre size update SC failed") \
}

◆ H5C__DLL_PREPEND

#define H5C__DLL_PREPEND (   entry_ptr,
  head_ptr,
  tail_ptr,
  len,
  Size,
  fail_val 
)
Value:
{ \
H5C__DLL_PRE_INSERT_SC(entry_ptr, head_ptr, tail_ptr, len, Size, \
fail_val) \
if ( (head_ptr) == NULL ) \
{ \
(head_ptr) = (entry_ptr); \
(tail_ptr) = (entry_ptr); \
} \
else \
{ \
(head_ptr)->prev = (entry_ptr); \
(entry_ptr)->next = (head_ptr); \
(head_ptr) = (entry_ptr); \
} \
(len)++; \
(Size) += entry_ptr->size; \
} /* H5C__DLL_PREPEND() */

◆ H5C__DLL_REMOVE

#define H5C__DLL_REMOVE (   entry_ptr,
  head_ptr,
  tail_ptr,
  len,
  Size,
  fail_val 
)
Value:
{ \
H5C__DLL_PRE_REMOVE_SC(entry_ptr, head_ptr, tail_ptr, len, Size, \
fail_val) \
{ \
if ( (head_ptr) == (entry_ptr) ) \
{ \
(head_ptr) = (entry_ptr)->next; \
if ( (head_ptr) != NULL ) \
(head_ptr)->prev = NULL; \
} \
else \
(entry_ptr)->prev->next = (entry_ptr)->next; \
if ( (tail_ptr) == (entry_ptr) ) \
{ \
(tail_ptr) = (entry_ptr)->prev; \
if ( (tail_ptr) != NULL ) \
(tail_ptr)->next = NULL; \
} \
else \
(entry_ptr)->next->prev = (entry_ptr)->prev; \
entry_ptr->next = NULL; \
entry_ptr->prev = NULL; \
(len)--; \
(Size) -= entry_ptr->size; \
} \
} /* H5C__DLL_REMOVE() */

◆ H5C__DLL_SC

#define H5C__DLL_SC (   head_ptr,
  tail_ptr,
  len,
  Size,
  fv 
)
Value:
if ( ( ( ( (head_ptr) == NULL ) || ( (tail_ptr) == NULL ) ) && \
( (head_ptr) != (tail_ptr) ) \
) || \
( (len) < 0 ) || \
( (Size) < 0 ) || \
( ( (len) == 1 ) && \
( ( (head_ptr) != (tail_ptr) ) || \
( (head_ptr) == NULL ) || ( (head_ptr)->size != (Size) ) \
) \
) || \
( ( (len) >= 1 ) && \
( ( (head_ptr) == NULL ) || ( (head_ptr)->prev != NULL ) || \
( (tail_ptr) == NULL ) || ( (tail_ptr)->next != NULL ) \
) \
) \
) { \
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, (fv), "DLL sanity check failed") \
}

◆ H5C__DLL_UPDATE_FOR_SIZE_CHANGE

#define H5C__DLL_UPDATE_FOR_SIZE_CHANGE (   dll_len,
  dll_size,
  old_size,
  new_size 
)
Value:
{ \
H5C__DLL_PRE_SIZE_UPDATE_SC(dll_len, dll_size, old_size, new_size) \
(dll_size) -= (old_size); \
(dll_size) += (new_size); \
H5C__DLL_POST_SIZE_UPDATE_SC(dll_len, dll_size, old_size, new_size) \
} /* H5C__DLL_UPDATE_FOR_SIZE_CHANGE() */

◆ H5C__FAKE_RP_FOR_MOST_RECENT_ACCESS

#define H5C__FAKE_RP_FOR_MOST_RECENT_ACCESS (   cache_ptr,
  entry_ptr,
  fail_val 
)
Value:
{ \
HDassert( (cache_ptr) ); \
HDassert( (cache_ptr)->magic == H5C__H5C_T_MAGIC ); \
HDassert( (entry_ptr) ); \
HDassert( !((entry_ptr)->is_protected) ); \
HDassert( !((entry_ptr)->is_read_only) ); \
HDassert( ((entry_ptr)->ro_ref_count) == 0 ); \
HDassert( (entry_ptr)->size > 0 ); \
\
if ( ! ((entry_ptr)->is_pinned) ) { \
\
/* modified LRU specific code */ \
\
/* 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)) \
\
/* End modified LRU specific code. */ \
} \
} /* H5C__FAKE_RP_FOR_MOST_RECENT_ACCESS */

◆ H5C__H5C_T_MAGIC

#define H5C__H5C_T_MAGIC   0x005CAC0E

◆ H5C__HASH_FCN

#define H5C__HASH_FCN (   x)    (int)((unsigned)((x) & H5C__HASH_MASK) >> 3)

◆ H5C__HASH_MASK

#define H5C__HASH_MASK   ((size_t)(H5C__HASH_TABLE_LEN - 1) << 3)

◆ H5C__HASH_TABLE_LEN

#define H5C__HASH_TABLE_LEN   (64 * 1024) /* must be a power of 2 */

◆ H5C__IL_DLL_APPEND

#define H5C__IL_DLL_APPEND (   entry_ptr,
  head_ptr,
  tail_ptr,
  len,
  Size,
  fail_val 
)
Value:
{ \
H5C__IL_DLL_PRE_INSERT_SC(entry_ptr, head_ptr, tail_ptr, len, Size, \
fail_val) \
if ( (head_ptr) == NULL ) \
{ \
(head_ptr) = (entry_ptr); \
(tail_ptr) = (entry_ptr); \
} \
else \
{ \
(tail_ptr)->il_next = (entry_ptr); \
(entry_ptr)->il_prev = (tail_ptr); \
(tail_ptr) = (entry_ptr); \
} \
(len)++; \
(Size) += entry_ptr->size; \
H5C__IL_DLL_SC(head_ptr, tail_ptr, len, Size, fail_val) \
} /* H5C__IL_DLL_APPEND() */

◆ H5C__IL_DLL_PRE_INSERT_SC

#define H5C__IL_DLL_PRE_INSERT_SC (   entry_ptr,
  hd_ptr,
  tail_ptr,
  len,
  Size,
  fv 
)
Value:
if ( ( (entry_ptr) == NULL ) || \
( (entry_ptr)->il_next != NULL ) || \
( (entry_ptr)->il_prev != NULL ) || \
( ( ( (hd_ptr) == NULL ) || ( (tail_ptr) == NULL ) ) && \
( (hd_ptr) != (tail_ptr) ) \
) || \
( ( (len) == 1 ) && \
( ( (hd_ptr) != (tail_ptr) ) || ( (Size) <= 0 ) || \
( (hd_ptr) == NULL ) || ( (hd_ptr)->size != (Size) ) \
) \
) || \
( ( (len) >= 1 ) && \
( ( (hd_ptr) == NULL ) || ( (hd_ptr)->il_prev != NULL ) || \
( (tail_ptr) == NULL ) || ( (tail_ptr)->il_next != NULL ) \
) \
) \
) { \
HDassert(0 && "IL DLL pre insert SC failed"); \
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, (fv), "IL DLL pre insert SC failed") \
}

◆ H5C__IL_DLL_PRE_REMOVE_SC

#define H5C__IL_DLL_PRE_REMOVE_SC (   entry_ptr,
  hd_ptr,
  tail_ptr,
  len,
  Size,
  fv 
)
Value:
if ( ( (hd_ptr) == NULL ) || \
( (tail_ptr) == NULL ) || \
( (entry_ptr) == NULL ) || \
( (len) <= 0 ) || \
( (Size) < (entry_ptr)->size ) || \
( ( (Size) == (entry_ptr)->size ) && ( ! ( (len) == 1 ) ) ) || \
( ( (entry_ptr)->il_prev == NULL ) && ( (hd_ptr) != (entry_ptr) ) ) || \
( ( (entry_ptr)->il_next == NULL ) && ( (tail_ptr) != (entry_ptr) ) ) || \
( ( (len) == 1 ) && \
( ! ( ( (hd_ptr) == (entry_ptr) ) && ( (tail_ptr) == (entry_ptr) ) && \
( (entry_ptr)->il_next == NULL ) && \
( (entry_ptr)->il_prev == NULL ) && \
( (Size) == (entry_ptr)->size ) \
) \
) \
) \
) { \
HDassert(0 && "il DLL pre remove SC failed"); \
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, (fv), "il DLL pre remove SC failed") \
}

◆ H5C__IL_DLL_REMOVE

#define H5C__IL_DLL_REMOVE (   entry_ptr,
  head_ptr,
  tail_ptr,
  len,
  Size,
  fv 
)
Value:
{ \
H5C__IL_DLL_PRE_REMOVE_SC(entry_ptr, head_ptr, tail_ptr, len, Size, fv) \
{ \
if ( (head_ptr) == (entry_ptr) ) \
{ \
(head_ptr) = (entry_ptr)->il_next; \
if ( (head_ptr) != NULL ) \
(head_ptr)->il_prev = NULL; \
} \
else \
(entry_ptr)->il_prev->il_next = (entry_ptr)->il_next; \
if ( (tail_ptr) == (entry_ptr) ) \
{ \
(tail_ptr) = (entry_ptr)->il_prev; \
if ( (tail_ptr) != NULL ) \
(tail_ptr)->il_next = NULL; \
} \
else \
(entry_ptr)->il_next->il_prev = (entry_ptr)->il_prev; \
entry_ptr->il_next = NULL; \
entry_ptr->il_prev = NULL; \
(len)--; \
(Size) -= entry_ptr->size; \
} \
H5C__IL_DLL_SC(head_ptr, tail_ptr, len, Size, fv) \
} /* H5C__IL_DLL_REMOVE() */

◆ H5C__IL_DLL_SC

#define H5C__IL_DLL_SC (   head_ptr,
  tail_ptr,
  len,
  Size,
  fv 
)
Value:
if ( ( ( ( (head_ptr) == NULL ) || ( (tail_ptr) == NULL ) ) && \
( (head_ptr) != (tail_ptr) ) \
) || \
( ( (len) == 1 ) && \
( ( (head_ptr) != (tail_ptr) ) || \
( (head_ptr) == NULL ) || ( (head_ptr)->size != (Size) ) \
) \
) || \
( ( (len) >= 1 ) && \
( ( (head_ptr) == NULL ) || ( (head_ptr)->il_prev != NULL ) || \
( (tail_ptr) == NULL ) || ( (tail_ptr)->il_next != NULL ) \
) \
) \
) { \
HDassert(0 && "IL DLL sanity check failed"); \
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, (fv), "IL DLL sanity check failed") \
}

◆ H5C__INSERT_ENTRY_IN_SLIST

#define H5C__INSERT_ENTRY_IN_SLIST (   cache_ptr,
  entry_ptr,
  fail_val 
)

◆ H5C__INSERT_IN_INDEX

#define H5C__INSERT_IN_INDEX (   cache_ptr,
  entry_ptr,
  fail_val 
)

◆ H5C__MAX_EPOCH_MARKERS

#define H5C__MAX_EPOCH_MARKERS   10

◆ H5C__POST_HT_ENTRY_SIZE_CHANGE_SC

#define H5C__POST_HT_ENTRY_SIZE_CHANGE_SC (   cache_ptr,
  old_size,
  new_size,
  entry_ptr 
)
Value:
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 ) ) { \
HDassert(FALSE); \
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "post HT entry size change SC failed") \
}

◆ H5C__POST_HT_INSERT_SC

#define H5C__POST_HT_INSERT_SC (   cache_ptr,
  entry_ptr,
  fail_val 
)
Value:
if ( ( (cache_ptr) == NULL ) || \
( (cache_ptr)->magic != H5C__H5C_T_MAGIC ) || \
( (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) ) { \
HDassert(FALSE); \
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, fail_val, "post HT insert SC failed") \
}

◆ H5C__POST_HT_REMOVE_SC

#define H5C__POST_HT_REMOVE_SC (   cache_ptr,
  entry_ptr 
)
Value:
if ( ( (cache_ptr) == NULL ) || \
( (cache_ptr)->magic != H5C__H5C_T_MAGIC ) || \
( (entry_ptr) == NULL ) || \
( ! H5F_addr_defined((entry_ptr)->addr) ) || \
( (entry_ptr)->size <= 0 ) || \
( (entry_ptr)->ht_prev != 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 ) ) { \
HDassert(FALSE); \
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "post HT remove SC failed") \
}

◆ H5C__POST_HT_SHIFT_TO_FRONT

#define H5C__POST_HT_SHIFT_TO_FRONT (   cache_ptr,
  entry_ptr,
  k,
  fail_val 
)
Value:
if ( ( (cache_ptr) == NULL ) || \
( ((cache_ptr)->index)[k] != (entry_ptr) ) || \
( (entry_ptr)->ht_prev != NULL ) ) { \
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, fail_val, "post HT shift to front SC failed") \
}

◆ H5C__POST_HT_UPDATE_FOR_ENTRY_CLEAN_SC

#define H5C__POST_HT_UPDATE_FOR_ENTRY_CLEAN_SC (   cache_ptr,
  entry_ptr 
)
Value:
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]) ) ) { \
HDassert(FALSE); \
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "post HT update for entry clean SC failed") \
}

◆ H5C__POST_HT_UPDATE_FOR_ENTRY_DIRTY_SC

#define H5C__POST_HT_UPDATE_FOR_ENTRY_DIRTY_SC (   cache_ptr,
  entry_ptr 
)
Value:
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]) ) ) { \
HDassert(FALSE); \
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "post HT update for entry dirty SC failed") \
}

◆ H5C__POST_SUC_HT_SEARCH_SC

#define H5C__POST_SUC_HT_SEARCH_SC (   cache_ptr,
  entry_ptr,
  k,
  fail_val 
)
Value:
if ( ( (cache_ptr) == NULL ) || \
( (cache_ptr)->magic != H5C__H5C_T_MAGIC ) || \
( (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) ) ) ) { \
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, fail_val, "post successful HT search SC failed") \
}

◆ H5C__PRE_HT_ENTRY_SIZE_CHANGE_SC

#define H5C__PRE_HT_ENTRY_SIZE_CHANGE_SC (   cache_ptr,
  old_size,
  new_size,
  entry_ptr,
  was_clean 
)

◆ H5C__PRE_HT_INSERT_SC

#define H5C__PRE_HT_INSERT_SC (   cache_ptr,
  entry_ptr,
  fail_val 
)
Value:
if ( ( (cache_ptr) == NULL ) || \
( (cache_ptr)->magic != H5C__H5C_T_MAGIC ) || \
( (entry_ptr) == NULL ) || \
( ! H5F_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 ) ) { \
HDassert(FALSE); \
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, fail_val, "pre HT insert SC failed") \
}

◆ H5C__PRE_HT_REMOVE_SC

#define H5C__PRE_HT_REMOVE_SC (   cache_ptr,
  entry_ptr 
)

◆ H5C__PRE_HT_SEARCH_SC

#define H5C__PRE_HT_SEARCH_SC (   cache_ptr,
  Addr,
  fail_val 
)
Value:
if ( ( (cache_ptr) == NULL ) || \
( (cache_ptr)->magic != H5C__H5C_T_MAGIC ) || \
( (cache_ptr)->index_size != \
((cache_ptr)->clean_index_size + (cache_ptr)->dirty_index_size) ) || \
( ! H5F_addr_defined(Addr) ) || \
( H5C__HASH_FCN(Addr) < 0 ) || \
( H5C__HASH_FCN(Addr) >= H5C__HASH_TABLE_LEN ) ) { \
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, fail_val, "pre HT search SC failed") \
}

◆ H5C__PRE_HT_UPDATE_FOR_ENTRY_CLEAN_SC

#define H5C__PRE_HT_UPDATE_FOR_ENTRY_CLEAN_SC (   cache_ptr,
  entry_ptr 
)
Value:
if ( \
( (cache_ptr) == NULL ) || \
( (cache_ptr)->magic != H5C__H5C_T_MAGIC ) || \
( (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]) ) ) { \
HDassert(FALSE); \
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "pre HT update for entry clean SC failed") \
}

◆ H5C__PRE_HT_UPDATE_FOR_ENTRY_DIRTY_SC

#define H5C__PRE_HT_UPDATE_FOR_ENTRY_DIRTY_SC (   cache_ptr,
  entry_ptr 
)
Value:
if ( \
( (cache_ptr) == NULL ) || \
( (cache_ptr)->magic != H5C__H5C_T_MAGIC ) || \
( (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]) ) ) { \
HDassert(FALSE); \
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "pre HT update for entry dirty SC failed") \
}

◆ H5C__REMOVE_ENTRY_FROM_SLIST

#define H5C__REMOVE_ENTRY_FROM_SLIST (   cache_ptr,
  entry_ptr,
  during_flush 
)

◆ H5C__RESET_CACHE_ENTRY_STATS

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

◆ H5C__SEARCH_INDEX

#define H5C__SEARCH_INDEX (   cache_ptr,
  Addr,
  entry_ptr,
  fail_val 
)
Value:
{ \
int k; \
int depth = 0; \
H5C__PRE_HT_SEARCH_SC(cache_ptr, Addr, fail_val) \
k = H5C__HASH_FCN(Addr); \
entry_ptr = ((cache_ptr)->index)[k]; \
while(entry_ptr) { \
if(H5F_addr_eq(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; \
HDassert((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(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) \
}

◆ H5C__SEARCH_INDEX_NO_STATS

#define H5C__SEARCH_INDEX_NO_STATS (   cache_ptr,
  Addr,
  entry_ptr,
  fail_val 
)
Value:
{ \
int k; \
H5C__PRE_HT_SEARCH_SC(cache_ptr, Addr, fail_val) \
k = H5C__HASH_FCN(Addr); \
entry_ptr = ((cache_ptr)->index)[k]; \
while(entry_ptr) { \
if(H5F_addr_eq(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; \
HDassert((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(cache_ptr, entry_ptr, k, fail_val) \
} \
break; \
} \
(entry_ptr) = (entry_ptr)->ht_next; \
} \
}

◆ H5C__UPDATE_CACHE_HIT_RATE_STATS

#define H5C__UPDATE_CACHE_HIT_RATE_STATS (   cache_ptr,
  hit 
)
Value:
(cache_ptr->cache_accesses)++; \
if ( hit ) { \
(cache_ptr->cache_hits)++; \
} \

◆ H5C__UPDATE_INDEX_FOR_ENTRY_CLEAN

#define H5C__UPDATE_INDEX_FOR_ENTRY_CLEAN (   cache_ptr,
  entry_ptr 
)
Value:
{ \
H5C__PRE_HT_UPDATE_FOR_ENTRY_CLEAN_SC(cache_ptr, entry_ptr); \
(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); \
}

◆ H5C__UPDATE_INDEX_FOR_ENTRY_DIRTY

#define H5C__UPDATE_INDEX_FOR_ENTRY_DIRTY (   cache_ptr,
  entry_ptr 
)
Value:
{ \
H5C__PRE_HT_UPDATE_FOR_ENTRY_DIRTY_SC(cache_ptr, entry_ptr); \
(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); \
}

◆ H5C__UPDATE_INDEX_FOR_SIZE_CHANGE

#define H5C__UPDATE_INDEX_FOR_SIZE_CHANGE (   cache_ptr,
  old_size,
  new_size,
  entry_ptr,
  was_clean 
)
Value:
{ \
H5C__PRE_HT_ENTRY_SIZE_CHANGE_SC(cache_ptr, old_size, new_size, \
entry_ptr, was_clean) \
(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)) \
H5C__POST_HT_ENTRY_SIZE_CHANGE_SC(cache_ptr, old_size, new_size, \
entry_ptr) \
}

◆ H5C__UPDATE_MAX_INDEX_SIZE_STATS

#define H5C__UPDATE_MAX_INDEX_SIZE_STATS (   cache_ptr)
Value:
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;

◆ H5C__UPDATE_RP_FOR_EVICTION

#define H5C__UPDATE_RP_FOR_EVICTION (   cache_ptr,
  entry_ptr,
  fail_val 
)
Value:
{ \
HDassert( (cache_ptr) ); \
HDassert( (cache_ptr)->magic == H5C__H5C_T_MAGIC ); \
HDassert( (entry_ptr) ); \
HDassert( !((entry_ptr)->is_protected) ); \
HDassert( !((entry_ptr)->is_read_only) ); \
HDassert( ((entry_ptr)->ro_ref_count) == 0 ); \
HDassert( !((entry_ptr)->is_pinned) ); \
HDassert( (entry_ptr)->size > 0 ); \
\
/* modified LRU specific code */ \
\
/* 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)) \
\
} /* H5C__UPDATE_RP_FOR_EVICTION */

◆ H5C__UPDATE_RP_FOR_FLUSH

#define H5C__UPDATE_RP_FOR_FLUSH (   cache_ptr,
  entry_ptr,
  fail_val 
)
Value:
{ \
HDassert( (cache_ptr) ); \
HDassert( (cache_ptr)->magic == H5C__H5C_T_MAGIC ); \
HDassert( (entry_ptr) ); \
HDassert( !((entry_ptr)->is_protected) ); \
HDassert( !((entry_ptr)->is_read_only) ); \
HDassert( ((entry_ptr)->ro_ref_count) == 0 ); \
HDassert( (entry_ptr)->size > 0 ); \
\
if ( ! ((entry_ptr)->is_pinned) ) { \
\
/* modified LRU specific code */ \
\
/* 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)) \
\
/* End modified LRU specific code. */ \
} \
} /* H5C__UPDATE_RP_FOR_FLUSH */

◆ H5C__UPDATE_RP_FOR_INSERT_APPEND

#define H5C__UPDATE_RP_FOR_INSERT_APPEND (   cache_ptr,
  entry_ptr,
  fail_val 
)
Value:
{ \
HDassert( (cache_ptr) ); \
HDassert( (cache_ptr)->magic == H5C__H5C_T_MAGIC ); \
HDassert( (entry_ptr) ); \
HDassert( !((entry_ptr)->is_protected) ); \
HDassert( !((entry_ptr)->is_read_only) ); \
HDassert( ((entry_ptr)->ro_ref_count) == 0 ); \
HDassert( (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 { \
\
/* modified LRU specific code */ \
\
/* 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)) \
\
/* End modified LRU specific code. */ \
} \
}

◆ H5C__UPDATE_RP_FOR_INSERTION

#define H5C__UPDATE_RP_FOR_INSERTION (   cache_ptr,
  entry_ptr,
  fail_val 
)
Value:
{ \
HDassert( (cache_ptr) ); \
HDassert( (cache_ptr)->magic == H5C__H5C_T_MAGIC ); \
HDassert( (entry_ptr) ); \
HDassert( !((entry_ptr)->is_protected) ); \
HDassert( !((entry_ptr)->is_read_only) ); \
HDassert( ((entry_ptr)->ro_ref_count) == 0 ); \
HDassert( (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 { \
\
/* modified LRU specific code */ \
\
/* 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)) \
\
/* End modified LRU specific code. */ \
} \
}

◆ H5C__UPDATE_RP_FOR_MOVE

#define H5C__UPDATE_RP_FOR_MOVE (   cache_ptr,
  entry_ptr,
  was_dirty,
  fail_val 
)
Value:
{ \
HDassert( (cache_ptr) ); \
HDassert( (cache_ptr)->magic == H5C__H5C_T_MAGIC ); \
HDassert( (entry_ptr) ); \
HDassert( !((entry_ptr)->is_read_only) ); \
HDassert( ((entry_ptr)->ro_ref_count) == 0 ); \
HDassert( (entry_ptr)->size > 0 ); \
\
if ( ! ( (entry_ptr)->is_pinned ) && ! ( (entry_ptr->is_protected ) ) ) { \
\
/* modified LRU specific code */ \
\
/* 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)) \
\
/* End modified LRU specific code. */ \
} \
} /* H5C__UPDATE_RP_FOR_MOVE */

◆ H5C__UPDATE_RP_FOR_PROTECT

#define H5C__UPDATE_RP_FOR_PROTECT (   cache_ptr,
  entry_ptr,
  fail_val 
)

◆ H5C__UPDATE_RP_FOR_SIZE_CHANGE

#define H5C__UPDATE_RP_FOR_SIZE_CHANGE (   cache_ptr,
  entry_ptr,
  new_size 
)

◆ H5C__UPDATE_RP_FOR_UNPIN

#define H5C__UPDATE_RP_FOR_UNPIN (   cache_ptr,
  entry_ptr,
  fail_val 
)
Value:
{ \
HDassert( (cache_ptr) ); \
HDassert( (cache_ptr)->magic == H5C__H5C_T_MAGIC ); \
HDassert( (entry_ptr) ); \
HDassert( !((entry_ptr)->is_protected) ); \
HDassert( !((entry_ptr)->is_read_only) ); \
HDassert( ((entry_ptr)->ro_ref_count) == 0 ); \
HDassert( (entry_ptr)->is_pinned); \
HDassert( (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)) \
\
/* modified LRU specific code */ \
\
/* 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)) \
\
/* End modified LRU specific code. */ \
\
} /* H5C__UPDATE_RP_FOR_UNPIN */

◆ H5C__UPDATE_RP_FOR_UNPROTECT

#define H5C__UPDATE_RP_FOR_UNPROTECT (   cache_ptr,
  entry_ptr,
  fail_val 
)

◆ H5C__UPDATE_SLIST_FOR_SIZE_CHANGE

#define H5C__UPDATE_SLIST_FOR_SIZE_CHANGE (   cache_ptr,
  old_size,
  new_size 
)
Value:
{ \
HDassert( (cache_ptr) ); \
HDassert( (cache_ptr)->magic == H5C__H5C_T_MAGIC ); \
HDassert( (old_size) > 0 ); \
HDassert( (new_size) > 0 ); \
HDassert( (old_size) <= (cache_ptr)->slist_size ); \
HDassert( (cache_ptr)->slist_len > 0 ); \
HDassert( ((cache_ptr)->slist_len > 1) || \
( (cache_ptr)->slist_size == (old_size) ) ); \
HDassert( (entry_ptr)->ring > H5C_RING_UNDEFINED ); \
HDassert( (entry_ptr)->ring < H5C_RING_NTYPES ); \
HDassert( (cache_ptr)->slist_ring_len[(entry_ptr)->ring] <= \
(cache_ptr)->slist_len ); \
HDassert( (cache_ptr)->slist_ring_size[(entry_ptr)->ring] <= \
(cache_ptr)->slist_size ); \
\
(cache_ptr)->slist_size -= (old_size); \
(cache_ptr)->slist_size += (new_size); \
\
HDassert( (cache_ptr)->slist_ring_size[(entry_ptr->ring)] >=(old_size) ); \
((cache_ptr)->slist_ring_size[(entry_ptr)->ring]) -= (old_size); \
((cache_ptr)->slist_ring_size[(entry_ptr)->ring]) += (new_size); \
\
(cache_ptr)->slist_size_increase -= (int64_t)(old_size); \
(cache_ptr)->slist_size_increase += (int64_t)(new_size); \
\
HDassert( (new_size) <= (cache_ptr)->slist_size ); \
HDassert( ( (cache_ptr)->slist_len > 1 ) || \
( (cache_ptr)->slist_size == (new_size) ) ); \
} /* H5C__UPDATE_SLIST_FOR_SIZE_CHANGE */

◆ H5C__UPDATE_STATS_FOR_CACHE_IMAGE_CREATE

#define H5C__UPDATE_STATS_FOR_CACHE_IMAGE_CREATE (   cache_ptr)
Value:
{ \
(cache_ptr)->images_created++; \
}

◆ H5C__UPDATE_STATS_FOR_CACHE_IMAGE_LOAD

#define H5C__UPDATE_STATS_FOR_CACHE_IMAGE_LOAD (   cache_ptr)
Value:
{ \
/* make sure image len is still good */ \
HDassert((cache_ptr)->image_len > 0); \
(cache_ptr)->images_loaded++; \
(cache_ptr)->last_image_size = (cache_ptr)->image_len; \
}

◆ H5C__UPDATE_STATS_FOR_CACHE_IMAGE_READ

#define H5C__UPDATE_STATS_FOR_CACHE_IMAGE_READ (   cache_ptr)
Value:
{ \
/* make sure image len is still good */ \
HDassert((cache_ptr)->image_len > 0); \
(cache_ptr)->images_read++; \
}

◆ H5C__UPDATE_STATS_FOR_CLEAR

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

◆ H5C__UPDATE_STATS_FOR_DIRTY_PIN

#define H5C__UPDATE_STATS_FOR_DIRTY_PIN (   cache_ptr,
  entry_ptr 
)    (((cache_ptr)->dirty_pins)[(entry_ptr)->type->id])++;

◆ H5C__UPDATE_STATS_FOR_ENTRY_SIZE_CHANGE

#define H5C__UPDATE_STATS_FOR_ENTRY_SIZE_CHANGE (   cache_ptr,
  entry_ptr,
  new_size 
)
Value:
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])++; \
}

◆ H5C__UPDATE_STATS_FOR_EVICTION

#define H5C__UPDATE_STATS_FOR_EVICTION (   cache_ptr,
  entry_ptr,
  take_ownership 
)
Value:
{ \
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; \
}

◆ H5C__UPDATE_STATS_FOR_FLUSH

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

◆ H5C__UPDATE_STATS_FOR_HT_DELETION

#define H5C__UPDATE_STATS_FOR_HT_DELETION (   cache_ptr)    (cache_ptr)->total_ht_deletions++;

◆ H5C__UPDATE_STATS_FOR_HT_INSERTION

#define H5C__UPDATE_STATS_FOR_HT_INSERTION (   cache_ptr)    (cache_ptr)->total_ht_insertions++;

◆ H5C__UPDATE_STATS_FOR_HT_SEARCH

#define H5C__UPDATE_STATS_FOR_HT_SEARCH (   cache_ptr,
  success,
  depth 
)
Value:
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; \
}

◆ H5C__UPDATE_STATS_FOR_INDEX_SCAN_RESTART

#define H5C__UPDATE_STATS_FOR_INDEX_SCAN_RESTART (   cache_ptr)    ((cache_ptr)->index_scan_restarts)++;

◆ H5C__UPDATE_STATS_FOR_INSERTION

#define H5C__UPDATE_STATS_FOR_INSERTION (   cache_ptr,
  entry_ptr 
)
Value:
{ \
(((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++; \
}

◆ H5C__UPDATE_STATS_FOR_LRU_SCAN_RESTART

#define H5C__UPDATE_STATS_FOR_LRU_SCAN_RESTART (   cache_ptr)    ((cache_ptr)->LRU_scan_restarts)++;

◆ H5C__UPDATE_STATS_FOR_MOVE

#define H5C__UPDATE_STATS_FOR_MOVE (   cache_ptr,
  entry_ptr 
)
Value:
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++;

◆ H5C__UPDATE_STATS_FOR_PIN

#define H5C__UPDATE_STATS_FOR_PIN (   cache_ptr,
  entry_ptr 
)
Value:
{ \
((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; \
}

◆ H5C__UPDATE_STATS_FOR_PREFETCH

#define H5C__UPDATE_STATS_FOR_PREFETCH (   cache_ptr,
  dirty 
)
Value:
{ \
(cache_ptr)->prefetches++; \
if ( dirty ) \
(cache_ptr)->dirty_prefetches++; \
}

◆ H5C__UPDATE_STATS_FOR_PREFETCH_HIT

#define H5C__UPDATE_STATS_FOR_PREFETCH_HIT (   cache_ptr)
Value:
{ \
(cache_ptr)->prefetch_hits++; \
}

◆ H5C__UPDATE_STATS_FOR_PROTECT

#define H5C__UPDATE_STATS_FOR_PROTECT (   cache_ptr,
  entry_ptr,
  hit 
)
Value:
{ \
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)++; \
}

◆ H5C__UPDATE_STATS_FOR_SLIST_SCAN_RESTART

#define H5C__UPDATE_STATS_FOR_SLIST_SCAN_RESTART (   cache_ptr)    ((cache_ptr)->slist_scan_restarts)++;

◆ H5C__UPDATE_STATS_FOR_UNPIN

#define H5C__UPDATE_STATS_FOR_UNPIN (   cache_ptr,
  entry_ptr 
)    ((cache_ptr)->unpins)[(entry_ptr)->type->id]++;

◆ H5C__UPDATE_STATS_FOR_UNPROTECT

#define H5C__UPDATE_STATS_FOR_UNPROTECT (   cache_ptr)
Value:
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;

◆ H5C_FLUSH_DEP_PARENT_INIT

#define H5C_FLUSH_DEP_PARENT_INIT   8

Typedef Documentation

◆ H5C_tag_info_t

typedef struct H5C_tag_info_t H5C_tag_info_t

◆ H5C_tag_iter_cb_t

typedef int(* H5C_tag_iter_cb_t) (H5C_cache_entry_t *entry, void *ctx)

Function Documentation

◆ H5C__deserialize_prefetched_entry()

H5_DLL herr_t H5C__deserialize_prefetched_entry ( H5F_t *  f,
H5C_t *  cache_ptr,
H5C_cache_entry_t **  entry_ptr_ptr,
const H5C_class_t *  type,
haddr_t  addr,
void *  udata 
)

◆ H5C__flush_marked_entries()

H5_DLL herr_t H5C__flush_marked_entries ( H5F_t *  f)

◆ H5C__flush_single_entry()

H5_DLL herr_t H5C__flush_single_entry ( H5F_t *  f,
H5C_cache_entry_t *  entry_ptr,
unsigned  flags 
)

◆ H5C__generate_cache_image()

H5_DLL herr_t H5C__generate_cache_image ( H5F_t *  f,
H5C_t *  cache_ptr 
)

◆ H5C__generate_image()

H5_DLL herr_t H5C__generate_image ( H5F_t *  f,
H5C_t *  cache_ptr,
H5C_cache_entry_t *  entry_ptr 
)

◆ H5C__iter_tagged_entries()

H5_DLL herr_t H5C__iter_tagged_entries ( H5C_t *  cache,
haddr_t  tag,
hbool_t  match_global,
H5C_tag_iter_cb_t  cb,
void *  cb_ctx 
)

◆ H5C__load_cache_image()

H5_DLL herr_t H5C__load_cache_image ( H5F_t *  f)

◆ H5C__make_space_in_cache()

H5_DLL herr_t H5C__make_space_in_cache ( H5F_t *  f,
size_t  space_needed,
hbool_t  write_permitted 
)

◆ H5C__mark_flush_dep_serialized()

H5_DLL herr_t H5C__mark_flush_dep_serialized ( H5C_cache_entry_t *  entry_ptr)

◆ H5C__mark_flush_dep_unserialized()

H5_DLL herr_t H5C__mark_flush_dep_unserialized ( H5C_cache_entry_t *  entry_ptr)

◆ H5C__prep_image_for_file_close()

H5_DLL herr_t H5C__prep_image_for_file_close ( H5F_t *  f,
hbool_t *  image_generated 
)

◆ H5C__serialize_cache()

H5_DLL herr_t H5C__serialize_cache ( H5F_t *  f)

◆ H5C__tag_entry()

H5_DLL herr_t H5C__tag_entry ( H5C_t *  cache_ptr,
H5C_cache_entry_t *  entry_ptr 
)

◆ H5C__untag_entry()

H5_DLL herr_t H5C__untag_entry ( H5C_t *  cache,
H5C_cache_entry_t *  entry 
)
size
iblock size
Definition: H5EAcache.c:787
H5F_addr_defined
#define H5F_addr_defined(X)
Definition: H5Fprivate.h:253
H5C_RING_NTYPES
#define H5C_RING_NTYPES
Definition: H5Cprivate.h:962
H5C__DLL_REMOVE
#define H5C__DLL_REMOVE(entry_ptr, head_ptr, tail_ptr, len, Size, fail_val)
Definition: H5Cpkg.h:290
H5E_CACHE
Invalid arguments to routine Resource unavailable Internal File accessibility Low level I O Function entry exit Object atom H5E_CACHE
Definition: H5err.txt:53
H5C__H5C_T_MAGIC
#define H5C__H5C_T_MAGIC
Definition: H5Cpkg.h:52
H5C__DLL_PREPEND
#define H5C__DLL_PREPEND(entry_ptr, head_ptr, tail_ptr, len, Size, fail_val)
Definition: H5Cpkg.h:271
int64_t
int64_t
Definition: H5overflow.txt:35
HDassert
#define HDassert(X)
Definition: H5private.h:669
H5F_addr_eq
#define H5F_addr_eq(X, Y)
Definition: H5Fprivate.h:257
H5E_SYSTEM
Invalid arguments to routine Resource unavailable Internal File accessibility Low level I O Function entry exit Object atom Object cache Links B Tree node Symbol table Heap Object header Datatype Dataspace Dataset Data storage Property lists Attribute Data filters External file list References Virtual File Layer Virtual Object Layer Ternary Search Trees Reference Counted Strings Error API Skip Lists Free Space Manager Shared Object Header Messages Extensible Array Fixed Array Plugin for dynamically loaded library Page Buffering API Context Map No error Argument errors Resource errors File accessibility errors Generic low level file I O errors Function entry exit interface errors Object atom related errors Cache related errors Link related errors B tree related errors Object header related errors Group related errors Datatype conversion errors Dataspace errors Property list errors Parallel MPI errors Heap errors Free space errors I O pipeline errors System level errors Plugin errors No error Information is uinitialized Feature is unsupported Inappropriate type Out of range Bad value No space available for allocation Can t allocate space Unable to copy object Unable to free object Object already exists Unable to lock object Unable to unlock object Unable to garbage collect Unable to compute size Object is already open File already exists File already open Unable to create file Unable to open file Unable to close file Not an HDF5 file Bad file ID accessed File has been truncated File mount error Unable to delete file Seek failed Read failed Write failed Close failed Address overflowed File Unable to initialize object Object already initialized Unable to release object Unable to find atom Unable to find ID group information Unable to register new atom Unable to increment reference count Unable to decrement reference count Out of IDs for group Unable to flush data from cache Unable to mark metadata as unserialized Unable to serialize data from cache Unable to tag metadata in the cache Unable to load metadata into cache Protected metadata error Metadata not currently cached H5E_SYSTEM
Definition: H5err.txt:169
image_len
* image_len
Definition: H5EAcache.c:449
H5C__HASH_TABLE_LEN
#define H5C__HASH_TABLE_LEN
Definition: H5Cpkg.h:51
FAIL
#define FAIL
Definition: H5private.h:352
H5C_RING_UNDEFINED
#define H5C_RING_UNDEFINED
Definition: H5Cprivate.h:956
H5C__HASH_FCN
#define H5C__HASH_FCN(x)
Definition: H5Cpkg.h:986
H5C__DLL_APPEND
#define H5C__DLL_APPEND(entry_ptr, head_ptr, tail_ptr, len, Size, fail_val)
Definition: H5Cpkg.h:252
TRUE
#define TRUE
Definition: H5FDmulti.c:36
H5C__IL_DLL_SC
#define H5C__IL_DLL_SC(head_ptr, tail_ptr, len, Size, fv)
Definition: H5Cpkg.h:509
if
if(NULL==(iblock=H5EA__iblock_protect(hdr, thing_acc)))
Definition: H5EA.c:408
FALSE
#define FALSE
Definition: H5FDmulti.c:33
Generated by   doxygen 1.8.18