mirror/hdf5
2
0
Fork 0
mirror of https://github.com/HDFGroup/hdf5.git synced 2025-02-05 15:42:32 +08:00
Code Issues Packages Projects Releases Wiki Activity

Cache tidy (#2693)

Browse Source 
* Correct concurrency bugs when running tests, along with a bugfix & small
warning cleanup.

* Committing clang-format changes

* Allow spaces (and tabs) in VOL connector info string from environment variable.

* Parse connector name from HDF5_PLUGIN_PATH environment variable better

* Correct H5VLquery_optional to use H5VL routine instead of H5I.  Also add an
error message to the failure return value from not finding a plugin.

* Play nice with existing plugin paths

* Use API routine to determine if native connector is terminal.

* Committing clang-format changes

* Make string size larger, to allow for connectors with longer names.

* Be more flexible about testing external pass through connectors, especially if
they have registered new optional operations.

* Bring style closer to library's agreed coding style

* Committing clang-format changes

---------

Co-authored-by: github-actions <41898282+github-actions[bot]@users.noreply.github.com>
Co-authored-by: AWS ParallelCluster user <ec2-user@ip-10-0-0-65.us-east-2.compute.internal>
Co-authored-by: Koziol <qkoziol@88665a374c70.ant.amazon.com>
This commit is contained in:
Quincey Koziol 2023-04-11 22:57:47 -05:00 committed by GitHub
parent 367e4a3933
commit 82b7221208
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
7 changed files with 522 additions and 1187 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

65
src/H5AC.c
View File

@ -312,7 +312,7 @@ H5AC_create(const H5F_t *f, H5AC_cache_config_t *config_ptr, H5AC_cache_image_co
HGOTO_ERROR(H5E_CACHE, H5E_CANTCREATE, FAIL, "can't create cleaned entry list")
} /* end if */
/* construct the candidate slist for all processes.
/* construct the candidate skip list for all processes.
* when the distributed strategy is selected as all processes
* will use it in the case of a flush.
*/
@ -439,34 +439,25 @@ H5AC_dest(H5F_t *f)
/* Check if log messages are being emitted */
if (H5C_get_logging_status(f->shared->cache, &log_enabled, &curr_logging) < 0)
HGOTO_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "unable to get logging status")
if (log_enabled && curr_logging) {
if (H5C_log_write_destroy_cache_msg(f->shared->cache) < 0)
HDONE_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "unable to emit log message")
}
/* Tear down logging */
if (log_enabled) {
if (curr_logging)
if (H5C_log_write_destroy_cache_msg(f->shared->cache) < 0)
HGOTO_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "unable to emit log message")
if (H5C_log_tear_down(f->shared->cache) < 0)
HGOTO_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "mdc logging tear-down failed")
}
HGOTO_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "metadata cache logging tear-down failed")
} /* end if */
#ifdef H5_HAVE_PARALLEL
/* destroying the cache, so clear all collective entries */
if (H5C_clear_coll_entries(f->shared->cache, FALSE) < 0)
HGOTO_ERROR(H5E_CACHE, H5E_CANTGET, FAIL, "H5C_clear_coll_entries() failed")
HGOTO_ERROR(H5E_CACHE, H5E_CANTSET, FAIL, "can't clear collective entries")
aux_ptr = (H5AC_aux_t *)H5C_get_aux_ptr(f->shared->cache);
if (aux_ptr) {
/* Sanity check */
HDassert(aux_ptr->magic == H5AC__H5AC_AUX_T_MAGIC);
@ -480,7 +471,7 @@ H5AC_dest(H5F_t *f)
* H5AC__flush_entries() and disable it afterwards, as the
* skip list will be disabled after the previous flush.
*
* Note that H5C_dest() does slist setup and take down as well.
* Note that H5C_dest() does skip list setup and take down as well.
* Unfortunately, we can't do the setup and take down just once,
* as H5C_dest() is called directly in the test code.
*
@ -488,59 +479,45 @@ H5AC_dest(H5F_t *f)
* point, so the overhead should be minimal.
*/
if (H5F_ACC_RDWR & H5F_INTENT(f)) {
/* enable and load the slist */
/* enable and load the skip list */
if (H5C_set_slist_enabled(f->shared->cache, TRUE, FALSE) < 0)
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "set slist enabled failed")
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "can't enable skip list")
if (H5AC__flush_entries(f) < 0)
HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "Can't flush")
/* disable the slist -- should be empty */
/* disable the skip list -- should be empty */
if (H5C_set_slist_enabled(f->shared->cache, FALSE, FALSE) < 0)
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "disable slist failed")
}
}
#endif /* H5_HAVE_PARALLEL */
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "can't disable skip list")
} /* end if */
} /* end if */
#endif /* H5_HAVE_PARALLEL */
/* Destroy the cache */
if (H5C_dest(f) < 0)
HGOTO_ERROR(H5E_CACHE, H5E_CANTFREE, FAIL, "can't destroy cache")
f->shared->cache = NULL;
#ifdef H5_HAVE_PARALLEL
if (aux_ptr != NULL) {
if (aux_ptr->d_slist_ptr != NULL) {
HDassert(H5SL_count(aux_ptr->d_slist_ptr) == 0);
H5SL_close(aux_ptr->d_slist_ptr);
} /* end if */
if (aux_ptr->c_slist_ptr != NULL) {
HDassert(H5SL_count(aux_ptr->c_slist_ptr) == 0);
H5SL_close(aux_ptr->c_slist_ptr);
} /* end if */
if (aux_ptr->candidate_slist_ptr != NULL) {
HDassert(H5SL_count(aux_ptr->candidate_slist_ptr) == 0);
H5SL_close(aux_ptr->candidate_slist_ptr);
} /* end if */
aux_ptr->magic = 0;
aux_ptr = H5FL_FREE(H5AC_aux_t, aux_ptr);
} /* end if */
#endif /* H5_HAVE_PARALLEL */
@ -1215,13 +1192,10 @@ H5AC_prep_for_file_flush(H5F_t *f)
HDassert(f->shared->cache);
if (H5C_set_slist_enabled(f->shared->cache, TRUE, FALSE) < 0)
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "slist enabled failed")
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "can't enable skip list")
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* H5AC_prep_for_file_flush() */
/*-------------------------------------------------------------------------
@ -1235,7 +1209,7 @@ done:
* to do any necessary necessary cleanup work after a cache
* flush.
*
* Initially, this means taking down the slist after the
* Initially, this means taking down the skip list after the
* flush. We do this in a separate call because
* H5F__flush_phase2() make repeated calls to H5AC_flush().
* Handling this detail in separate calls allows us to avoid
@ -1262,13 +1236,10 @@ H5AC_secure_from_file_flush(H5F_t *f)
HDassert(f->shared->cache);
if (H5C_set_slist_enabled(f->shared->cache, FALSE, FALSE) < 0)
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "slist enabled failed")
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "can't disable skip list")
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* H5AC_secure_from_file_flush() */
/*-------------------------------------------------------------------------

25
src/H5ACmpio.c
View File

@ -1888,12 +1888,9 @@ H5AC__rsp__p0_only__flush(H5F_t *f)
* However, when flushing from within the close operation from a file,
* it's possible to skip this barrier (on the second flush of the cache).
*/
if (!H5CX_get_mpi_file_flushing()) {
if (!H5CX_get_mpi_file_flushing())
if (MPI_SUCCESS != (mpi_result = MPI_Barrier(aux_ptr->mpi_comm)))
HMPI_GOTO_ERROR(FAIL, "MPI_Barrier failed", mpi_result)
}
/* Flush data to disk, from rank 0 process */
if (aux_ptr->mpi_rank == 0) {
@ -2102,31 +2099,28 @@ H5AC__run_sync_point(H5F_t *f, int sync_point_op)
/* Sanity checks */
HDassert(f != NULL);
cache_ptr = f->shared->cache;
HDassert(cache_ptr != NULL);
aux_ptr = (H5AC_aux_t *)H5C_get_aux_ptr(cache_ptr);
HDassert(aux_ptr != NULL);
HDassert(aux_ptr->magic == H5AC__H5AC_AUX_T_MAGIC);
HDassert((sync_point_op == H5AC_SYNC_POINT_OP__FLUSH_TO_MIN_CLEAN) ||
(sync_point_op == H5AC_METADATA_WRITE_STRATEGY__DISTRIBUTED));
#ifdef H5AC_DEBUG_DIRTY_BYTES_CREATION
HDfprintf(stdout, "%d:H5AC_propagate...:%u: (u/uu/i/iu/m/mu) = %zu/%u/%zu/%u/%zu/%u\n", aux_ptr->mpi_rank,
aux_ptr->dirty_bytes_propagations, aux_ptr->unprotect_dirty_bytes,
HDfprintf(stdout, "%d:%s...:%u: (u/uu/i/iu/m/mu) = %zu/%u/%zu/%u/%zu/%u\n", aux_ptr->mpi_rank,
__func__ aux_ptr->dirty_bytes_propagations, aux_ptr->unprotect_dirty_bytes,
aux_ptr->unprotect_dirty_bytes_updates, aux_ptr->insert_dirty_bytes,
aux_ptr->insert_dirty_bytes_updates, aux_ptr->move_dirty_bytes,
aux_ptr->move_dirty_bytes_updates);
#endif /* H5AC_DEBUG_DIRTY_BYTES_CREATION */
/* clear collective access flag on half of the entries in the
cache and mark them as independent in case they need to be
evicted later. All ranks are guaranteed to mark the same entries
since we don't modify the order of the collectively accessed
entries except through collective access. */
/* Clear collective access flag on half of the entries in the cache and
* mark them as independent in case they need to be evicted later. All
* ranks are guaranteed to mark the same entries since we don't modify the
* order of the collectively accessed entries except through collective
* access.
*/
if (H5C_clear_coll_entries(cache_ptr, TRUE) < 0)
HGOTO_ERROR(H5E_CACHE, H5E_CANTGET, FAIL, "H5C_clear_coll_entries() failed.")
@ -2188,7 +2182,6 @@ H5AC__run_sync_point(H5F_t *f, int sync_point_op)
#endif /* H5AC_DEBUG_DIRTY_BYTES_CREATION */
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* H5AC__run_sync_point() */

1141
src/H5C.c
View File

File diff suppressed because it is too large Load Diff

24
src/H5Cdbg.c
View File

@ -291,49 +291,33 @@ H5C_dump_cache_skip_list(H5C_t *cache_ptr, char *calling_fcn)
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 {
else
entry_ptr = NULL;
}
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, " node_ptr = %p, item = %p\n", (void *)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 {
else
entry_ptr = NULL;
}
i++;
} /* end while */
} /* end if */
HDfprintf(stdout, "\n\n");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5C_dump_cache_skip_list() */
#endif /* NDEBUG */

95
src/H5Cimage.c
View File

@ -298,8 +298,8 @@ H5C__construct_cache_image_buffer(H5F_t *f, H5C_t *cache_ptr)
HDassert(fake_cache_ptr->image_entries);
for (u = 0; u < fake_cache_ptr->num_entries_in_image; u++) {
(fake_cache_ptr->image_entries)[u].magic = H5C_IMAGE_ENTRY_T_MAGIC;
(fake_cache_ptr->image_entries)[u].image_ptr = NULL;
fake_cache_ptr->image_entries[u].magic = H5C_IMAGE_ENTRY_T_MAGIC;
fake_cache_ptr->image_entries[u].image_ptr = NULL;
/* touch up f->shared->cache to satisfy sanity checks... */
f->shared->cache = fake_cache_ptr;
@ -310,43 +310,42 @@ H5C__construct_cache_image_buffer(H5F_t *f, H5C_t *cache_ptr)
f->shared->cache = cache_ptr;
/* verify expected contents */
HDassert((cache_ptr->image_entries)[u].addr == (fake_cache_ptr->image_entries)[u].addr);
HDassert((cache_ptr->image_entries)[u].size == (fake_cache_ptr->image_entries)[u].size);
HDassert((cache_ptr->image_entries)[u].type_id == (fake_cache_ptr->image_entries)[u].type_id);
HDassert((cache_ptr->image_entries)[u].lru_rank == (fake_cache_ptr->image_entries)[u].lru_rank);
HDassert((cache_ptr->image_entries)[u].is_dirty == (fake_cache_ptr->image_entries)[u].is_dirty);
HDassert(cache_ptr->image_entries[u].addr == fake_cache_ptr->image_entries[u].addr);
HDassert(cache_ptr->image_entries[u].size == fake_cache_ptr->image_entries[u].size);
HDassert(cache_ptr->image_entries[u].type_id == fake_cache_ptr->image_entries[u].type_id);
HDassert(cache_ptr->image_entries[u].lru_rank == fake_cache_ptr->image_entries[u].lru_rank);
HDassert(cache_ptr->image_entries[u].is_dirty == fake_cache_ptr->image_entries[u].is_dirty);
/* don't check image_fd_height as it is not stored in
* the metadata cache image block.
*/
HDassert((cache_ptr->image_entries)[u].fd_child_count ==
(fake_cache_ptr->image_entries)[u].fd_child_count);
HDassert((cache_ptr->image_entries)[u].fd_dirty_child_count ==
(fake_cache_ptr->image_entries)[u].fd_dirty_child_count);
HDassert((cache_ptr->image_entries)[u].fd_parent_count ==
(fake_cache_ptr->image_entries)[u].fd_parent_count);
HDassert(cache_ptr->image_entries[u].fd_child_count ==
fake_cache_ptr->image_entries[u].fd_child_count);
HDassert(cache_ptr->image_entries[u].fd_dirty_child_count ==
fake_cache_ptr->image_entries[u].fd_dirty_child_count);
HDassert(cache_ptr->image_entries[u].fd_parent_count ==
fake_cache_ptr->image_entries[u].fd_parent_count);
for (v = 0; v < (cache_ptr->image_entries)[u].fd_parent_count; v++)
HDassert((cache_ptr->image_entries)[u].fd_parent_addrs[v] ==
(fake_cache_ptr->image_entries)[u].fd_parent_addrs[v]);
for (v = 0; v < cache_ptr->image_entries[u].fd_parent_count; v++)
HDassert(cache_ptr->image_entries[u].fd_parent_addrs[v] ==
fake_cache_ptr->image_entries[u].fd_parent_addrs[v]);
/* free the fd_parent_addrs array if it exists */
if ((fake_cache_ptr->image_entries)[u].fd_parent_addrs) {
HDassert((fake_cache_ptr->image_entries)[u].fd_parent_count > 0);
(fake_cache_ptr->image_entries)[u].fd_parent_addrs =
(haddr_t *)H5MM_xfree((fake_cache_ptr->image_entries)[u].fd_parent_addrs);
(fake_cache_ptr->image_entries)[u].fd_parent_count = 0;
if (fake_cache_ptr->image_entries[u].fd_parent_addrs) {
HDassert(fake_cache_ptr->image_entries[u].fd_parent_count > 0);
fake_cache_ptr->image_entries[u].fd_parent_addrs =
(haddr_t *)H5MM_xfree(fake_cache_ptr->image_entries[u].fd_parent_addrs);
fake_cache_ptr->image_entries[u].fd_parent_count = 0;
} /* end if */
else
HDassert((fake_cache_ptr->image_entries)[u].fd_parent_count == 0);
HDassert(fake_cache_ptr->image_entries[u].fd_parent_count == 0);
HDassert((cache_ptr->image_entries)[u].image_ptr);
HDassert((fake_cache_ptr->image_entries)[u].image_ptr);
HDassert(!HDmemcmp((cache_ptr->image_entries)[u].image_ptr,
(fake_cache_ptr->image_entries)[u].image_ptr,
(cache_ptr->image_entries)[u].size));
HDassert(cache_ptr->image_entries[u].image_ptr);
HDassert(fake_cache_ptr->image_entries[u].image_ptr);
HDassert(!HDmemcmp(cache_ptr->image_entries[u].image_ptr,
fake_cache_ptr->image_entries[u].image_ptr, cache_ptr->image_entries[u].size));
(fake_cache_ptr->image_entries)[u].image_ptr =
H5MM_xfree((fake_cache_ptr->image_entries)[u].image_ptr);
fake_cache_ptr->image_entries[u].image_ptr =
H5MM_xfree(fake_cache_ptr->image_entries[u].image_ptr);
} /* end for */
HDassert((size_t)(q - (const uint8_t *)cache_ptr->image_buffer) ==
@ -692,12 +691,10 @@ H5C__deserialize_prefetched_entry(H5F_t *f, H5C_t *cache_ptr, H5C_cache_entry_t
pf_entry_ptr->image_ptr = NULL;
if (pf_entry_ptr->is_dirty) {
HDassert(((cache_ptr->slist_enabled) && (pf_entry_ptr->in_slist)) ||
((!cache_ptr->slist_enabled) && (!pf_entry_ptr->in_slist)));
flush_flags |= H5C__DEL_FROM_SLIST_ON_DESTROY_FLAG;
} /* end if */
if (H5C__flush_single_entry(f, pf_entry_ptr, flush_flags) < 0)
@ -826,7 +823,7 @@ H5C__free_image_entries_array(H5C_t *cache_ptr)
H5C_image_entry_t *ie_ptr; /* Image entry to release */
/* Get pointer to image entry */
ie_ptr = &((cache_ptr->image_entries)[u]);
ie_ptr = &(cache_ptr->image_entries[u]);
/* Sanity checks */
HDassert(ie_ptr);
@ -987,7 +984,6 @@ H5C__read_cache_image(H5F_t *f, H5C_t *cache_ptr)
int mpi_result;
if ((NULL == aux_ptr) || (aux_ptr->mpi_rank == 0)) {
HDassert((NULL == aux_ptr) || (aux_ptr->magic == H5AC__H5AC_AUX_T_MAGIC));
#endif /* H5_HAVE_PARALLEL */
@ -1003,21 +999,16 @@ H5C__read_cache_image(H5F_t *f, H5C_t *cache_ptr)
#ifdef H5_HAVE_PARALLEL
if (aux_ptr) {
/* Broadcast cache image */
if (MPI_SUCCESS != (mpi_result = MPI_Bcast(cache_ptr->image_buffer, (int)cache_ptr->image_len,
MPI_BYTE, 0, aux_ptr->mpi_comm)))
HMPI_GOTO_ERROR(FAIL, "MPI_Bcast failed", mpi_result)
} /* end if */
} /* end if */
else if (aux_ptr) {
/* Retrieve the contents of the metadata cache image from process 0 */
if (MPI_SUCCESS != (mpi_result = MPI_Bcast(cache_ptr->image_buffer, (int)cache_ptr->image_len,
MPI_BYTE, 0, aux_ptr->mpi_comm)))
HMPI_GOTO_ERROR(FAIL, "can't receive cache image MPI_Bcast", mpi_result)
} /* end else-if */
} /* end block */
@ -1866,7 +1857,7 @@ H5C__decode_cache_image_entry(const H5F_t *f, const H5C_t *cache_ptr, const uint
HDassert(buf);
HDassert(*buf);
HDassert(entry_num < cache_ptr->num_entries_in_image);
ie_ptr = &((cache_ptr->image_entries)[entry_num]);
ie_ptr = &(cache_ptr->image_entries[entry_num]);
HDassert(ie_ptr);
HDassert(ie_ptr->magic == H5C_IMAGE_ENTRY_T_MAGIC);
@ -2217,7 +2208,7 @@ H5C__encode_cache_image_entry(H5F_t *f, H5C_t *cache_ptr, uint8_t **buf, unsigne
HDassert(buf);
HDassert(*buf);
HDassert(entry_num < cache_ptr->num_entries_in_image);
ie_ptr = &((cache_ptr->image_entries)[entry_num]);
ie_ptr = &(cache_ptr->image_entries[entry_num]);
HDassert(ie_ptr->magic == H5C_IMAGE_ENTRY_T_MAGIC);
/* Get pointer to buffer to encode into */
@ -2924,12 +2915,14 @@ H5C__prep_for_file_close__scan_entries(const H5F_t *f, H5C_t *cache_ptr)
HDassert(num_entries_in_image <= num_entries_tentatively_in_image);
#ifndef NDEBUG
unsigned j = 0;
for (int i = H5C_MAX_RING_IN_IMAGE + 1; i <= H5C_RING_SB; i++)
j += cache_ptr->index_ring_len[i];
{
unsigned j = 0;
for (int i = H5C_MAX_RING_IN_IMAGE + 1; i <= H5C_RING_SB; i++)
j += cache_ptr->index_ring_len[i];
/* This will change */
HDassert(entries_visited == (num_entries_tentatively_in_image + j));
/* This will change */
HDassert(entries_visited == (num_entries_tentatively_in_image + j));
}
#endif
cache_ptr->num_entries_in_image = num_entries_in_image;
@ -3127,23 +3120,17 @@ H5C__reconstruct_cache_contents(H5F_t *f, H5C_t *cache_ptr)
i = -1;
entry_ptr = cache_ptr->LRU_head_ptr;
while (entry_ptr != NULL) {
HDassert(entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
HDassert(entry_ptr->type != NULL);
if (entry_ptr->prefetched) {
HDassert(entry_ptr->lru_rank != 0);
HDassert((entry_ptr->lru_rank == -1) || (entry_ptr->lru_rank > i));
if ((entry_ptr->lru_rank > 1) && (entry_ptr->lru_rank > i + 1))
lru_rank_holes += entry_ptr->lru_rank - (i + 1);
i = entry_ptr->lru_rank;
} /* end if */
entry_ptr = entry_ptr->next;
@ -3168,10 +3155,8 @@ H5C__reconstruct_cache_contents(H5F_t *f, H5C_t *cache_ptr)
*/
hbool_t write_permitted = FALSE;
if (cache_ptr->check_write_permitted != NULL) {
if ((cache_ptr->check_write_permitted)(f, &write_permitted) < 0)
HGOTO_ERROR(H5E_CACHE, H5E_CANTPROTECT, FAIL, "Can't get write_permitted")
} /* end if */
if (cache_ptr->check_write_permitted && (cache_ptr->check_write_permitted)(f, &write_permitted) < 0)
HGOTO_ERROR(H5E_CACHE, H5E_CANTPROTECT, FAIL, "Can't get write_permitted")
else
write_permitted = cache_ptr->write_permitted;

52
src/H5Cmpio.c
View File

@ -212,7 +212,7 @@ H5C_apply_candidate_list(H5F_t *f, H5C_t *cache_ptr, unsigned num_candidates, ha
/* Create skip list of entries for collective write */
if (NULL == (cache_ptr->coll_write_list = H5SL_create(H5SL_TYPE_HADDR, NULL)))
HGOTO_ERROR(H5E_DATASET, H5E_CANTCREATE, FAIL, "can't create skip list for entries")
HGOTO_ERROR(H5E_CACHE, H5E_CANTCREATE, FAIL, "can't create skip list for entries")
} /* end if */
n = num_candidates / (unsigned)mpi_size;
@ -220,8 +220,7 @@ H5C_apply_candidate_list(H5F_t *f, H5C_t *cache_ptr, unsigned num_candidates, ha
if (NULL ==
(candidate_assignment_table = (unsigned *)H5MM_malloc(sizeof(unsigned) * (size_t)(mpi_size + 1))))
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL,
"memory allocation failed for candidate assignment table")
HGOTO_ERROR(H5E_CACHE, H5E_NOSPACE, FAIL, "memory allocation failed for candidate assignment table")
candidate_assignment_table[0] = 0;
candidate_assignment_table[mpi_size] = num_candidates;
@ -437,7 +436,6 @@ H5C_construct_candidate_list__clean_cache(H5C_t *cache_ptr)
(cache_ptr->slist_len <= (cache_ptr->dLRU_list_len + cache_ptr->pel_len)));
if (space_needed > 0) {
H5C_cache_entry_t *entry_ptr;
unsigned nominated_entries_count = 0;
size_t nominated_entries_size = 0;
@ -449,11 +447,9 @@ H5C_construct_candidate_list__clean_cache(H5C_t *cache_ptr)
* entries to free up the necessary space.
*/
entry_ptr = cache_ptr->dLRU_tail_ptr;
while ((nominated_entries_size < space_needed) &&
((!cache_ptr->slist_enabled) || (nominated_entries_count < cache_ptr->slist_len)) &&
(entry_ptr != NULL)) {
HDassert(!(entry_ptr->is_protected));
HDassert(!(entry_ptr->is_read_only));
HDassert(entry_ptr->ro_ref_count == 0);
@ -461,15 +457,13 @@ H5C_construct_candidate_list__clean_cache(H5C_t *cache_ptr)
HDassert((!cache_ptr->slist_enabled) || (entry_ptr->in_slist));
nominated_addr = entry_ptr->addr;
if (H5AC_add_candidate((H5AC_t *)cache_ptr, nominated_addr) < 0)
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "H5AC_add_candidate() failed")
nominated_entries_size += entry_ptr->size;
nominated_entries_count++;
entry_ptr = entry_ptr->aux_prev;
entry_ptr = entry_ptr->aux_prev;
} /* end while */
HDassert(entry_ptr == NULL);
@ -478,13 +472,10 @@ H5C_construct_candidate_list__clean_cache(H5C_t *cache_ptr)
* protected entry list as well -- scan it too if necessary
*/
entry_ptr = cache_ptr->pel_head_ptr;
while ((nominated_entries_size < space_needed) &&
((!cache_ptr->slist_enabled) || (nominated_entries_count < cache_ptr->slist_len)) &&
(entry_ptr != NULL)) {
if (entry_ptr->is_dirty) {
HDassert(!(entry_ptr->is_protected));
HDassert(!(entry_ptr->is_read_only));
HDassert(entry_ptr->ro_ref_count == 0);
@ -492,29 +483,22 @@ H5C_construct_candidate_list__clean_cache(H5C_t *cache_ptr)
HDassert(entry_ptr->in_slist);
nominated_addr = entry_ptr->addr;
if (H5AC_add_candidate((H5AC_t *)cache_ptr, nominated_addr) < 0)
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "H5AC_add_candidate() failed")
nominated_entries_size += entry_ptr->size;
nominated_entries_count++;
} /* end if */
entry_ptr = entry_ptr->next;
} /* end while */
HDassert((!cache_ptr->slist_enabled) || (nominated_entries_count == cache_ptr->slist_len));
HDassert(nominated_entries_size == space_needed);
} /* end if */
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* H5C_construct_candidate_list__clean_cache() */
/*-------------------------------------------------------------------------
@ -552,30 +536,20 @@ H5C_construct_candidate_list__min_clean(H5C_t *cache_ptr)
if (cache_ptr->max_cache_size > cache_ptr->index_size) {
if (((cache_ptr->max_cache_size - cache_ptr->index_size) + cache_ptr->cLRU_list_size) >=
cache_ptr->min_clean_size) {
cache_ptr->min_clean_size)
space_needed = 0;
}
else {
else
space_needed = cache_ptr->min_clean_size -
((cache_ptr->max_cache_size - cache_ptr->index_size) + cache_ptr->cLRU_list_size);
}
} /* end if */
else {
if (cache_ptr->min_clean_size <= cache_ptr->cLRU_list_size) {
if (cache_ptr->min_clean_size <= cache_ptr->cLRU_list_size)
space_needed = 0;
}
else {
else
space_needed = cache_ptr->min_clean_size - cache_ptr->cLRU_list_size;
}
} /* end else */
if (space_needed > 0) { /* we have work to do */
H5C_cache_entry_t *entry_ptr;
unsigned nominated_entries_count = 0;
size_t nominated_entries_size = 0;
@ -586,11 +560,9 @@ H5C_construct_candidate_list__min_clean(H5C_t *cache_ptr)
* entries to free up the necessary space.
*/
entry_ptr = cache_ptr->dLRU_tail_ptr;
while ((nominated_entries_size < space_needed) &&
((!cache_ptr->slist_enabled) || (nominated_entries_count < cache_ptr->slist_len)) &&
(entry_ptr != NULL) && (!entry_ptr->flush_me_last)) {
haddr_t nominated_addr;
HDassert(!(entry_ptr->is_protected));
@ -600,15 +572,13 @@ H5C_construct_candidate_list__min_clean(H5C_t *cache_ptr)
HDassert((!cache_ptr->slist_enabled) || (entry_ptr->in_slist));
nominated_addr = entry_ptr->addr;
if (H5AC_add_candidate((H5AC_t *)cache_ptr, nominated_addr) < 0)
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "H5AC_add_candidate() failed")
nominated_entries_size += entry_ptr->size;
nominated_entries_count++;
entry_ptr = entry_ptr->aux_prev;
entry_ptr = entry_ptr->aux_prev;
} /* end while */
HDassert((!cache_ptr->slist_enabled) || (nominated_entries_count <= cache_ptr->slist_len));
@ -833,10 +803,8 @@ H5C_mark_entries_as_clean(H5F_t *f, unsigned ce_array_len, haddr_t *ce_array_ptr
u = 0;
entry_ptr = cache_ptr->pl_head_ptr;
while (entry_ptr != NULL) {
if (entry_ptr->clear_on_unprotect) {
if (entry_ptr->clear_on_unprotect)
u++;
}
entry_ptr = entry_ptr->next;
}
HDassert((entries_cleared + u) == ce_array_len);
@ -846,7 +814,7 @@ done:
#ifdef H5C_DO_EXTREME_SANITY_CHECKS
if (H5C_validate_protected_entry_list(cache_ptr) < 0 || H5C_validate_pinned_entry_list(cache_ptr) < 0 ||
H5C_validate_lru_list(cache_ptr) < 0)
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on exit")
HDONE_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on exit")
#endif /* H5C_DO_EXTREME_SANITY_CHECKS */
FUNC_LEAVE_NOAPI(ret_value)

307
src/H5Cpkg.h
View File

@ -212,7 +212,7 @@ if ( ( (new_size) > (dll_size) ) || \
(head_ptr) = (entry_ptr); \
} \
(len)++; \
(Size) += entry_ptr->size; \
(Size) += (entry_ptr)->size; \
} /* H5C__DLL_PREPEND() */
#define H5C__DLL_REMOVE(entry_ptr, head_ptr, tail_ptr, len, Size, fail_val) \
@ -236,10 +236,10 @@ if ( ( (new_size) > (dll_size) ) || \
} \
else \
(entry_ptr)->next->prev = (entry_ptr)->prev; \
entry_ptr->next = NULL; \
entry_ptr->prev = NULL; \
(entry_ptr)->next = NULL; \
(entry_ptr)->prev = NULL; \
(len)--; \
(Size) -= entry_ptr->size; \
(Size) -= (entry_ptr)->size; \
} \
} /* H5C__DLL_REMOVE() */
@ -525,61 +525,55 @@ if ( ( ( ( (head_ptr) == NULL ) || ( (tail_ptr) == NULL ) ) && \
***********************************************************************/
#define H5C__UPDATE_CACHE_HIT_RATE_STATS(cache_ptr, hit) \
(cache_ptr->cache_accesses)++; \
if ( hit ) { \
(cache_ptr->cache_hits)++; \
} \
(cache_ptr)->cache_accesses++; \
if (hit) \
(cache_ptr)->cache_hits++;
#if H5C_COLLECT_CACHE_STATS
#define H5C__UPDATE_MAX_INDEX_SIZE_STATS(cache_ptr) \
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;
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;
#define H5C__UPDATE_STATS_FOR_DIRTY_PIN(cache_ptr, entry_ptr) \
(((cache_ptr)->dirty_pins)[(entry_ptr)->type->id])++;
(cache_ptr)->dirty_pins[(entry_ptr)->type->id]++;
#define H5C__UPDATE_STATS_FOR_UNPROTECT(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 ( (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 ) \
#define H5C__UPDATE_STATS_FOR_UNPROTECT(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 ((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;
#define H5C__UPDATE_STATS_FOR_MOVE(cache_ptr, entry_ptr) \
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++;
#define H5C__UPDATE_STATS_FOR_MOVE(cache_ptr, entry_ptr) \
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++;
#define H5C__UPDATE_STATS_FOR_ENTRY_SIZE_CHANGE(cache_ptr, entry_ptr, new_size)\
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])++; \
}
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]++;
#define H5C__UPDATE_STATS_FOR_HT_INSERTION(cache_ptr) \
(cache_ptr)->total_ht_insertions++;
@ -588,7 +582,7 @@ if ( ( ( ( (head_ptr) == NULL ) || ( (tail_ptr) == NULL ) ) && \
(cache_ptr)->total_ht_deletions++;
#define H5C__UPDATE_STATS_FOR_HT_SEARCH(cache_ptr, success, depth) \
if ( success ) { \
if (success) { \
(cache_ptr)->successful_ht_searches++; \
(cache_ptr)->total_successful_ht_search_depth += depth; \
} else { \
@ -597,21 +591,19 @@ if ( ( ( ( (head_ptr) == NULL ) || ( (tail_ptr) == NULL ) ) && \
}
#define H5C__UPDATE_STATS_FOR_UNPIN(cache_ptr, entry_ptr) \
((cache_ptr)->unpins)[(entry_ptr)->type->id]++;
(cache_ptr)->unpins[(entry_ptr)->type->id]++;
#define H5C__UPDATE_STATS_FOR_SLIST_SCAN_RESTART(cache_ptr) \
((cache_ptr)->slist_scan_restarts)++;
(cache_ptr)->slist_scan_restarts++;
#define H5C__UPDATE_STATS_FOR_LRU_SCAN_RESTART(cache_ptr) \
((cache_ptr)->LRU_scan_restarts)++;
(cache_ptr)->LRU_scan_restarts++;
#define H5C__UPDATE_STATS_FOR_INDEX_SCAN_RESTART(cache_ptr) \
((cache_ptr)->index_scan_restarts)++;
(cache_ptr)->index_scan_restarts++;
#define H5C__UPDATE_STATS_FOR_CACHE_IMAGE_CREATE(cache_ptr) \
{ \
(cache_ptr)->images_created++; \
}
(cache_ptr)->images_created++;
#define H5C__UPDATE_STATS_FOR_CACHE_IMAGE_READ(cache_ptr) \
{ \
@ -631,14 +623,12 @@ if ( ( ( ( (head_ptr) == NULL ) || ( (tail_ptr) == NULL ) ) && \
#define H5C__UPDATE_STATS_FOR_PREFETCH(cache_ptr, dirty) \
{ \
(cache_ptr)->prefetches++; \
if ( dirty ) \
if (dirty) \
(cache_ptr)->dirty_prefetches++; \
}
#define H5C__UPDATE_STATS_FOR_PREFETCH_HIT(cache_ptr) \
{ \
(cache_ptr)->prefetch_hits++; \
}
(cache_ptr)->prefetch_hits++;
#if H5C_COLLECT_CACHE_ENTRY_STATS
@ -652,113 +642,96 @@ if ( ( ( ( (head_ptr) == NULL ) || ( (tail_ptr) == NULL ) ) && \
#define H5C__UPDATE_STATS_FOR_CLEAR(cache_ptr, entry_ptr) \
{ \
(((cache_ptr)->clears)[(entry_ptr)->type->id])++; \
(cache_ptr)->clears[(entry_ptr)->type->id]++; \
if((entry_ptr)->is_pinned) \
(((cache_ptr)->pinned_clears)[(entry_ptr)->type->id])++; \
((entry_ptr)->clears)++; \
(cache_ptr)->pinned_clears[(entry_ptr)->type->id]++; \
(entry_ptr)->clears++; \
}
#define H5C__UPDATE_STATS_FOR_FLUSH(cache_ptr, entry_ptr) \
{ \
(((cache_ptr)->flushes)[(entry_ptr)->type->id])++; \
(cache_ptr)->flushes[(entry_ptr)->type->id]++; \
if((entry_ptr)->is_pinned) \
(((cache_ptr)->pinned_flushes)[(entry_ptr)->type->id])++; \
((entry_ptr)->flushes)++; \
(cache_ptr)->pinned_flushes[(entry_ptr)->type->id]++; \
(entry_ptr)->flushes++; \
}
#define H5C__UPDATE_STATS_FOR_EVICTION(cache_ptr, entry_ptr, take_ownership) \
{ \
if ( take_ownership ) \
(((cache_ptr)->take_ownerships)[(entry_ptr)->type->id])++; \
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; \
(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; \
}
#define H5C__UPDATE_STATS_FOR_INSERTION(cache_ptr, entry_ptr) \
{ \
(((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]++; \
(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 ) \
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 ) \
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 ) \
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 ) \
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 ) \
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++; \
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++; \
}
#define H5C__UPDATE_STATS_FOR_PROTECT(cache_ptr, entry_ptr, hit) \
{ \
if ( hit ) \
((cache_ptr)->hits)[(entry_ptr)->type->id]++; \
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); \
(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 ) \
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 ) \
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 ) \
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)++; \
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++; \
}
#define H5C__UPDATE_STATS_FOR_PIN(cache_ptr, entry_ptr) \
{ \
((cache_ptr)->pins)[(entry_ptr)->type->id]++; \
(cache_ptr)->pins[(entry_ptr)->type->id]++; \
(entry_ptr)->pins++; \
if ( (cache_ptr)->pel_len > (cache_ptr)->max_pel_len ) \
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 ) \
if ((cache_ptr)->pel_size > (cache_ptr)->max_pel_size) \
(cache_ptr)->max_pel_size = (cache_ptr)->pel_size; \
}
@ -768,24 +741,24 @@ if ( ( ( ( (head_ptr) == NULL ) || ( (tail_ptr) == NULL ) ) && \
#define H5C__UPDATE_STATS_FOR_CLEAR(cache_ptr, entry_ptr) \
{ \
(((cache_ptr)->clears)[(entry_ptr)->type->id])++; \
(cache_ptr)->clears[(entry_ptr)->type->id]++; \
if((entry_ptr)->is_pinned) \
(((cache_ptr)->pinned_clears)[(entry_ptr)->type->id])++; \
(cache_ptr)->pinned_clears[(entry_ptr)->type->id]++; \
}
#define H5C__UPDATE_STATS_FOR_FLUSH(cache_ptr, entry_ptr) \
{ \
(((cache_ptr)->flushes)[(entry_ptr)->type->id])++; \
if ( (entry_ptr)->is_pinned ) \
(((cache_ptr)->pinned_flushes)[(entry_ptr)->type->id])++; \
(cache_ptr)->flushes[(entry_ptr)->type->id]++; \
if ((entry_ptr)->is_pinned) \
(cache_ptr)->pinned_flushes[(entry_ptr)->type->id]++; \
}
#define H5C__UPDATE_STATS_FOR_EVICTION(cache_ptr, entry_ptr, take_ownership) \
{ \
if ( take_ownership ) \
(((cache_ptr)->take_ownerships)[(entry_ptr)->type->id])++; \
if (take_ownership) \
(cache_ptr)->take_ownerships[(entry_ptr)->type->id]++; \
else \
(((cache_ptr)->evictions)[(entry_ptr)->type->id])++; \
(cache_ptr)->evictions[(entry_ptr)->type->id]++; \
}
#define H5C__UPDATE_STATS_FOR_INSERTION(cache_ptr, entry_ptr) \
@ -806,7 +779,7 @@ if ( ( ( ( (head_ptr) == NULL ) || ( (tail_ptr) == NULL ) ) && \
(cache_ptr)->max_slist_len = (cache_ptr)->slist_len; \
if ( (cache_ptr)->slist_size > (cache_ptr)->max_slist_size ) \
(cache_ptr)->max_slist_size = (cache_ptr)->slist_size; \
cache_ptr->entries_inserted_counter++; \
(cache_ptr)->entries_inserted_counter++; \
}
#define H5C__UPDATE_STATS_FOR_PROTECT(cache_ptr, entry_ptr, hit) \
@ -855,7 +828,7 @@ if ( ( ( ( (head_ptr) == NULL ) || ( (tail_ptr) == NULL ) ) && \
#define H5C__UPDATE_STATS_FOR_HT_DELETION(cache_ptr)
#define H5C__UPDATE_STATS_FOR_HT_SEARCH(cache_ptr, success, depth)
#define H5C__UPDATE_STATS_FOR_INSERTION(cache_ptr, entry_ptr)
#define H5C__UPDATE_STATS_FOR_CLEAR(cache_ptr, 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_PROTECT(cache_ptr, entry_ptr, hit)
@ -1238,16 +1211,16 @@ if ( ( (cache_ptr)->index_size != \
((cache_ptr)->index)[k] = (entry_ptr); \
(cache_ptr)->index_len++; \
(cache_ptr)->index_size += (entry_ptr)->size; \
((cache_ptr)->index_ring_len[entry_ptr->ring])++; \
((cache_ptr)->index_ring_size[entry_ptr->ring]) \
((cache_ptr)->index_ring_len[(entry_ptr)->ring])++; \
((cache_ptr)->index_ring_size[(entry_ptr)->ring]) \
+= (entry_ptr)->size; \
if((entry_ptr)->is_dirty) { \
(cache_ptr)->dirty_index_size += (entry_ptr)->size; \
((cache_ptr)->dirty_index_ring_size[entry_ptr->ring]) \
((cache_ptr)->dirty_index_ring_size[(entry_ptr)->ring]) \
+= (entry_ptr)->size; \
} else { \
(cache_ptr)->clean_index_size += (entry_ptr)->size; \
((cache_ptr)->clean_index_ring_size[entry_ptr->ring]) \
((cache_ptr)->clean_index_ring_size[(entry_ptr)->ring]) \
+= (entry_ptr)->size; \
} \
if((entry_ptr)->flush_me_last) { \
@ -1276,16 +1249,16 @@ if ( ( (cache_ptr)->index_size != \
(entry_ptr)->ht_prev = NULL; \
(cache_ptr)->index_len--; \
(cache_ptr)->index_size -= (entry_ptr)->size; \
((cache_ptr)->index_ring_len[entry_ptr->ring])--; \
((cache_ptr)->index_ring_size[entry_ptr->ring]) \
((cache_ptr)->index_ring_len[(entry_ptr)->ring])--; \
((cache_ptr)->index_ring_size[(entry_ptr)->ring]) \
-= (entry_ptr)->size; \
if((entry_ptr)->is_dirty) { \
(cache_ptr)->dirty_index_size -= (entry_ptr)->size; \
((cache_ptr)->dirty_index_ring_size[entry_ptr->ring]) \
((cache_ptr)->dirty_index_ring_size[(entry_ptr)->ring]) \
-= (entry_ptr)->size; \
} else { \
(cache_ptr)->clean_index_size -= (entry_ptr)->size; \
((cache_ptr)->clean_index_ring_size[entry_ptr->ring]) \
((cache_ptr)->clean_index_ring_size[(entry_ptr)->ring]) \
-= (entry_ptr)->size; \
} \
if((entry_ptr)->flush_me_last) { \
@ -1358,10 +1331,10 @@ if ( ( (cache_ptr)->index_size != \
{ \
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]) \
((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]) \
((cache_ptr)->clean_index_ring_size[(entry_ptr)->ring]) \
+= (entry_ptr)->size; \
H5C__POST_HT_UPDATE_FOR_ENTRY_CLEAN_SC(cache_ptr, entry_ptr); \
}
@ -1370,10 +1343,10 @@ if ( ( (cache_ptr)->index_size != \
{ \
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]) \
((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]) \
((cache_ptr)->dirty_index_ring_size[(entry_ptr)->ring]) \
+= (entry_ptr)->size; \
H5C__POST_HT_UPDATE_FOR_ENTRY_DIRTY_SC(cache_ptr, entry_ptr); \
}
@ -1385,21 +1358,21 @@ if ( ( (cache_ptr)->index_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); \
((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); \
((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); \
((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); \
((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); \
((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, \
@ -1595,7 +1568,7 @@ if ( ( (cache_ptr)->index_size != \
HDassert( (cache_ptr)->slist_size >= (entry_ptr)->size ); \
(cache_ptr)->slist_size -= (entry_ptr)->size; \
((cache_ptr)->slist_ring_len[(entry_ptr)->ring])--; \
HDassert( (cache_ptr)->slist_ring_size[(entry_ptr->ring)] >= \
HDassert( (cache_ptr)->slist_ring_size[((entry_ptr)->ring)] >= \
(entry_ptr)->size ); \
((cache_ptr)->slist_ring_size[(entry_ptr)->ring]) -= (entry_ptr)->size;\
(cache_ptr)->slist_len_increase--; \
@ -1642,7 +1615,7 @@ if ( ( (cache_ptr)->index_size != \
HDassert( (cache_ptr)->slist_size >= (entry_ptr)->size ); \
(cache_ptr)->slist_size -= (entry_ptr)->size; \
((cache_ptr)->slist_ring_len[(entry_ptr)->ring])--; \
HDassert( (cache_ptr)->slist_ring_size[(entry_ptr->ring)] >= \
HDassert( (cache_ptr)->slist_ring_size[((entry_ptr)->ring)] >= \
(entry_ptr)->size ); \
((cache_ptr)->slist_ring_size[(entry_ptr)->ring]) -= (entry_ptr)->size;\
(entry_ptr)->in_slist = FALSE; \
@ -1696,7 +1669,7 @@ if ( ( (cache_ptr)->index_size != \
(cache_ptr)->slist_size -= (old_size); \
(cache_ptr)->slist_size += (new_size); \
\
HDassert( (cache_ptr)->slist_ring_size[(entry_ptr->ring)] \
HDassert( (cache_ptr)->slist_ring_size[((entry_ptr)->ring)] \
>= (old_size) ); \
\
((cache_ptr)->slist_ring_size[(entry_ptr)->ring]) -= (old_size); \
@ -1741,7 +1714,7 @@ if ( ( (cache_ptr)->index_size != \
(cache_ptr)->slist_size -= (old_size); \
(cache_ptr)->slist_size += (new_size); \
\
HDassert( (cache_ptr)->slist_ring_size[(entry_ptr->ring)] >= \
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); \
@ -2153,7 +2126,7 @@ if ( ( (cache_ptr)->index_size != \
* appropriate. \
*/ \
\
if ( entry_ptr->is_dirty ) { \
if ( (entry_ptr)->is_dirty ) { \
H5C__AUX_DLL_APPEND((entry_ptr), (cache_ptr)->dLRU_head_ptr, \
(cache_ptr)->dLRU_tail_ptr, \
(cache_ptr)->dLRU_list_len, \
@ -2259,7 +2232,7 @@ if ( ( (cache_ptr)->index_size != \
* appropriate. \
*/ \
\
if ( entry_ptr->is_dirty ) { \
if ( (entry_ptr)->is_dirty ) { \
H5C__AUX_DLL_PREPEND((entry_ptr), (cache_ptr)->dLRU_head_ptr, \
(cache_ptr)->dLRU_tail_ptr, \
(cache_ptr)->dLRU_list_len, \
@ -2473,7 +2446,7 @@ if ( ( (cache_ptr)->index_size != \
HDassert( ((entry_ptr)->ro_ref_count) == 0 ); \
HDassert( (entry_ptr)->size > 0 ); \
\
if ( ! ( (entry_ptr)->is_pinned ) && ! ( (entry_ptr->is_protected ) ) ) {\
if ( ! ( (entry_ptr)->is_pinned ) && ! ( ((entry_ptr)->is_protected ) ) ) {\
\
/* modified LRU specific code */ \
\
@ -2550,7 +2523,7 @@ if ( ( (cache_ptr)->index_size != \
HDassert( ((entry_ptr)->ro_ref_count) == 0 ); \
HDassert( (entry_ptr)->size > 0 ); \
\
if ( ! ( (entry_ptr)->is_pinned ) && ! ( (entry_ptr->is_protected ) ) ) {\
if ( ! ( (entry_ptr)->is_pinned ) && ! ( ((entry_ptr)->is_protected ) ) ) {\
\
/* modified LRU specific code */ \
\
@ -3162,9 +3135,9 @@ if ( ( (entry_ptr) == NULL ) || \
#define H5C__MOVE_TO_TOP_IN_COLL_LIST(cache_ptr, entry_ptr, fail_val) \
{ \
HDassert( (cache_ptr) ); \
HDassert( (cache_ptr)->magic == H5C__H5C_T_MAGIC ); \
HDassert( (entry_ptr) ); \
HDassert((cache_ptr)); \
HDassert((cache_ptr)->magic == H5C__H5C_T_MAGIC); \
HDassert((entry_ptr)); \
\
/* Remove entry and insert at the head of the list. */ \
H5C__COLL_DLL_REMOVE((entry_ptr), (cache_ptr)->coll_head_ptr, \