diff options
Diffstat (limited to 'src/H5Cimage.c')
| -rw-r--r-- | src/H5Cimage.c | 703 |
1 files changed, 351 insertions, 352 deletions
diff --git a/src/H5Cimage.c b/src/H5Cimage.c index b8f46f1..b6e5712 100644 --- a/src/H5Cimage.c +++ b/src/H5Cimage.c @@ -95,13 +95,13 @@ #define H5C__UPDATE_STATS_FOR_CACHE_IMAGE_READ(cache_ptr) \ { \ /* make sure image len is still good */ \ - HDassert((cache_ptr)->image_len > 0); \ + assert((cache_ptr)->image_len > 0); \ (cache_ptr)->images_read++; \ } #define H5C__UPDATE_STATS_FOR_CACHE_IMAGE_LOAD(cache_ptr) \ { \ /* make sure image len is still good */ \ - HDassert((cache_ptr)->image_len > 0); \ + assert((cache_ptr)->image_len > 0); \ (cache_ptr)->images_loaded++; \ (cache_ptr)->last_image_size = (cache_ptr)->image_len; \ } @@ -195,8 +195,8 @@ H5C_cache_image_pending(const H5C_t *cache_ptr) FUNC_ENTER_NOAPI_NOINIT_NOERR /* Sanity checks */ - HDassert(cache_ptr); - HDassert(cache_ptr->magic == H5C__H5C_T_MAGIC); + assert(cache_ptr); + assert(cache_ptr->magic == H5C__H5C_T_MAGIC); ret_value = (cache_ptr->load_image && !cache_ptr->image_loaded); @@ -233,13 +233,13 @@ H5C_cache_image_status(H5F_t *f, hbool_t *load_ci_ptr, hbool_t *write_ci_ptr) FUNC_ENTER_NOAPI_NOINIT_NOERR /* Sanity checks */ - HDassert(f); - HDassert(f->shared); + assert(f); + assert(f->shared); cache_ptr = f->shared->cache; - HDassert(cache_ptr); - HDassert(cache_ptr->magic == H5C__H5C_T_MAGIC); - HDassert(load_ci_ptr); - HDassert(write_ci_ptr); + assert(cache_ptr); + assert(cache_ptr->magic == H5C__H5C_T_MAGIC); + assert(load_ci_ptr); + assert(write_ci_ptr); *load_ci_ptr = cache_ptr->load_image || cache_ptr->image_loaded; *write_ci_ptr = cache_ptr->image_ctl.generate_image; @@ -274,17 +274,17 @@ H5C__construct_cache_image_buffer(H5F_t *f, H5C_t *cache_ptr) FUNC_ENTER_PACKAGE /* Sanity checks */ - HDassert(f); - HDassert(f->shared); - HDassert(cache_ptr == f->shared->cache); - HDassert(cache_ptr); - HDassert(cache_ptr->magic == H5C__H5C_T_MAGIC); - HDassert(cache_ptr->close_warning_received); - HDassert(cache_ptr->image_ctl.generate_image); - HDassert(cache_ptr->num_entries_in_image > 0); - HDassert(cache_ptr->index_len == 0); - HDassert(cache_ptr->image_data_len > 0); - HDassert(cache_ptr->image_data_len <= cache_ptr->image_len); + assert(f); + assert(f->shared); + assert(cache_ptr == f->shared->cache); + assert(cache_ptr); + assert(cache_ptr->magic == H5C__H5C_T_MAGIC); + assert(cache_ptr->close_warning_received); + assert(cache_ptr->image_ctl.generate_image); + assert(cache_ptr->num_entries_in_image > 0); + assert(cache_ptr->index_len == 0); + assert(cache_ptr->image_data_len > 0); + assert(cache_ptr->image_data_len <= cache_ptr->image_len); /* Allocate the buffer in which to construct the cache image block */ if (NULL == (cache_ptr->image_buffer = H5MM_malloc(cache_ptr->image_len + 1))) @@ -294,13 +294,13 @@ H5C__construct_cache_image_buffer(H5F_t *f, H5C_t *cache_ptr) p = (uint8_t *)cache_ptr->image_buffer; if (H5C__encode_cache_image_header(f, cache_ptr, &p) < 0) HGOTO_ERROR(H5E_CACHE, H5E_CANTENCODE, FAIL, "header image construction failed") - HDassert((size_t)(p - (uint8_t *)cache_ptr->image_buffer) < cache_ptr->image_data_len); + assert((size_t)(p - (uint8_t *)cache_ptr->image_buffer) < cache_ptr->image_data_len); /* Construct the cache entry images */ for (u = 0; u < cache_ptr->num_entries_in_image; u++) if (H5C__encode_cache_image_entry(f, cache_ptr, &p, u) < 0) HGOTO_ERROR(H5E_CACHE, H5E_CANTENCODE, FAIL, "entry image construction failed") - HDassert((size_t)(p - (uint8_t *)cache_ptr->image_buffer) < cache_ptr->image_data_len); + assert((size_t)(p - (uint8_t *)cache_ptr->image_buffer) < cache_ptr->image_data_len); /* Construct the adaptive resize status image -- not yet */ @@ -308,8 +308,8 @@ H5C__construct_cache_image_buffer(H5F_t *f, H5C_t *cache_ptr) chksum = H5_checksum_metadata(cache_ptr->image_buffer, (size_t)(cache_ptr->image_data_len - H5F_SIZEOF_CHKSUM), 0); UINT32ENCODE(p, chksum); - HDassert((size_t)(p - (uint8_t *)cache_ptr->image_buffer) == cache_ptr->image_data_len); - HDassert((size_t)(p - (uint8_t *)cache_ptr->image_buffer) <= cache_ptr->image_len); + assert((size_t)(p - (uint8_t *)cache_ptr->image_buffer) == cache_ptr->image_data_len); + assert((size_t)(p - (uint8_t *)cache_ptr->image_buffer) <= cache_ptr->image_len); #ifndef NDEBUG /* validate the metadata cache image we just constructed by decoding it @@ -323,21 +323,21 @@ H5C__construct_cache_image_buffer(H5F_t *f, H5C_t *cache_ptr) herr_t status; /* Status from decoding */ fake_cache_ptr = (H5C_t *)H5MM_malloc(sizeof(H5C_t)); - HDassert(fake_cache_ptr); + assert(fake_cache_ptr); fake_cache_ptr->magic = H5C__H5C_T_MAGIC; /* needed for sanity checks */ fake_cache_ptr->image_len = cache_ptr->image_len; q = (const uint8_t *)cache_ptr->image_buffer; status = H5C__decode_cache_image_header(f, fake_cache_ptr, &q); - HDassert(status >= 0); + assert(status >= 0); - HDassert(NULL != p); - HDassert(fake_cache_ptr->num_entries_in_image == cache_ptr->num_entries_in_image); + assert(NULL != p); + assert(fake_cache_ptr->num_entries_in_image == cache_ptr->num_entries_in_image); fake_cache_ptr->image_entries = (H5C_image_entry_t *)H5MM_malloc( sizeof(H5C_image_entry_t) * (size_t)(fake_cache_ptr->num_entries_in_image + 1)); - HDassert(fake_cache_ptr->image_entries); + assert(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; @@ -346,58 +346,58 @@ H5C__construct_cache_image_buffer(H5F_t *f, H5C_t *cache_ptr) /* touch up f->shared->cache to satisfy sanity checks... */ f->shared->cache = fake_cache_ptr; status = H5C__decode_cache_image_entry(f, fake_cache_ptr, &q, u); - HDassert(status >= 0); + assert(status >= 0); /* ...and then return f->shared->cache to its correct value */ 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); + assert(cache_ptr->image_entries[u].addr == fake_cache_ptr->image_entries[u].addr); + assert(cache_ptr->image_entries[u].size == fake_cache_ptr->image_entries[u].size); + assert(cache_ptr->image_entries[u].type_id == fake_cache_ptr->image_entries[u].type_id); + assert(cache_ptr->image_entries[u].lru_rank == fake_cache_ptr->image_entries[u].lru_rank); + assert(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); + assert(cache_ptr->image_entries[u].fd_child_count == + fake_cache_ptr->image_entries[u].fd_child_count); + assert(cache_ptr->image_entries[u].fd_dirty_child_count == + fake_cache_ptr->image_entries[u].fd_dirty_child_count); + assert(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]); + assert(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); + assert(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); + assert(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)); + assert(cache_ptr->image_entries[u].image_ptr); + assert(fake_cache_ptr->image_entries[u].image_ptr); + assert(!memcmp(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); } /* end for */ - HDassert((size_t)(q - (const uint8_t *)cache_ptr->image_buffer) == - cache_ptr->image_data_len - H5F_SIZEOF_CHKSUM); + assert((size_t)(q - (const uint8_t *)cache_ptr->image_buffer) == + cache_ptr->image_data_len - H5F_SIZEOF_CHKSUM); /* compute the checksum */ old_chksum = chksum; chksum = H5_checksum_metadata(cache_ptr->image_buffer, (size_t)(cache_ptr->image_data_len - H5F_SIZEOF_CHKSUM), 0); - HDassert(chksum == old_chksum); + assert(chksum == old_chksum); fake_cache_ptr->image_entries = (H5C_image_entry_t *)H5MM_xfree(fake_cache_ptr->image_entries); fake_cache_ptr = (H5C_t *)H5MM_xfree(fake_cache_ptr); @@ -429,11 +429,11 @@ H5C__generate_cache_image(H5F_t *f, H5C_t *cache_ptr) FUNC_ENTER_PACKAGE /* Sanity checks */ - HDassert(f); - HDassert(f->shared); - HDassert(cache_ptr == f->shared->cache); - HDassert(cache_ptr); - HDassert(cache_ptr->magic == H5C__H5C_T_MAGIC); + assert(f); + assert(f->shared); + assert(cache_ptr == f->shared->cache); + assert(cache_ptr); + assert(cache_ptr->magic == H5C__H5C_T_MAGIC); /* Construct cache image */ if (H5C__construct_cache_image_buffer(f, cache_ptr) < 0) @@ -452,7 +452,7 @@ H5C__generate_cache_image(H5F_t *f, H5C_t *cache_ptr) } /* end if */ /* Free cache image buffer */ - HDassert(cache_ptr->image_buffer); + assert(cache_ptr->image_buffer); cache_ptr->image_buffer = H5MM_xfree(cache_ptr->image_buffer); done: @@ -521,56 +521,56 @@ H5C__deserialize_prefetched_entry(H5F_t *f, H5C_t *cache_ptr, H5C_cache_entry_t FUNC_ENTER_PACKAGE /* sanity checks */ - HDassert(f); - HDassert(f->shared); - HDassert(f->shared->cache); - HDassert(f->shared->cache == cache_ptr); - HDassert(cache_ptr->magic == H5C__H5C_T_MAGIC); - HDassert(entry_ptr_ptr); - HDassert(*entry_ptr_ptr); + assert(f); + assert(f->shared); + assert(f->shared->cache); + assert(f->shared->cache == cache_ptr); + assert(cache_ptr->magic == H5C__H5C_T_MAGIC); + assert(entry_ptr_ptr); + assert(*entry_ptr_ptr); pf_entry_ptr = *entry_ptr_ptr; - HDassert(pf_entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC); - HDassert(pf_entry_ptr->type); - HDassert(pf_entry_ptr->type->id == H5AC_PREFETCHED_ENTRY_ID); - HDassert(pf_entry_ptr->prefetched); - HDassert(pf_entry_ptr->image_up_to_date); - HDassert(pf_entry_ptr->image_ptr); - HDassert(pf_entry_ptr->size > 0); - HDassert(pf_entry_ptr->addr == addr); - HDassert(type); - HDassert(type->id == pf_entry_ptr->prefetch_type_id); - HDassert(type->mem_type == cache_ptr->class_table_ptr[type->id]->mem_type); + assert(pf_entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC); + assert(pf_entry_ptr->type); + assert(pf_entry_ptr->type->id == H5AC_PREFETCHED_ENTRY_ID); + assert(pf_entry_ptr->prefetched); + assert(pf_entry_ptr->image_up_to_date); + assert(pf_entry_ptr->image_ptr); + assert(pf_entry_ptr->size > 0); + assert(pf_entry_ptr->addr == addr); + assert(type); + assert(type->id == pf_entry_ptr->prefetch_type_id); + assert(type->mem_type == cache_ptr->class_table_ptr[type->id]->mem_type); /* verify absence of prohibited or unsupported type flag combinations */ - HDassert(!(type->flags & H5C__CLASS_SKIP_READS)); + assert(!(type->flags & H5C__CLASS_SKIP_READS)); /* Can't see how skip reads could be usefully combined with * either the speculative read flag. Hence disallow. */ - HDassert(!((type->flags & H5C__CLASS_SKIP_READS) && (type->flags & H5C__CLASS_SPECULATIVE_LOAD_FLAG))); - HDassert(H5F_addr_defined(addr)); - HDassert(type->get_initial_load_size); - HDassert(type->deserialize); + assert(!((type->flags & H5C__CLASS_SKIP_READS) && (type->flags & H5C__CLASS_SPECULATIVE_LOAD_FLAG))); + assert(H5F_addr_defined(addr)); + assert(type->get_initial_load_size); + assert(type->deserialize); /* if *pf_entry_ptr is a flush dependency child, destroy all such * relationships now. The client will restore the relationship(s) with * the deserialized entry if appropriate. */ - HDassert(pf_entry_ptr->fd_parent_count == pf_entry_ptr->flush_dep_nparents); + assert(pf_entry_ptr->fd_parent_count == pf_entry_ptr->flush_dep_nparents); for (i = (int)(pf_entry_ptr->fd_parent_count) - 1; i >= 0; i--) { - HDassert(pf_entry_ptr->flush_dep_parent); - HDassert(pf_entry_ptr->flush_dep_parent[i]); - HDassert(pf_entry_ptr->flush_dep_parent[i]->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC); - HDassert(pf_entry_ptr->flush_dep_parent[i]->flush_dep_nchildren > 0); - HDassert(pf_entry_ptr->fd_parent_addrs); - HDassert(pf_entry_ptr->flush_dep_parent[i]->addr == pf_entry_ptr->fd_parent_addrs[i]); + assert(pf_entry_ptr->flush_dep_parent); + assert(pf_entry_ptr->flush_dep_parent[i]); + assert(pf_entry_ptr->flush_dep_parent[i]->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC); + assert(pf_entry_ptr->flush_dep_parent[i]->flush_dep_nchildren > 0); + assert(pf_entry_ptr->fd_parent_addrs); + assert(pf_entry_ptr->flush_dep_parent[i]->addr == pf_entry_ptr->fd_parent_addrs[i]); if (H5C_destroy_flush_dependency(pf_entry_ptr->flush_dep_parent[i], pf_entry_ptr) < 0) HGOTO_ERROR(H5E_CACHE, H5E_CANTUNDEPEND, FAIL, "can't destroy pf entry parent flush dependency") pf_entry_ptr->fd_parent_addrs[i] = HADDR_UNDEF; } /* end for */ - HDassert(pf_entry_ptr->flush_dep_nparents == 0); + assert(pf_entry_ptr->flush_dep_nparents == 0); /* If *pf_entry_ptr is a flush dependency parent, destroy its flush * dependency relationships with all its children (which must be @@ -616,7 +616,7 @@ H5C__deserialize_prefetched_entry(H5F_t *f, H5C_t *cache_ptr, H5C_cache_entry_t * * In the following assert: * - * HDassert( ( dirty == FALSE ) || ( type->id == 5 || type->id == 6 ) ); + * assert( ( dirty == FALSE ) || ( type->id == 5 || type->id == 6 ) ); * * note that type ids 5 & 6 are associated with object headers in the * metadata cache. @@ -633,13 +633,13 @@ H5C__deserialize_prefetched_entry(H5F_t *f, H5C_t *cache_ptr, H5C_cache_entry_t * hence the value assigned to ds_entry_ptr->is_dirty below. */ - HDassert((dirty == FALSE) || (type->id == 5 || type->id == 6)); + assert((dirty == FALSE) || (type->id == 5 || type->id == 6)); ds_entry_ptr->magic = H5C__H5C_CACHE_ENTRY_T_MAGIC; ds_entry_ptr->cache_ptr = f->shared->cache; ds_entry_ptr->addr = addr; ds_entry_ptr->size = len; - HDassert(ds_entry_ptr->size < H5C_MAX_ENTRY_SIZE); + assert(ds_entry_ptr->size < H5C_MAX_ENTRY_SIZE); ds_entry_ptr->image_ptr = pf_entry_ptr->image_ptr; ds_entry_ptr->image_up_to_date = !dirty; ds_entry_ptr->type = type; @@ -733,8 +733,8 @@ 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))); + assert(((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 */ @@ -745,13 +745,13 @@ H5C__deserialize_prefetched_entry(H5F_t *f, H5C_t *cache_ptr, H5C_cache_entry_t #ifndef NDEGUG /* verify deletion */ H5C__SEARCH_INDEX(cache_ptr, addr, pf_entry_ptr, FAIL); - HDassert(NULL == pf_entry_ptr); + assert(NULL == pf_entry_ptr); #endif /* NDEBUG */ /* Insert the deserialized entry into the cache. */ H5C__INSERT_IN_INDEX(cache_ptr, ds_entry_ptr, FAIL) - HDassert(!ds_entry_ptr->in_slist); + assert(!ds_entry_ptr->in_slist); if (ds_entry_ptr->is_dirty) H5C__INSERT_ENTRY_IN_SLIST(cache_ptr, ds_entry_ptr, FAIL) @@ -777,10 +777,10 @@ H5C__deserialize_prefetched_entry(H5F_t *f, H5C_t *cache_ptr, H5C_cache_entry_t ds_entry_ptr->is_protected = TRUE; while (fd_children[i] != NULL) { /* Sanity checks */ - HDassert((fd_children[i])->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC); - HDassert((fd_children[i])->prefetched); - HDassert((fd_children[i])->fd_parent_count > 0); - HDassert((fd_children[i])->fd_parent_addrs); + assert((fd_children[i])->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC); + assert((fd_children[i])->prefetched); + assert((fd_children[i])->fd_parent_count > 0); + assert((fd_children[i])->fd_parent_addrs); #ifndef NDEBUG { @@ -795,7 +795,7 @@ H5C__deserialize_prefetched_entry(H5F_t *f, H5C_t *cache_ptr, H5C_cache_entry_t j++; } /* end while */ - HDassert(found); + assert(found); } #endif /* NDEBUG */ @@ -808,7 +808,7 @@ H5C__deserialize_prefetched_entry(H5F_t *f, H5C_t *cache_ptr, H5C_cache_entry_t H5C__UPDATE_RP_FOR_UNPROTECT(cache_ptr, ds_entry_ptr, FAIL); ds_entry_ptr->is_protected = FALSE; } /* end if ( fd_children != NULL ) */ - HDassert((unsigned)i == ds_entry_ptr->fd_child_count); + assert((unsigned)i == ds_entry_ptr->fd_child_count); ds_entry_ptr->fd_child_count = 0; H5C__UPDATE_STATS_FOR_PREFETCH_HIT(cache_ptr) @@ -851,11 +851,11 @@ H5C__free_image_entries_array(H5C_t *cache_ptr) FUNC_ENTER_PACKAGE_NOERR /* Sanity checks */ - HDassert(cache_ptr); - HDassert(cache_ptr->magic == H5C__H5C_T_MAGIC); - HDassert(cache_ptr->close_warning_received); - HDassert(cache_ptr->image_ctl.generate_image); - HDassert(cache_ptr->index_len == 0); + assert(cache_ptr); + assert(cache_ptr->magic == H5C__H5C_T_MAGIC); + assert(cache_ptr->close_warning_received); + assert(cache_ptr->image_ctl.generate_image); + assert(cache_ptr->index_len == 0); /* Check for entries to free */ if (cache_ptr->image_entries != NULL) { @@ -868,18 +868,18 @@ H5C__free_image_entries_array(H5C_t *cache_ptr) ie_ptr = &(cache_ptr->image_entries[u]); /* Sanity checks */ - HDassert(ie_ptr); - HDassert(ie_ptr->magic == H5C_IMAGE_ENTRY_T_MAGIC); - HDassert(ie_ptr->image_ptr); + assert(ie_ptr); + assert(ie_ptr->magic == H5C_IMAGE_ENTRY_T_MAGIC); + assert(ie_ptr->image_ptr); /* Free the parent addrs array if appropriate */ if (ie_ptr->fd_parent_addrs) { - HDassert(ie_ptr->fd_parent_count > 0); + assert(ie_ptr->fd_parent_count > 0); ie_ptr->fd_parent_addrs = (haddr_t *)H5MM_xfree(ie_ptr->fd_parent_addrs); } /* end if */ else - HDassert(ie_ptr->fd_parent_count == 0); + assert(ie_ptr->fd_parent_count == 0); /* Free the image */ ie_ptr->image_ptr = H5MM_xfree(ie_ptr->image_ptr); @@ -977,16 +977,15 @@ H5C_image_stats(H5C_t *cache_ptr, hbool_t H5_ATTR_UNUSED print_header) prefetch_use_rate = 0.0; if (print_header) { - HDfprintf(stdout, "\nhit prefetches prefetch image pf hit\n"); - HDfprintf(stdout, "rate: total: dirty: hits: flshs: evct: size: rate:\n"); + fprintf(stdout, "\nhit prefetches prefetch image pf hit\n"); + fprintf(stdout, "rate: total: dirty: hits: flshs: evct: size: rate:\n"); } /* end if */ - HDfprintf(stdout, "%3.1lf %5lld %5lld %5lld %5lld %5lld %5lld %3.1lf\n", hit_rate, - (long long)(cache_ptr->prefetches), (long long)(cache_ptr->dirty_prefetches), - (long long)(cache_ptr->prefetch_hits), - (long long)(cache_ptr->flushes[H5AC_PREFETCHED_ENTRY_ID]), - (long long)(cache_ptr->evictions[H5AC_PREFETCHED_ENTRY_ID]), - (long long)(cache_ptr->last_image_size), prefetch_use_rate); + fprintf(stdout, "%3.1lf %5lld %5lld %5lld %5lld %5lld %5lld %3.1lf\n", hit_rate, + (long long)(cache_ptr->prefetches), (long long)(cache_ptr->dirty_prefetches), + (long long)(cache_ptr->prefetch_hits), (long long)(cache_ptr->flushes[H5AC_PREFETCHED_ENTRY_ID]), + (long long)(cache_ptr->evictions[H5AC_PREFETCHED_ENTRY_ID]), + (long long)(cache_ptr->last_image_size), prefetch_use_rate); #endif /* H5C_COLLECT_CACHE_STATS */ done: @@ -1014,11 +1013,11 @@ H5C__read_cache_image(H5F_t *f, H5C_t *cache_ptr) FUNC_ENTER_PACKAGE /* Sanity checks */ - HDassert(f); - HDassert(cache_ptr); - HDassert(H5F_addr_defined(cache_ptr->image_addr)); - HDassert(cache_ptr->image_len > 0); - HDassert(cache_ptr->image_buffer); + assert(f); + assert(cache_ptr); + assert(H5F_addr_defined(cache_ptr->image_addr)); + assert(cache_ptr->image_len > 0); + assert(cache_ptr->image_buffer); #ifdef H5_HAVE_PARALLEL { @@ -1026,7 +1025,7 @@ 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)); + assert((NULL == aux_ptr) || (aux_ptr->magic == H5AC__H5AC_AUX_T_MAGIC)); #endif /* H5_HAVE_PARALLEL */ /* Read the buffer (if serial access, or rank 0 of parallel access) */ @@ -1086,11 +1085,11 @@ H5C__load_cache_image(H5F_t *f) FUNC_ENTER_PACKAGE /* Sanity checks */ - HDassert(f); - HDassert(f->shared); + assert(f); + assert(f->shared); cache_ptr = f->shared->cache; - HDassert(cache_ptr); - HDassert(cache_ptr->magic == H5C__H5C_T_MAGIC); + assert(cache_ptr); + assert(cache_ptr->magic == H5C__H5C_T_MAGIC); /* If the image address is defined, load the image, decode it, * and insert its contents into the metadata cache. @@ -1103,8 +1102,8 @@ H5C__load_cache_image(H5F_t *f) */ if (H5F_addr_defined(cache_ptr->image_addr)) { /* Sanity checks */ - HDassert(cache_ptr->image_len > 0); - HDassert(cache_ptr->image_buffer == NULL); + assert(cache_ptr->image_len > 0); + assert(cache_ptr->image_buffer == NULL); /* Allocate space for the image */ if (NULL == (cache_ptr->image_buffer = H5MM_malloc(cache_ptr->image_len + 1))) @@ -1181,11 +1180,11 @@ H5C_load_cache_image_on_next_protect(H5F_t *f, haddr_t addr, hsize_t len, hbool_ FUNC_ENTER_NOAPI_NOINIT_NOERR /* Sanity checks */ - HDassert(f); - HDassert(f->shared); + assert(f); + assert(f->shared); cache_ptr = f->shared->cache; - HDassert(cache_ptr); - HDassert(cache_ptr->magic == H5C__H5C_T_MAGIC); + assert(cache_ptr); + assert(cache_ptr->magic == H5C__H5C_T_MAGIC); /* Set information needed to load cache image */ cache_ptr->image_addr = addr; @@ -1230,8 +1229,8 @@ H5C__image_entry_cmp(const void *_entry1, const void *_entry2) FUNC_ENTER_PACKAGE_NOERR /* Sanity checks */ - HDassert(entry1); - HDassert(entry2); + assert(entry1); + assert(entry2); if (entry1->image_fd_height > entry2->image_fd_height) ret_value = -1; @@ -1239,8 +1238,8 @@ H5C__image_entry_cmp(const void *_entry1, const void *_entry2) ret_value = 1; else { /* Sanity check */ - HDassert(entry1->lru_rank >= -1); - HDassert(entry2->lru_rank >= -1); + assert(entry1->lru_rank >= -1); + assert(entry2->lru_rank >= -1); if (entry1->lru_rank < entry2->lru_rank) ret_value = -1; @@ -1309,13 +1308,13 @@ H5C__prep_image_for_file_close(H5F_t *f, hbool_t *image_generated) FUNC_ENTER_PACKAGE /* Sanity checks */ - HDassert(f); - HDassert(f->shared); - HDassert(f->shared->cache); + assert(f); + assert(f->shared); + assert(f->shared->cache); cache_ptr = f->shared->cache; - HDassert(cache_ptr); - HDassert(cache_ptr->magic == H5C__H5C_T_MAGIC); - HDassert(image_generated); + assert(cache_ptr); + assert(cache_ptr->magic == H5C__H5C_T_MAGIC); + assert(image_generated); /* If the file is opened and closed without any access to * any group or data set, it is possible that the cache image (if @@ -1346,7 +1345,7 @@ H5C__prep_image_for_file_close(H5F_t *f, hbool_t *image_generated) H5C_cache_image_ctl_t default_image_ctl = H5C__DEFAULT_CACHE_IMAGE_CTL; cache_ptr->image_ctl = default_image_ctl; - HDassert(!(cache_ptr->image_ctl.generate_image)); + assert(!(cache_ptr->image_ctl.generate_image)); } /* end if */ /* Generate the cache image, if requested */ @@ -1391,7 +1390,7 @@ H5C__prep_image_for_file_close(H5F_t *f, hbool_t *image_generated) */ if (H5C__prep_for_file_close__scan_entries(f, cache_ptr) < 0) HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "H5C__prep_for_file_close__scan_entries failed") - HDassert(HADDR_UNDEF == cache_ptr->image_addr); + assert(HADDR_UNDEF == cache_ptr->image_addr); #ifdef H5_HAVE_PARALLEL /* In the parallel case, overwrite the image_len with the @@ -1411,7 +1410,7 @@ H5C__prep_image_for_file_close(H5F_t *f, hbool_t *image_generated) (mpi_result = MPI_Bcast(&p0_image_len, 1, MPI_UNSIGNED, 0, aux_ptr->mpi_comm))) HMPI_GOTO_ERROR(FAIL, "MPI_Bcast failed", mpi_result) - HDassert(p0_image_len == aux_ptr->p0_image_len); + assert(p0_image_len == aux_ptr->p0_image_len); } /* end if */ else { if (MPI_SUCCESS != @@ -1453,7 +1452,7 @@ H5C__prep_image_for_file_close(H5F_t *f, hbool_t *image_generated) * shutdown the self referential free space managers after * we destroy the metadata cache. */ - HDassert(HADDR_UNDEF == f->shared->eoa_post_mdci_fsalloc); + assert(HADDR_UNDEF == f->shared->eoa_post_mdci_fsalloc); if (HADDR_UNDEF == (f->shared->eoa_post_mdci_fsalloc = H5FD_get_eoa(f->shared->lf, H5FD_MEM_DEFAULT))) HGOTO_ERROR(H5E_FILE, H5E_CANTGET, FAIL, "unable to get file size") @@ -1469,7 +1468,7 @@ H5C__prep_image_for_file_close(H5F_t *f, hbool_t *image_generated) * a fragment on a cache image allocation, leave the following * assertion in the code so we will find out. */ - HDassert((eoa_frag_size == 0) || (f->shared->alignment != 1)); + assert((eoa_frag_size == 0) || (f->shared->alignment != 1)); /* Eventually it will be possible for the length of the cache image * block on file to be greater than the size of the data it @@ -1533,7 +1532,7 @@ H5C__prep_image_for_file_close(H5F_t *f, hbool_t *image_generated) sizeof(H5C_image_entry_t), H5C__image_entry_cmp); } /* end if */ else { /* cancel creation of metadata cache image */ - HDassert(cache_ptr->image_entries == NULL); + assert(cache_ptr->image_entries == NULL); /* To avoid breaking the control flow tests, only delete * the mdci superblock extension message if the @@ -1592,9 +1591,9 @@ H5C_set_cache_image_config(const H5F_t *f, H5C_t *cache_ptr, H5C_cache_image_ctl FUNC_ENTER_NOAPI(FAIL) /* Sanity checks */ - HDassert(f); - HDassert(f->shared); - HDassert(f->shared->cache == f->shared->cache); + assert(f); + assert(f->shared); + assert(f->shared->cache == f->shared->cache); /* Check arguments */ if ((cache_ptr == NULL) || (cache_ptr->magic != H5C__H5C_T_MAGIC)) @@ -1613,7 +1612,7 @@ H5C_set_cache_image_config(const H5F_t *f, H5C_t *cache_ptr, H5C_cache_image_ctl H5C_cache_image_ctl_t default_image_ctl = H5C__DEFAULT_CACHE_IMAGE_CTL; cache_ptr->image_ctl = default_image_ctl; - HDassert(!(cache_ptr->image_ctl.generate_image)); + assert(!(cache_ptr->image_ctl.generate_image)); } /* end if */ else { #endif /* H5_HAVE_PARALLEL */ @@ -1635,7 +1634,7 @@ H5C_set_cache_image_config(const H5F_t *f, H5C_t *cache_ptr, H5C_cache_image_ctl H5C_cache_image_ctl_t default_image_ctl = H5C__DEFAULT_CACHE_IMAGE_CTL; cache_ptr->image_ctl = default_image_ctl; - HDassert(!(cache_ptr->image_ctl.generate_image)); + assert(!(cache_ptr->image_ctl.generate_image)); } /* end else */ #ifdef H5_HAVE_PARALLEL } /* end else */ @@ -1794,16 +1793,16 @@ H5C__decode_cache_image_header(const H5F_t *f, H5C_t *cache_ptr, const uint8_t * FUNC_ENTER_PACKAGE /* Sanity checks */ - HDassert(cache_ptr); - HDassert(cache_ptr->magic == H5C__H5C_T_MAGIC); - HDassert(buf); - HDassert(*buf); + assert(cache_ptr); + assert(cache_ptr->magic == H5C__H5C_T_MAGIC); + assert(buf); + assert(*buf); /* Point to buffer to decode */ p = *buf; /* Check signature */ - if (HDmemcmp(p, H5C__MDCI_BLOCK_SIGNATURE, (size_t)H5C__MDCI_BLOCK_SIGNATURE_LEN) != 0) + if (memcmp(p, H5C__MDCI_BLOCK_SIGNATURE, (size_t)H5C__MDCI_BLOCK_SIGNATURE_LEN) != 0) HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, FAIL, "Bad metadata cache image header signature") p += H5C__MDCI_BLOCK_SIGNATURE_LEN; @@ -1891,17 +1890,17 @@ H5C__decode_cache_image_entry(const H5F_t *f, const H5C_t *cache_ptr, const uint FUNC_ENTER_PACKAGE /* Sanity checks */ - HDassert(f); - HDassert(f->shared); - HDassert(cache_ptr == f->shared->cache); - HDassert(cache_ptr); - HDassert(cache_ptr->magic == H5C__H5C_T_MAGIC); - HDassert(buf); - HDassert(*buf); - HDassert(entry_num < cache_ptr->num_entries_in_image); + assert(f); + assert(f->shared); + assert(cache_ptr == f->shared->cache); + assert(cache_ptr); + assert(cache_ptr->magic == H5C__H5C_T_MAGIC); + assert(buf); + assert(*buf); + assert(entry_num < cache_ptr->num_entries_in_image); ie_ptr = &(cache_ptr->image_entries[entry_num]); - HDassert(ie_ptr); - HDassert(ie_ptr->magic == H5C_IMAGE_ENTRY_T_MAGIC); + assert(ie_ptr); + assert(ie_ptr->magic == H5C_IMAGE_ENTRY_T_MAGIC); /* Get pointer to buffer */ p = *buf; @@ -1922,15 +1921,15 @@ H5C__decode_cache_image_entry(const H5F_t *f, const H5C_t *cache_ptr, const uint /* Decode ring */ ring = *p++; - HDassert(ring > (uint8_t)(H5C_RING_UNDEFINED)); - HDassert(ring < (uint8_t)(H5C_RING_NTYPES)); + assert(ring > (uint8_t)(H5C_RING_UNDEFINED)); + assert(ring < (uint8_t)(H5C_RING_NTYPES)); /* Decode age */ age = *p++; /* Decode dependency child count */ UINT16DECODE(p, fd_child_count); - HDassert((is_fd_parent && fd_child_count > 0) || (!is_fd_parent && fd_child_count == 0)); + assert((is_fd_parent && fd_child_count > 0) || (!is_fd_parent && fd_child_count == 0)); /* Decode dirty dependency child count */ UINT16DECODE(p, fd_dirty_child_count); @@ -1939,11 +1938,11 @@ H5C__decode_cache_image_entry(const H5F_t *f, const H5C_t *cache_ptr, const uint /* Decode dependency parent count */ UINT16DECODE(p, fd_parent_count); - HDassert((is_fd_child && fd_parent_count > 0) || (!is_fd_child && fd_parent_count == 0)); + assert((is_fd_child && fd_parent_count > 0) || (!is_fd_child && fd_parent_count == 0)); /* Decode index in LRU */ INT32DECODE(p, lru_rank); - HDassert((in_lru && lru_rank >= 0) || (!in_lru && lru_rank == -1)); + assert((in_lru && lru_rank >= 0) || (!in_lru && lru_rank == -1)); /* Decode entry offset */ H5F_addr_decode(f, &p, &addr); @@ -2047,20 +2046,20 @@ H5C__destroy_pf_entry_child_flush_deps(H5C_t *cache_ptr, H5C_cache_entry_t *pf_e FUNC_ENTER_PACKAGE /* Sanity checks */ - HDassert(cache_ptr); - HDassert(cache_ptr->magic == H5C__H5C_T_MAGIC); - HDassert(pf_entry_ptr); - HDassert(pf_entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC); - HDassert(pf_entry_ptr->type); - HDassert(pf_entry_ptr->type->id == H5AC_PREFETCHED_ENTRY_ID); - HDassert(pf_entry_ptr->prefetched); - HDassert(pf_entry_ptr->fd_child_count > 0); - HDassert(fd_children); + assert(cache_ptr); + assert(cache_ptr->magic == H5C__H5C_T_MAGIC); + assert(pf_entry_ptr); + assert(pf_entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC); + assert(pf_entry_ptr->type); + assert(pf_entry_ptr->type->id == H5AC_PREFETCHED_ENTRY_ID); + assert(pf_entry_ptr->prefetched); + assert(pf_entry_ptr->fd_child_count > 0); + assert(fd_children); /* Scan each entry on the index list */ entry_ptr = cache_ptr->il_head; while (entry_ptr != NULL) { - HDassert(entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC); + assert(entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC); /* Here we look at entry_ptr->flush_dep_nparents and not * entry_ptr->fd_parent_count as it is possible that some @@ -2075,17 +2074,17 @@ H5C__destroy_pf_entry_child_flush_deps(H5C_t *cache_ptr, H5C_cache_entry_t *pf_e found = FALSE; /* Sanity checks */ - HDassert(entry_ptr->type); - HDassert(entry_ptr->type->id == H5AC_PREFETCHED_ENTRY_ID); - HDassert(entry_ptr->fd_parent_count >= entry_ptr->flush_dep_nparents); - HDassert(entry_ptr->fd_parent_addrs); - HDassert(entry_ptr->flush_dep_parent); + assert(entry_ptr->type); + assert(entry_ptr->type->id == H5AC_PREFETCHED_ENTRY_ID); + assert(entry_ptr->fd_parent_count >= entry_ptr->flush_dep_nparents); + assert(entry_ptr->fd_parent_addrs); + assert(entry_ptr->flush_dep_parent); /* Look for correct entry */ while (!found && (u < entry_ptr->fd_parent_count)) { /* Sanity check entry */ - HDassert(entry_ptr->flush_dep_parent[u]); - HDassert(entry_ptr->flush_dep_parent[u]->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC); + assert(entry_ptr->flush_dep_parent[u]); + assert(entry_ptr->flush_dep_parent[u]->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC); /* Correct entry? */ if (pf_entry_ptr == entry_ptr->flush_dep_parent[u]) @@ -2095,7 +2094,7 @@ H5C__destroy_pf_entry_child_flush_deps(H5C_t *cache_ptr, H5C_cache_entry_t *pf_e } /* end while */ if (found) { - HDassert(NULL == fd_children[fd_children_found]); + assert(NULL == fd_children[fd_children_found]); /* Remove flush dependency */ fd_children[fd_children_found] = entry_ptr; @@ -2118,7 +2117,7 @@ H5C__destroy_pf_entry_child_flush_deps(H5C_t *cache_ptr, H5C_cache_entry_t *pf_e found = TRUE; u++; } /* end while */ - HDassert(found); + assert(found); #endif /* NDEBUG */ } /* end if */ } /* end if */ @@ -2128,10 +2127,10 @@ H5C__destroy_pf_entry_child_flush_deps(H5C_t *cache_ptr, H5C_cache_entry_t *pf_e } /* end while */ /* Post-op sanity checks */ - HDassert(NULL == fd_children[fd_children_found]); - HDassert((unsigned)fd_children_found == pf_entry_ptr->fd_child_count); - HDassert(entries_visited == cache_ptr->index_len); - HDassert(!pf_entry_ptr->is_pinned); + assert(NULL == fd_children[fd_children_found]); + assert((unsigned)fd_children_found == pf_entry_ptr->fd_child_count); + assert(entries_visited == cache_ptr->index_len); + assert(!pf_entry_ptr->is_pinned); done: FUNC_LEAVE_NOAPI(ret_value) @@ -2163,15 +2162,15 @@ H5C__encode_cache_image_header(const H5F_t *f, const H5C_t *cache_ptr, uint8_t * FUNC_ENTER_PACKAGE /* Sanity checks */ - HDassert(cache_ptr); - HDassert(cache_ptr->magic == H5C__H5C_T_MAGIC); - HDassert(cache_ptr->close_warning_received); - HDassert(cache_ptr->image_ctl.generate_image); - HDassert(cache_ptr->index_len == 0); - HDassert(cache_ptr->image_data_len > 0); - HDassert(cache_ptr->image_data_len <= cache_ptr->image_len); - HDassert(buf); - HDassert(*buf); + assert(cache_ptr); + assert(cache_ptr->magic == H5C__H5C_T_MAGIC); + assert(cache_ptr->close_warning_received); + assert(cache_ptr->image_ctl.generate_image); + assert(cache_ptr->index_len == 0); + assert(cache_ptr->image_data_len > 0); + assert(cache_ptr->image_data_len <= cache_ptr->image_len); + assert(buf); + assert(*buf); /* Set pointer into buffer */ p = *buf; @@ -2186,7 +2185,7 @@ H5C__encode_cache_image_header(const H5F_t *f, const H5C_t *cache_ptr, uint8_t * /* setup and write flags */ /* at present we don't support saving resize status */ - HDassert(!cache_ptr->image_ctl.save_resize_status); + assert(!cache_ptr->image_ctl.save_resize_status); if (cache_ptr->image_ctl.save_resize_status) flags |= H5C__MDCI_HEADER_HAVE_RESIZE_STATUS; @@ -2194,7 +2193,7 @@ H5C__encode_cache_image_header(const H5F_t *f, const H5C_t *cache_ptr, uint8_t * /* Encode image data length */ /* this must be true at present */ - HDassert(cache_ptr->image_len == cache_ptr->image_data_len); + assert(cache_ptr->image_len == cache_ptr->image_data_len); H5F_ENCODE_LENGTH(f, p, cache_ptr->image_data_len); /* write num entries */ @@ -2239,19 +2238,19 @@ H5C__encode_cache_image_entry(H5F_t *f, H5C_t *cache_ptr, uint8_t **buf, unsigne FUNC_ENTER_PACKAGE /* Sanity checks */ - HDassert(f); - HDassert(f->shared); - HDassert(cache_ptr == f->shared->cache); - HDassert(cache_ptr); - HDassert(cache_ptr->magic == H5C__H5C_T_MAGIC); - HDassert(cache_ptr->close_warning_received); - HDassert(cache_ptr->image_ctl.generate_image); - HDassert(cache_ptr->index_len == 0); - HDassert(buf); - HDassert(*buf); - HDassert(entry_num < cache_ptr->num_entries_in_image); + assert(f); + assert(f->shared); + assert(cache_ptr == f->shared->cache); + assert(cache_ptr); + assert(cache_ptr->magic == H5C__H5C_T_MAGIC); + assert(cache_ptr->close_warning_received); + assert(cache_ptr->image_ctl.generate_image); + assert(cache_ptr->index_len == 0); + assert(buf); + assert(*buf); + assert(entry_num < cache_ptr->num_entries_in_image); ie_ptr = &(cache_ptr->image_entries[entry_num]); - HDassert(ie_ptr->magic == H5C_IMAGE_ENTRY_T_MAGIC); + assert(ie_ptr->magic == H5C_IMAGE_ENTRY_T_MAGIC); /* Get pointer to buffer to encode into */ p = *buf; @@ -2384,8 +2383,8 @@ H5C__prep_for_file_close__compute_fd_heights(const H5C_t *cache_ptr) FUNC_ENTER_PACKAGE /* sanity checks */ - HDassert(cache_ptr); - HDassert(cache_ptr->magic == H5C__H5C_T_MAGIC); + assert(cache_ptr); + assert(cache_ptr->magic == H5C__H5C_T_MAGIC); /* Remove from the cache image all dirty entries that are * flush dependency children of dirty entries that are not in the @@ -2399,17 +2398,17 @@ H5C__prep_for_file_close__compute_fd_heights(const H5C_t *cache_ptr) done = TRUE; entry_ptr = cache_ptr->il_head; while (entry_ptr != NULL) { - HDassert(entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC); + assert(entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC); /* Should this entry be in the image */ if (entry_ptr->image_dirty && entry_ptr->include_in_image && (entry_ptr->fd_parent_count > 0)) { - HDassert(entry_ptr->flush_dep_parent != NULL); + assert(entry_ptr->flush_dep_parent != NULL); for (u = 0; u < entry_ptr->flush_dep_nparents; u++) { parent_ptr = entry_ptr->flush_dep_parent[u]; /* Sanity check parent */ - HDassert(parent_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC); - HDassert(entry_ptr->ring == parent_ptr->ring); + assert(parent_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC); + assert(entry_ptr->ring == parent_ptr->ring); if (parent_ptr->is_dirty && !parent_ptr->include_in_image && entry_ptr->include_in_image) { @@ -2431,7 +2430,7 @@ H5C__prep_for_file_close__compute_fd_heights(const H5C_t *cache_ptr) * so. Note that this will change when we start aging entries out * of the cache image. */ - HDassert(entries_removed_from_image == 0); + assert(entries_removed_from_image == 0); /* Next, remove from entries in the cache image, references to * flush dependency parents or children that are not in the cache image. @@ -2439,22 +2438,22 @@ H5C__prep_for_file_close__compute_fd_heights(const H5C_t *cache_ptr) entry_ptr = cache_ptr->il_head; while (entry_ptr != NULL) { if (!entry_ptr->include_in_image && entry_ptr->flush_dep_nparents > 0) { - HDassert(entry_ptr->flush_dep_parent != NULL); + assert(entry_ptr->flush_dep_parent != NULL); for (u = 0; u < entry_ptr->flush_dep_nparents; u++) { parent_ptr = entry_ptr->flush_dep_parent[u]; /* Sanity check parent */ - HDassert(parent_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC); - HDassert(entry_ptr->ring == parent_ptr->ring); + assert(parent_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC); + assert(entry_ptr->ring == parent_ptr->ring); if (parent_ptr->include_in_image) { /* Must remove reference to child */ - HDassert(parent_ptr->fd_child_count > 0); + assert(parent_ptr->fd_child_count > 0); parent_ptr->fd_child_count--; if (entry_ptr->is_dirty) { - HDassert(parent_ptr->fd_dirty_child_count > 0); + assert(parent_ptr->fd_dirty_child_count > 0); parent_ptr->fd_dirty_child_count--; } /* end if */ @@ -2464,23 +2463,23 @@ H5C__prep_for_file_close__compute_fd_heights(const H5C_t *cache_ptr) } /* end if */ else if (entry_ptr->include_in_image && entry_ptr->flush_dep_nparents > 0) { /* Sanity checks */ - HDassert(entry_ptr->flush_dep_parent != NULL); - HDassert(entry_ptr->flush_dep_nparents == entry_ptr->fd_parent_count); - HDassert(entry_ptr->fd_parent_addrs); + assert(entry_ptr->flush_dep_parent != NULL); + assert(entry_ptr->flush_dep_nparents == entry_ptr->fd_parent_count); + assert(entry_ptr->fd_parent_addrs); for (u = 0; u < entry_ptr->flush_dep_nparents; u++) { parent_ptr = entry_ptr->flush_dep_parent[u]; /* Sanity check parent */ - HDassert(parent_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC); - HDassert(entry_ptr->ring == parent_ptr->ring); + assert(parent_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC); + assert(entry_ptr->ring == parent_ptr->ring); if (!parent_ptr->include_in_image) { /* Must remove reference to parent */ - HDassert(entry_ptr->fd_parent_count > 0); + assert(entry_ptr->fd_parent_count > 0); parent_ptr->fd_child_count--; - HDassert(parent_ptr->addr == entry_ptr->fd_parent_addrs[u]); + assert(parent_ptr->addr == entry_ptr->fd_parent_addrs[u]); entry_ptr->fd_parent_addrs[u] = HADDR_UNDEF; external_parent_fd_refs_removed++; @@ -2509,7 +2508,7 @@ H5C__prep_for_file_close__compute_fd_heights(const H5C_t *cache_ptr) } /* end if */ } /* end for */ - HDassert(v == entry_ptr->fd_parent_count); + assert(v == entry_ptr->fd_parent_count); } /* end else-if */ } /* end else-if */ @@ -2520,8 +2519,8 @@ H5C__prep_for_file_close__compute_fd_heights(const H5C_t *cache_ptr) * should exist -- hence the following assertions. This will change * if we support ageout of entries in the cache image. */ - HDassert(external_child_fd_refs_removed == 0); - HDassert(external_parent_fd_refs_removed == 0); + assert(external_child_fd_refs_removed == 0); + assert(external_parent_fd_refs_removed == 0); /* At this point we should have removed all flush dependencies that * cross cache image boundaries. Now compute the flush dependency @@ -2539,7 +2538,7 @@ H5C__prep_for_file_close__compute_fd_heights(const H5C_t *cache_ptr) for (u = 0; u < entry_ptr->fd_parent_count; u++) { parent_ptr = entry_ptr->flush_dep_parent[u]; - HDassert(parent_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC); + assert(parent_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC); if (parent_ptr->include_in_image && parent_ptr->image_fd_height <= 0) H5C__prep_for_file_close__compute_fd_heights_real(parent_ptr, 1); } /* end for */ @@ -2606,23 +2605,23 @@ H5C__prep_for_file_close__compute_fd_heights_real(H5C_cache_entry_t *entry_ptr, FUNC_ENTER_PACKAGE_NOERR /* Sanity checks */ - HDassert(entry_ptr); - HDassert(entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC); - HDassert(entry_ptr->include_in_image); - HDassert((entry_ptr->image_fd_height == 0) || (entry_ptr->image_fd_height < fd_height)); - HDassert(((fd_height == 0) && (entry_ptr->fd_child_count == 0)) || - ((fd_height > 0) && (entry_ptr->fd_child_count > 0))); + assert(entry_ptr); + assert(entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC); + assert(entry_ptr->include_in_image); + assert((entry_ptr->image_fd_height == 0) || (entry_ptr->image_fd_height < fd_height)); + assert(((fd_height == 0) && (entry_ptr->fd_child_count == 0)) || + ((fd_height > 0) && (entry_ptr->fd_child_count > 0))); entry_ptr->image_fd_height = fd_height; if (entry_ptr->flush_dep_nparents > 0) { unsigned u; - HDassert(entry_ptr->flush_dep_parent); + assert(entry_ptr->flush_dep_parent); for (u = 0; u < entry_ptr->fd_parent_count; u++) { H5C_cache_entry_t *parent_ptr; parent_ptr = entry_ptr->flush_dep_parent[u]; - HDassert(parent_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC); + assert(parent_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC); if (parent_ptr->include_in_image && parent_ptr->image_fd_height <= fd_height) H5C__prep_for_file_close__compute_fd_heights_real(parent_ptr, fd_height + 1); @@ -2658,12 +2657,12 @@ H5C__prep_for_file_close__setup_image_entries_array(H5C_t *cache_ptr) FUNC_ENTER_PACKAGE /* Sanity checks */ - HDassert(cache_ptr); - HDassert(cache_ptr->magic == H5C__H5C_T_MAGIC); - HDassert(cache_ptr->close_warning_received); - HDassert(cache_ptr->pl_len == 0); - HDassert(cache_ptr->num_entries_in_image > 0); - HDassert(cache_ptr->image_entries == NULL); + assert(cache_ptr); + assert(cache_ptr->magic == H5C__H5C_T_MAGIC); + assert(cache_ptr->close_warning_received); + assert(cache_ptr->pl_len == 0); + assert(cache_ptr->num_entries_in_image > 0); + assert(cache_ptr->image_entries == NULL); /* Allocate and initialize image_entries array */ if (NULL == (image_entries = (H5C_image_entry_t *)H5MM_calloc( @@ -2682,15 +2681,15 @@ H5C__prep_for_file_close__setup_image_entries_array(H5C_t *cache_ptr) u = 0; entry_ptr = cache_ptr->il_head; while (entry_ptr != NULL) { - HDassert(entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC); + assert(entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC); if (entry_ptr->include_in_image) { /* Since we have already serialized the cache, the following * should hold. */ - HDassert(entry_ptr->image_up_to_date); - HDassert(entry_ptr->image_ptr); - HDassert(entry_ptr->type); + assert(entry_ptr->image_up_to_date); + assert(entry_ptr->image_ptr); + assert(entry_ptr->type); image_entries[u].addr = entry_ptr->addr; image_entries[u].size = entry_ptr->size; @@ -2733,7 +2732,7 @@ H5C__prep_for_file_close__setup_image_entries_array(H5C_t *cache_ptr) u++; - HDassert(u <= cache_ptr->num_entries_in_image); + assert(u <= cache_ptr->num_entries_in_image); } /* end if */ entries_visited++; @@ -2742,11 +2741,11 @@ H5C__prep_for_file_close__setup_image_entries_array(H5C_t *cache_ptr) } /* end while */ /* Sanity checks */ - HDassert(entries_visited == cache_ptr->index_len); - HDassert(u == cache_ptr->num_entries_in_image); + assert(entries_visited == cache_ptr->index_len); + assert(u == cache_ptr->num_entries_in_image); - HDassert(image_entries[u].fd_parent_addrs == NULL); - HDassert(image_entries[u].image_ptr == NULL); + assert(image_entries[u].fd_parent_addrs == NULL); + assert(image_entries[u].image_ptr == NULL); cache_ptr->image_entries = image_entries; @@ -2801,13 +2800,13 @@ H5C__prep_for_file_close__scan_entries(const H5F_t *f, H5C_t *cache_ptr) FUNC_ENTER_PACKAGE /* Sanity checks */ - HDassert(f); - HDassert(f->shared); - HDassert(f->shared->sblock); - HDassert(cache_ptr); - HDassert(cache_ptr->magic == H5C__H5C_T_MAGIC); - HDassert(cache_ptr->close_warning_received); - HDassert(cache_ptr->pl_len == 0); + assert(f); + assert(f->shared); + assert(f->shared->sblock); + assert(cache_ptr); + assert(cache_ptr->magic == H5C__H5C_T_MAGIC); + assert(cache_ptr->close_warning_received); + assert(cache_ptr->pl_len == 0); /* Initialize image len to the size of the metadata cache image block * header. @@ -2818,13 +2817,13 @@ H5C__prep_for_file_close__scan_entries(const H5F_t *f, H5C_t *cache_ptr) /* Scan each entry on the index list */ entry_ptr = cache_ptr->il_head; while (entry_ptr != NULL) { - HDassert(entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC); + assert(entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC); /* Since we have already serialized the cache, the following * should hold. */ - HDassert(entry_ptr->image_up_to_date); - HDassert(entry_ptr->image_ptr); + assert(entry_ptr->image_up_to_date); + assert(entry_ptr->image_ptr); /* Initially, we mark all entries in the rings included * in the cache image as being included in the in the @@ -2854,15 +2853,15 @@ H5C__prep_for_file_close__scan_entries(const H5F_t *f, H5C_t *cache_ptr) /* parent addresses array should already be allocated * and of the correct size. */ - HDassert(entry_ptr->fd_parent_addrs); + assert(entry_ptr->fd_parent_addrs); } /* end if */ else if (entry_ptr->fd_parent_count > 0) { - HDassert(entry_ptr->fd_parent_addrs); + assert(entry_ptr->fd_parent_addrs); entry_ptr->fd_parent_addrs = (haddr_t *)H5MM_xfree(entry_ptr->fd_parent_addrs); } /* end else-if */ else { - HDassert(entry_ptr->fd_parent_count == 0); - HDassert(entry_ptr->fd_parent_addrs == NULL); + assert(entry_ptr->fd_parent_count == 0); + assert(entry_ptr->fd_parent_addrs == NULL); } /* end else */ entry_ptr->fd_parent_count = entry_ptr->flush_dep_nparents; @@ -2874,15 +2873,15 @@ H5C__prep_for_file_close__scan_entries(const H5F_t *f, H5C_t *cache_ptr) for (int i = 0; i < (int)(entry_ptr->fd_parent_count); i++) { entry_ptr->fd_parent_addrs[i] = entry_ptr->flush_dep_parent[i]->addr; - HDassert(H5F_addr_defined(entry_ptr->fd_parent_addrs[i])); + assert(H5F_addr_defined(entry_ptr->fd_parent_addrs[i])); } /* end for */ } /* end if */ else if (entry_ptr->fd_parent_count > 0) { - HDassert(entry_ptr->fd_parent_addrs); + assert(entry_ptr->fd_parent_addrs); entry_ptr->fd_parent_addrs = (haddr_t *)H5MM_xfree(entry_ptr->fd_parent_addrs); } /* end else-if */ else - HDassert(entry_ptr->fd_parent_addrs == NULL); + assert(entry_ptr->fd_parent_addrs == NULL); /* Initially, all flush dependency children are included int * the count of flush dependency child relationships to be @@ -2903,7 +2902,7 @@ H5C__prep_for_file_close__scan_entries(const H5F_t *f, H5C_t *cache_ptr) entries_visited++; entry_ptr = entry_ptr->il_next; } /* end while */ - HDassert(entries_visited == cache_ptr->index_len); + assert(entries_visited == cache_ptr->index_len); /* Now compute the flush dependency heights of all flush dependency * relationships to be represented in the image. @@ -2938,7 +2937,7 @@ H5C__prep_for_file_close__scan_entries(const H5F_t *f, H5C_t *cache_ptr) entries_visited = 0; entry_ptr = cache_ptr->il_head; while (entry_ptr != NULL) { - HDassert(entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC); + assert(entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC); if (entry_ptr->include_in_image) { if (entry_ptr->fd_parent_count > 0) @@ -2953,8 +2952,8 @@ H5C__prep_for_file_close__scan_entries(const H5F_t *f, H5C_t *cache_ptr) entries_visited++; entry_ptr = entry_ptr->il_next; } /* end while */ - HDassert(entries_visited == cache_ptr->index_len); - HDassert(num_entries_in_image <= num_entries_tentatively_in_image); + assert(entries_visited == cache_ptr->index_len); + assert(num_entries_in_image <= num_entries_tentatively_in_image); #ifndef NDEBUG { @@ -2963,7 +2962,7 @@ H5C__prep_for_file_close__scan_entries(const H5F_t *f, H5C_t *cache_ptr) j += cache_ptr->index_ring_len[i]; /* This will change */ - HDassert(entries_visited == (num_entries_tentatively_in_image + j)); + assert(entries_visited == (num_entries_tentatively_in_image + j)); } #endif @@ -2982,8 +2981,8 @@ H5C__prep_for_file_close__scan_entries(const H5F_t *f, H5C_t *cache_ptr) */ 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); + assert(entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC); + assert(entry_ptr->type != NULL); /* to avoid confusion, don't set lru_rank on epoch markers. * Note that we still increment the lru_rank, so that the holes @@ -3004,7 +3003,7 @@ H5C__prep_for_file_close__scan_entries(const H5F_t *f, H5C_t *cache_ptr) entries_visited++; entry_ptr = entry_ptr->next; } /* end while */ - HDassert(entries_visited == cache_ptr->LRU_list_len); + assert(entries_visited == cache_ptr->LRU_list_len); image_len += H5F_SIZEOF_CHKSUM; cache_ptr->image_data_len = image_len; @@ -3041,24 +3040,24 @@ H5C__reconstruct_cache_contents(H5F_t *f, H5C_t *cache_ptr) FUNC_ENTER_PACKAGE /* Sanity checks */ - HDassert(f); - HDassert(f->shared); - HDassert(cache_ptr == f->shared->cache); - HDassert(cache_ptr); - HDassert(cache_ptr->magic == H5C__H5C_T_MAGIC); - HDassert(cache_ptr->image_buffer); - HDassert(cache_ptr->image_len > 0); + assert(f); + assert(f->shared); + assert(cache_ptr == f->shared->cache); + assert(cache_ptr); + assert(cache_ptr->magic == H5C__H5C_T_MAGIC); + assert(cache_ptr->image_buffer); + assert(cache_ptr->image_len > 0); /* Decode metadata cache image header */ p = (uint8_t *)cache_ptr->image_buffer; if (H5C__decode_cache_image_header(f, cache_ptr, &p) < 0) HGOTO_ERROR(H5E_CACHE, H5E_CANTDECODE, FAIL, "cache image header decode failed") - HDassert((size_t)(p - (uint8_t *)cache_ptr->image_buffer) < cache_ptr->image_len); + assert((size_t)(p - (uint8_t *)cache_ptr->image_buffer) < cache_ptr->image_len); /* The image_data_len and # of entries should be defined now */ - HDassert(cache_ptr->image_data_len > 0); - HDassert(cache_ptr->image_data_len <= cache_ptr->image_len); - HDassert(cache_ptr->num_entries_in_image > 0); + assert(cache_ptr->image_data_len > 0); + assert(cache_ptr->image_data_len <= cache_ptr->image_len); + assert(cache_ptr->num_entries_in_image > 0); /* Reconstruct entries in image */ for (u = 0; u < cache_ptr->num_entries_in_image; u++) { @@ -3093,8 +3092,8 @@ H5C__reconstruct_cache_contents(H5F_t *f, H5C_t *cache_ptr) */ for (v = 0; v < pf_entry_ptr->fd_parent_count; v++) { /* Sanity checks */ - HDassert(pf_entry_ptr->fd_parent_addrs); - HDassert(H5F_addr_defined(pf_entry_ptr->fd_parent_addrs[v])); + assert(pf_entry_ptr->fd_parent_addrs); + assert(H5F_addr_defined(pf_entry_ptr->fd_parent_addrs[v])); /* Find the parent entry */ parent_ptr = NULL; @@ -3103,9 +3102,9 @@ H5C__reconstruct_cache_contents(H5F_t *f, H5C_t *cache_ptr) HGOTO_ERROR(H5E_CACHE, H5E_NOTFOUND, FAIL, "fd parent not in cache?!?") /* Sanity checks */ - HDassert(parent_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC); - HDassert(parent_ptr->addr == pf_entry_ptr->fd_parent_addrs[v]); - HDassert(parent_ptr->lru_rank == -1); + assert(parent_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC); + assert(parent_ptr->addr == pf_entry_ptr->fd_parent_addrs[v]); + assert(parent_ptr->lru_rank == -1); /* Must protect parent entry to set up a flush dependency. * Do this now, and then uprotect when done. @@ -3129,24 +3128,24 @@ H5C__reconstruct_cache_contents(H5F_t *f, H5C_t *cache_ptr) */ pf_entry_ptr = cache_ptr->il_head; while (pf_entry_ptr != NULL) { - HDassert(pf_entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC); - HDassert((pf_entry_ptr->prefetched && pf_entry_ptr->type == H5AC_PREFETCHED_ENTRY) || - (!pf_entry_ptr->prefetched && pf_entry_ptr->type != H5AC_PREFETCHED_ENTRY)); + assert(pf_entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC); + assert((pf_entry_ptr->prefetched && pf_entry_ptr->type == H5AC_PREFETCHED_ENTRY) || + (!pf_entry_ptr->prefetched && pf_entry_ptr->type != H5AC_PREFETCHED_ENTRY)); if (pf_entry_ptr->type == H5AC_PREFETCHED_ENTRY) - HDassert(pf_entry_ptr->fd_parent_count == pf_entry_ptr->flush_dep_nparents); + assert(pf_entry_ptr->fd_parent_count == pf_entry_ptr->flush_dep_nparents); for (v = 0; v < pf_entry_ptr->fd_parent_count; v++) { parent_ptr = pf_entry_ptr->flush_dep_parent[v]; - HDassert(parent_ptr); - HDassert(parent_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC); - HDassert(pf_entry_ptr->fd_parent_addrs); - HDassert(pf_entry_ptr->fd_parent_addrs[v] == parent_ptr->addr); - HDassert(parent_ptr->flush_dep_nchildren > 0); + assert(parent_ptr); + assert(parent_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC); + assert(pf_entry_ptr->fd_parent_addrs); + assert(pf_entry_ptr->fd_parent_addrs[v] == parent_ptr->addr); + assert(parent_ptr->flush_dep_nchildren > 0); } /* end for */ if (pf_entry_ptr->type == H5AC_PREFETCHED_ENTRY) { - HDassert(pf_entry_ptr->fd_child_count == pf_entry_ptr->flush_dep_nchildren); - HDassert(pf_entry_ptr->fd_dirty_child_count == pf_entry_ptr->flush_dep_ndirty_children); + assert(pf_entry_ptr->fd_child_count == pf_entry_ptr->flush_dep_nchildren); + assert(pf_entry_ptr->fd_dirty_child_count == pf_entry_ptr->flush_dep_ndirty_children); } /* end if */ pf_entry_ptr = pf_entry_ptr->il_next; @@ -3163,12 +3162,12 @@ 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); + assert(entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC); + assert(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)); + assert(entry_ptr->lru_rank != 0); + assert((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); @@ -3184,7 +3183,7 @@ H5C__reconstruct_cache_contents(H5F_t *f, H5C_t *cache_ptr) * the following sanity check will have to be revised when * we add code to store and restore adaptive resize status. */ - HDassert(lru_rank_holes <= H5C__MAX_EPOCH_MARKERS); + assert(lru_rank_holes <= H5C__MAX_EPOCH_MARKERS); } /* end block */ #endif /* NDEBUG */ @@ -3245,10 +3244,10 @@ H5C__reconstruct_cache_entry(const H5F_t *f, H5C_t *cache_ptr, const uint8_t **b FUNC_ENTER_PACKAGE /* Sanity checks */ - HDassert(cache_ptr); - HDassert(cache_ptr->magic == H5C__H5C_T_MAGIC); - HDassert(cache_ptr->num_entries_in_image > 0); - HDassert(buf && *buf); + assert(cache_ptr); + assert(cache_ptr->magic == H5C__H5C_T_MAGIC); + assert(cache_ptr->num_entries_in_image > 0); + assert(buf && *buf); /* Key R/W access off of whether the image will be deleted */ file_is_rw = cache_ptr->delete_image; @@ -3292,16 +3291,16 @@ H5C__reconstruct_cache_entry(const H5F_t *f, H5C_t *cache_ptr, const uint8_t **b /* Decode ring */ pf_entry_ptr->ring = *p++; - HDassert(pf_entry_ptr->ring > (uint8_t)(H5C_RING_UNDEFINED)); - HDassert(pf_entry_ptr->ring < (uint8_t)(H5C_RING_NTYPES)); + assert(pf_entry_ptr->ring > (uint8_t)(H5C_RING_UNDEFINED)); + assert(pf_entry_ptr->ring < (uint8_t)(H5C_RING_NTYPES)); /* Decode age */ pf_entry_ptr->age = *p++; /* Decode dependency child count */ UINT16DECODE(p, pf_entry_ptr->fd_child_count); - HDassert((is_fd_parent && pf_entry_ptr->fd_child_count > 0) || - (!is_fd_parent && pf_entry_ptr->fd_child_count == 0)); + assert((is_fd_parent && pf_entry_ptr->fd_child_count > 0) || + (!is_fd_parent && pf_entry_ptr->fd_child_count == 0)); /* Decode dirty dependency child count */ UINT16DECODE(p, pf_entry_ptr->fd_dirty_child_count); @@ -3312,12 +3311,12 @@ H5C__reconstruct_cache_entry(const H5F_t *f, H5C_t *cache_ptr, const uint8_t **b /* Decode dependency parent count */ UINT16DECODE(p, pf_entry_ptr->fd_parent_count); - HDassert((is_fd_child && pf_entry_ptr->fd_parent_count > 0) || - (!is_fd_child && pf_entry_ptr->fd_parent_count == 0)); + assert((is_fd_child && pf_entry_ptr->fd_parent_count > 0) || + (!is_fd_child && pf_entry_ptr->fd_parent_count == 0)); /* Decode index in LRU */ INT32DECODE(p, pf_entry_ptr->lru_rank); - HDassert((in_lru && pf_entry_ptr->lru_rank >= 0) || (!in_lru && pf_entry_ptr->lru_rank == -1)); + assert((in_lru && pf_entry_ptr->lru_rank >= 0) || (!in_lru && pf_entry_ptr->lru_rank == -1)); /* Decode entry offset */ H5F_addr_decode(f, &p, &pf_entry_ptr->addr); @@ -3371,7 +3370,7 @@ H5C__reconstruct_cache_entry(const H5F_t *f, H5C_t *cache_ptr, const uint8_t **b pf_entry_ptr->prefetched_dirty = is_dirty && (!file_is_rw); /* Sanity checks */ - HDassert(pf_entry_ptr->size > 0 && pf_entry_ptr->size < H5C_MAX_ENTRY_SIZE); + assert(pf_entry_ptr->size > 0 && pf_entry_ptr->size < H5C_MAX_ENTRY_SIZE); /* Update buffer pointer */ *buf = p; @@ -3415,13 +3414,13 @@ H5C__write_cache_image_superblock_msg(H5F_t *f, hbool_t create) FUNC_ENTER_PACKAGE /* Sanity checks */ - HDassert(f); - HDassert(f->shared); - HDassert(f->shared->cache); + assert(f); + assert(f->shared); + assert(f->shared->cache); cache_ptr = f->shared->cache; - HDassert(cache_ptr); - HDassert(cache_ptr->magic == H5C__H5C_T_MAGIC); - HDassert(cache_ptr->close_warning_received); + assert(cache_ptr); + assert(cache_ptr->magic == H5C__H5C_T_MAGIC); + assert(cache_ptr->close_warning_received); /* Write data into the metadata cache image superblock extension message. * Note that this data will be bogus when we first create the message. @@ -3433,7 +3432,7 @@ H5C__write_cache_image_superblock_msg(H5F_t *f, hbool_t create) H5AC_aux_t *aux_ptr; aux_ptr = (H5AC_aux_t *)cache_ptr->aux_ptr; - HDassert(aux_ptr->magic == H5AC__H5AC_AUX_T_MAGIC); + assert(aux_ptr->magic == H5AC__H5AC_AUX_T_MAGIC); mdci_msg.size = aux_ptr->p0_image_len; } /* end if */ else @@ -3470,18 +3469,18 @@ H5C__write_cache_image(H5F_t *f, const H5C_t *cache_ptr) FUNC_ENTER_PACKAGE /* Sanity checks */ - HDassert(f); - HDassert(cache_ptr); - HDassert(H5F_addr_defined(cache_ptr->image_addr)); - HDassert(cache_ptr->image_len > 0); - HDassert(cache_ptr->image_buffer); + assert(f); + assert(cache_ptr); + assert(H5F_addr_defined(cache_ptr->image_addr)); + assert(cache_ptr->image_len > 0); + assert(cache_ptr->image_buffer); #ifdef H5_HAVE_PARALLEL { H5AC_aux_t *aux_ptr = (H5AC_aux_t *)cache_ptr->aux_ptr; if ((NULL == aux_ptr) || (aux_ptr->mpi_rank == 0)) { - HDassert((NULL == aux_ptr) || (aux_ptr->magic == H5AC__H5AC_AUX_T_MAGIC)); + assert((NULL == aux_ptr) || (aux_ptr->magic == H5AC__H5AC_AUX_T_MAGIC)); #endif /* H5_HAVE_PARALLEL */ /* Write the buffer (if serial access, or rank 0 for parallel access) */ |