summaryrefslogtreecommitdiffstats
path: root/src/H5Cdbg.c
diff options
context:
space:
mode:
authorAllen Byrne <byrn@hdfgroup.org>2020-10-01 14:04:36 (GMT)
committerAllen Byrne <byrn@hdfgroup.org>2020-10-01 14:04:36 (GMT)
commitf1ba03cea5b82699a984c80bd2deac14fdc8df18 (patch)
treeebe777c3e0b83f4c4cec9212731da9ebe0a0cfd3 /src/H5Cdbg.c
parent10343c197906415388f2a4c8d292e21d25cf7381 (diff)
downloadhdf5-f1ba03cea5b82699a984c80bd2deac14fdc8df18.zip
hdf5-f1ba03cea5b82699a984c80bd2deac14fdc8df18.tar.gz
hdf5-f1ba03cea5b82699a984c80bd2deac14fdc8df18.tar.bz2
Source formatted
Diffstat (limited to 'src/H5Cdbg.c')
-rw-r--r--src/H5Cdbg.c1014
1 files changed, 416 insertions, 598 deletions
diff --git a/src/H5Cdbg.c b/src/H5Cdbg.c
index d820ca0..7dc7d34 100644
--- a/src/H5Cdbg.c
+++ b/src/H5Cdbg.c
@@ -26,50 +26,42 @@
/* Module Setup */
/****************/
-#include "H5Cmodule.h" /* This source code file is part of the H5C module */
-
+#include "H5Cmodule.h" /* This source code file is part of the H5C module */
/***********/
/* Headers */
/***********/
-#include "H5private.h" /* Generic Functions */
-#include "H5ACprivate.h" /* Metadata Cache */
-#include "H5Cpkg.h" /* Cache */
-#include "H5Eprivate.h" /* Error Handling */
-
+#include "H5private.h" /* Generic Functions */
+#include "H5ACprivate.h" /* Metadata Cache */
+#include "H5Cpkg.h" /* Cache */
+#include "H5Eprivate.h" /* Error Handling */
/****************/
/* Local Macros */
/****************/
-
/******************/
/* Local Typedefs */
/******************/
-
/********************/
/* Local Prototypes */
/********************/
-
/*********************/
/* Package Variables */
/*********************/
-
/*****************************/
/* Library Private Variables */
/*****************************/
-
/*******************/
/* Local Variables */
/*******************/
-
#ifndef NDEBUG
-
+
/*-------------------------------------------------------------------------
* Function: H5C_dump_cache
*
@@ -84,39 +76,39 @@
*-------------------------------------------------------------------------
*/
herr_t
-H5C_dump_cache(H5C_t * cache_ptr, const char * cache_name)
+H5C_dump_cache(H5C_t *cache_ptr, const char *cache_name)
{
- H5C_cache_entry_t * entry_ptr;
- H5SL_t * slist_ptr = NULL;
- int i; /* Local index variable */
- herr_t ret_value = SUCCEED; /* Return value */
+ H5C_cache_entry_t *entry_ptr;
+ H5SL_t * slist_ptr = NULL;
+ int i; /* Local index variable */
+ herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_NOAPI(FAIL)
/* Sanity check */
HDassert(cache_ptr != NULL);
HDassert(cache_ptr->magic == H5C__H5C_T_MAGIC);
- HDassert(cache_name != NULL );
+ HDassert(cache_name != NULL);
/* First, create a skip list */
- if(NULL == (slist_ptr = H5SL_create(H5SL_TYPE_HADDR, NULL)))
+ if (NULL == (slist_ptr = H5SL_create(H5SL_TYPE_HADDR, NULL)))
HGOTO_ERROR(H5E_CACHE, H5E_CANTCREATE, FAIL, "can't create skip list")
/* Next, scan the index, and insert all entries in the skip list.
* Do this, as we want to display cache entries in increasing address
* order.
*/
- for(i = 0; i < H5C__HASH_TABLE_LEN; i++) {
+ for (i = 0; i < H5C__HASH_TABLE_LEN; i++) {
entry_ptr = cache_ptr->index[i];
- while(entry_ptr != NULL) {
+ while (entry_ptr != NULL) {
HDassert(entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
- if(H5SL_insert(slist_ptr, entry_ptr, &(entry_ptr->addr)) < 0)
+ if (H5SL_insert(slist_ptr, entry_ptr, &(entry_ptr->addr)) < 0)
HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, FAIL, "can't insert entry in skip list")
entry_ptr = entry_ptr->ht_next;
} /* end while */
- } /* end for */
+ } /* end for */
/* If we get this far, all entries in the cache are listed in the
* skip list -- scan the skip list generating the desired output.
@@ -134,17 +126,18 @@ H5C_dump_cache(H5C_t * cache_ptr, const char * cache_name)
HDfprintf(stdout, "| Prot/Pin/Dirty");
HDfprintf(stdout, "\n");
- HDfprintf(stdout, "----------------------------------------------------------------------------------------------------------------\n");
+ HDfprintf(stdout, "--------------------------------------------------------------------------------------"
+ "--------------------------\n");
- i = 0;
+ i = 0;
entry_ptr = (H5C_cache_entry_t *)H5SL_remove_first(slist_ptr);
- while(entry_ptr != NULL) {
+ while (entry_ptr != NULL) {
HDassert(entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
/* Print entry */
HDfprintf(stdout, "%s%5d ", cache_ptr->prefix, i);
HDfprintf(stdout, " 0x%16llx ", (long long)(entry_ptr->addr));
- if(NULL == entry_ptr->tag_info)
+ if (NULL == entry_ptr->tag_info)
HDfprintf(stdout, " %16s ", "N/A");
else
HDfprintf(stdout, " 0x%16llx ", (long long)(entry_ptr->tag_info->tag));
@@ -169,7 +162,7 @@ H5C_dump_cache(H5C_t * cache_ptr, const char * cache_name)
done:
/* Discard the skip list */
- if(slist_ptr)
+ if (slist_ptr)
H5SL_close(slist_ptr);
FUNC_LEAVE_NOAPI(ret_value)
@@ -177,7 +170,7 @@ done:
#endif /* NDEBUG */
#ifndef NDEBUG
-
+
/*-------------------------------------------------------------------------
* Function: H5C_dump_cache_LRU
*
@@ -194,21 +187,21 @@ done:
herr_t
H5C_dump_cache_LRU(H5C_t *cache_ptr, const char *cache_name)
{
- H5C_cache_entry_t * entry_ptr;
- int i = 0;
+ H5C_cache_entry_t *entry_ptr;
+ int i = 0;
FUNC_ENTER_NOAPI_NOERR
/* Sanity check */
HDassert(cache_ptr != NULL);
HDassert(cache_ptr->magic == H5C__H5C_T_MAGIC);
- HDassert(cache_name != NULL );
+ HDassert(cache_name != NULL);
HDfprintf(stdout, "\n\nDump of metadata cache LRU \"%s\"\n", cache_name);
- HDfprintf(stdout, "LRU len = %d, LRU size = %d\n",
- cache_ptr->LRU_list_len, (int)(cache_ptr->LRU_list_size));
- HDfprintf(stdout, "index_size = %d, max_cache_size = %d, delta = %d\n\n",
- (int)(cache_ptr->index_size), (int)(cache_ptr->max_cache_size),
+ HDfprintf(stdout, "LRU len = %d, LRU size = %d\n", cache_ptr->LRU_list_len,
+ (int)(cache_ptr->LRU_list_size));
+ HDfprintf(stdout, "index_size = %d, max_cache_size = %d, delta = %d\n\n", (int)(cache_ptr->index_size),
+ (int)(cache_ptr->max_cache_size),
(int)(cache_ptr->max_cache_size) - (int)(cache_ptr->index_size));
/* Print header */
@@ -221,26 +214,25 @@ H5C_dump_cache_LRU(H5C_t *cache_ptr, const char *cache_name)
HDfprintf(stdout, "| Dirty");
HDfprintf(stdout, "\n");
- HDfprintf(stdout, "----------------------------------------------------------------------------------------------------------------\n");
+ HDfprintf(stdout, "--------------------------------------------------------------------------------------"
+ "--------------------------\n");
entry_ptr = cache_ptr->LRU_head_ptr;
- while(entry_ptr != NULL) {
+ while (entry_ptr != NULL) {
HDassert(entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
/* Print entry */
HDfprintf(stdout, "%s%5d ", cache_ptr->prefix, i);
HDfprintf(stdout, " 0x%16llx ", (long long)(entry_ptr->addr));
- if(NULL == entry_ptr->tag_info)
+ if (NULL == entry_ptr->tag_info)
HDfprintf(stdout, " %16s ", "N/A");
else
- HDfprintf(stdout, " 0x%16llx ",
- (long long)(entry_ptr->tag_info->tag));
+ HDfprintf(stdout, " 0x%16llx ", (long long)(entry_ptr->tag_info->tag));
HDfprintf(stdout, " %5lld ", (long long)(entry_ptr->size));
HDfprintf(stdout, " %d ", (int)(entry_ptr->ring));
- HDfprintf(stdout, " %2d %-32s ", (int)(entry_ptr->type->id),
- (entry_ptr->type->name));
+ HDfprintf(stdout, " %2d %-32s ", (int)(entry_ptr->type->id), (entry_ptr->type->name));
HDfprintf(stdout, " %d", (int)(entry_ptr->is_dirty));
HDfprintf(stdout, "\n");
@@ -248,13 +240,13 @@ H5C_dump_cache_LRU(H5C_t *cache_ptr, const char *cache_name)
entry_ptr = entry_ptr->next;
} /* end while */
- HDfprintf(stdout, "----------------------------------------------------------------------------------------------------------------\n");
+ HDfprintf(stdout, "--------------------------------------------------------------------------------------"
+ "--------------------------\n");
FUNC_LEAVE_NOAPI(SUCCEED)
} /* H5C_dump_cache_LRU() */
#endif /* NDEBUG */
-
/*-------------------------------------------------------------------------
* Function: H5C_dump_cache_skip_list
*
@@ -271,12 +263,12 @@ H5C_dump_cache_LRU(H5C_t *cache_ptr, const char *cache_name)
*/
#ifndef NDEBUG
herr_t
-H5C_dump_cache_skip_list(H5C_t * cache_ptr, char * calling_fcn)
+H5C_dump_cache_skip_list(H5C_t *cache_ptr, char *calling_fcn)
{
- herr_t ret_value = SUCCEED; /* Return value */
- int i;
- H5C_cache_entry_t * entry_ptr = NULL;
- H5SL_node_t * node_ptr = NULL;
+ herr_t ret_value = SUCCEED; /* Return value */
+ int i;
+ H5C_cache_entry_t *entry_ptr = NULL;
+ H5SL_node_t * node_ptr = NULL;
FUNC_ENTER_NOAPI_NOERR
@@ -288,46 +280,39 @@ H5C_dump_cache_skip_list(H5C_t * cache_ptr, char * calling_fcn)
HDfprintf(stdout, " slist len = %u.\n", cache_ptr->slist_len);
HDfprintf(stdout, " slist size = %lld.\n", (long long)(cache_ptr->slist_size));
- if(cache_ptr->slist_len > 0) {
+ if (cache_ptr->slist_len > 0) {
/* If we get this far, all entries in the cache are listed in the
* skip list -- scan the skip list generating the desired output.
*/
- HDfprintf(stdout,
- "Num: Addr: Len: Prot/Pind: Dirty: Type:\n");
+ HDfprintf(stdout, "Num: Addr: Len: Prot/Pind: Dirty: Type:\n");
- i = 0;
+ i = 0;
node_ptr = H5SL_first(cache_ptr->slist_ptr);
- if(node_ptr != NULL)
+ if (node_ptr != NULL)
entry_ptr = (H5C_cache_entry_t *)H5SL_item(node_ptr);
else
entry_ptr = NULL;
- while(entry_ptr != NULL) {
- HDassert( entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC );
+ while (entry_ptr != NULL) {
+ HDassert(entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
- HDfprintf(stdout,
- "%s%d 0x%016llx %4lld %d/%d %d %s\n",
- cache_ptr->prefix, i,
- (long long)(entry_ptr->addr),
- (long long)(entry_ptr->size),
- (int)(entry_ptr->is_protected),
- (int)(entry_ptr->is_pinned),
- (int)(entry_ptr->is_dirty),
- entry_ptr->type->name);
+ HDfprintf(stdout, "%s%d 0x%016llx %4lld %d/%d %d %s\n", cache_ptr->prefix, i,
+ (long long)(entry_ptr->addr), (long long)(entry_ptr->size),
+ (int)(entry_ptr->is_protected), (int)(entry_ptr->is_pinned), (int)(entry_ptr->is_dirty),
+ entry_ptr->type->name);
- HDfprintf(stdout, " node_ptr = %p, item = %p\n",
- node_ptr, H5SL_item(node_ptr));
+ HDfprintf(stdout, " node_ptr = %p, item = %p\n", node_ptr, H5SL_item(node_ptr));
/* increment node_ptr before we delete its target */
node_ptr = H5SL_next(node_ptr);
- if(node_ptr != NULL)
+ if (node_ptr != NULL)
entry_ptr = (H5C_cache_entry_t *)H5SL_item(node_ptr);
else
entry_ptr = NULL;
i++;
} /* end while */
- } /* end if */
+ } /* end if */
HDfprintf(stdout, "\n\n");
@@ -335,7 +320,6 @@ H5C_dump_cache_skip_list(H5C_t * cache_ptr, char * calling_fcn)
} /* H5C_dump_cache_skip_list() */
#endif /* NDEBUG */
-
/*-------------------------------------------------------------------------
* Function: H5C_set_prefix
*
@@ -350,14 +334,14 @@ H5C_dump_cache_skip_list(H5C_t * cache_ptr, char * calling_fcn)
*-------------------------------------------------------------------------
*/
herr_t
-H5C_set_prefix(H5C_t * cache_ptr, char * prefix)
+H5C_set_prefix(H5C_t *cache_ptr, char *prefix)
{
- herr_t ret_value = SUCCEED; /* Return value */
+ herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_NOAPI(FAIL)
- if((cache_ptr == NULL) || (cache_ptr->magic != H5C__H5C_T_MAGIC) ||
- (prefix == NULL) || (HDstrlen(prefix) >= H5C__PREFIX_LEN))
+ if ((cache_ptr == NULL) || (cache_ptr->magic != H5C__H5C_T_MAGIC) || (prefix == NULL) ||
+ (HDstrlen(prefix) >= H5C__PREFIX_LEN))
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Bad param(s) on entry")
HDstrncpy(&(cache_ptr->prefix[0]), prefix, (size_t)(H5C__PREFIX_LEN));
@@ -368,7 +352,6 @@ done:
FUNC_LEAVE_NOAPI(ret_value)
} /* H5C_set_prefix() */
-
/*-------------------------------------------------------------------------
* Function: H5C_stats
*
@@ -382,479 +365,328 @@ done:
*-------------------------------------------------------------------------
*/
herr_t
-H5C_stats(H5C_t * cache_ptr,
- const char * cache_name,
+H5C_stats(H5C_t *cache_ptr, const char *cache_name,
hbool_t
#if !H5C_COLLECT_CACHE_STATS
- H5_ATTR_UNUSED
+ H5_ATTR_UNUSED
#endif /* H5C_COLLECT_CACHE_STATS */
- display_detailed_stats)
+ display_detailed_stats)
{
#if H5C_COLLECT_CACHE_STATS
- int i;
- int64_t total_hits = 0;
- int64_t total_misses = 0;
- int64_t total_write_protects = 0;
- int64_t total_read_protects = 0;
- int64_t max_read_protects = 0;
- int64_t total_insertions = 0;
- int64_t total_pinned_insertions = 0;
- int64_t total_clears = 0;
- int64_t total_flushes = 0;
- int64_t total_evictions = 0;
- int64_t total_take_ownerships = 0;
- int64_t total_moves = 0;
- int64_t total_entry_flush_moves = 0;
- int64_t total_cache_flush_moves = 0;
- int64_t total_size_increases = 0;
- int64_t total_size_decreases = 0;
- int64_t total_entry_flush_size_changes = 0;
- int64_t total_cache_flush_size_changes = 0;
- int64_t total_pins = 0;
- int64_t total_unpins = 0;
- int64_t total_dirty_pins = 0;
- int64_t total_pinned_flushes = 0;
- int64_t total_pinned_clears = 0;
- int32_t aggregate_max_accesses = 0;
- int32_t aggregate_min_accesses = 1000000;
- int32_t aggregate_max_clears = 0;
- int32_t aggregate_max_flushes = 0;
- size_t aggregate_max_size = 0;
- int32_t aggregate_max_pins = 0;
- double hit_rate;
- double prefetch_use_rate;
- double average_successful_search_depth = 0.0f;
- double average_failed_search_depth = 0.0f;
- double average_entries_skipped_per_calls_to_msic = 0.0f;
- double average_dirty_pf_entries_skipped_per_call_to_msic = 0.0f;
- double average_entries_scanned_per_calls_to_msic = 0.0f;
-#endif /* H5C_COLLECT_CACHE_STATS */
- herr_t ret_value = SUCCEED; /* Return value */
+ int i;
+ int64_t total_hits = 0;
+ int64_t total_misses = 0;
+ int64_t total_write_protects = 0;
+ int64_t total_read_protects = 0;
+ int64_t max_read_protects = 0;
+ int64_t total_insertions = 0;
+ int64_t total_pinned_insertions = 0;
+ int64_t total_clears = 0;
+ int64_t total_flushes = 0;
+ int64_t total_evictions = 0;
+ int64_t total_take_ownerships = 0;
+ int64_t total_moves = 0;
+ int64_t total_entry_flush_moves = 0;
+ int64_t total_cache_flush_moves = 0;
+ int64_t total_size_increases = 0;
+ int64_t total_size_decreases = 0;
+ int64_t total_entry_flush_size_changes = 0;
+ int64_t total_cache_flush_size_changes = 0;
+ int64_t total_pins = 0;
+ int64_t total_unpins = 0;
+ int64_t total_dirty_pins = 0;
+ int64_t total_pinned_flushes = 0;
+ int64_t total_pinned_clears = 0;
+ int32_t aggregate_max_accesses = 0;
+ int32_t aggregate_min_accesses = 1000000;
+ int32_t aggregate_max_clears = 0;
+ int32_t aggregate_max_flushes = 0;
+ size_t aggregate_max_size = 0;
+ int32_t aggregate_max_pins = 0;
+ double hit_rate;
+ double prefetch_use_rate;
+ double average_successful_search_depth = 0.0f;
+ double average_failed_search_depth = 0.0f;
+ double average_entries_skipped_per_calls_to_msic = 0.0f;
+ double average_dirty_pf_entries_skipped_per_call_to_msic = 0.0f;
+ double average_entries_scanned_per_calls_to_msic = 0.0f;
+#endif /* H5C_COLLECT_CACHE_STATS */
+ herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_NOAPI(FAIL)
- HDassert( cache_ptr->magic == H5C__H5C_T_MAGIC );
+ HDassert(cache_ptr->magic == H5C__H5C_T_MAGIC);
/* This would normally be an assert, but we need to use an HGOTO_ERROR
* call to shut up the compiler.
*/
- if((NULL == cache_ptr) || (cache_ptr->magic != H5C__H5C_T_MAGIC) ||
- (NULL == cache_name))
+ if ((NULL == cache_ptr) || (cache_ptr->magic != H5C__H5C_T_MAGIC) || (NULL == cache_name))
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Bad cache_ptr or cache_name")
#if H5C_COLLECT_CACHE_STATS
- for(i = 0; i <= cache_ptr->max_type_id; i++ ) {
- total_hits += cache_ptr->hits[i];
- total_misses += cache_ptr->misses[i];
- total_write_protects += cache_ptr->write_protects[i];
- total_read_protects += cache_ptr->read_protects[i];
- if(max_read_protects < cache_ptr->max_read_protects[i])
- max_read_protects = cache_ptr->max_read_protects[i];
- total_insertions += cache_ptr->insertions[i];
+ for (i = 0; i <= cache_ptr->max_type_id; i++) {
+ total_hits += cache_ptr->hits[i];
+ total_misses += cache_ptr->misses[i];
+ total_write_protects += cache_ptr->write_protects[i];
+ total_read_protects += cache_ptr->read_protects[i];
+ if (max_read_protects < cache_ptr->max_read_protects[i])
+ max_read_protects = cache_ptr->max_read_protects[i];
+ total_insertions += cache_ptr->insertions[i];
total_pinned_insertions += cache_ptr->pinned_insertions[i];
- total_clears += cache_ptr->clears[i];
- total_flushes += cache_ptr->flushes[i];
- total_evictions += cache_ptr->evictions[i];
- total_take_ownerships += cache_ptr->take_ownerships[i];
- total_moves += cache_ptr->moves[i];
- total_entry_flush_moves += cache_ptr->entry_flush_moves[i];
- total_cache_flush_moves += cache_ptr->cache_flush_moves[i];
- total_size_increases += cache_ptr->size_increases[i];
- total_size_decreases += cache_ptr->size_decreases[i];
- total_entry_flush_size_changes
- += cache_ptr->entry_flush_size_changes[i];
- total_cache_flush_size_changes
- += cache_ptr->cache_flush_size_changes[i];
- total_pins += cache_ptr->pins[i];
- total_unpins += cache_ptr->unpins[i];
- total_dirty_pins += cache_ptr->dirty_pins[i];
- total_pinned_flushes += cache_ptr->pinned_flushes[i];
- total_pinned_clears += cache_ptr->pinned_clears[i];
+ total_clears += cache_ptr->clears[i];
+ total_flushes += cache_ptr->flushes[i];
+ total_evictions += cache_ptr->evictions[i];
+ total_take_ownerships += cache_ptr->take_ownerships[i];
+ total_moves += cache_ptr->moves[i];
+ total_entry_flush_moves += cache_ptr->entry_flush_moves[i];
+ total_cache_flush_moves += cache_ptr->cache_flush_moves[i];
+ total_size_increases += cache_ptr->size_increases[i];
+ total_size_decreases += cache_ptr->size_decreases[i];
+ total_entry_flush_size_changes += cache_ptr->entry_flush_size_changes[i];
+ total_cache_flush_size_changes += cache_ptr->cache_flush_size_changes[i];
+ total_pins += cache_ptr->pins[i];
+ total_unpins += cache_ptr->unpins[i];
+ total_dirty_pins += cache_ptr->dirty_pins[i];
+ total_pinned_flushes += cache_ptr->pinned_flushes[i];
+ total_pinned_clears += cache_ptr->pinned_clears[i];
#if H5C_COLLECT_CACHE_ENTRY_STATS
- if(aggregate_max_accesses < cache_ptr->max_accesses[i])
+ if (aggregate_max_accesses < cache_ptr->max_accesses[i])
aggregate_max_accesses = cache_ptr->max_accesses[i];
- if(aggregate_min_accesses > aggregate_max_accesses)
+ if (aggregate_min_accesses > aggregate_max_accesses)
aggregate_min_accesses = aggregate_max_accesses;
- if(aggregate_min_accesses > cache_ptr->min_accesses[i])
+ if (aggregate_min_accesses > cache_ptr->min_accesses[i])
aggregate_min_accesses = cache_ptr->min_accesses[i];
- if(aggregate_max_clears < cache_ptr->max_clears[i])
+ if (aggregate_max_clears < cache_ptr->max_clears[i])
aggregate_max_clears = cache_ptr->max_clears[i];
- if(aggregate_max_flushes < cache_ptr->max_flushes[i])
+ if (aggregate_max_flushes < cache_ptr->max_flushes[i])
aggregate_max_flushes = cache_ptr->max_flushes[i];
- if(aggregate_max_size < cache_ptr->max_size[i])
+ if (aggregate_max_size < cache_ptr->max_size[i])
aggregate_max_size = cache_ptr->max_size[i];
- if(aggregate_max_pins < cache_ptr->max_pins[i])
+ if (aggregate_max_pins < cache_ptr->max_pins[i])
aggregate_max_pins = cache_ptr->max_pins[i];
#endif /* H5C_COLLECT_CACHE_ENTRY_STATS */
- } /* end for */
+ } /* end for */
- if((total_hits > 0) || (total_misses > 0))
- hit_rate = (double)100.0f * ((double)(total_hits)) /
- ((double)(total_hits + total_misses));
+ if ((total_hits > 0) || (total_misses > 0))
+ hit_rate = (double)100.0f * ((double)(total_hits)) / ((double)(total_hits + total_misses));
else
hit_rate = 0.0f;
- if(cache_ptr->successful_ht_searches > 0)
- average_successful_search_depth =
- ((double)(cache_ptr->total_successful_ht_search_depth)) /
- ((double)(cache_ptr->successful_ht_searches));
+ if (cache_ptr->successful_ht_searches > 0)
+ average_successful_search_depth = ((double)(cache_ptr->total_successful_ht_search_depth)) /
+ ((double)(cache_ptr->successful_ht_searches));
- if(cache_ptr->failed_ht_searches > 0)
+ if (cache_ptr->failed_ht_searches > 0)
average_failed_search_depth =
- ((double)(cache_ptr->total_failed_ht_search_depth)) /
- ((double)(cache_ptr->failed_ht_searches));
-
+ ((double)(cache_ptr->total_failed_ht_search_depth)) / ((double)(cache_ptr->failed_ht_searches));
- HDfprintf(stdout, "\n%sH5C: cache statistics for %s\n",
- cache_ptr->prefix, cache_name);
+ HDfprintf(stdout, "\n%sH5C: cache statistics for %s\n", cache_ptr->prefix, cache_name);
HDfprintf(stdout, "\n");
- HDfprintf(stdout,
- "%s hash table insertion / deletions = %ld / %ld\n",
- cache_ptr->prefix,
- (long)(cache_ptr->total_ht_insertions),
- (long)(cache_ptr->total_ht_deletions));
-
- HDfprintf(stdout,
- "%s HT successful / failed searches = %ld / %ld\n",
- cache_ptr->prefix,
- (long)(cache_ptr->successful_ht_searches),
- (long)(cache_ptr->failed_ht_searches));
-
- HDfprintf(stdout,
- "%s Av. HT suc / failed search depth = %f / %f\n",
- cache_ptr->prefix,
- average_successful_search_depth,
- average_failed_search_depth);
-
- HDfprintf(stdout,
- "%s current (max) index size / length = %ld (%ld) / %lu (%lu)\n",
- cache_ptr->prefix,
- (long)(cache_ptr->index_size),
- (long)(cache_ptr->max_index_size),
- (unsigned long)(cache_ptr->index_len),
- (unsigned long)(cache_ptr->max_index_len));
-
- HDfprintf(stdout,
- "%s current (max) clean/dirty idx size = %ld (%ld) / %ld (%ld)\n",
- cache_ptr->prefix,
- (long)(cache_ptr->clean_index_size),
- (long)(cache_ptr->max_clean_index_size),
- (long)(cache_ptr->dirty_index_size),
- (long)(cache_ptr->max_dirty_index_size));
-
- HDfprintf(stdout,
- "%s current (max) slist size / length = %ld (%ld) / %lu (%lu)\n",
- cache_ptr->prefix,
- (long)(cache_ptr->slist_size),
- (long)(cache_ptr->max_slist_size),
- (unsigned long)(cache_ptr->slist_len),
- (unsigned long)(cache_ptr->max_slist_len));
-
- HDfprintf(stdout,
- "%s current (max) PL size / length = %ld (%ld) / %lu (%lu)\n",
- cache_ptr->prefix,
- (long)(cache_ptr->pl_size),
- (long)(cache_ptr->max_pl_size),
- (unsigned long)(cache_ptr->pl_len),
+ HDfprintf(stdout, "%s hash table insertion / deletions = %ld / %ld\n", cache_ptr->prefix,
+ (long)(cache_ptr->total_ht_insertions), (long)(cache_ptr->total_ht_deletions));
+
+ HDfprintf(stdout, "%s HT successful / failed searches = %ld / %ld\n", cache_ptr->prefix,
+ (long)(cache_ptr->successful_ht_searches), (long)(cache_ptr->failed_ht_searches));
+
+ HDfprintf(stdout, "%s Av. HT suc / failed search depth = %f / %f\n", cache_ptr->prefix,
+ average_successful_search_depth, average_failed_search_depth);
+
+ HDfprintf(stdout, "%s current (max) index size / length = %ld (%ld) / %lu (%lu)\n", cache_ptr->prefix,
+ (long)(cache_ptr->index_size), (long)(cache_ptr->max_index_size),
+ (unsigned long)(cache_ptr->index_len), (unsigned long)(cache_ptr->max_index_len));
+
+ HDfprintf(stdout, "%s current (max) clean/dirty idx size = %ld (%ld) / %ld (%ld)\n", cache_ptr->prefix,
+ (long)(cache_ptr->clean_index_size), (long)(cache_ptr->max_clean_index_size),
+ (long)(cache_ptr->dirty_index_size), (long)(cache_ptr->max_dirty_index_size));
+
+ HDfprintf(stdout, "%s current (max) slist size / length = %ld (%ld) / %lu (%lu)\n", cache_ptr->prefix,
+ (long)(cache_ptr->slist_size), (long)(cache_ptr->max_slist_size),
+ (unsigned long)(cache_ptr->slist_len), (unsigned long)(cache_ptr->max_slist_len));
+
+ HDfprintf(stdout, "%s current (max) PL size / length = %ld (%ld) / %lu (%lu)\n", cache_ptr->prefix,
+ (long)(cache_ptr->pl_size), (long)(cache_ptr->max_pl_size), (unsigned long)(cache_ptr->pl_len),
(unsigned long)(cache_ptr->max_pl_len));
- HDfprintf(stdout,
- "%s current (max) PEL size / length = %ld (%ld) / %lu (%lu)\n",
- cache_ptr->prefix,
- (long)(cache_ptr->pel_size),
- (long)(cache_ptr->max_pel_size),
- (unsigned long)(cache_ptr->pel_len),
- (unsigned long)(cache_ptr->max_pel_len));
+ HDfprintf(stdout, "%s current (max) PEL size / length = %ld (%ld) / %lu (%lu)\n", cache_ptr->prefix,
+ (long)(cache_ptr->pel_size), (long)(cache_ptr->max_pel_size),
+ (unsigned long)(cache_ptr->pel_len), (unsigned long)(cache_ptr->max_pel_len));
- HDfprintf(stdout,
- "%s current LRU list size / length = %ld / %lu\n",
- cache_ptr->prefix,
- (long)(cache_ptr->LRU_list_size),
- (unsigned long)(cache_ptr->LRU_list_len));
+ HDfprintf(stdout, "%s current LRU list size / length = %ld / %lu\n", cache_ptr->prefix,
+ (long)(cache_ptr->LRU_list_size), (unsigned long)(cache_ptr->LRU_list_len));
#if H5C_MAINTAIN_CLEAN_AND_DIRTY_LRU_LISTS
- HDfprintf(stdout,
- "%s current clean LRU size / length = %ld / %lu\n",
- cache_ptr->prefix,
- (long)(cache_ptr->cLRU_list_size),
- (unsigned long)(cache_ptr->cLRU_list_len));
-
- HDfprintf(stdout,
- "%s current dirty LRU size / length = %ld / %lu\n",
- cache_ptr->prefix,
- (long)(cache_ptr->dLRU_list_size),
- (unsigned long)(cache_ptr->dLRU_list_len));
+ HDfprintf(stdout, "%s current clean LRU size / length = %ld / %lu\n", cache_ptr->prefix,
+ (long)(cache_ptr->cLRU_list_size), (unsigned long)(cache_ptr->cLRU_list_len));
+
+ HDfprintf(stdout, "%s current dirty LRU size / length = %ld / %lu\n", cache_ptr->prefix,
+ (long)(cache_ptr->dLRU_list_size), (unsigned long)(cache_ptr->dLRU_list_len));
#endif /* H5C_MAINTAIN_CLEAN_AND_DIRTY_LRU_LISTS */
- HDfprintf(stdout,
- "%s Total hits / misses / hit_rate = %ld / %ld / %f\n",
- cache_ptr->prefix,
- (long)total_hits,
- (long)total_misses,
- hit_rate);
-
- HDfprintf(stdout,
- "%s Total write / read (max) protects = %ld / %ld (%ld)\n",
- cache_ptr->prefix,
- (long)total_write_protects,
- (long)total_read_protects,
- (long)max_read_protects);
-
- HDfprintf(stdout,
- "%s Total clears / flushes = %ld / %ld\n",
- cache_ptr->prefix,
- (long)total_clears,
- (long)total_flushes);
-
- HDfprintf(stdout,
- "%s Total evictions / take ownerships = %ld / %ld\n",
- cache_ptr->prefix,
- (long)total_evictions,
- (long)total_take_ownerships);
-
- HDfprintf(stdout,
- "%s Total insertions(pinned) / moves = %ld(%ld) / %ld\n",
- cache_ptr->prefix,
- (long)total_insertions,
- (long)total_pinned_insertions,
- (long)total_moves);
-
- HDfprintf(stdout,
- "%s Total entry / cache flush moves = %ld / %ld\n",
- cache_ptr->prefix,
- (long)total_entry_flush_moves,
- (long)total_cache_flush_moves);
-
- HDfprintf(stdout, "%s Total entry size incrs / decrs = %ld / %ld\n",
- cache_ptr->prefix,
- (long)total_size_increases,
- (long)total_size_decreases);
-
- HDfprintf(stdout, "%s Ttl entry/cache flush size changes = %ld / %ld\n",
- cache_ptr->prefix,
- (long)total_entry_flush_size_changes,
- (long)total_cache_flush_size_changes);
-
- HDfprintf(stdout,
- "%s Total entry pins (dirty) / unpins = %ld (%ld) / %ld\n",
- cache_ptr->prefix,
- (long)total_pins,
- (long)total_dirty_pins,
- (long)total_unpins);
-
- HDfprintf(stdout, "%s Total pinned flushes / clears = %ld / %ld\n",
- cache_ptr->prefix,
- (long)total_pinned_flushes,
- (long)total_pinned_clears);
-
- HDfprintf(stdout, "%s MSIC: (make space in cache) calls = %lld\n",
- cache_ptr->prefix,
+ HDfprintf(stdout, "%s Total hits / misses / hit_rate = %ld / %ld / %f\n", cache_ptr->prefix,
+ (long)total_hits, (long)total_misses, hit_rate);
+
+ HDfprintf(stdout, "%s Total write / read (max) protects = %ld / %ld (%ld)\n", cache_ptr->prefix,
+ (long)total_write_protects, (long)total_read_protects, (long)max_read_protects);
+
+ HDfprintf(stdout, "%s Total clears / flushes = %ld / %ld\n", cache_ptr->prefix,
+ (long)total_clears, (long)total_flushes);
+
+ HDfprintf(stdout, "%s Total evictions / take ownerships = %ld / %ld\n", cache_ptr->prefix,
+ (long)total_evictions, (long)total_take_ownerships);
+
+ HDfprintf(stdout, "%s Total insertions(pinned) / moves = %ld(%ld) / %ld\n", cache_ptr->prefix,
+ (long)total_insertions, (long)total_pinned_insertions, (long)total_moves);
+
+ HDfprintf(stdout, "%s Total entry / cache flush moves = %ld / %ld\n", cache_ptr->prefix,
+ (long)total_entry_flush_moves, (long)total_cache_flush_moves);
+
+ HDfprintf(stdout, "%s Total entry size incrs / decrs = %ld / %ld\n", cache_ptr->prefix,
+ (long)total_size_increases, (long)total_size_decreases);
+
+ HDfprintf(stdout, "%s Ttl entry/cache flush size changes = %ld / %ld\n", cache_ptr->prefix,
+ (long)total_entry_flush_size_changes, (long)total_cache_flush_size_changes);
+
+ HDfprintf(stdout, "%s Total entry pins (dirty) / unpins = %ld (%ld) / %ld\n", cache_ptr->prefix,
+ (long)total_pins, (long)total_dirty_pins, (long)total_unpins);
+
+ HDfprintf(stdout, "%s Total pinned flushes / clears = %ld / %ld\n", cache_ptr->prefix,
+ (long)total_pinned_flushes, (long)total_pinned_clears);
+
+ HDfprintf(stdout, "%s MSIC: (make space in cache) calls = %lld\n", cache_ptr->prefix,
(long long)(cache_ptr->calls_to_msic));
if (cache_ptr->calls_to_msic > 0)
average_entries_skipped_per_calls_to_msic =
- (((double)(cache_ptr->total_entries_skipped_in_msic)) /
- ((double)(cache_ptr->calls_to_msic)));
+ (((double)(cache_ptr->total_entries_skipped_in_msic)) / ((double)(cache_ptr->calls_to_msic)));
- HDfprintf(stdout, "%s MSIC: Average/max entries skipped = %lf / %ld\n",
- cache_ptr->prefix,
+ HDfprintf(stdout, "%s MSIC: Average/max entries skipped = %lf / %ld\n", cache_ptr->prefix,
(double)average_entries_skipped_per_calls_to_msic,
(long)(cache_ptr->max_entries_skipped_in_msic));
- if(cache_ptr->calls_to_msic > 0)
+ if (cache_ptr->calls_to_msic > 0)
average_dirty_pf_entries_skipped_per_call_to_msic =
(((double)(cache_ptr->total_dirty_pf_entries_skipped_in_msic)) /
- ((double)(cache_ptr->calls_to_msic)));
+ ((double)(cache_ptr->calls_to_msic)));
- HDfprintf(stdout,
- "%s MSIC: Average/max dirty pf entries skipped = %lf / %ld\n",
- cache_ptr->prefix,
+ HDfprintf(stdout, "%s MSIC: Average/max dirty pf entries skipped = %lf / %ld\n", cache_ptr->prefix,
average_dirty_pf_entries_skipped_per_call_to_msic,
(long)(cache_ptr->max_dirty_pf_entries_skipped_in_msic));
- if(cache_ptr->calls_to_msic > 0)
+ if (cache_ptr->calls_to_msic > 0)
average_entries_scanned_per_calls_to_msic =
- (((double)(cache_ptr->total_entries_scanned_in_msic)) /
- ((double)(cache_ptr->calls_to_msic)));
+ (((double)(cache_ptr->total_entries_scanned_in_msic)) / ((double)(cache_ptr->calls_to_msic)));
- HDfprintf(stdout, "%s MSIC: Average/max entries scanned = %lf / %ld\n",
- cache_ptr->prefix,
+ HDfprintf(stdout, "%s MSIC: Average/max entries scanned = %lf / %ld\n", cache_ptr->prefix,
(double)average_entries_scanned_per_calls_to_msic,
(long)(cache_ptr->max_entries_scanned_in_msic));
- HDfprintf(stdout, "%s MSIC: Scanned to make space(evict) = %lld\n",
- cache_ptr->prefix,
+ HDfprintf(stdout, "%s MSIC: Scanned to make space(evict) = %lld\n", cache_ptr->prefix,
(long long)(cache_ptr->entries_scanned_to_make_space));
- HDfprintf(stdout, "%s MSIC: Scanned to satisfy min_clean = %lld\n",
- cache_ptr->prefix,
- (long long)(cache_ptr->total_entries_scanned_in_msic -
- cache_ptr->entries_scanned_to_make_space));
+ HDfprintf(
+ stdout, "%s MSIC: Scanned to satisfy min_clean = %lld\n", cache_ptr->prefix,
+ (long long)(cache_ptr->total_entries_scanned_in_msic - cache_ptr->entries_scanned_to_make_space));
- HDfprintf(stdout,
- "%s slist/LRU/index scan restarts = %lld / %lld / %lld.\n",
- cache_ptr->prefix,
- (long long)(cache_ptr->slist_scan_restarts),
- (long long)(cache_ptr->LRU_scan_restarts),
+ HDfprintf(stdout, "%s slist/LRU/index scan restarts = %lld / %lld / %lld.\n", cache_ptr->prefix,
+ (long long)(cache_ptr->slist_scan_restarts), (long long)(cache_ptr->LRU_scan_restarts),
(long long)(cache_ptr->index_scan_restarts));
- HDfprintf(stdout,
- "%s cache image creations/reads/loads/size = %d / %d /%d / %Hu\n",
- cache_ptr->prefix,
- cache_ptr->images_created,
- cache_ptr->images_read,
- cache_ptr->images_loaded,
+ HDfprintf(stdout, "%s cache image creations/reads/loads/size = %d / %d /%d / %Hu\n", cache_ptr->prefix,
+ cache_ptr->images_created, cache_ptr->images_read, cache_ptr->images_loaded,
cache_ptr->last_image_size);
- HDfprintf(stdout,
- "%s prefetches / dirty prefetches = %lld / %lld\n",
- cache_ptr->prefix,
- (long long)(cache_ptr->prefetches),
- (long long)(cache_ptr->dirty_prefetches));
+ HDfprintf(stdout, "%s prefetches / dirty prefetches = %lld / %lld\n", cache_ptr->prefix,
+ (long long)(cache_ptr->prefetches), (long long)(cache_ptr->dirty_prefetches));
- HDfprintf(stdout,
- "%s prefetch hits/flushes/evictions = %lld / %lld / %lld\n",
- cache_ptr->prefix,
+ HDfprintf(stdout, "%s prefetch hits/flushes/evictions = %lld / %lld / %lld\n", cache_ptr->prefix,
(long long)(cache_ptr->prefetch_hits),
(long long)(cache_ptr->flushes[H5AC_PREFETCHED_ENTRY_ID]),
(long long)(cache_ptr->evictions[H5AC_PREFETCHED_ENTRY_ID]));
- if(cache_ptr->prefetches > 0)
+ if (cache_ptr->prefetches > 0)
prefetch_use_rate =
- (double)100.0f * ((double)(cache_ptr->prefetch_hits)) /
- ((double)(cache_ptr->prefetches));
+ (double)100.0f * ((double)(cache_ptr->prefetch_hits)) / ((double)(cache_ptr->prefetches));
else
prefetch_use_rate = 0.0f;
- HDfprintf(stdout,
- "%s prefetched entry use rate = %lf\n",
- cache_ptr->prefix,
- prefetch_use_rate);
+ HDfprintf(stdout, "%s prefetched entry use rate = %lf\n", cache_ptr->prefix, prefetch_use_rate);
#if H5C_COLLECT_CACHE_ENTRY_STATS
- HDfprintf(stdout, "%s aggregate max / min accesses = %d / %d\n",
- cache_ptr->prefix,
- (int)aggregate_max_accesses,
- (int)aggregate_min_accesses);
+ HDfprintf(stdout, "%s aggregate max / min accesses = %d / %d\n", cache_ptr->prefix,
+ (int)aggregate_max_accesses, (int)aggregate_min_accesses);
- HDfprintf(stdout, "%s aggregate max_clears / max_flushes = %d / %d\n",
- cache_ptr->prefix,
- (int)aggregate_max_clears,
- (int)aggregate_max_flushes);
+ HDfprintf(stdout, "%s aggregate max_clears / max_flushes = %d / %d\n", cache_ptr->prefix,
+ (int)aggregate_max_clears, (int)aggregate_max_flushes);
- HDfprintf(stdout, "%s aggregate max_size / max_pins = %d / %d\n",
- cache_ptr->prefix,
- (int)aggregate_max_size,
- (int)aggregate_max_pins);
+ HDfprintf(stdout, "%s aggregate max_size / max_pins = %d / %d\n", cache_ptr->prefix,
+ (int)aggregate_max_size, (int)aggregate_max_pins);
#endif /* H5C_COLLECT_CACHE_ENTRY_STATS */
- if(display_detailed_stats) {
- for(i = 0; i <= cache_ptr->max_type_id; i++) {
+ if (display_detailed_stats) {
+ for (i = 0; i <= cache_ptr->max_type_id; i++) {
HDfprintf(stdout, "\n");
- HDfprintf(stdout, "%s Stats on %s:\n",
- cache_ptr->prefix,
+ HDfprintf(stdout, "%s Stats on %s:\n", cache_ptr->prefix,
((cache_ptr->class_table_ptr))[i]->name);
- if((cache_ptr->hits[i] > 0) || (cache_ptr->misses[i] > 0))
+ if ((cache_ptr->hits[i] > 0) || (cache_ptr->misses[i] > 0))
hit_rate = (double)100.0f * ((double)(cache_ptr->hits[i])) /
- ((double)(cache_ptr->hits[i] + cache_ptr->misses[i]));
+ ((double)(cache_ptr->hits[i] + cache_ptr->misses[i]));
else
hit_rate = 0.0f;
- HDfprintf(stdout,
- "%s hits / misses / hit_rate = %ld / %ld / %f\n",
- cache_ptr->prefix,
- (long)(cache_ptr->hits[i]),
- (long)(cache_ptr->misses[i]),
- hit_rate);
-
- HDfprintf(stdout,
- "%s write / read (max) protects = %ld / %ld (%d)\n",
- cache_ptr->prefix,
- (long)(cache_ptr->write_protects[i]),
- (long)(cache_ptr->read_protects[i]),
+ HDfprintf(stdout, "%s hits / misses / hit_rate = %ld / %ld / %f\n", cache_ptr->prefix,
+ (long)(cache_ptr->hits[i]), (long)(cache_ptr->misses[i]), hit_rate);
+
+ HDfprintf(stdout, "%s write / read (max) protects = %ld / %ld (%d)\n", cache_ptr->prefix,
+ (long)(cache_ptr->write_protects[i]), (long)(cache_ptr->read_protects[i]),
(int)(cache_ptr->max_read_protects[i]));
- HDfprintf(stdout,
- "%s clears / flushes = %ld / %ld\n",
- cache_ptr->prefix,
- (long)(cache_ptr->clears[i]),
- (long)(cache_ptr->flushes[i]));
-
- HDfprintf(stdout,
- "%s evictions / take ownerships = %ld / %ld\n",
- cache_ptr->prefix,
- (long)(cache_ptr->evictions[i]),
- (long)(cache_ptr->take_ownerships[i]));
-
- HDfprintf(stdout,
- "%s insertions(pinned) / moves = %ld(%ld) / %ld\n",
- cache_ptr->prefix,
- (long)(cache_ptr->insertions[i]),
- (long)(cache_ptr->pinned_insertions[i]),
+ HDfprintf(stdout, "%s clears / flushes = %ld / %ld\n", cache_ptr->prefix,
+ (long)(cache_ptr->clears[i]), (long)(cache_ptr->flushes[i]));
+
+ HDfprintf(stdout, "%s evictions / take ownerships = %ld / %ld\n", cache_ptr->prefix,
+ (long)(cache_ptr->evictions[i]), (long)(cache_ptr->take_ownerships[i]));
+
+ HDfprintf(stdout, "%s insertions(pinned) / moves = %ld(%ld) / %ld\n", cache_ptr->prefix,
+ (long)(cache_ptr->insertions[i]), (long)(cache_ptr->pinned_insertions[i]),
(long)(cache_ptr->moves[i]));
- HDfprintf(stdout,
- "%s entry / cache flush moves = %ld / %ld\n",
- cache_ptr->prefix,
- (long)(cache_ptr->entry_flush_moves[i]),
- (long)(cache_ptr->cache_flush_moves[i]));
-
- HDfprintf(stdout,
- "%s size increases / decreases = %ld / %ld\n",
- cache_ptr->prefix,
- (long)(cache_ptr->size_increases[i]),
- (long)(cache_ptr->size_decreases[i]));
-
- HDfprintf(stdout,
- "%s entry/cache flush size changes = %ld / %ld\n",
- cache_ptr->prefix,
+ HDfprintf(stdout, "%s entry / cache flush moves = %ld / %ld\n", cache_ptr->prefix,
+ (long)(cache_ptr->entry_flush_moves[i]), (long)(cache_ptr->cache_flush_moves[i]));
+
+ HDfprintf(stdout, "%s size increases / decreases = %ld / %ld\n", cache_ptr->prefix,
+ (long)(cache_ptr->size_increases[i]), (long)(cache_ptr->size_decreases[i]));
+
+ HDfprintf(stdout, "%s entry/cache flush size changes = %ld / %ld\n", cache_ptr->prefix,
(long)(cache_ptr->entry_flush_size_changes[i]),
(long)(cache_ptr->cache_flush_size_changes[i]));
+ HDfprintf(stdout, "%s entry pins / unpins = %ld / %ld\n", cache_ptr->prefix,
+ (long)(cache_ptr->pins[i]), (long)(cache_ptr->unpins[i]));
- HDfprintf(stdout,
- "%s entry pins / unpins = %ld / %ld\n",
- cache_ptr->prefix,
- (long)(cache_ptr->pins[i]),
- (long)(cache_ptr->unpins[i]));
-
- HDfprintf(stdout,
- "%s entry dirty pins/pin'd flushes = %ld / %ld\n",
- cache_ptr->prefix,
- (long)(cache_ptr->dirty_pins[i]),
- (long)(cache_ptr->pinned_flushes[i]));
+ HDfprintf(stdout, "%s entry dirty pins/pin'd flushes = %ld / %ld\n", cache_ptr->prefix,
+ (long)(cache_ptr->dirty_pins[i]), (long)(cache_ptr->pinned_flushes[i]));
#if H5C_COLLECT_CACHE_ENTRY_STATS
- HDfprintf(stdout,
- "%s entry max / min accesses = %d / %d\n",
- cache_ptr->prefix,
- cache_ptr->max_accesses[i],
- cache_ptr->min_accesses[i]);
-
- HDfprintf(stdout,
- "%s entry max_clears / max_flushes = %d / %d\n",
- cache_ptr->prefix,
- cache_ptr->max_clears[i],
- cache_ptr->max_flushes[i]);
+ HDfprintf(stdout, "%s entry max / min accesses = %d / %d\n", cache_ptr->prefix,
+ cache_ptr->max_accesses[i], cache_ptr->min_accesses[i]);
- HDfprintf(stdout,
- "%s entry max_size / max_pins = %d / %d\n",
- cache_ptr->prefix,
- (int)(cache_ptr->max_size[i]),
- (int)(cache_ptr->max_pins[i]));
+ HDfprintf(stdout, "%s entry max_clears / max_flushes = %d / %d\n", cache_ptr->prefix,
+ cache_ptr->max_clears[i], cache_ptr->max_flushes[i]);
+ HDfprintf(stdout, "%s entry max_size / max_pins = %d / %d\n", cache_ptr->prefix,
+ (int)(cache_ptr->max_size[i]), (int)(cache_ptr->max_pins[i]));
#endif /* H5C_COLLECT_CACHE_ENTRY_STATS */
} /* end for */
- } /* end if */
+ } /* end if */
HDfprintf(stdout, "\n");
@@ -864,7 +696,6 @@ done:
FUNC_LEAVE_NOAPI(ret_value)
} /* H5C_stats() */
-
/*-------------------------------------------------------------------------
*
* Function: H5C_stats__reset
@@ -879,12 +710,12 @@ done:
*/
void
#ifndef NDEBUG
-H5C_stats__reset(H5C_t * cache_ptr)
+H5C_stats__reset(H5C_t *cache_ptr)
#else /* NDEBUG */
#if H5C_COLLECT_CACHE_STATS
-H5C_stats__reset(H5C_t * cache_ptr)
-#else /* H5C_COLLECT_CACHE_STATS */
-H5C_stats__reset(H5C_t H5_ATTR_UNUSED * cache_ptr)
+H5C_stats__reset(H5C_t *cache_ptr)
+#else /* H5C_COLLECT_CACHE_STATS */
+H5C_stats__reset(H5C_t H5_ATTR_UNUSED *cache_ptr)
#endif /* H5C_COLLECT_CACHE_STATS */
#endif /* NDEBUG */
{
@@ -896,52 +727,52 @@ H5C_stats__reset(H5C_t H5_ATTR_UNUSED * cache_ptr)
HDassert(cache_ptr->magic == H5C__H5C_T_MAGIC);
#if H5C_COLLECT_CACHE_STATS
- for(i = 0; i <= cache_ptr->max_type_id; i++) {
- cache_ptr->hits[i] = 0;
- cache_ptr->misses[i] = 0;
- cache_ptr->write_protects[i] = 0;
- cache_ptr->read_protects[i] = 0;
- cache_ptr->max_read_protects[i] = 0;
- cache_ptr->insertions[i] = 0;
- cache_ptr->pinned_insertions[i] = 0;
- cache_ptr->clears[i] = 0;
- cache_ptr->flushes[i] = 0;
- cache_ptr->evictions[i] = 0;
- cache_ptr->take_ownerships[i] = 0;
- cache_ptr->moves[i] = 0;
- cache_ptr->entry_flush_moves[i] = 0;
- cache_ptr->cache_flush_moves[i] = 0;
- cache_ptr->pins[i] = 0;
- cache_ptr->unpins[i] = 0;
- cache_ptr->dirty_pins[i] = 0;
- cache_ptr->pinned_flushes[i] = 0;
- cache_ptr->pinned_clears[i] = 0;
- cache_ptr->size_increases[i] = 0;
- cache_ptr->size_decreases[i] = 0;
- cache_ptr->entry_flush_size_changes[i] = 0;
- cache_ptr->cache_flush_size_changes[i] = 0;
+ for (i = 0; i <= cache_ptr->max_type_id; i++) {
+ cache_ptr->hits[i] = 0;
+ cache_ptr->misses[i] = 0;
+ cache_ptr->write_protects[i] = 0;
+ cache_ptr->read_protects[i] = 0;
+ cache_ptr->max_read_protects[i] = 0;
+ cache_ptr->insertions[i] = 0;
+ cache_ptr->pinned_insertions[i] = 0;
+ cache_ptr->clears[i] = 0;
+ cache_ptr->flushes[i] = 0;
+ cache_ptr->evictions[i] = 0;
+ cache_ptr->take_ownerships[i] = 0;
+ cache_ptr->moves[i] = 0;
+ cache_ptr->entry_flush_moves[i] = 0;
+ cache_ptr->cache_flush_moves[i] = 0;
+ cache_ptr->pins[i] = 0;
+ cache_ptr->unpins[i] = 0;
+ cache_ptr->dirty_pins[i] = 0;
+ cache_ptr->pinned_flushes[i] = 0;
+ cache_ptr->pinned_clears[i] = 0;
+ cache_ptr->size_increases[i] = 0;
+ cache_ptr->size_decreases[i] = 0;
+ cache_ptr->entry_flush_size_changes[i] = 0;
+ cache_ptr->cache_flush_size_changes[i] = 0;
} /* end for */
- cache_ptr->total_ht_insertions = 0;
- cache_ptr->total_ht_deletions = 0;
- cache_ptr->successful_ht_searches = 0;
- cache_ptr->total_successful_ht_search_depth = 0;
- cache_ptr->failed_ht_searches = 0;
- cache_ptr->total_failed_ht_search_depth = 0;
+ cache_ptr->total_ht_insertions = 0;
+ cache_ptr->total_ht_deletions = 0;
+ cache_ptr->successful_ht_searches = 0;
+ cache_ptr->total_successful_ht_search_depth = 0;
+ cache_ptr->failed_ht_searches = 0;
+ cache_ptr->total_failed_ht_search_depth = 0;
- cache_ptr->max_index_len = 0;
- cache_ptr->max_index_size = (size_t)0;
- cache_ptr->max_clean_index_size = (size_t)0;
- cache_ptr->max_dirty_index_size = (size_t)0;
+ cache_ptr->max_index_len = 0;
+ cache_ptr->max_index_size = (size_t)0;
+ cache_ptr->max_clean_index_size = (size_t)0;
+ cache_ptr->max_dirty_index_size = (size_t)0;
- cache_ptr->max_slist_len = 0;
- cache_ptr->max_slist_size = (size_t)0;
+ cache_ptr->max_slist_len = 0;
+ cache_ptr->max_slist_size = (size_t)0;
- cache_ptr->max_pl_len = 0;
- cache_ptr->max_pl_size = (size_t)0;
+ cache_ptr->max_pl_len = 0;
+ cache_ptr->max_pl_size = (size_t)0;
- cache_ptr->max_pel_len = 0;
- cache_ptr->max_pel_size = (size_t)0;
+ cache_ptr->max_pel_len = 0;
+ cache_ptr->max_pel_size = (size_t)0;
cache_ptr->calls_to_msic = 0;
cache_ptr->total_entries_skipped_in_msic = 0;
@@ -952,27 +783,27 @@ H5C_stats__reset(H5C_t H5_ATTR_UNUSED * cache_ptr)
cache_ptr->max_entries_scanned_in_msic = 0;
cache_ptr->entries_scanned_to_make_space = 0;
- cache_ptr->slist_scan_restarts = 0;
- cache_ptr->LRU_scan_restarts = 0;
- cache_ptr->index_scan_restarts = 0;
+ cache_ptr->slist_scan_restarts = 0;
+ cache_ptr->LRU_scan_restarts = 0;
+ cache_ptr->index_scan_restarts = 0;
- cache_ptr->images_created = 0;
- cache_ptr->images_read = 0;
- cache_ptr->images_loaded = 0;
- cache_ptr->last_image_size = (hsize_t)0;
+ cache_ptr->images_created = 0;
+ cache_ptr->images_read = 0;
+ cache_ptr->images_loaded = 0;
+ cache_ptr->last_image_size = (hsize_t)0;
- cache_ptr->prefetches = 0;
- cache_ptr->dirty_prefetches = 0;
- cache_ptr->prefetch_hits = 0;
+ cache_ptr->prefetches = 0;
+ cache_ptr->dirty_prefetches = 0;
+ cache_ptr->prefetch_hits = 0;
#if H5C_COLLECT_CACHE_ENTRY_STATS
- for(i = 0; i <= cache_ptr->max_type_id; i++) {
- cache_ptr->max_accesses[i] = 0;
- cache_ptr->min_accesses[i] = 1000000;
- cache_ptr->max_clears[i] = 0;
- cache_ptr->max_flushes[i] = 0;
- cache_ptr->max_size[i] = (size_t)0;
- cache_ptr->max_pins[i] = 0;
+ for (i = 0; i <= cache_ptr->max_type_id; i++) {
+ cache_ptr->max_accesses[i] = 0;
+ cache_ptr->min_accesses[i] = 1000000;
+ cache_ptr->max_clears[i] = 0;
+ cache_ptr->max_flushes[i] = 0;
+ cache_ptr->max_size[i] = (size_t)0;
+ cache_ptr->max_pins[i] = 0;
} /* end for */
#endif /* H5C_COLLECT_CACHE_ENTRY_STATS */
@@ -981,7 +812,6 @@ H5C_stats__reset(H5C_t H5_ATTR_UNUSED * cache_ptr)
return;
} /* H5C_stats__reset() */
-
/*-------------------------------------------------------------------------
* Function: H5C_flush_dependency_exists()
*
@@ -1009,13 +839,12 @@ H5C_stats__reset(H5C_t H5_ATTR_UNUSED * cache_ptr)
*/
#ifndef NDEBUG
herr_t
-H5C_flush_dependency_exists(H5C_t *cache_ptr, haddr_t parent_addr, haddr_t child_addr,
- hbool_t *fd_exists_ptr)
+H5C_flush_dependency_exists(H5C_t *cache_ptr, haddr_t parent_addr, haddr_t child_addr, hbool_t *fd_exists_ptr)
{
- hbool_t fd_exists = FALSE; /* whether flush dependency exists */
- H5C_cache_entry_t * parent_ptr; /* Ptr to parent entry */
- H5C_cache_entry_t * child_ptr; /* Ptr to child entry */
- hbool_t ret_value = FALSE; /* Return value */
+ hbool_t fd_exists = FALSE; /* whether flush dependency exists */
+ H5C_cache_entry_t *parent_ptr; /* Ptr to parent entry */
+ H5C_cache_entry_t *child_ptr; /* Ptr to child entry */
+ hbool_t ret_value = FALSE; /* Return value */
FUNC_ENTER_NOAPI(NULL)
@@ -1029,25 +858,25 @@ H5C_flush_dependency_exists(H5C_t *cache_ptr, haddr_t parent_addr, haddr_t child
H5C__SEARCH_INDEX(cache_ptr, parent_addr, parent_ptr, FAIL)
H5C__SEARCH_INDEX(cache_ptr, child_addr, child_ptr, FAIL)
- if(parent_ptr && child_ptr) {
+ if (parent_ptr && child_ptr) {
HDassert(parent_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
HDassert(child_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
- if(child_ptr->flush_dep_nparents > 0) {
- unsigned u; /* Local index variable */
+ if (child_ptr->flush_dep_nparents > 0) {
+ unsigned u; /* Local index variable */
HDassert(child_ptr->flush_dep_parent);
HDassert(child_ptr->flush_dep_parent_nalloc >= child_ptr->flush_dep_nparents);
- for(u = 0; u < child_ptr->flush_dep_nparents; u++) {
- if(child_ptr->flush_dep_parent[u] == parent_ptr) {
+ for (u = 0; u < child_ptr->flush_dep_nparents; u++) {
+ if (child_ptr->flush_dep_parent[u] == parent_ptr) {
fd_exists = TRUE;
HDassert(parent_ptr->flush_dep_nchildren > 0);
break;
} /* end if */
- } /* end for */
- } /* end if */
- } /* end if */
+ } /* end for */
+ } /* end if */
+ } /* end if */
*fd_exists_ptr = fd_exists;
@@ -1056,7 +885,6 @@ done:
} /* H5C_flush_dependency_exists() */
#endif /* NDEBUG */
-
/*-------------------------------------------------------------------------
*
* Function: H5C_validate_index_list
@@ -1077,17 +905,17 @@ done:
herr_t
H5C_validate_index_list(H5C_t *cache_ptr)
{
- H5C_cache_entry_t * entry_ptr = NULL;
- uint32_t len = 0;
- int32_t index_ring_len[H5C_RING_NTYPES];
- size_t size = 0;
- size_t clean_size = 0;
- size_t dirty_size = 0;
- size_t index_ring_size[H5C_RING_NTYPES];
- size_t clean_index_ring_size[H5C_RING_NTYPES];
- size_t dirty_index_ring_size[H5C_RING_NTYPES];
- int i;
- herr_t ret_value = SUCCEED; /* Return value */
+ H5C_cache_entry_t *entry_ptr = NULL;
+ uint32_t len = 0;
+ int32_t index_ring_len[H5C_RING_NTYPES];
+ size_t size = 0;
+ size_t clean_size = 0;
+ size_t dirty_size = 0;
+ size_t index_ring_size[H5C_RING_NTYPES];
+ size_t clean_index_ring_size[H5C_RING_NTYPES];
+ size_t dirty_index_ring_size[H5C_RING_NTYPES];
+ int i;
+ herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_NOAPI_NOINIT
@@ -1095,89 +923,84 @@ H5C_validate_index_list(H5C_t *cache_ptr)
HDassert(cache_ptr);
HDassert(cache_ptr->magic == H5C__H5C_T_MAGIC);
- for(i = 0; i < H5C_RING_NTYPES; i++) {
- index_ring_len[i] = 0;
- index_ring_size[i] = 0;
- clean_index_ring_size[i] = 0;
- dirty_index_ring_size[i] = 0;
+ for (i = 0; i < H5C_RING_NTYPES; i++) {
+ index_ring_len[i] = 0;
+ index_ring_size[i] = 0;
+ clean_index_ring_size[i] = 0;
+ dirty_index_ring_size[i] = 0;
} /* end if */
- if(((cache_ptr->il_head == NULL) || (cache_ptr->il_tail == NULL))
- && (cache_ptr->il_head != cache_ptr->il_tail))
+ if (((cache_ptr->il_head == NULL) || (cache_ptr->il_tail == NULL)) &&
+ (cache_ptr->il_head != cache_ptr->il_tail))
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Index list pointer validation failed")
- if((cache_ptr->index_len == 1) && ((cache_ptr->il_head != cache_ptr->il_tail)
- || (cache_ptr->il_head == NULL) || (cache_ptr->il_head->size != cache_ptr->index_size)))
+ if ((cache_ptr->index_len == 1) &&
+ ((cache_ptr->il_head != cache_ptr->il_tail) || (cache_ptr->il_head == NULL) ||
+ (cache_ptr->il_head->size != cache_ptr->index_size)))
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Index list pointer sanity checks failed")
- if((cache_ptr->index_len >= 1)
- && ((cache_ptr->il_head == NULL)
- || (cache_ptr->il_head->il_prev != NULL)
- || (cache_ptr->il_tail == NULL)
- || (cache_ptr->il_tail->il_next != NULL)))
+ if ((cache_ptr->index_len >= 1) &&
+ ((cache_ptr->il_head == NULL) || (cache_ptr->il_head->il_prev != NULL) ||
+ (cache_ptr->il_tail == NULL) || (cache_ptr->il_tail->il_next != NULL)))
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Index list length sanity checks failed")
entry_ptr = cache_ptr->il_head;
- while(entry_ptr != NULL) {
- if((entry_ptr != cache_ptr->il_head)
- && ((entry_ptr->il_prev == NULL) || (entry_ptr->il_prev->il_next != entry_ptr)))
+ while (entry_ptr != NULL) {
+ if ((entry_ptr != cache_ptr->il_head) &&
+ ((entry_ptr->il_prev == NULL) || (entry_ptr->il_prev->il_next != entry_ptr)))
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Index list pointers for entry are invalid")
- if((entry_ptr != cache_ptr->il_tail)
- && ((entry_ptr->il_next == NULL) || (entry_ptr->il_next->il_prev != entry_ptr)))
+ if ((entry_ptr != cache_ptr->il_tail) &&
+ ((entry_ptr->il_next == NULL) || (entry_ptr->il_next->il_prev != entry_ptr)))
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Index list pointers for entry are invalid")
- HDassert(entry_ptr->ring > 0);
- HDassert(entry_ptr->ring < H5C_RING_NTYPES);
+ HDassert(entry_ptr->ring > 0);
+ HDassert(entry_ptr->ring < H5C_RING_NTYPES);
len++;
- index_ring_len[entry_ptr->ring] += 1;
+ index_ring_len[entry_ptr->ring] += 1;
size += entry_ptr->size;
index_ring_size[entry_ptr->ring] += entry_ptr->size;
- if(entry_ptr->is_dirty) {
- dirty_size += entry_ptr->size;
- dirty_index_ring_size[entry_ptr->ring] += entry_ptr->size;
- } /* end if */
+ if (entry_ptr->is_dirty) {
+ dirty_size += entry_ptr->size;
+ dirty_index_ring_size[entry_ptr->ring] += entry_ptr->size;
+ } /* end if */
else {
- clean_size += entry_ptr->size;
- clean_index_ring_size[entry_ptr->ring] += entry_ptr->size;
- } /* end else */
+ clean_size += entry_ptr->size;
+ clean_index_ring_size[entry_ptr->ring] += entry_ptr->size;
+ } /* end else */
entry_ptr = entry_ptr->il_next;
} /* end while */
- if((cache_ptr->index_len != len) || (cache_ptr->il_len != len)
- || (cache_ptr->index_size != size) || (cache_ptr->il_size != size)
- || (cache_ptr->clean_index_size != clean_size)
- || (cache_ptr->dirty_index_size != dirty_size)
- || (clean_size + dirty_size != size))
+ if ((cache_ptr->index_len != len) || (cache_ptr->il_len != len) || (cache_ptr->index_size != size) ||
+ (cache_ptr->il_size != size) || (cache_ptr->clean_index_size != clean_size) ||
+ (cache_ptr->dirty_index_size != dirty_size) || (clean_size + dirty_size != size))
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Index, clean and dirty sizes for cache are invalid")
- size = 0;
+ size = 0;
clean_size = 0;
dirty_size = 0;
- for(i = 0; i < H5C_RING_NTYPES; i++) {
- size += clean_index_ring_size[i] + dirty_index_ring_size[i];
- clean_size += clean_index_ring_size[i];
- dirty_size += dirty_index_ring_size[i];
+ for (i = 0; i < H5C_RING_NTYPES; i++) {
+ size += clean_index_ring_size[i] + dirty_index_ring_size[i];
+ clean_size += clean_index_ring_size[i];
+ dirty_size += dirty_index_ring_size[i];
} /* end for */
- if((cache_ptr->index_size != size)
- || (cache_ptr->clean_index_size != clean_size)
- || (cache_ptr->dirty_index_size != dirty_size))
+ if ((cache_ptr->index_size != size) || (cache_ptr->clean_index_size != clean_size) ||
+ (cache_ptr->dirty_index_size != dirty_size))
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Index, clean and dirty sizes for cache are invalid")
done:
- if(ret_value != SUCCEED)
+ if (ret_value != SUCCEED)
HDassert(0);
FUNC_LEAVE_NOAPI(ret_value)
} /* H5C_validate_index_list() */
#endif /* NDEBUG */
-
/*-------------------------------------------------------------------------
*
* Function: H5C_get_entry_ptr_from_addr()
@@ -1218,8 +1041,8 @@ done:
herr_t
H5C_get_entry_ptr_from_addr(H5C_t *cache_ptr, haddr_t addr, void **entry_ptr_ptr)
{
- H5C_cache_entry_t * entry_ptr = NULL;
- herr_t ret_value = SUCCEED; /* Return value */
+ H5C_cache_entry_t *entry_ptr = NULL;
+ herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_NOAPI(FAIL)
@@ -1231,7 +1054,7 @@ H5C_get_entry_ptr_from_addr(H5C_t *cache_ptr, haddr_t addr, void **entry_ptr_ptr
H5C__SEARCH_INDEX(cache_ptr, addr, entry_ptr, FAIL)
- if(entry_ptr == NULL)
+ if (entry_ptr == NULL)
/* the entry doesn't exist in the cache -- report this
* and quit.
*/
@@ -1239,8 +1062,8 @@ H5C_get_entry_ptr_from_addr(H5C_t *cache_ptr, haddr_t addr, void **entry_ptr_ptr
else {
*entry_ptr_ptr = entry_ptr;
- /* increment call counter */
- (cache_ptr->get_entry_ptr_from_addr_counter)++;
+ /* increment call counter */
+ (cache_ptr->get_entry_ptr_from_addr_counter)++;
} /* end else */
done:
@@ -1248,7 +1071,6 @@ done:
} /* H5C_get_entry_ptr_from_addr() */
#endif /* NDEBUG */
-
/*-------------------------------------------------------------------------
* Function: H5C_get_serialization_in_progress
*
@@ -1276,7 +1098,6 @@ H5C_get_serialization_in_progress(const H5C_t *cache_ptr)
} /* H5C_get_serialization_in_progress() */
#endif /* NDEBUG */
-
/*-------------------------------------------------------------------------
*
* Function: H5C_cache_is_clean()
@@ -1298,8 +1119,8 @@ H5C_get_serialization_in_progress(const H5C_t *cache_ptr)
hbool_t
H5C_cache_is_clean(const H5C_t *cache_ptr, H5C_ring_t inner_ring)
{
- H5C_ring_t ring = H5C_RING_USER;
- hbool_t ret_value = TRUE; /* Return value */
+ H5C_ring_t ring = H5C_RING_USER;
+ hbool_t ret_value = TRUE; /* Return value */
FUNC_ENTER_NOAPI_NOINIT_NOERR
@@ -1309,11 +1130,11 @@ H5C_cache_is_clean(const H5C_t *cache_ptr, H5C_ring_t inner_ring)
HDassert(inner_ring >= H5C_RING_USER);
HDassert(inner_ring <= H5C_RING_SB);
- while(ring <= inner_ring) {
- if(cache_ptr->dirty_index_ring_size[ring] > 0)
+ while (ring <= inner_ring) {
+ if (cache_ptr->dirty_index_ring_size[ring] > 0)
HGOTO_DONE(FALSE)
- ring++;
+ ring++;
} /* end while */
done:
@@ -1321,7 +1142,6 @@ done:
} /* H5C_cache_is_clean() */
#endif /* NDEBUG */
-
/*-------------------------------------------------------------------------
*
* Function: H5C_verify_entry_type()
@@ -1349,12 +1169,11 @@ done:
*/
#ifndef NDEBUG
herr_t
-H5C_verify_entry_type(H5C_t *cache_ptr, haddr_t addr,
- const H5C_class_t *expected_type, hbool_t *in_cache_ptr,
- hbool_t *type_ok_ptr)
+H5C_verify_entry_type(H5C_t *cache_ptr, haddr_t addr, const H5C_class_t *expected_type, hbool_t *in_cache_ptr,
+ hbool_t *type_ok_ptr)
{
- H5C_cache_entry_t * entry_ptr = NULL;
- herr_t ret_value = SUCCEED; /* Return value */
+ H5C_cache_entry_t *entry_ptr = NULL;
+ herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_NOAPI(FAIL)
@@ -1368,7 +1187,7 @@ H5C_verify_entry_type(H5C_t *cache_ptr, haddr_t addr,
H5C__SEARCH_INDEX(cache_ptr, addr, entry_ptr, FAIL)
- if(entry_ptr == NULL)
+ if (entry_ptr == NULL)
/* the entry doesn't exist in the cache -- report this
* and quit.
*/
@@ -1376,14 +1195,13 @@ H5C_verify_entry_type(H5C_t *cache_ptr, haddr_t addr,
else {
*in_cache_ptr = TRUE;
- if(entry_ptr->prefetched)
- *type_ok_ptr = (expected_type->id == entry_ptr->prefetch_type_id);
- else
- *type_ok_ptr = (expected_type == entry_ptr->type);
+ if (entry_ptr->prefetched)
+ *type_ok_ptr = (expected_type->id == entry_ptr->prefetch_type_id);
+ else
+ *type_ok_ptr = (expected_type == entry_ptr->type);
} /* end else */
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* H5C_verify_entry_type() */
#endif /* NDEBUG */
-