diff options
Diffstat (limited to 'src/H5Cmpio.c')
| -rw-r--r-- | src/H5Cmpio.c | 767 |
1 files changed, 357 insertions, 410 deletions
diff --git a/src/H5Cmpio.c b/src/H5Cmpio.c index 9171cf7..4a3a2d8 100644 --- a/src/H5Cmpio.c +++ b/src/H5Cmpio.c @@ -27,22 +27,20 @@ /* Module Setup */ /****************/ -#include "H5Cmodule.h" /* This source code file is part of the H5C module */ -#define H5F_FRIEND /*suppress error about including H5Fpkg */ - +#include "H5Cmodule.h" /* This source code file is part of the H5C module */ +#define H5F_FRIEND /*suppress error about including H5Fpkg */ /***********/ /* Headers */ /***********/ -#include "H5private.h" /* Generic Functions */ -#include "H5ACprivate.h" /* Metadata cache */ -#include "H5Cpkg.h" /* Cache */ -#include "H5CXprivate.h" /* API Contexts */ -#include "H5Eprivate.h" /* Error handling */ -#include "H5Fpkg.h" /* Files */ -#include "H5FDprivate.h" /* File drivers */ -#include "H5MMprivate.h" /* Memory management */ - +#include "H5private.h" /* Generic Functions */ +#include "H5ACprivate.h" /* Metadata cache */ +#include "H5Cpkg.h" /* Cache */ +#include "H5CXprivate.h" /* API Contexts */ +#include "H5Eprivate.h" /* Error handling */ +#include "H5Fpkg.h" /* Files */ +#include "H5FDprivate.h" /* File drivers */ +#include "H5MMprivate.h" /* Memory management */ #ifdef H5_HAVE_PARALLEL /****************/ @@ -50,38 +48,31 @@ /****************/ #define H5C_APPLY_CANDIDATE_LIST__DEBUG 0 - /******************/ /* Local Typedefs */ /******************/ - /********************/ /* Local Prototypes */ /********************/ static herr_t H5C__collective_write(H5F_t *f); static herr_t H5C__flush_candidate_entries(H5F_t *f, unsigned entries_to_flush[H5C_RING_NTYPES], - unsigned entries_to_clear[H5C_RING_NTYPES]); -static herr_t H5C__flush_candidates_in_ring(H5F_t *f, H5C_ring_t ring, - unsigned entries_to_flush, unsigned entries_to_clear); - + unsigned entries_to_clear[H5C_RING_NTYPES]); +static herr_t H5C__flush_candidates_in_ring(H5F_t *f, H5C_ring_t ring, unsigned entries_to_flush, + unsigned entries_to_clear); /*********************/ /* Package Variables */ /*********************/ - /*****************************/ /* Library Private Variables */ /*****************************/ - /*******************/ /* Local Variables */ /*******************/ - - /*------------------------------------------------------------------------- * Function: H5C_apply_candidate_list * @@ -163,43 +154,39 @@ static herr_t H5C__flush_candidates_in_ring(H5F_t *f, H5C_ring_t ring, * Programmer: John Mainzer * 3/17/10 * - * Changes: Updated sanity checks to allow for the possibility that + * Changes: Updated sanity checks to allow for the possibility that * the slist is disabled. * JRM -- 8/3/20 * *------------------------------------------------------------------------- */ herr_t -H5C_apply_candidate_list(H5F_t * f, - H5C_t * cache_ptr, - unsigned num_candidates, - haddr_t * candidates_list_ptr, - int mpi_rank, - int mpi_size) +H5C_apply_candidate_list(H5F_t *f, H5C_t *cache_ptr, unsigned num_candidates, haddr_t *candidates_list_ptr, + int mpi_rank, int mpi_size) { - int i; - int m; - unsigned n; - unsigned first_entry_to_flush; - unsigned last_entry_to_flush; - unsigned total_entries_to_clear = 0; - unsigned total_entries_to_flush = 0; - unsigned * candidate_assignment_table = NULL; - unsigned entries_to_flush[H5C_RING_NTYPES]; - unsigned entries_to_clear[H5C_RING_NTYPES]; - haddr_t addr; - H5C_cache_entry_t * entry_ptr = NULL; + int i; + int m; + unsigned n; + unsigned first_entry_to_flush; + unsigned last_entry_to_flush; + unsigned total_entries_to_clear = 0; + unsigned total_entries_to_flush = 0; + unsigned * candidate_assignment_table = NULL; + unsigned entries_to_flush[H5C_RING_NTYPES]; + unsigned entries_to_clear[H5C_RING_NTYPES]; + haddr_t addr; + H5C_cache_entry_t *entry_ptr = NULL; #if H5C_DO_SANITY_CHECKS - haddr_t last_addr; + haddr_t last_addr; #endif /* H5C_DO_SANITY_CHECKS */ #if H5C_APPLY_CANDIDATE_LIST__DEBUG - char tbl_buf[1024]; + char tbl_buf[1024]; #endif /* H5C_APPLY_CANDIDATE_LIST__DEBUG */ - unsigned u; /* Local index variable */ - herr_t ret_value = SUCCEED; /* Return value */ + unsigned u; /* Local index variable */ + herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_NOAPI(FAIL) @@ -207,8 +194,7 @@ H5C_apply_candidate_list(H5F_t * f, HDassert(cache_ptr != NULL); HDassert(cache_ptr->magic == H5C__H5C_T_MAGIC); HDassert(num_candidates > 0); - HDassert( ( ! cache_ptr->slist_enabled ) || - ( num_candidates <= cache_ptr->slist_len )); + HDassert((!cache_ptr->slist_enabled) || (num_candidates <= cache_ptr->slist_len)); HDassert(candidates_list_ptr != NULL); HDassert(0 <= mpi_rank); HDassert(mpi_rank < mpi_size); @@ -223,93 +209,95 @@ H5C_apply_candidate_list(H5F_t * f, HDmemset(tbl_buf, 0, sizeof(tbl_buf)); HDsprintf(&(tbl_buf[0]), "candidate list = "); - for(u = 0; u < num_candidates; u++) + for (u = 0; u < num_candidates; u++) HDsprintf(&(tbl_buf[HDstrlen(tbl_buf)]), " 0x%llx", (long long)(*(candidates_list_ptr + u))); HDsprintf(&(tbl_buf[HDstrlen(tbl_buf)]), "\n"); HDfprintf(stdout, "%s", tbl_buf); #endif /* H5C_APPLY_CANDIDATE_LIST__DEBUG */ - if(f->shared->coll_md_write) { + if (f->shared->coll_md_write) { /* Sanity check */ HDassert(NULL == cache_ptr->coll_write_list); /* Create skip list of entries for collective write */ - if(NULL == (cache_ptr->coll_write_list = H5SL_create(H5SL_TYPE_HADDR, NULL))) + 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") } /* end if */ n = num_candidates / (unsigned)mpi_size; - if(num_candidates % (unsigned)mpi_size > INT_MAX) + if (num_candidates % (unsigned)mpi_size > INT_MAX) HGOTO_ERROR(H5E_DATASET, H5E_BADVALUE, FAIL, "m overflow") m = (int)(num_candidates % (unsigned)mpi_size); - 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") + 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") - candidate_assignment_table[0] = 0; + candidate_assignment_table[0] = 0; candidate_assignment_table[mpi_size] = num_candidates; - if(m == 0) { /* mpi_size is an even divisor of num_candidates */ - for(i = 1; i < mpi_size; i++) + if (m == 0) { /* mpi_size is an even divisor of num_candidates */ + for (i = 1; i < mpi_size; i++) candidate_assignment_table[i] = candidate_assignment_table[i - 1] + n; } /* end if */ else { - for(i = 1; i <= m; i++) + for (i = 1; i <= m; i++) candidate_assignment_table[i] = candidate_assignment_table[i - 1] + n + 1; - if(num_candidates < (unsigned)mpi_size) { - for(i = m + 1; i < mpi_size; i++) + if (num_candidates < (unsigned)mpi_size) { + for (i = m + 1; i < mpi_size; i++) candidate_assignment_table[i] = num_candidates; } /* end if */ else { - for(i = m + 1; i < mpi_size; i++) + for (i = m + 1; i < mpi_size; i++) candidate_assignment_table[i] = candidate_assignment_table[i - 1] + n; } /* end else */ - } /* end else */ + } /* end else */ HDassert((candidate_assignment_table[mpi_size - 1] + n) == num_candidates); #if H5C_DO_SANITY_CHECKS /* Verify that the candidate assignment table has the expected form */ - for(i = 1; i < mpi_size - 1; i++) { + for (i = 1; i < mpi_size - 1; i++) { unsigned a, b; a = candidate_assignment_table[i] - candidate_assignment_table[i - 1]; b = candidate_assignment_table[i + 1] - candidate_assignment_table[i]; - HDassert( n + 1 >= a ); - HDassert( a >= b ); - HDassert( b >= n ); + HDassert(n + 1 >= a); + HDassert(a >= b); + HDassert(b >= n); } #endif /* H5C_DO_SANITY_CHECKS */ first_entry_to_flush = candidate_assignment_table[mpi_rank]; - last_entry_to_flush = candidate_assignment_table[mpi_rank + 1] - 1; + last_entry_to_flush = candidate_assignment_table[mpi_rank + 1] - 1; #if H5C_APPLY_CANDIDATE_LIST__DEBUG - for ( i = 0; i < 1024; i++ ) + for (i = 0; i < 1024; i++) tbl_buf[i] = '\0'; HDsprintf(&(tbl_buf[0]), "candidate assignment table = "); - for(i = 0; i <= mpi_size; i++) + for (i = 0; i <= mpi_size; i++) HDsprintf(&(tbl_buf[HDstrlen(tbl_buf)]), " %u", candidate_assignment_table[i]); HDsprintf(&(tbl_buf[HDstrlen(tbl_buf)]), "\n"); HDfprintf(stdout, "%s", tbl_buf); - HDfprintf(stdout, "%s:%d: flush entries [%u, %u].\n", - FUNC, mpi_rank, first_entry_to_flush, last_entry_to_flush); + HDfprintf(stdout, "%s:%d: flush entries [%u, %u].\n", FUNC, mpi_rank, first_entry_to_flush, + last_entry_to_flush); HDfprintf(stdout, "%s:%d: marking entries.\n", FUNC, mpi_rank); #endif /* H5C_APPLY_CANDIDATE_LIST__DEBUG */ - for(u = 0; u < num_candidates; u++) { + for (u = 0; u < num_candidates; u++) { addr = candidates_list_ptr[u]; HDassert(H5F_addr_defined(addr)); #if H5C_DO_SANITY_CHECKS - if(u > 0) { - if(last_addr == addr) + if (u > 0) { + if (last_addr == addr) HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "duplicate entry in cleaned list") - else if(last_addr > addr) + else if (last_addr > addr) HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "candidate list not sorted") } /* end if */ @@ -317,11 +305,11 @@ H5C_apply_candidate_list(H5F_t * f, #endif /* H5C_DO_SANITY_CHECKS */ H5C__SEARCH_INDEX(cache_ptr, addr, entry_ptr, FAIL) - if(entry_ptr == NULL) + if (entry_ptr == NULL) HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "listed candidate entry not in cache?!?!?") - if(!entry_ptr->is_dirty) + if (!entry_ptr->is_dirty) HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Listed entry not dirty?!?!?") - if(entry_ptr->is_protected) + if (entry_ptr->is_protected) /* For now at least, we can't deal with protected entries. * If we encounter one, scream and die. If it becomes an * issue, we should be able to work around this. @@ -340,7 +328,7 @@ H5C_apply_candidate_list(H5F_t * f, * pinned list shortly, and clear or flush according to these * markings. */ - if(u >= first_entry_to_flush && u <= last_entry_to_flush) { + if (u >= first_entry_to_flush && u <= last_entry_to_flush) { total_entries_to_flush++; entries_to_flush[entry_ptr->ring]++; entry_ptr->flush_immediately = TRUE; @@ -357,16 +345,16 @@ H5C_apply_candidate_list(H5F_t * f, * candidate list is collective and uniform across all * ranks. */ - if(entry_ptr->coll_access) { + if (entry_ptr->coll_access) { entry_ptr->coll_access = FALSE; H5C__REMOVE_FROM_COLL_LIST(cache_ptr, entry_ptr, FAIL) } /* end if */ - } /* end for */ + } /* end for */ #if H5C_DO_SANITY_CHECKS m = 0; n = 0; - for(i = 0; i < H5C_RING_NTYPES; i++) { + for (i = 0; i < H5C_RING_NTYPES; i++) { m += (int)entries_to_flush[i]; n += entries_to_clear[i]; } /* end if */ @@ -376,9 +364,8 @@ H5C_apply_candidate_list(H5F_t * f, #endif /* H5C_DO_SANITY_CHECKS */ #if H5C_APPLY_CANDIDATE_LIST__DEBUG - HDfprintf(stdout, "%s:%d: num candidates/to clear/to flush = %u/%u/%u.\n", - FUNC, mpi_rank, num_candidates, total_entries_to_clear, - total_entries_to_flush); + HDfprintf(stdout, "%s:%d: num candidates/to clear/to flush = %u/%u/%u.\n", FUNC, mpi_rank, num_candidates, + total_entries_to_clear, total_entries_to_flush); #endif /* H5C_APPLY_CANDIDATE_LIST__DEBUG */ /* We have now marked all the entries on the candidate list for @@ -391,24 +378,24 @@ H5C_apply_candidate_list(H5F_t * f, * If we don't do this, my experiments indicate that we will have a * noticeably poorer hit ratio as a result. */ - if(H5C__flush_candidate_entries(f, entries_to_flush, entries_to_clear) < 0) - HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "flush candidates failed") + if (H5C__flush_candidate_entries(f, entries_to_flush, entries_to_clear) < 0) + HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "flush candidates failed") /* If we've deferred writing to do it collectively, take care of that now */ - if(f->shared->coll_md_write) { + if (f->shared->coll_md_write) { /* Sanity check */ HDassert(cache_ptr->coll_write_list); /* Write collective list */ - if(H5C__collective_write(f) < 0) + if (H5C__collective_write(f) < 0) HGOTO_ERROR(H5E_CACHE, H5E_WRITEERROR, FAIL, "can't write metadata collectively") } /* end if */ done: - if(candidate_assignment_table != NULL) + if (candidate_assignment_table != NULL) candidate_assignment_table = (unsigned *)H5MM_xfree((void *)candidate_assignment_table); - if(cache_ptr->coll_write_list) { - if(H5SL_close(cache_ptr->coll_write_list) < 0) + if (cache_ptr->coll_write_list) { + if (H5SL_close(cache_ptr->coll_write_list) < 0) HDONE_ERROR(H5E_CACHE, H5E_CANTFREE, FAIL, "failed to destroy skip list") cache_ptr->coll_write_list = NULL; } /* end if */ @@ -416,7 +403,6 @@ done: FUNC_LEAVE_NOAPI(ret_value) } /* H5C_apply_candidate_list() */ - /*------------------------------------------------------------------------- * * Function: H5C_construct_candidate_list__clean_cache @@ -436,82 +422,73 @@ done: * * Changes: With the slist optimization, the slist is not maintained * unless a flush is in progress. Thus we can not longer use - * cache_ptr->slist_size to determine the total size of + * cache_ptr->slist_size to determine the total size of * the entries we must insert in the candidate list. * * To address this, we now use cache_ptr->dirty_index_size - * instead. + * instead. * * JRM -- 7/27/20 * *------------------------------------------------------------------------- */ herr_t -H5C_construct_candidate_list__clean_cache(H5C_t * cache_ptr) +H5C_construct_candidate_list__clean_cache(H5C_t *cache_ptr) { - size_t space_needed; - herr_t ret_value = SUCCEED; /* Return value */ + size_t space_needed; + herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_NOAPI(FAIL) - HDassert( cache_ptr != NULL ); - HDassert( cache_ptr->magic == H5C__H5C_T_MAGIC ); + HDassert(cache_ptr != NULL); + HDassert(cache_ptr->magic == H5C__H5C_T_MAGIC); /* As a sanity check, set space needed to the dirty_index_size. This * should be the sum total of the sizes of all the dirty entries - * in the metadata cache. Note that if the slist is enabled, + * in the metadata cache. Note that if the slist is enabled, * cache_ptr->slist_size should equal cache_ptr->dirty_index_size. */ space_needed = cache_ptr->dirty_index_size; - HDassert( ( ! cache_ptr->slist_enabled ) || - ( space_needed == cache_ptr->slist_size ) ); - + HDassert((!cache_ptr->slist_enabled) || (space_needed == cache_ptr->slist_size)); /* Recall that while we shouldn't have any protected entries at this * point, it is possible that some dirty entries may reside on the * pinned list at this point. */ - HDassert( cache_ptr->dirty_index_size <= - (cache_ptr->dLRU_list_size + cache_ptr->pel_size) ); - HDassert( ( ! cache_ptr->slist_enabled ) || - ( cache_ptr->slist_len <= - (cache_ptr->dLRU_list_len + cache_ptr->pel_len) ) ); - + HDassert(cache_ptr->dirty_index_size <= (cache_ptr->dLRU_list_size + cache_ptr->pel_size)); + HDassert((!cache_ptr->slist_enabled) || + (cache_ptr->slist_len <= (cache_ptr->dLRU_list_len + cache_ptr->pel_len))); - if(space_needed > 0) { /* we have work to do */ + 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; - haddr_t nominated_addr; + unsigned nominated_entries_count = 0; + size_t nominated_entries_size = 0; + haddr_t nominated_addr; - HDassert( ( ! cache_ptr->slist_enabled ) || - ( cache_ptr->slist_len > 0 ) ); + HDassert((!cache_ptr->slist_enabled) || (cache_ptr->slist_len > 0)); /* Scan the dirty LRU list from tail forward and nominate sufficient * 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 ) ) { + 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 ); - HDassert( entry_ptr->is_dirty ); - HDassert( ( ! cache_ptr->slist_enabled ) || - ( entry_ptr->in_slist ) ); + HDassert(!(entry_ptr->is_protected)); + HDassert(!(entry_ptr->is_read_only)); + HDassert(entry_ptr->ro_ref_count == 0); + HDassert(entry_ptr->is_dirty); + 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) + if (H5AC_add_candidate((H5AC_t *)cache_ptr, nominated_addr) < 0) - HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \ - "H5AC_add_candidate() failed") + HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "H5AC_add_candidate() failed") nominated_entries_size += entry_ptr->size; nominated_entries_count++; @@ -519,32 +496,30 @@ H5C_construct_candidate_list__clean_cache(H5C_t * cache_ptr) } /* end while */ - HDassert( entry_ptr == NULL ); + HDassert(entry_ptr == NULL); /* it is possible that there are some dirty entries on the * 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 ) ) { + 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) { + if (entry_ptr->is_dirty) { - HDassert( ! (entry_ptr->is_protected) ); - HDassert( ! (entry_ptr->is_read_only) ); - HDassert( entry_ptr->ro_ref_count == 0 ); - HDassert( entry_ptr->is_dirty ); - HDassert( entry_ptr->in_slist ); + HDassert(!(entry_ptr->is_protected)); + HDassert(!(entry_ptr->is_read_only)); + HDassert(entry_ptr->ro_ref_count == 0); + HDassert(entry_ptr->is_dirty); + HDassert(entry_ptr->in_slist); nominated_addr = entry_ptr->addr; - if(H5AC_add_candidate((H5AC_t *)cache_ptr, nominated_addr) < 0) + if (H5AC_add_candidate((H5AC_t *)cache_ptr, nominated_addr) < 0) - HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \ - "H5AC_add_candidate() failed") + HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "H5AC_add_candidate() failed") nominated_entries_size += entry_ptr->size; nominated_entries_count++; @@ -555,9 +530,8 @@ H5C_construct_candidate_list__clean_cache(H5C_t * cache_ptr) } /* end while */ - HDassert( ( ! cache_ptr->slist_enabled ) || - ( nominated_entries_count == cache_ptr->slist_len ) ); - HDassert( nominated_entries_size == space_needed ); + HDassert((!cache_ptr->slist_enabled) || (nominated_entries_count == cache_ptr->slist_len)); + HDassert(nominated_entries_size == space_needed); } /* end if */ @@ -567,7 +541,6 @@ done: } /* H5C_construct_candidate_list__clean_cache() */ - /*------------------------------------------------------------------------- * Function: H5C_construct_candidate_list__min_clean * @@ -585,7 +558,7 @@ done: * 3/17/10 * * Changes: With the slist optimization, the slist is not maintained - * unless a flush is in progress. Updated sanity checks to + * unless a flush is in progress. Updated sanity checks to * reflect this. * * JRM -- 7/27/20 @@ -593,81 +566,74 @@ done: *------------------------------------------------------------------------- */ herr_t -H5C_construct_candidate_list__min_clean(H5C_t * cache_ptr) +H5C_construct_candidate_list__min_clean(H5C_t *cache_ptr) { - size_t space_needed = 0; - herr_t ret_value = SUCCEED; /* Return value */ + size_t space_needed = 0; + herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_NOAPI(FAIL) - HDassert( cache_ptr != NULL ); - HDassert( cache_ptr->magic == H5C__H5C_T_MAGIC ); + HDassert(cache_ptr != NULL); + HDassert(cache_ptr->magic == H5C__H5C_T_MAGIC); /* compute the number of bytes (if any) that must be flushed to get the * cache back within its min clean constraints. */ - if(cache_ptr->max_cache_size > cache_ptr->index_size) { + 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 ) { - - space_needed = 0; + if (((cache_ptr->max_cache_size - cache_ptr->index_size) + cache_ptr->cLRU_list_size) >= + cache_ptr->min_clean_size) { - } else { + space_needed = 0; + } + else { space_needed = cache_ptr->min_clean_size - - ((cache_ptr->max_cache_size - cache_ptr->index_size) + - cache_ptr->cLRU_list_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 { + space_needed = 0; + } + else { - space_needed = cache_ptr->min_clean_size - - cache_ptr->cLRU_list_size; + space_needed = cache_ptr->min_clean_size - cache_ptr->cLRU_list_size; } } /* end else */ - if(space_needed > 0) { /* we have work to do */ + 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; + unsigned nominated_entries_count = 0; + size_t nominated_entries_size = 0; - HDassert( ( ! cache_ptr->slist_enabled ) || - ( cache_ptr->slist_len > 0 ) ); + HDassert((!cache_ptr->slist_enabled) || (cache_ptr->slist_len > 0)); /* Scan the dirty LRU list from tail forward and nominate sufficient * 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 ) ) { + 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; + haddr_t nominated_addr; - HDassert( ! (entry_ptr->is_protected) ); - HDassert( ! (entry_ptr->is_read_only) ); - HDassert( entry_ptr->ro_ref_count == 0 ); - HDassert( entry_ptr->is_dirty ); - HDassert( ( ! cache_ptr->slist_enabled ) || - ( entry_ptr->in_slist ) ); + HDassert(!(entry_ptr->is_protected)); + HDassert(!(entry_ptr->is_read_only)); + HDassert(entry_ptr->ro_ref_count == 0); + HDassert(entry_ptr->is_dirty); + 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) + if (H5AC_add_candidate((H5AC_t *)cache_ptr, nominated_addr) < 0) - HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \ - "H5AC_add_candidate() failed") + HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "H5AC_add_candidate() failed") nominated_entries_size += entry_ptr->size; nominated_entries_count++; @@ -675,17 +641,15 @@ H5C_construct_candidate_list__min_clean(H5C_t * cache_ptr) } /* end while */ - HDassert( ( ! cache_ptr->slist_enabled ) || - ( nominated_entries_count <= cache_ptr->slist_len ) ); - HDassert( nominated_entries_size <= cache_ptr->dirty_index_size ); - HDassert( nominated_entries_size >= space_needed ); + HDassert((!cache_ptr->slist_enabled) || (nominated_entries_count <= cache_ptr->slist_len)); + HDassert(nominated_entries_size <= cache_ptr->dirty_index_size); + HDassert(nominated_entries_size >= space_needed); } /* end if */ done: FUNC_LEAVE_NOAPI(ret_value) } /* H5C_construct_candidate_list__min_clean() */ - /*------------------------------------------------------------------------- * * Function: H5C_mark_entries_as_clean @@ -718,84 +682,77 @@ done: *------------------------------------------------------------------------- */ herr_t -H5C_mark_entries_as_clean(H5F_t * f, - unsigned ce_array_len, - haddr_t * ce_array_ptr) +H5C_mark_entries_as_clean(H5F_t *f, unsigned ce_array_len, haddr_t *ce_array_ptr) { - H5C_t * cache_ptr; - unsigned entries_cleared; - unsigned pinned_entries_cleared; - hbool_t progress; - unsigned entries_examined; - unsigned initial_list_len; - haddr_t addr; - unsigned pinned_entries_marked = 0; + H5C_t * cache_ptr; + unsigned entries_cleared; + unsigned pinned_entries_cleared; + hbool_t progress; + unsigned entries_examined; + unsigned initial_list_len; + haddr_t addr; + unsigned pinned_entries_marked = 0; #if H5C_DO_SANITY_CHECKS - unsigned protected_entries_marked = 0; - unsigned other_entries_marked = 0; - haddr_t last_addr; + unsigned protected_entries_marked = 0; + unsigned other_entries_marked = 0; + haddr_t last_addr; #endif /* H5C_DO_SANITY_CHECKS */ - H5C_cache_entry_t * clear_ptr = NULL; - H5C_cache_entry_t * entry_ptr = NULL; - unsigned u; - herr_t ret_value = SUCCEED; /* Return value */ + H5C_cache_entry_t *clear_ptr = NULL; + H5C_cache_entry_t *entry_ptr = NULL; + unsigned u; + herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_NOAPI(FAIL) - HDassert( f ); - HDassert( f->shared ); + HDassert(f); + HDassert(f->shared); cache_ptr = f->shared->cache; - HDassert( cache_ptr ); - HDassert( cache_ptr->magic == H5C__H5C_T_MAGIC ); + HDassert(cache_ptr); + HDassert(cache_ptr->magic == H5C__H5C_T_MAGIC); - HDassert( ce_array_len > 0 ); - HDassert( ce_array_ptr != NULL ); + HDassert(ce_array_len > 0); + HDassert(ce_array_ptr != NULL); #if 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) + 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 entry") #endif /* H5C_DO_EXTREME_SANITY_CHECKS */ - for(u = 0; u < ce_array_len; u++) { + for (u = 0; u < ce_array_len; u++) { addr = ce_array_ptr[u]; #if H5C_DO_SANITY_CHECKS - if(u == 0) + if (u == 0) last_addr = addr; else { - if(last_addr == addr) + if (last_addr == addr) HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Duplicate entry in cleaned list") - if(last_addr > addr) + if (last_addr > addr) HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "cleaned list not sorted") } /* end else */ #if 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) + 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 in for loop") #endif /* H5C_DO_EXTREME_SANITY_CHECKS */ #endif /* H5C_DO_SANITY_CHECKS */ - HDassert( H5F_addr_defined(addr) ); + HDassert(H5F_addr_defined(addr)); H5C__SEARCH_INDEX(cache_ptr, addr, entry_ptr, FAIL) - if(entry_ptr == NULL) { + if (entry_ptr == NULL) { #if H5C_DO_SANITY_CHECKS - HDfprintf(stdout, - "H5C_mark_entries_as_clean: entry[%u] = %" PRIuHADDR - " not in cache.\n", u, addr); + HDfprintf(stdout, "H5C_mark_entries_as_clean: entry[%u] = %" PRIuHADDR " not in cache.\n", u, + addr); #endif /* H5C_DO_SANITY_CHECKS */ HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Listed entry not in cache?!?!?") } /* end if */ - else if(!entry_ptr->is_dirty) { + else if (!entry_ptr->is_dirty) { #if H5C_DO_SANITY_CHECKS - HDfprintf(stdout, - "H5C_mark_entries_as_clean: entry %" PRIuHADDR - " is not dirty!?!\n", addr); + HDfprintf(stdout, "H5C_mark_entries_as_clean: entry %" PRIuHADDR " is not dirty!?!\n", addr); #endif /* H5C_DO_SANITY_CHECKS */ HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Listed entry not dirty?!?!?") } /* end else-if */ @@ -807,16 +764,16 @@ H5C_mark_entries_as_clean(H5F_t * f, /* Make sure first that we clear the collective flag from it so it can be cleared */ - if(TRUE == entry_ptr->coll_access) { + if (TRUE == entry_ptr->coll_access) { entry_ptr->coll_access = FALSE; H5C__REMOVE_FROM_COLL_LIST(cache_ptr, entry_ptr, FAIL) } /* end if */ entry_ptr->clear_on_unprotect = TRUE; - if(entry_ptr->is_pinned) + if (entry_ptr->is_pinned) pinned_entries_marked++; #if H5C_DO_SANITY_CHECKS - else if(entry_ptr->is_protected) + else if (entry_ptr->is_protected) protected_entries_marked++; else other_entries_marked++; @@ -849,20 +806,20 @@ H5C_mark_entries_as_clean(H5F_t * f, * point. * JRM -- 4/7/15 */ - entries_cleared = 0; + entries_cleared = 0; entries_examined = 0; initial_list_len = cache_ptr->LRU_list_len; - entry_ptr = cache_ptr->LRU_tail_ptr; - while(entry_ptr != NULL && entries_examined <= initial_list_len && - entries_cleared < ce_array_len) { - if(entry_ptr->clear_on_unprotect) { + entry_ptr = cache_ptr->LRU_tail_ptr; + while (entry_ptr != NULL && entries_examined <= initial_list_len && entries_cleared < ce_array_len) { + if (entry_ptr->clear_on_unprotect) { entry_ptr->clear_on_unprotect = FALSE; - clear_ptr = entry_ptr; - entry_ptr = entry_ptr->prev; + clear_ptr = entry_ptr; + entry_ptr = entry_ptr->prev; entries_cleared++; - if(H5C__flush_single_entry(f, clear_ptr, - (H5C__FLUSH_CLEAR_ONLY_FLAG | H5C__GENERATE_IMAGE_FLAG | H5C__UPDATE_PAGE_BUFFER_FLAG)) < 0) + if (H5C__flush_single_entry(f, clear_ptr, + (H5C__FLUSH_CLEAR_ONLY_FLAG | H5C__GENERATE_IMAGE_FLAG | + H5C__UPDATE_PAGE_BUFFER_FLAG)) < 0) HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "can't clear entry") } /* end if */ else @@ -871,69 +828,66 @@ H5C_mark_entries_as_clean(H5F_t * f, } /* end while */ #if H5C_DO_SANITY_CHECKS - HDassert( entries_cleared == other_entries_marked ); + HDassert(entries_cleared == other_entries_marked); #endif /* H5C_DO_SANITY_CHECKS */ /* It is also possible that some of the cleared entries are on the * pinned list. Must scan that also. */ pinned_entries_cleared = 0; - progress = TRUE; - while((pinned_entries_cleared < pinned_entries_marked) && progress) { - progress = FALSE; + progress = TRUE; + while ((pinned_entries_cleared < pinned_entries_marked) && progress) { + progress = FALSE; entry_ptr = cache_ptr->pel_head_ptr; - while(entry_ptr != NULL) { - if(entry_ptr->clear_on_unprotect && entry_ptr->flush_dep_ndirty_children == 0) { + while (entry_ptr != NULL) { + if (entry_ptr->clear_on_unprotect && entry_ptr->flush_dep_ndirty_children == 0) { entry_ptr->clear_on_unprotect = FALSE; - clear_ptr = entry_ptr; - entry_ptr = entry_ptr->next; + clear_ptr = entry_ptr; + entry_ptr = entry_ptr->next; entries_cleared++; pinned_entries_cleared++; progress = TRUE; - if(H5C__flush_single_entry(f, clear_ptr, - (H5C__FLUSH_CLEAR_ONLY_FLAG | H5C__GENERATE_IMAGE_FLAG | H5C__UPDATE_PAGE_BUFFER_FLAG)) < 0) + if (H5C__flush_single_entry(f, clear_ptr, + (H5C__FLUSH_CLEAR_ONLY_FLAG | H5C__GENERATE_IMAGE_FLAG | + H5C__UPDATE_PAGE_BUFFER_FLAG)) < 0) HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "can't clear entry") } /* end if */ else entry_ptr = entry_ptr->next; - } /* end while */ - } /* end while */ + } /* end while */ + } /* end while */ #if H5C_DO_SANITY_CHECKS - HDassert( entries_cleared == pinned_entries_marked + other_entries_marked ); - HDassert( entries_cleared + protected_entries_marked == ce_array_len ); + HDassert(entries_cleared == pinned_entries_marked + other_entries_marked); + HDassert(entries_cleared + protected_entries_marked == ce_array_len); #endif /* H5C_DO_SANITY_CHECKS */ - HDassert( ( entries_cleared == ce_array_len ) || - ( (ce_array_len - entries_cleared) <= cache_ptr->pl_len ) ); + HDassert((entries_cleared == ce_array_len) || ((ce_array_len - entries_cleared) <= cache_ptr->pl_len)); #if H5C_DO_SANITY_CHECKS - u = 0; + u = 0; entry_ptr = cache_ptr->pl_head_ptr; - while ( entry_ptr != NULL ) - { - if ( entry_ptr->clear_on_unprotect ) { + while (entry_ptr != NULL) { + if (entry_ptr->clear_on_unprotect) { u++; } entry_ptr = entry_ptr->next; } - HDassert( (entries_cleared + u) == ce_array_len ); + HDassert((entries_cleared + u) == ce_array_len); #endif /* H5C_DO_SANITY_CHECKS */ done: #if 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) + 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") #endif /* H5C_DO_EXTREME_SANITY_CHECKS */ FUNC_LEAVE_NOAPI(ret_value) } /* H5C_mark_entries_as_clean() */ - /*------------------------------------------------------------------------- * * Function: H5C_clear_coll_entries @@ -951,15 +905,15 @@ done: herr_t H5C_clear_coll_entries(H5C_t *cache_ptr, hbool_t partial) { - uint32_t clear_cnt; - H5C_cache_entry_t * entry_ptr = NULL; - herr_t ret_value = SUCCEED; + uint32_t clear_cnt; + H5C_cache_entry_t *entry_ptr = NULL; + herr_t ret_value = SUCCEED; FUNC_ENTER_NOAPI_NOINIT entry_ptr = cache_ptr->coll_tail_ptr; clear_cnt = (partial ? cache_ptr->coll_list_len / 2 : cache_ptr->coll_list_len); - while(entry_ptr && clear_cnt > 0) { + while (entry_ptr && clear_cnt > 0) { H5C_cache_entry_t *prev_ptr = entry_ptr->coll_prev; /* Sanity check */ @@ -980,7 +934,6 @@ done: FUNC_LEAVE_NOAPI(ret_value) } /* H5C_clear_coll_entries */ - /*------------------------------------------------------------------------- * * Function: H5C__collective_write @@ -997,21 +950,21 @@ done: static herr_t H5C__collective_write(H5F_t *f) { - H5AC_t *cache_ptr; - H5FD_mpio_xfer_t orig_xfer_mode = H5FD_MPIO_COLLECTIVE; - void *base_buf; - int count; - int *length_array = NULL; - MPI_Aint *buf_array = NULL; - MPI_Aint *offset_array = NULL; - MPI_Datatype btype; - hbool_t btype_created = FALSE; - MPI_Datatype ftype; - hbool_t ftype_created = FALSE; - int mpi_code; - char unused = 0; /* Unused, except for non-NULL pointer value */ - size_t buf_count; - herr_t ret_value = SUCCEED; + H5AC_t * cache_ptr; + H5FD_mpio_xfer_t orig_xfer_mode = H5FD_MPIO_COLLECTIVE; + void * base_buf; + int count; + int * length_array = NULL; + MPI_Aint * buf_array = NULL; + MPI_Aint * offset_array = NULL; + MPI_Datatype btype; + hbool_t btype_created = FALSE; + MPI_Datatype ftype; + hbool_t ftype_created = FALSE; + int mpi_code; + char unused = 0; /* Unused, except for non-NULL pointer value */ + size_t buf_count; + herr_t ret_value = SUCCEED; FUNC_ENTER_STATIC @@ -1022,49 +975,52 @@ H5C__collective_write(H5F_t *f) HDassert(cache_ptr->coll_write_list != NULL); /* Get original transfer mode */ - if(H5CX_get_io_xfer_mode(&orig_xfer_mode) < 0) + if (H5CX_get_io_xfer_mode(&orig_xfer_mode) < 0) HGOTO_ERROR(H5E_CACHE, H5E_CANTGET, FAIL, "can't get MPI-I/O transfer mode") /* Set transfer mode */ - if(H5CX_set_io_xfer_mode(H5FD_MPIO_COLLECTIVE) < 0) + if (H5CX_set_io_xfer_mode(H5FD_MPIO_COLLECTIVE) < 0) HGOTO_ERROR(H5E_CACHE, H5E_CANTSET, FAIL, "can't set MPI-I/O transfer mode") /* Get number of entries in collective write list */ count = (int)H5SL_count(cache_ptr->coll_write_list); - if(count > 0) { - H5SL_node_t *node; - H5C_cache_entry_t *entry_ptr; - int i; + if (count > 0) { + H5SL_node_t * node; + H5C_cache_entry_t *entry_ptr; + int i; /* Allocate arrays */ - if(NULL == (length_array = (int *)H5MM_malloc((size_t)count * sizeof(int))) ) - HGOTO_ERROR(H5E_CACHE, H5E_CANTALLOC, FAIL, "memory allocation failed for collective write table length array") - if(NULL == (buf_array = (MPI_Aint *)H5MM_malloc((size_t)count * sizeof(MPI_Aint))) ) - HGOTO_ERROR(H5E_CACHE, H5E_CANTALLOC, FAIL, "memory allocation failed for collective buf table length array") - if(NULL == (offset_array = (MPI_Aint *)H5MM_malloc((size_t)count * sizeof(MPI_Aint))) ) - HGOTO_ERROR(H5E_CACHE, H5E_CANTALLOC, FAIL, "memory allocation failed for collective offset table length array") + if (NULL == (length_array = (int *)H5MM_malloc((size_t)count * sizeof(int)))) + HGOTO_ERROR(H5E_CACHE, H5E_CANTALLOC, FAIL, + "memory allocation failed for collective write table length array") + if (NULL == (buf_array = (MPI_Aint *)H5MM_malloc((size_t)count * sizeof(MPI_Aint)))) + HGOTO_ERROR(H5E_CACHE, H5E_CANTALLOC, FAIL, + "memory allocation failed for collective buf table length array") + if (NULL == (offset_array = (MPI_Aint *)H5MM_malloc((size_t)count * sizeof(MPI_Aint)))) + HGOTO_ERROR(H5E_CACHE, H5E_CANTALLOC, FAIL, + "memory allocation failed for collective offset table length array") /* Fill arrays */ node = H5SL_first(cache_ptr->coll_write_list); HDassert(node); - if(NULL == (entry_ptr = (H5C_cache_entry_t *)H5SL_item(node))) + if (NULL == (entry_ptr = (H5C_cache_entry_t *)H5SL_item(node))) HGOTO_ERROR(H5E_CACHE, H5E_NOTFOUND, FAIL, "can't retrieve skip list item") /* Set up initial array position & buffer base address */ length_array[0] = (int)entry_ptr->size; - base_buf = entry_ptr->image_ptr; - buf_array[0] = (MPI_Aint)0; + base_buf = entry_ptr->image_ptr; + buf_array[0] = (MPI_Aint)0; offset_array[0] = (MPI_Aint)entry_ptr->addr; node = H5SL_next(node); - i = 1; - while(node) { - if(NULL == (entry_ptr = (H5C_cache_entry_t *)H5SL_item(node))) + i = 1; + while (node) { + if (NULL == (entry_ptr = (H5C_cache_entry_t *)H5SL_item(node))) HGOTO_ERROR(H5E_CACHE, H5E_NOTFOUND, FAIL, "can't retrieve skip list item") /* Set up array position */ length_array[i] = (int)entry_ptr->size; - buf_array[i] = (MPI_Aint)entry_ptr->image_ptr - (MPI_Aint)base_buf; + buf_array[i] = (MPI_Aint)entry_ptr->image_ptr - (MPI_Aint)base_buf; offset_array[i] = (MPI_Aint)entry_ptr->addr; /* Advance to next node & array location */ @@ -1073,17 +1029,19 @@ H5C__collective_write(H5F_t *f) } /* end while */ /* Create memory MPI type */ - if(MPI_SUCCESS != (mpi_code = MPI_Type_create_hindexed(count, length_array, buf_array, MPI_BYTE, &btype))) + if (MPI_SUCCESS != + (mpi_code = MPI_Type_create_hindexed(count, length_array, buf_array, MPI_BYTE, &btype))) HMPI_GOTO_ERROR(FAIL, "MPI_Type_create_hindexed failed", mpi_code) btype_created = TRUE; - if(MPI_SUCCESS != (mpi_code = MPI_Type_commit(&btype))) + if (MPI_SUCCESS != (mpi_code = MPI_Type_commit(&btype))) HMPI_GOTO_ERROR(FAIL, "MPI_Type_commit failed", mpi_code) /* Create file MPI type */ - if(MPI_SUCCESS != (mpi_code = MPI_Type_create_hindexed(count, length_array, offset_array, MPI_BYTE, &ftype))) + if (MPI_SUCCESS != + (mpi_code = MPI_Type_create_hindexed(count, length_array, offset_array, MPI_BYTE, &ftype))) HMPI_GOTO_ERROR(FAIL, "MPI_Type_create_hindexed failed", mpi_code) ftype_created = TRUE; - if(MPI_SUCCESS != (mpi_code = MPI_Type_commit(&ftype))) + if (MPI_SUCCESS != (mpi_code = MPI_Type_commit(&ftype))) HMPI_GOTO_ERROR(FAIL, "MPI_Type_commit failed", mpi_code) /* MPI count to write */ @@ -1102,34 +1060,33 @@ H5C__collective_write(H5F_t *f) } /* end else */ /* Pass buf type, file type to the file driver */ - if(H5CX_set_mpi_coll_datatypes(btype, ftype) < 0) + if (H5CX_set_mpi_coll_datatypes(btype, ftype) < 0) HGOTO_ERROR(H5E_CACHE, H5E_CANTSET, FAIL, "can't set MPI-I/O properties") /* Write data */ - if(H5F_block_write(f, H5FD_MEM_DEFAULT, (haddr_t)0, buf_count, base_buf) < 0) + if (H5F_block_write(f, H5FD_MEM_DEFAULT, (haddr_t)0, buf_count, base_buf) < 0) HGOTO_ERROR(H5E_CACHE, H5E_WRITEERROR, FAIL, "unable to write entries collectively") done: /* Free arrays */ length_array = (int *)H5MM_xfree(length_array); - buf_array = (MPI_Aint *)H5MM_xfree(buf_array); + buf_array = (MPI_Aint *)H5MM_xfree(buf_array); offset_array = (MPI_Aint *)H5MM_xfree(offset_array); /* Free MPI Types */ - if(btype_created && MPI_SUCCESS != (mpi_code = MPI_Type_free(&btype))) + if (btype_created && MPI_SUCCESS != (mpi_code = MPI_Type_free(&btype))) HMPI_DONE_ERROR(FAIL, "MPI_Type_free failed", mpi_code) - if(ftype_created && MPI_SUCCESS != (mpi_code = MPI_Type_free(&ftype))) + if (ftype_created && MPI_SUCCESS != (mpi_code = MPI_Type_free(&ftype))) HMPI_DONE_ERROR(FAIL, "MPI_Type_free failed", mpi_code) /* Reset transfer mode in API context, if changed */ - if(orig_xfer_mode != H5FD_MPIO_COLLECTIVE) - if(H5CX_set_io_xfer_mode(orig_xfer_mode) < 0) + if (orig_xfer_mode != H5FD_MPIO_COLLECTIVE) + if (H5CX_set_io_xfer_mode(orig_xfer_mode) < 0) HDONE_ERROR(H5E_CACHE, H5E_CANTSET, FAIL, "can't set MPI-I/O transfer mode") FUNC_LEAVE_NOAPI(ret_value); } /* end H5C__collective_write() */ - /*------------------------------------------------------------------------- * Function: H5C__flush_candidate_entries * @@ -1170,20 +1127,20 @@ done: */ static herr_t H5C__flush_candidate_entries(H5F_t *f, unsigned entries_to_flush[H5C_RING_NTYPES], - unsigned entries_to_clear[H5C_RING_NTYPES]) + unsigned entries_to_clear[H5C_RING_NTYPES]) { #if H5C_DO_SANITY_CHECKS - int i; - uint32_t index_len = 0; - size_t index_size = (size_t)0; - size_t clean_index_size = (size_t)0; - size_t dirty_index_size = (size_t)0; - size_t slist_size = (size_t)0; - uint32_t slist_len = 0; + int i; + uint32_t index_len = 0; + size_t index_size = (size_t)0; + size_t clean_index_size = (size_t)0; + size_t dirty_index_size = (size_t)0; + size_t slist_size = (size_t)0; + uint32_t slist_len = 0; #endif /* H5C_DO_SANITY_CHECKS */ - H5C_ring_t ring; - H5C_t * cache_ptr; - herr_t ret_value = SUCCEED; + H5C_ring_t ring; + H5C_t * cache_ptr; + herr_t ret_value = SUCCEED; FUNC_ENTER_STATIC @@ -1207,7 +1164,7 @@ H5C__flush_candidate_entries(H5F_t *f, unsigned entries_to_flush[H5C_RING_NTYPES HDassert(cache_ptr->slist_ring_len[H5C_RING_UNDEFINED] == 0); HDassert(cache_ptr->slist_ring_size[H5C_RING_UNDEFINED] == (size_t)0); - for(i = H5C_RING_USER; i < H5C_RING_NTYPES; i++) { + for (i = H5C_RING_USER; i < H5C_RING_NTYPES; i++) { index_len += cache_ptr->index_ring_len[i]; index_size += cache_ptr->index_ring_size[i]; clean_index_size += cache_ptr->clean_index_ring_size[i]; @@ -1226,9 +1183,8 @@ H5C__flush_candidate_entries(H5F_t *f, unsigned entries_to_flush[H5C_RING_NTYPES #endif /* H5C_DO_SANITY_CHECKS */ #if 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) + 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 entry") #endif /* H5C_DO_EXTREME_SANITY_CHECKS */ @@ -1238,12 +1194,12 @@ H5C__flush_candidate_entries(H5F_t *f, unsigned entries_to_flush[H5C_RING_NTYPES * working inward. */ ring = H5C_RING_USER; - while(ring < H5C_RING_NTYPES) { - if(H5C__flush_candidates_in_ring(f, ring, entries_to_flush[ring], entries_to_clear[ring]) < 0) + while (ring < H5C_RING_NTYPES) { + if (H5C__flush_candidates_in_ring(f, ring, entries_to_flush[ring], entries_to_clear[ring]) < 0) HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "flush candidates in ring failed") ring++; - } /* end while */ + } /* end while */ done: cache_ptr->flush_in_progress = FALSE; @@ -1251,7 +1207,6 @@ done: FUNC_LEAVE_NOAPI(ret_value) } /* H5C__flush_candidate_entries() */ - /*------------------------------------------------------------------------- * Function: H5C__flush_candidates_in_ring * @@ -1289,25 +1244,23 @@ done: *------------------------------------------------------------------------- */ static herr_t -H5C__flush_candidates_in_ring(H5F_t *f, H5C_ring_t ring, - unsigned entries_to_flush, unsigned entries_to_clear) +H5C__flush_candidates_in_ring(H5F_t *f, H5C_ring_t ring, unsigned entries_to_flush, unsigned entries_to_clear) { - H5C_t * cache_ptr; - hbool_t progress; - hbool_t restart_scan = FALSE; - unsigned entries_flushed = 0; - unsigned entries_cleared = 0; + H5C_t * cache_ptr; + hbool_t progress; + hbool_t restart_scan = FALSE; + unsigned entries_flushed = 0; + unsigned entries_cleared = 0; #if H5C_DO_SANITY_CHECKS - unsigned init_index_len; + unsigned init_index_len; #endif /* H5C_DO_SANITY_CHECKS */ - unsigned clear_flags = H5C__FLUSH_CLEAR_ONLY_FLAG | - H5C__GENERATE_IMAGE_FLAG | - H5C__UPDATE_PAGE_BUFFER_FLAG; - unsigned flush_flags = H5C__NO_FLAGS_SET; - unsigned op_flags; + unsigned clear_flags = + H5C__FLUSH_CLEAR_ONLY_FLAG | H5C__GENERATE_IMAGE_FLAG | H5C__UPDATE_PAGE_BUFFER_FLAG; + unsigned flush_flags = H5C__NO_FLAGS_SET; + unsigned op_flags; H5C_cache_entry_t *op_ptr; H5C_cache_entry_t *entry_ptr; - herr_t ret_value = SUCCEED; + herr_t ret_value = SUCCEED; FUNC_ENTER_STATIC @@ -1322,9 +1275,8 @@ H5C__flush_candidates_in_ring(H5F_t *f, H5C_ring_t ring, HDassert(ring < H5C_RING_NTYPES); #if 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)) + 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 entry") #endif /* H5C_DO_EXTREME_SANITY_CHECKS */ @@ -1343,27 +1295,27 @@ H5C__flush_candidates_in_ring(H5F_t *f, H5C_ring_t ring, * It is possible that this will change -- hence the assertion. */ restart_scan = FALSE; - entry_ptr = cache_ptr->LRU_tail_ptr; - while(((entries_flushed < entries_to_flush) || (entries_cleared < entries_to_clear)) - && (entry_ptr != NULL)) { - hbool_t prev_is_dirty = FALSE; + entry_ptr = cache_ptr->LRU_tail_ptr; + while (((entries_flushed < entries_to_flush) || (entries_cleared < entries_to_clear)) && + (entry_ptr != NULL)) { + hbool_t prev_is_dirty = FALSE; H5C_cache_entry_t *next_ptr; /* Entries in the LRU must not have flush dependency children */ HDassert(entry_ptr->flush_dep_nchildren == 0); /* Remember dirty state of entry to advance to */ - if(entry_ptr->prev != NULL) + if (entry_ptr->prev != NULL) prev_is_dirty = entry_ptr->prev->is_dirty; /* If the entry is in the ring */ - if(entry_ptr->ring == ring) { + if (entry_ptr->ring == ring) { /* If this process needs to clear this entry. */ - if(entry_ptr->clear_on_unprotect) { + if (entry_ptr->clear_on_unprotect) { HDassert(entry_ptr->is_dirty); /* Set entry and flags for operation */ - op_ptr = entry_ptr; + op_ptr = entry_ptr; op_flags = clear_flags; /* Set next entry appropriately */ @@ -1373,11 +1325,11 @@ H5C__flush_candidates_in_ring(H5F_t *f, H5C_ring_t ring, entry_ptr->clear_on_unprotect = FALSE; entries_cleared++; } /* end if */ - else if(entry_ptr->flush_immediately) { + else if (entry_ptr->flush_immediately) { HDassert(entry_ptr->is_dirty); /* Set entry and flags for operation */ - op_ptr = entry_ptr; + op_ptr = entry_ptr; op_flags = flush_flags; /* Set next entry appropriately */ @@ -1399,7 +1351,7 @@ H5C__flush_candidates_in_ring(H5F_t *f, H5C_ring_t ring, entry_ptr = entry_ptr->prev; /* Check for operation */ - if(op_ptr) { + if (op_ptr) { /* reset entries_removed_counter and * last_entry_removed_ptr prior to the call to * H5C__flush_single_entry() so that we can spot @@ -1418,14 +1370,13 @@ H5C__flush_candidates_in_ring(H5F_t *f, H5C_ring_t ring, cache_ptr->entries_removed_counter = 0; cache_ptr->last_entry_removed_ptr = NULL; - if(H5C__flush_single_entry(f, op_ptr, op_flags) < 0) + if (H5C__flush_single_entry(f, op_ptr, op_flags) < 0) HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "can't flush entry") - if(cache_ptr->entries_removed_counter != 0 - || cache_ptr->last_entry_removed_ptr != NULL) + if (cache_ptr->entries_removed_counter != 0 || cache_ptr->last_entry_removed_ptr != NULL) restart_scan = TRUE; } /* end if */ - } /* end if */ + } /* end if */ else { /* Remember "next" pointer (after advancing entries) */ next_ptr = entry_ptr; @@ -1435,10 +1386,9 @@ H5C__flush_candidates_in_ring(H5F_t *f, H5C_ring_t ring, } /* end else */ /* Check for restarts, etc. */ - if((entry_ptr != NULL) && - (restart_scan || (entry_ptr->is_dirty != prev_is_dirty) - || (entry_ptr->next != next_ptr) || entry_ptr->is_protected - || entry_ptr->is_pinned)) { + if ((entry_ptr != NULL) && + (restart_scan || (entry_ptr->is_dirty != prev_is_dirty) || (entry_ptr->next != next_ptr) || + entry_ptr->is_protected || entry_ptr->is_pinned)) { /* Something has happened to the LRU -- start over * from the tail. @@ -1458,11 +1408,11 @@ H5C__flush_candidates_in_ring(H5F_t *f, H5C_ring_t ring, HDassert(FALSE); /* see comment above */ restart_scan = FALSE; - entry_ptr = cache_ptr->LRU_tail_ptr; + entry_ptr = cache_ptr->LRU_tail_ptr; H5C__UPDATE_STATS_FOR_LRU_SCAN_RESTART(cache_ptr) } /* end if */ - } /* end while */ + } /* end while */ /* It is also possible that some of the cleared entries are on the * pinned list. Must scan that also. @@ -1486,26 +1436,26 @@ H5C__flush_candidates_in_ring(H5F_t *f, H5C_ring_t ring, * such changes and cause this function to fail if they are detected. */ progress = TRUE; - while(progress && ((entries_flushed < entries_to_flush) || (entries_cleared < entries_to_clear))) { - progress = FALSE; + while (progress && ((entries_flushed < entries_to_flush) || (entries_cleared < entries_to_clear))) { + progress = FALSE; entry_ptr = cache_ptr->pel_head_ptr; - while((entry_ptr != NULL) && - ((entries_flushed < entries_to_flush) || (entries_cleared < entries_to_clear))) { + while ((entry_ptr != NULL) && + ((entries_flushed < entries_to_flush) || (entries_cleared < entries_to_clear))) { H5C_cache_entry_t *prev_ptr; - hbool_t next_is_dirty = FALSE; + hbool_t next_is_dirty = FALSE; HDassert(entry_ptr->is_pinned); /* Remember dirty state of entry to advance to */ - if(entry_ptr->next != NULL) + if (entry_ptr->next != NULL) next_is_dirty = entry_ptr->next->is_dirty; - if(entry_ptr->ring == ring && entry_ptr->flush_dep_ndirty_children == 0) { - if(entry_ptr->clear_on_unprotect) { + if (entry_ptr->ring == ring && entry_ptr->flush_dep_ndirty_children == 0) { + if (entry_ptr->clear_on_unprotect) { HDassert(entry_ptr->is_dirty); /* Set entry and flags for operation */ - op_ptr = entry_ptr; + op_ptr = entry_ptr; op_flags = clear_flags; /* Reset entry flag */ @@ -1513,11 +1463,11 @@ H5C__flush_candidates_in_ring(H5F_t *f, H5C_ring_t ring, entries_cleared++; progress = TRUE; } /* end if */ - else if(entry_ptr->flush_immediately) { + else if (entry_ptr->flush_immediately) { HDassert(entry_ptr->is_dirty); /* Set entry and flags for operation */ - op_ptr = entry_ptr; + op_ptr = entry_ptr; op_flags = flush_flags; /* Reset entry flag */ @@ -1530,7 +1480,7 @@ H5C__flush_candidates_in_ring(H5F_t *f, H5C_ring_t ring, op_ptr = NULL; /* Check for operation */ - if(op_ptr) { + if (op_ptr) { /* reset entries_removed_counter and * last_entry_removed_ptr prior to the call to * H5C__flush_single_entry() so that we can spot @@ -1556,14 +1506,13 @@ H5C__flush_candidates_in_ring(H5F_t *f, H5C_ring_t ring, * * JRM -- 2/9/17 */ - if(H5C__flush_single_entry(f, op_ptr, op_flags) < 0) + if (H5C__flush_single_entry(f, op_ptr, op_flags) < 0) HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "can't flush entry") - if(cache_ptr->entries_removed_counter != 0 - || cache_ptr->last_entry_removed_ptr != NULL) + if (cache_ptr->entries_removed_counter != 0 || cache_ptr->last_entry_removed_ptr != NULL) restart_scan = TRUE; } /* end if */ - } /* end if */ + } /* end if */ /* Remember "previous" pointer (after advancing entries) */ prev_ptr = entry_ptr; @@ -1572,10 +1521,9 @@ H5C__flush_candidates_in_ring(H5F_t *f, H5C_ring_t ring, entry_ptr = entry_ptr->next; /* Check for restarts, etc. */ - if((entry_ptr != NULL) && - (restart_scan || (entry_ptr->is_dirty != next_is_dirty) - || (entry_ptr->prev != prev_ptr) || entry_ptr->is_protected - || !entry_ptr->is_pinned)) { + if ((entry_ptr != NULL) && + (restart_scan || (entry_ptr->is_dirty != next_is_dirty) || (entry_ptr->prev != prev_ptr) || + entry_ptr->is_protected || !entry_ptr->is_pinned)) { /* Something has happened to the pinned entry list -- start * over from the head. * @@ -1606,22 +1554,22 @@ H5C__flush_candidates_in_ring(H5F_t *f, H5C_ring_t ring, * H5C__UPDATE_STATS_FOR_PEL_SCAN_RESTART(cache_ptr) */ } /* end if */ - } /* end while ( ( entry_ptr != NULL ) && - * ( ( entries_flushed > entries_to_flush ) || - * ( entries_cleared > entries_to_clear ) ) ) - */ - } /* end while ( ( ( entries_flushed > entries_to_flush ) || - * ( entries_cleared > entries_to_clear ) ) && - * ( progress ) ) - */ + } /* end while ( ( entry_ptr != NULL ) && + * ( ( entries_flushed > entries_to_flush ) || + * ( entries_cleared > entries_to_clear ) ) ) + */ + } /* end while ( ( ( entries_flushed > entries_to_flush ) || + * ( entries_cleared > entries_to_clear ) ) && + * ( progress ) ) + */ #if H5C_DO_SANITY_CHECKS HDassert(init_index_len == cache_ptr->index_len); #endif /* H5C_DO_SANITY_CHECKS */ - if(entries_flushed != entries_to_flush || entries_cleared != entries_to_clear) { + if (entries_flushed != entries_to_flush || entries_cleared != entries_to_clear) { entry_ptr = cache_ptr->il_head; - while(entry_ptr != NULL) { + while (entry_ptr != NULL) { HDassert(!entry_ptr->clear_on_unprotect || (entry_ptr->ring > ring)); HDassert(!entry_ptr->flush_immediately || (entry_ptr->ring > ring)); entry_ptr = entry_ptr->il_next; @@ -1634,4 +1582,3 @@ done: FUNC_LEAVE_NOAPI(ret_value) } /* H5C__flush_candidates_in_ring() */ #endif /* H5_HAVE_PARALLEL */ - |