From 20a6b825972ef359c33fcd2e79177b812696f14c Mon Sep 17 00:00:00 2001 From: David Young Date: Mon, 3 Aug 2020 11:11:23 -0500 Subject: In VFD SWMR, use `H5F_shared_t` instead of `H5F_t` wherever that is possible. --- src/H5FDvfd_swmr_private.h | 2 +- src/H5Fvfd_swmr.c | 361 +++++++++++++++++++++++---------------------- src/H5MV.c | 82 +++++----- src/H5MVpkg.h | 2 +- src/H5MVsection.c | 11 +- 5 files changed, 233 insertions(+), 225 deletions(-) diff --git a/src/H5FDvfd_swmr_private.h b/src/H5FDvfd_swmr_private.h index df57f24..67a72ec 100644 --- a/src/H5FDvfd_swmr_private.h +++ b/src/H5FDvfd_swmr_private.h @@ -82,7 +82,7 @@ H5_DLL herr_t H5F_vfd_swmr_writer__delay_write(struct H5F_shared_t *, uint64_t, H5_DLL herr_t H5F_vfd_swmr_writer__prep_for_flush_or_close(struct H5F_t *f); herr_t H5F_vfd_swmr_process_eot_queue(bool); H5_DLL herr_t H5F_vfd_swmr_writer_end_of_tick(struct H5F_t *f, bool); -H5_DLL herr_t H5F_vfd_swmr_writer__dump_index(struct H5F_t * f); +H5_DLL herr_t H5F_vfd_swmr_writer__dump_index(struct H5F_shared_t *); H5_DLL herr_t H5F_vfd_swmr_reader_end_of_tick(struct H5F_t *f, bool); H5_DLL herr_t H5F_vfd_swmr_remove_entry_eot(struct H5F_t *f); diff --git a/src/H5Fvfd_swmr.c b/src/H5Fvfd_swmr.c index f0b5f8b..376fa38 100644 --- a/src/H5Fvfd_swmr.c +++ b/src/H5Fvfd_swmr.c @@ -61,12 +61,14 @@ /* Local Prototypes */ /********************/ -static herr_t H5F__vfd_swmr_update_end_of_tick_and_tick_num(H5F_t *f, hbool_t incr_tick_num); -static herr_t H5F__vfd_swmr_construct_write_md_hdr(H5F_t *f, uint32_t num_entries); -static herr_t H5F__vfd_swmr_construct_write_md_idx(H5F_t *f, uint32_t num_entries, struct H5FD_vfd_swmr_idx_entry_t index[]); +static herr_t H5F__vfd_swmr_update_end_of_tick_and_tick_num(H5F_shared_t *, + hbool_t); +static herr_t H5F__vfd_swmr_construct_write_md_hdr(H5F_shared_t *, uint32_t); +static herr_t H5F__vfd_swmr_construct_write_md_idx(H5F_shared_t *, uint32_t, + struct H5FD_vfd_swmr_idx_entry_t[]); static herr_t H5F__idx_entry_cmp(const void *_entry1, const void *_entry2); static herr_t H5F__vfd_swmr_create_index(H5F_shared_t *); -static herr_t H5F__vfd_swmr_writer__wait_a_tick(H5F_t *f); +static herr_t H5F__vfd_swmr_writer__wait_a_tick(H5F_t *); /*********************/ /* Package Variables */ @@ -150,115 +152,116 @@ H5F_vfd_swmr_init(H5F_t *f, hbool_t file_create) hsize_t md_size; /* Size of the metadata file */ haddr_t hdr_addr, idx_addr; /* Addresses returned from H5MV_alloc() */ herr_t ret_value = SUCCEED; /* Return value */ + H5F_shared_t *shared = f->shared; FUNC_ENTER_NOAPI(FAIL) - HDassert(H5F_VFD_SWMR_CONFIG(f)); + HDassert(H5F_SHARED_VFD_SWMR_CONFIG(shared)); - f->shared->vfd_swmr = TRUE; + shared->vfd_swmr = TRUE; - if(H5F_INTENT(f) & H5F_ACC_RDWR) { + if(H5F_SHARED_INTENT(shared) & H5F_ACC_RDWR) { - HDassert(f->shared->vfd_swmr_config.writer); + HDassert(shared->vfd_swmr_config.writer); - SIMPLEQ_INIT(&f->shared->lower_defrees); - f->shared->vfd_swmr_writer = TRUE; - f->shared->tick_num = 1; + SIMPLEQ_INIT(&shared->lower_defrees); + shared->vfd_swmr_writer = TRUE; + shared->tick_num = 1; - if ( H5PB_vfd_swmr__set_tick(f->shared) < 0 ) + if ( H5PB_vfd_swmr__set_tick(shared) < 0 ) HGOTO_ERROR(H5E_FILE, H5E_SYSTEM, FAIL, \ "Can't update page buffer current tick") /* Create the metadata file */ - if ( ((f->shared->vfd_swmr_md_fd = - HDopen(f->shared->vfd_swmr_config.md_file_path, O_CREAT|O_RDWR, + if ( ((shared->vfd_swmr_md_fd = + HDopen(shared->vfd_swmr_config.md_file_path, O_CREAT|O_RDWR, H5_POSIX_CREATE_MODE_RW))) < 0 ) HGOTO_ERROR(H5E_FILE, H5E_CANTOPENFILE, FAIL, \ "unable to create the metadata file") - md_size = (hsize_t)f->shared->vfd_swmr_config.md_pages_reserved * - f->shared->fs_page_size; + md_size = (hsize_t)shared->vfd_swmr_config.md_pages_reserved * + shared->fs_page_size; - assert(f->shared->fs_page_size >= H5FD_MD_HEADER_SIZE); + assert(shared->fs_page_size >= H5FD_MD_HEADER_SIZE); /* Allocate an entire page from the shadow file for the header. */ - if ((hdr_addr = H5MV_alloc(f, f->shared->fs_page_size)) == HADDR_UNDEF){ + if ((hdr_addr = H5MV_alloc(f, shared->fs_page_size)) == HADDR_UNDEF){ HGOTO_ERROR(H5E_FILE, H5E_WRITEERROR, FAIL, "error allocating shadow-file header"); } HDassert(H5F_addr_eq(hdr_addr, H5FD_MD_HEADER_OFF)); - idx_addr = H5MV_alloc(f, md_size - f->shared->fs_page_size); + idx_addr = H5MV_alloc(f, md_size - shared->fs_page_size); if (idx_addr == HADDR_UNDEF) { HGOTO_ERROR(H5E_FILE, H5E_WRITEERROR, FAIL, "error allocating shadow-file index"); } - HDassert(H5F_addr_eq(idx_addr, f->shared->fs_page_size)); + HDassert(H5F_addr_eq(idx_addr, shared->fs_page_size)); - f->shared->writer_index_offset = idx_addr; + shared->writer_index_offset = idx_addr; /* Set the metadata file size to md_pages_reserved */ - if ( -1 == HDftruncate(f->shared->vfd_swmr_md_fd, (HDoff_t)md_size) ) + if ( -1 == HDftruncate(shared->vfd_swmr_md_fd, (HDoff_t)md_size) ) HGOTO_ERROR(H5E_FILE, H5E_WRITEERROR, FAIL, "truncate fail for the metadata file"); /* Set eof for metadata file to md_pages_reserved */ - f->shared->vfd_swmr_md_eoa = (haddr_t)md_size; + shared->vfd_swmr_md_eoa = (haddr_t)md_size; /* When opening an existing HDF5 file, create header and empty * index in the metadata file */ if (!file_create) { - if ( H5F__vfd_swmr_construct_write_md_idx(f, 0, NULL) < 0 ) + if (H5F__vfd_swmr_construct_write_md_idx(shared, 0, NULL) < 0) HGOTO_ERROR(H5E_FILE, H5E_CANTSET, FAIL, "fail to create index in md"); - if ( H5F__vfd_swmr_construct_write_md_hdr(f, 0) < 0 ) + if (H5F__vfd_swmr_construct_write_md_hdr(shared, 0) < 0) HGOTO_ERROR(H5E_FILE, H5E_CANTSET, FAIL, "fail to create header in md"); } } else { /* VFD SWMR reader */ - HDassert(!f->shared->vfd_swmr_config.writer); + HDassert(!shared->vfd_swmr_config.writer); - f->shared->vfd_swmr_writer = FALSE; + shared->vfd_swmr_writer = FALSE; - HDassert(f->shared->mdf_idx == NULL); + HDassert(shared->mdf_idx == NULL); /* allocate an index to save the initial index */ - if (H5F__vfd_swmr_create_index(f->shared) < 0) + if (H5F__vfd_swmr_create_index(shared) < 0) HGOTO_ERROR(H5E_FILE, H5E_CANTALLOC, FAIL, "unable to allocate metadata file index"); /* Set tick_num to the current tick read from the metadata file */ - f->shared->mdf_idx_entries_used = f->shared->mdf_idx_len; - if (H5FD_vfd_swmr_get_tick_and_idx(f->shared->lf, FALSE, - &f->shared->tick_num, - &(f->shared->mdf_idx_entries_used), - f->shared->mdf_idx) < 0) + shared->mdf_idx_entries_used = shared->mdf_idx_len; + if (H5FD_vfd_swmr_get_tick_and_idx(shared->lf, FALSE, + &shared->tick_num, + &(shared->mdf_idx_entries_used), + shared->mdf_idx) < 0) HGOTO_ERROR(H5E_FILE, H5E_CANTLOAD, FAIL, "unable to load/decode metadata file"); - assert(f->shared->tick_num != 0); - vfd_swmr_reader_did_increase_tick_to(f->shared->tick_num); + assert(shared->tick_num != 0); + vfd_swmr_reader_did_increase_tick_to(shared->tick_num); hlog_fast(tick, "%s first tick %" PRIu64, - __func__, f->shared->tick_num); + __func__, shared->tick_num); #if 0 /* JRM */ HDfprintf(stderr, "##### initialized index: tick/used/len = %lld/%d/%d #####\n", - f->shared->tick_num, f->shared->mdf_idx_entries_used, - f->shared->mdf_idx_len); + shared->tick_num, shared->mdf_idx_entries_used, + shared->mdf_idx_len); #endif /* JRM */ } /* Update end_of_tick */ - if (H5F__vfd_swmr_update_end_of_tick_and_tick_num(f, FALSE) < 0) { + if (H5F__vfd_swmr_update_end_of_tick_and_tick_num(shared, FALSE) < 0) { HGOTO_ERROR(H5E_FILE, H5E_CANTSET, FAIL, "unable to update end of tick"); } @@ -302,34 +305,35 @@ done: herr_t H5F_vfd_swmr_close_or_flush(H5F_t *f, hbool_t closing) { + H5F_shared_t *shared = f->shared; shadow_defree_t *curr; herr_t ret_value = SUCCEED; FUNC_ENTER_NOAPI(FAIL) - HDassert(f->shared->vfd_swmr_writer); - HDassert(f->shared->vfd_swmr_md_fd >= 0); + HDassert(shared->vfd_swmr_writer); + HDassert(shared->vfd_swmr_md_fd >= 0); /* Write empty index to the md file */ - if (H5F__vfd_swmr_construct_write_md_idx(f, 0, NULL) < 0) + if (H5F__vfd_swmr_construct_write_md_idx(shared, 0, NULL) < 0) HGOTO_ERROR(H5E_FILE, H5E_CANTSET, FAIL, "fail to create index in md"); /* Write header to the md file */ - if ( H5F__vfd_swmr_construct_write_md_hdr(f, 0) < 0 ) + if (H5F__vfd_swmr_construct_write_md_hdr(shared, 0) < 0) HGOTO_ERROR(H5E_FILE, H5E_CANTSET, FAIL, "fail to create header in md"); if ( closing ) { /* For file close */ - ++f->shared->tick_num; + ++shared->tick_num; /* Close the md file */ - if(HDclose(f->shared->vfd_swmr_md_fd) < 0) + if(HDclose(shared->vfd_swmr_md_fd) < 0) HGOTO_ERROR(H5E_FILE, H5E_CANTCLOSEFILE, FAIL, "unable to close the metadata file"); - f->shared->vfd_swmr_md_fd = -1; + shared->vfd_swmr_md_fd = -1; /* Unlink the md file */ - if ( HDunlink(f->shared->vfd_swmr_config.md_file_path) < 0 ) + if ( HDunlink(shared->vfd_swmr_config.md_file_path) < 0 ) HGOTO_ERROR(H5E_FILE, H5E_CANTREMOVE, FAIL, "unable to unlink the metadata file"); @@ -339,16 +343,16 @@ H5F_vfd_swmr_close_or_flush(H5F_t *f, hbool_t closing) "unable to close the free-space manager for the metadata file"); /* Free the delayed list */ - while ((curr = TAILQ_FIRST(&f->shared->shadow_defrees)) != NULL) { - TAILQ_REMOVE(&f->shared->shadow_defrees, curr, link); + while ((curr = TAILQ_FIRST(&shared->shadow_defrees)) != NULL) { + TAILQ_REMOVE(&shared->shadow_defrees, curr, link); H5FL_FREE(shadow_defree_t, curr); } hlog_fast(shadow_defrees, "Emptied deferred shadow frees."); - assert(TAILQ_EMPTY(&f->shared->shadow_defrees)); + assert(TAILQ_EMPTY(&shared->shadow_defrees)); } else { /* For file flush */ /* Update end_of_tick */ - if (H5F__vfd_swmr_update_end_of_tick_and_tick_num(f, TRUE) < 0) + if (H5F__vfd_swmr_update_end_of_tick_and_tick_num(shared, TRUE) < 0) HDONE_ERROR(H5E_FILE, H5E_CANTSET, FAIL, "unable to update end of tick"); } @@ -422,6 +426,7 @@ herr_t H5F_update_vfd_swmr_metadata_file(H5F_t *f, uint32_t num_entries, H5FD_vfd_swmr_idx_entry_t *index) { + H5F_shared_t *shared = f->shared; shadow_defree_t *prev; shadow_defree_t *shadow_defree; haddr_t md_addr; /* Address in the metadata file */ @@ -458,7 +463,7 @@ H5F_update_vfd_swmr_metadata_file(H5F_t *f, uint32_t num_entries, /* Prepend previous image of the entry to the delayed list */ if ( index[i].md_file_page_offset ) { - if (shadow_image_defer_free(f->shared, &index[i]) == -1) { + if (shadow_image_defer_free(shared, &index[i]) == -1) { HGOTO_ERROR(H5E_FILE, H5E_CANTALLOC, FAIL, \ "unable to allocate the delayed entry") } @@ -471,12 +476,12 @@ H5F_update_vfd_swmr_metadata_file(H5F_t *f, uint32_t num_entries, hlog_fast(noisy_shadow_defrees, "shadow index %" PRIu32 " page offset %" PRIu64 " -> %" PRIuHADDR, - i, index[i].md_file_page_offset * f->shared->fs_page_size, md_addr); + i, index[i].md_file_page_offset * shared->fs_page_size, md_addr); - HDassert(md_addr % f->shared->fs_page_size == 0); + HDassert(md_addr % shared->fs_page_size == 0); /* Compute checksum and update the index entry */ - index[i].md_file_page_offset = md_addr / f->shared->fs_page_size; + index[i].md_file_page_offset = md_addr / shared->fs_page_size; index[i].chksum = H5_checksum_metadata(index[i].entry_ptr, index[i].length, 0); @@ -492,18 +497,18 @@ H5F_update_vfd_swmr_metadata_file(H5F_t *f, uint32_t num_entries, (((char*)(index[i].entry_ptr))[4095])); HDassert(md_addr == index[i].md_file_page_offset * - f->shared->fs_page_size); - HDassert(f->shared->fs_page_size == 4096); + shared->fs_page_size); + HDassert(shared->fs_page_size == 4096); #endif /* JRM */ /* Seek and write the entry to the metadata file */ - if ( HDlseek(f->shared->vfd_swmr_md_fd, (HDoff_t)md_addr, + if ( HDlseek(shared->vfd_swmr_md_fd, (HDoff_t)md_addr, SEEK_SET) < 0) HGOTO_ERROR(H5E_FILE, H5E_SEEKERROR, FAIL, \ "unable to seek in the metadata file") - if ( HDwrite(f->shared->vfd_swmr_md_fd, index[i].entry_ptr, + if ( HDwrite(shared->vfd_swmr_md_fd, index[i].entry_ptr, index[i].length) != (ssize_t)index[i].length ) HGOTO_ERROR(H5E_FILE, H5E_WRITEERROR, FAIL, \ @@ -513,18 +518,18 @@ H5F_update_vfd_swmr_metadata_file(H5F_t *f, uint32_t num_entries, } /* Construct and write index to the metadata file */ - if ( H5F__vfd_swmr_construct_write_md_idx(f, num_entries, index) < 0 ) + if (H5F__vfd_swmr_construct_write_md_idx(shared, num_entries, index) < 0) HGOTO_ERROR(H5E_FILE, H5E_CANTSET, FAIL, \ "fail to construct & write index to md") /* Construct and write header to the md file */ - if ( H5F__vfd_swmr_construct_write_md_hdr(f, num_entries) < 0 ) + if (H5F__vfd_swmr_construct_write_md_hdr(shared, num_entries) < 0) HGOTO_ERROR(H5E_FILE, H5E_CANTSET, FAIL, \ "fail to construct & write header to md") - queue_was_nonempty = !TAILQ_EMPTY(&f->shared->shadow_defrees); + queue_was_nonempty = !TAILQ_EMPTY(&shared->shadow_defrees); /* * Release time out entries from the delayed list by scanning the @@ -537,14 +542,14 @@ H5F_update_vfd_swmr_metadata_file(H5F_t *f, uint32_t num_entries, * --remove the associated entries from the list */ - if (f->shared->tick_num <= f->shared->vfd_swmr_config.max_lag) + if (shared->tick_num <= shared->vfd_swmr_config.max_lag) goto done; // It is too early for any reclamations to be due. - TAILQ_FOREACH_REVERSE_SAFE(shadow_defree, &f->shared->shadow_defrees, + TAILQ_FOREACH_REVERSE_SAFE(shadow_defree, &shared->shadow_defrees, shadow_defree_queue, link, prev) { - if (shadow_defree->tick_num + f->shared->vfd_swmr_config.max_lag > - f->shared->tick_num) { + if (shadow_defree->tick_num + shared->vfd_swmr_config.max_lag > + shared->tick_num) { break; // No more entries are due for reclamation. } @@ -557,12 +562,12 @@ H5F_update_vfd_swmr_metadata_file(H5F_t *f, uint32_t num_entries, "released %" PRIu32 " bytes at %" PRIu64, shadow_defree->length, shadow_defree->offset); - TAILQ_REMOVE(&f->shared->shadow_defrees, shadow_defree, link); + TAILQ_REMOVE(&shared->shadow_defrees, shadow_defree, link); H5FL_FREE(shadow_defree_t, shadow_defree); } - if (queue_was_nonempty && TAILQ_EMPTY(&f->shared->shadow_defrees)) + if (queue_was_nonempty && TAILQ_EMPTY(&shared->shadow_defrees)) hlog_fast(shadow_defrees, "Removed last deferred shadow free."); done: @@ -693,14 +698,13 @@ herr_t H5F_vfd_swmr_writer__prep_for_flush_or_close(H5F_t *f) { herr_t ret_value = SUCCEED; /* Return value */ + H5F_shared_t *shared = f->shared; FUNC_ENTER_NOAPI(FAIL) - HDassert(f); - HDassert(f->shared); - HDassert(f->shared->vfd_swmr); - HDassert(f->shared->vfd_swmr_writer); - HDassert(f->shared->pb_ptr); + HDassert(shared->vfd_swmr); + HDassert(shared->vfd_swmr_writer); + HDassert(shared->pb_ptr); /* since we are about to flush the page buffer, force and end of * tick so as to avoid attempts to flush entries on the page buffer @@ -711,7 +715,7 @@ H5F_vfd_swmr_writer__prep_for_flush_or_close(H5F_t *f) HGOTO_ERROR(H5E_FILE, H5E_SYSTEM, FAIL, \ "H5F_vfd_swmr_writer_end_of_tick() failed.") - while(f->shared->pb_ptr->dwl_len > 0) { + while(shared->pb_ptr->dwl_len > 0) { if(H5F__vfd_swmr_writer__wait_a_tick(f) < 0) @@ -830,6 +834,7 @@ clean_shadow_index(H5F_t *f, uint32_t nentries, herr_t H5F_vfd_swmr_writer_end_of_tick(H5F_t *f, bool wait_for_reader) { + H5F_shared_t *shared = f->shared; uint32_t idx_entries_added = 0; uint32_t idx_entries_modified = 0; uint32_t idx_entries_removed = 0; @@ -840,12 +845,11 @@ H5F_vfd_swmr_writer_end_of_tick(H5F_t *f, bool wait_for_reader) FUNC_ENTER_NOAPI(FAIL) - HDassert(f); - HDassert(f->shared); - HDassert(f->shared->pb_ptr); - HDassert(f->shared->vfd_swmr_writer); + HDassert(shared); + HDassert(shared->pb_ptr); + HDassert(shared->vfd_swmr_writer); - if (!vfd_swmr_writer_may_increase_tick_to(f->shared->tick_num + 1, + if (!vfd_swmr_writer_may_increase_tick_to(shared->tick_num + 1, wait_for_reader)) goto update_eot; @@ -855,7 +859,7 @@ H5F_vfd_swmr_writer_end_of_tick(H5F_t *f, bool wait_for_reader) * * (Not for first cut.) */ - HDassert(!f->shared->vfd_swmr_config.flush_raw_data); + HDassert(!shared->vfd_swmr_config.flush_raw_data); #if 1 /* Test to see if b-tree corruption seen in VFD SWMR tests @@ -876,7 +880,7 @@ H5F_vfd_swmr_writer_end_of_tick(H5F_t *f, bool wait_for_reader) HGOTO_ERROR(H5E_FILE, H5E_CANTRELEASE, FAIL, "can't release file space") - if ( f->shared->cache ) { + if ( shared->cache ) { if ( H5AC_flush(f) < 0 ) @@ -886,13 +890,13 @@ H5F_vfd_swmr_writer_end_of_tick(H5F_t *f, bool wait_for_reader) - if ( H5FD_truncate(f->shared->lf, FALSE) < 0 ) + if ( H5FD_truncate(shared->lf, FALSE) < 0 ) HGOTO_ERROR(H5E_FILE, H5E_WRITEERROR, FAIL, "low level truncate failed") #endif /* 2) If it exists, flush the metadata cache to the page buffer. */ - if ( f->shared->cache ) { + if ( shared->cache ) { if ( H5AC_flush(f) < 0 ) @@ -904,8 +908,8 @@ H5F_vfd_swmr_writer_end_of_tick(H5F_t *f, bool wait_for_reader) /* 3) If this is the first tick (i.e. tick == 1), create the * in memory version of the metadata file index. */ - if ( ( f->shared->tick_num == 1 ) && - ( H5F__vfd_swmr_create_index(f->shared) < 0 ) ) + if ( ( shared->tick_num == 1 ) && + ( H5F__vfd_swmr_create_index(shared) < 0 ) ) HGOTO_ERROR(H5E_FILE, H5E_CANTALLOC, FAIL, \ "unable to allocate metadata file index") @@ -929,8 +933,8 @@ H5F_vfd_swmr_writer_end_of_tick(H5F_t *f, bool wait_for_reader) * been modified since. */ if (clean_shadow_index(f, - f->shared->mdf_idx_entries_used + idx_entries_added, - f->shared->mdf_idx, &idx_entries_removed) < 0) + shared->mdf_idx_entries_used + idx_entries_added, + shared->mdf_idx, &idx_entries_removed) < 0) HGOTO_ERROR(H5E_FILE, H5E_SYSTEM, FAIL, "can't clean shadow file index") /* 6) Update the metadata file. Must do this before we @@ -941,31 +945,31 @@ H5F_vfd_swmr_writer_end_of_tick(H5F_t *f, bool wait_for_reader) * sorted order. */ if (H5F_update_vfd_swmr_metadata_file(f, - f->shared->mdf_idx_entries_used + idx_entries_added - + shared->mdf_idx_entries_used + idx_entries_added - idx_entries_removed, - f->shared->mdf_idx) < 0) + shared->mdf_idx) < 0) HGOTO_ERROR(H5E_FILE, H5E_SYSTEM, FAIL, "can't update MD file") /* at this point the metadata file index should be sorted -- update - * f->shared->mdf_idx_entries_used. + * shared->mdf_idx_entries_used. */ - f->shared->mdf_idx_entries_used += idx_entries_added; - f->shared->mdf_idx_entries_used -= idx_entries_removed; + shared->mdf_idx_entries_used += idx_entries_added; + shared->mdf_idx_entries_used -= idx_entries_removed; - HDassert(f->shared->mdf_idx_entries_used <= f->shared->mdf_idx_len); + HDassert(shared->mdf_idx_entries_used <= shared->mdf_idx_len); #if 0 /* JRM */ H5F__vfd_swmr_writer__dump_index(f); #endif /* JRM */ /* 7) Release the page buffer tick list. */ - if ( H5PB_vfd_swmr__release_tick_list(f->shared) < 0 ) + if ( H5PB_vfd_swmr__release_tick_list(shared) < 0 ) HGOTO_ERROR(H5E_FILE, H5E_SYSTEM, FAIL, "can't release tick list") /* 8) Release any delayed writes whose delay has expired */ - if ( H5PB_vfd_swmr__release_delayed_writes(f->shared) < 0 ) + if ( H5PB_vfd_swmr__release_delayed_writes(shared) < 0 ) HGOTO_ERROR(H5E_FILE, H5E_SYSTEM, FAIL, "can't release delayed writes") @@ -975,7 +979,7 @@ update_eot: /* 9) Increment the tick, and update the end of tick. */ /* Update end_of_tick */ - if ( H5F__vfd_swmr_update_end_of_tick_and_tick_num(f, incr_tick) < 0 ) + if (H5F__vfd_swmr_update_end_of_tick_and_tick_num(shared, incr_tick) < 0) HGOTO_ERROR(H5E_FILE, H5E_CANTSET, FAIL, \ "unable to update end of tick") @@ -989,7 +993,7 @@ update_eot: HGOTO_ERROR(H5E_FILE, H5E_CANTSET, FAIL, "unable to insert entry into the EOT queue") hlog_fast(eot, "%s leave tick %" PRIu64 " idx len %" PRIu32, - __func__, f->shared->tick_num, f->shared->mdf_idx_entries_used); + __func__, shared->tick_num, shared->mdf_idx_entries_used); done: FUNC_LEAVE_NOAPI(ret_value) @@ -1011,7 +1015,7 @@ done: *------------------------------------------------------------------------- */ herr_t -H5F_vfd_swmr_writer__dump_index(H5F_t * f) +H5F_vfd_swmr_writer__dump_index(H5F_shared_t *shared) { unsigned int i; uint32_t mdf_idx_len; @@ -1021,15 +1025,14 @@ H5F_vfd_swmr_writer__dump_index(H5F_t * f) FUNC_ENTER_NOAPI(FAIL) - HDassert(f); - HDassert(f->shared); - HDassert(f->shared->vfd_swmr); - HDassert(f->shared->mdf_idx); + HDassert(shared); + HDassert(shared->vfd_swmr); + HDassert(shared->mdf_idx); - index = f->shared->mdf_idx; - mdf_idx_len = f->shared->mdf_idx_len; - mdf_idx_entries_used = f->shared->mdf_idx_entries_used; + index = shared->mdf_idx; + mdf_idx_len = shared->mdf_idx_len; + mdf_idx_entries_used = shared->mdf_idx_entries_used; HDfprintf(stderr, "\n\nDumping Index:\n\n"); HDfprintf(stderr, @@ -1100,24 +1103,25 @@ H5F_vfd_swmr_reader_end_of_tick(H5F_t *f, bool entering_api) uint32_t tmp_mdf_idx_len; uint32_t tmp_mdf_idx_entries_used; uint32_t mdf_idx_entries_used; + H5F_shared_t *shared = f->shared; struct { uint64_t pgno; uint32_t length; } *change = NULL; herr_t ret_value = SUCCEED; uint32_t i, j, nchanges; - H5FD_t *file = f->shared->lf; + H5FD_t *file = shared->lf; FUNC_ENTER_NOAPI(FAIL) - HDassert(f->shared->pb_ptr); - HDassert(f->shared->vfd_swmr); - HDassert(!f->shared->vfd_swmr_writer); + HDassert(shared->pb_ptr); + HDassert(shared->vfd_swmr); + HDassert(!shared->vfd_swmr_writer); HDassert(file); hlog_fast(eot, "%s enter file %p index len %" PRIu32 " used %" PRIu32, __func__, (void *)file, - f->shared->mdf_idx_len, f->shared->mdf_idx_entries_used); + shared->mdf_idx_len, shared->mdf_idx_entries_used); /* 1) Direct the VFD SWMR reader VFD to load the current header * from the metadata file, and report the current tick. @@ -1133,20 +1137,20 @@ H5F_vfd_swmr_reader_end_of_tick(H5F_t *f, bool entering_api) hlog_fast(tick, "%s last tick %" PRIu64 " new tick %" PRIu64, - __func__, f->shared->tick_num, tmp_tick_num); + __func__, shared->tick_num, tmp_tick_num); /* This is ok if we're entering the API, but it should * not happen if we're exiting the API. */ assert(entering_api || tmp_tick_num < - f->shared->tick_num + f->shared->vfd_swmr_config.max_lag); + shared->tick_num + shared->vfd_swmr_config.max_lag); if (!entering_api) { - H5FD_vfd_swmr_record_elapsed_ticks(f->shared->lf, - tmp_tick_num - f->shared->tick_num); + H5FD_vfd_swmr_record_elapsed_ticks(shared->lf, + tmp_tick_num - shared->tick_num); } - if ( tmp_tick_num != f->shared->tick_num ) { + if ( tmp_tick_num != shared->tick_num ) { const H5FD_vfd_swmr_idx_entry_t *new_mdf_idx; const H5FD_vfd_swmr_idx_entry_t *old_mdf_idx; uint32_t new_mdf_idx_entries_used; @@ -1154,25 +1158,25 @@ H5F_vfd_swmr_reader_end_of_tick(H5F_t *f, bool entering_api) /* swap the old and new metadata file indexes */ - tmp_mdf_idx = f->shared->old_mdf_idx; - tmp_mdf_idx_len = f->shared->old_mdf_idx_len; - tmp_mdf_idx_entries_used = f->shared->old_mdf_idx_entries_used; + tmp_mdf_idx = shared->old_mdf_idx; + tmp_mdf_idx_len = shared->old_mdf_idx_len; + tmp_mdf_idx_entries_used = shared->old_mdf_idx_entries_used; - f->shared->old_mdf_idx = f->shared->mdf_idx; - f->shared->old_mdf_idx_len = f->shared->mdf_idx_len; - f->shared->old_mdf_idx_entries_used = f->shared->mdf_idx_entries_used; + shared->old_mdf_idx = shared->mdf_idx; + shared->old_mdf_idx_len = shared->mdf_idx_len; + shared->old_mdf_idx_entries_used = shared->mdf_idx_entries_used; - f->shared->mdf_idx = tmp_mdf_idx; - f->shared->mdf_idx_len = tmp_mdf_idx_len; - f->shared->mdf_idx_entries_used = tmp_mdf_idx_entries_used; + shared->mdf_idx = tmp_mdf_idx; + shared->mdf_idx_len = tmp_mdf_idx_len; + shared->mdf_idx_entries_used = tmp_mdf_idx_entries_used; - /* if f->shared->mdf_idx is NULL, allocate an index */ - if (f->shared->mdf_idx == NULL && - H5F__vfd_swmr_create_index(f->shared) < 0) + /* if shared->mdf_idx is NULL, allocate an index */ + if (shared->mdf_idx == NULL && + H5F__vfd_swmr_create_index(shared) < 0) HGOTO_ERROR(H5E_FILE, H5E_CANTALLOC, FAIL, "unable to allocate metadata file index"); - mdf_idx_entries_used = f->shared->mdf_idx_len; + mdf_idx_entries_used = shared->mdf_idx_len; #if 0 /* JRM */ HDfprintf(stderr, "--- reader EOT mdf_idx_entries_used = %d ---\n", @@ -1181,24 +1185,24 @@ H5F_vfd_swmr_reader_end_of_tick(H5F_t *f, bool entering_api) if (H5FD_vfd_swmr_get_tick_and_idx(file, FALSE, NULL, &mdf_idx_entries_used, - f->shared->mdf_idx) < 0) + shared->mdf_idx) < 0) HGOTO_ERROR(H5E_ARGS, H5E_CANTGET, FAIL, "error in retrieving tick_num from driver"); - HDassert(mdf_idx_entries_used <= f->shared->mdf_idx_len); + HDassert(mdf_idx_entries_used <= shared->mdf_idx_len); - f->shared->mdf_idx_entries_used = mdf_idx_entries_used; + shared->mdf_idx_entries_used = mdf_idx_entries_used; #if 0 /* JRM */ HDfprintf(stderr, "--- reader EOT index used / len = %" PRIu32 "/%" PRIu32 " ---\n", - f->shared->mdf_idx_entries_used, f->shared->mdf_idx_len); + shared->mdf_idx_entries_used, shared->mdf_idx_len); #endif /* JRM */ - new_mdf_idx = f->shared->mdf_idx; - old_mdf_idx = f->shared->old_mdf_idx; - new_mdf_idx_entries_used = f->shared->mdf_idx_entries_used; - old_mdf_idx_entries_used = f->shared->old_mdf_idx_entries_used; + new_mdf_idx = shared->mdf_idx; + old_mdf_idx = shared->old_mdf_idx; + new_mdf_idx_entries_used = shared->mdf_idx_entries_used; + old_mdf_idx_entries_used = shared->old_mdf_idx_entries_used; change = malloc(sizeof(change[0]) * (old_mdf_idx_entries_used + new_mdf_idx_entries_used)); @@ -1328,8 +1332,8 @@ H5F_vfd_swmr_reader_end_of_tick(H5F_t *f, bool entering_api) } for (i = 0; i < nchanges; i++) { haddr_t page_addr = - (haddr_t)(change[i].pgno * f->shared->pb_ptr->page_size); - if (H5PB_remove_entry(f->shared, page_addr) < 0) { + (haddr_t)(change[i].pgno * shared->pb_ptr->page_size); + if (H5PB_remove_entry(shared, page_addr) < 0) { HGOTO_ERROR(H5E_FILE, H5E_CANTFLUSH, FAIL, "remove page buffer entry failed"); } @@ -1350,19 +1354,20 @@ H5F_vfd_swmr_reader_end_of_tick(H5F_t *f, bool entering_api) #if 0 /* JRM */ HDfprintf(stderr, "--- reader EOT pre new tick index " "used/len = %" PRIu32 "/ %" PRIu32 " ---\n", - f->shared->mdf_idx_entries_used, f->shared->mdf_idx_len); + shared->mdf_idx_entries_used, shared->mdf_idx_len); #endif /* JRM */ /* At this point, we should have evicted or refreshed all stale * page buffer and metadata cache entries. * * Start the next tick. */ - f->shared->tick_num = tmp_tick_num; + shared->tick_num = tmp_tick_num; vfd_swmr_reader_did_increase_tick_to(tmp_tick_num); /* Update end_of_tick */ - if (H5F__vfd_swmr_update_end_of_tick_and_tick_num(f, FALSE) < 0) { + if (H5F__vfd_swmr_update_end_of_tick_and_tick_num(shared, + FALSE) < 0) { HGOTO_ERROR(H5E_FILE, H5E_CANTSET, FAIL, "unable to update end of tick"); } @@ -1386,9 +1391,9 @@ done: " len %" PRIu32 " -> %" PRIu32 " used %" PRIu32 " -> %" PRIu32 " added %" PRIu32 " removed %" PRIu32 " moved %" PRIu32 " %s", - __func__, f->shared->tick_num, - f->shared->old_mdf_idx_len, f->shared->mdf_idx_len, - f->shared->old_mdf_idx_entries_used, f->shared->mdf_idx_entries_used, + __func__, shared->tick_num, + shared->old_mdf_idx_len, shared->mdf_idx_len, + shared->old_mdf_idx_entries_used, shared->mdf_idx_entries_used, entries_added, entries_removed, entries_moved, (ret_value == SUCCEED) ? "success" : "failure"); @@ -1430,6 +1435,7 @@ void H5F_vfd_swmr_update_entry_eot(eot_queue_entry_t *entry) { H5F_t *f = entry->vfd_swmr_file; + H5F_shared_t *shared = f->shared; /* Free the entry on the EOT queue that corresponds to f */ @@ -1441,9 +1447,9 @@ H5F_vfd_swmr_update_entry_eot(eot_queue_entry_t *entry) entry->tick_num, (intmax_t)entry->end_of_tick.tv_sec, entry->end_of_tick.tv_nsec); - assert(entry->vfd_swmr_writer == f->shared->vfd_swmr_writer); - entry->tick_num = f->shared->tick_num; - entry->end_of_tick = f->shared->end_of_tick; + assert(entry->vfd_swmr_writer == shared->vfd_swmr_writer); + entry->tick_num = shared->tick_num; + entry->end_of_tick = shared->end_of_tick; hlog_fast(eotq, "%s: ... to tick %" PRIu64 " ending %jd.%09ld", __func__, entry->tick_num, (intmax_t)entry->end_of_tick.tv_sec, @@ -1510,6 +1516,7 @@ H5F_vfd_swmr_remove_entry_eot(H5F_t *f) herr_t H5F_vfd_swmr_insert_entry_eot(H5F_t *f) { + H5F_shared_t *shared = f->shared; eot_queue_entry_t *entry_ptr; /* An entry on the EOT end of tick queue */ herr_t ret_value = SUCCEED; /* Return value */ @@ -1520,9 +1527,9 @@ H5F_vfd_swmr_insert_entry_eot(H5F_t *f) HGOTO_ERROR(H5E_FILE, H5E_CANTALLOC, FAIL, "unable to allocate the end of tick queue entry") /* Initialize the entry */ - entry_ptr->vfd_swmr_writer = f->shared->vfd_swmr_writer; - entry_ptr->tick_num = f->shared->tick_num; - entry_ptr->end_of_tick = f->shared->end_of_tick; + entry_ptr->vfd_swmr_writer = shared->vfd_swmr_writer; + entry_ptr->tick_num = shared->tick_num; + entry_ptr->end_of_tick = shared->end_of_tick; entry_ptr->vfd_swmr_file = f; insert_eot_entry(entry_ptr); @@ -1581,8 +1588,8 @@ H5F_dump_eot_queue(void) * * Function: H5F__vfd_swmr_update_end_of_tick_and_tick_num * - * Purpose: Update end_of_tick (f->shared->end_of_tick) - * Update tick_num (f->shared->tick_num) + * Purpose: Update end_of_tick (shared->end_of_tick) + * Update tick_num (shared->tick_num) * * Return: Success: SUCCEED * Failure: FAIL @@ -1594,7 +1601,8 @@ H5F_dump_eot_queue(void) *------------------------------------------------------------------------- */ static herr_t -H5F__vfd_swmr_update_end_of_tick_and_tick_num(H5F_t *f, hbool_t incr_tick_num) +H5F__vfd_swmr_update_end_of_tick_and_tick_num(H5F_shared_t *shared, + hbool_t incr_tick_num) { struct timespec curr; /* Current time in struct timespec */ struct timespec new_end_of_tick; /* new end_of_tick in struct timespec */ @@ -1615,26 +1623,26 @@ H5F__vfd_swmr_update_end_of_tick_and_tick_num(H5F_t *f, hbool_t incr_tick_num) curr_nsecs = curr.tv_sec * nanosecs_per_second + curr.tv_nsec; /* Convert tick_len to nanosecs */ - tlen_nsecs = f->shared->vfd_swmr_config.tick_len * nanosecs_per_tenth_sec; + tlen_nsecs = shared->vfd_swmr_config.tick_len * nanosecs_per_tenth_sec; /* - * Update f->shared->tick_num + * Update shared->tick_num */ if ( incr_tick_num ) { - f->shared->tick_num++; + shared->tick_num++; hlog_fast(tick, "%s tick %" PRIu64 " -> %" PRIu64, - __func__, f->shared->tick_num - 1, f->shared->tick_num); + __func__, shared->tick_num - 1, shared->tick_num); - if ( H5PB_vfd_swmr__set_tick(f->shared) < 0 ) + if ( H5PB_vfd_swmr__set_tick(shared) < 0 ) HGOTO_ERROR(H5E_FILE, H5E_SYSTEM, FAIL, \ "Can't update page buffer current tick") } /* - * Update f->shared->end_of_tick + * Update shared->end_of_tick */ /* Calculate new end_of_tick */ @@ -1648,7 +1656,7 @@ H5F__vfd_swmr_update_end_of_tick_and_tick_num(H5F_t *f, hbool_t incr_tick_num) new_end_of_tick.tv_nsec = (long)(new_end_nsecs % nanosecs_per_second); new_end_of_tick.tv_sec = new_end_nsecs / nanosecs_per_second; - f->shared->end_of_tick = new_end_of_tick; + shared->end_of_tick = new_end_of_tick; done: @@ -1680,7 +1688,7 @@ done: *------------------------------------------------------------------------- */ static herr_t -H5F__vfd_swmr_construct_write_md_hdr(H5F_t *f, uint32_t num_entries) +H5F__vfd_swmr_construct_write_md_hdr(H5F_shared_t *shared, uint32_t num_entries) { uint8_t image[H5FD_MD_HEADER_SIZE]; /* Buffer for header */ uint8_t *p = NULL; /* Pointer to buffer */ @@ -1702,9 +1710,9 @@ H5F__vfd_swmr_construct_write_md_hdr(H5F_t *f, uint32_t num_entries) p += H5_SIZEOF_MAGIC; /* Encode page size, tick number, index offset, index length */ - UINT32ENCODE(p, f->shared->fs_page_size); - UINT64ENCODE(p, f->shared->tick_num); - UINT64ENCODE(p, f->shared->writer_index_offset); + UINT32ENCODE(p, shared->fs_page_size); + UINT64ENCODE(p, shared->tick_num); + UINT64ENCODE(p, shared->writer_index_offset); UINT64ENCODE(p, H5FD_MD_INDEX_SIZE(num_entries)); /* Calculate checksum for header */ @@ -1717,12 +1725,12 @@ H5F__vfd_swmr_construct_write_md_hdr(H5F_t *f, uint32_t num_entries) HDassert(p - image == (ptrdiff_t)hdr_size); /* Set to beginning of the file */ - if ( HDlseek(f->shared->vfd_swmr_md_fd, H5FD_MD_HEADER_OFF, SEEK_SET) < 0 ) + if ( HDlseek(shared->vfd_swmr_md_fd, H5FD_MD_HEADER_OFF, SEEK_SET) < 0 ) HGOTO_ERROR(H5E_VFL, H5E_SEEKERROR, FAIL, \ "unable to seek in metadata file") - nwritten = HDwrite(f->shared->vfd_swmr_md_fd, image, hdr_size); + nwritten = HDwrite(shared->vfd_swmr_md_fd, image, hdr_size); /* Write header to the metadata file */ if (nwritten != (ssize_t)hdr_size) { HGOTO_ERROR(H5E_FILE, H5E_WRITEERROR, FAIL, \ @@ -1759,8 +1767,8 @@ done: *------------------------------------------------------------------------- */ static herr_t -H5F__vfd_swmr_construct_write_md_idx(H5F_t *f, uint32_t num_entries, - struct H5FD_vfd_swmr_idx_entry_t index[]) +H5F__vfd_swmr_construct_write_md_idx(H5F_shared_t *shared, + uint32_t num_entries, struct H5FD_vfd_swmr_idx_entry_t index[]) { uint8_t *image = NULL; /* Pointer to buffer */ uint8_t *p = NULL; /* Pointer to buffer */ @@ -1791,7 +1799,7 @@ H5F__vfd_swmr_construct_write_md_idx(H5F_t *f, uint32_t num_entries, p += H5_SIZEOF_MAGIC; /* Encode tick number */ - UINT64ENCODE(p, f->shared->tick_num); + UINT64ENCODE(p, shared->tick_num); /* Encode number of entries in index */ UINT32ENCODE(p, num_entries); @@ -1814,14 +1822,14 @@ H5F__vfd_swmr_construct_write_md_idx(H5F_t *f, uint32_t num_entries, HDassert(p - image == (ptrdiff_t)idx_size); /* Verify the md file descriptor exists */ - HDassert(f->shared->vfd_swmr_md_fd >= 0); + HDassert(shared->vfd_swmr_md_fd >= 0); - if (HDlseek(f->shared->vfd_swmr_md_fd, - (HDoff_t)f->shared->writer_index_offset, SEEK_SET) < 0) + if (HDlseek(shared->vfd_swmr_md_fd, + (HDoff_t)shared->writer_index_offset, SEEK_SET) < 0) HGOTO_ERROR(H5E_VFL, H5E_SEEKERROR, FAIL, \ "unable to seek in metadata file") - nwritten = HDwrite(f->shared->vfd_swmr_md_fd, image, idx_size); + nwritten = HDwrite(shared->vfd_swmr_md_fd, image, idx_size); /* Write index to the metadata file */ if (nwritten != (ssize_t)idx_size) { HGOTO_ERROR(H5E_FILE, H5E_WRITEERROR, FAIL, \ @@ -2072,6 +2080,7 @@ H5F_vfd_swmr_process_eot_queue(bool entering_api) do { H5F_t *f = head->vfd_swmr_file; + H5F_shared_t *shared = f->shared; if(HDclock_gettime(CLOCK_MONOTONIC, &now) < 0) { HGOTO_ERROR(H5E_FUNC, H5E_CANTGET, FAIL, @@ -2085,9 +2094,9 @@ H5F_vfd_swmr_process_eot_queue(bool entering_api) * multiple H5F_t share the H5F_shared_t. Just update the * EOT queue entry and move to the next. */ - if (timespeccmp(&head->end_of_tick, &f->shared->end_of_tick, <)) { + if (timespeccmp(&head->end_of_tick, &shared->end_of_tick, <)) { H5F_vfd_swmr_update_entry_eot(head); - } else if (f->shared->vfd_swmr_writer) { + } else if (shared->vfd_swmr_writer) { if (H5F_vfd_swmr_writer_end_of_tick(f, false) < 0) HGOTO_ERROR(H5E_FUNC, H5E_CANTSET, FAIL, "end of tick error for VFD SWMR writer"); diff --git a/src/H5MV.c b/src/H5MV.c index ffa33ba..5b73b9a 100644 --- a/src/H5MV.c +++ b/src/H5MV.c @@ -113,6 +113,7 @@ HLOG_OUTLET_SHORT_DEFN(h5mv, all); herr_t H5MV__create(H5F_t *f) { + H5F_shared_t *shared = f->shared; /* Free space section classes implemented for file */ const H5FS_section_class_t *classes[] = { H5MV_FSPACE_SECT_CLS_SIMPLE }; H5FS_create_t fs_create; /* Free space creation parameters */ @@ -123,22 +124,21 @@ H5MV__create(H5F_t *f) /* * Check arguments. */ - HDassert(f->shared); - HDassert(f->shared->fs_state_md == H5F_FS_STATE_CLOSED); + HDassert(shared->fs_state_md == H5F_FS_STATE_CLOSED); /* Set the free space creation parameters */ fs_create.client = H5FS_CLIENT_MD_VFD_ID; fs_create.shrink_percent = H5MV_FSPACE_SHRINK; fs_create.expand_percent = H5MV_FSPACE_EXPAND; - fs_create.max_sect_addr = 1 + H5VM_log2_gen((uint64_t)f->shared->maxaddr); - fs_create.max_sect_size = f->shared->maxaddr; + fs_create.max_sect_addr = 1 + H5VM_log2_gen((uint64_t)shared->maxaddr); + fs_create.max_sect_size = shared->maxaddr; - if(NULL == (f->shared->fs_man_md = H5FS_create(f, NULL, &fs_create, NELMTS(classes), classes, f, f->shared->fs_page_size, f->shared->fs_page_size))) + if(NULL == (shared->fs_man_md = H5FS_create(f, NULL, &fs_create, NELMTS(classes), classes, f, shared->fs_page_size, shared->fs_page_size))) HGOTO_ERROR(H5E_RESOURCE, H5E_CANTINIT, FAIL, "can't initialize free space info") /* Set the state for the free space manager to "open", if it is now */ - if(f->shared->fs_man_md) - f->shared->fs_state_md = H5F_FS_STATE_OPEN; + if(shared->fs_man_md) + shared->fs_state_md = H5F_FS_STATE_OPEN; done: FUNC_LEAVE_NOAPI(ret_value) @@ -158,6 +158,7 @@ done: herr_t H5MV_close(H5F_t *f) { + H5F_shared_t *shared = f->shared; herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_NOAPI(FAIL) @@ -165,25 +166,24 @@ H5MV_close(H5F_t *f) /* * Check arguments. */ - HDassert(f); - HDassert(f->shared); + HDassert(shared); #ifdef H5MV_VFD_SWMR_DEBUG HDfprintf(stderr, "%s: Trying to close free space manager\n", FUNC); #endif /* Close an existing free space structure for the file */ - if(f->shared->fs_man_md) { + if(shared->fs_man_md) { #ifdef H5MV_VFD_SWMR_DEBUG HDfprintf(stderr, "%s: Going to close free space manager\n", FUNC); #endif - HDassert(f->shared->fs_state_md != H5F_FS_STATE_CLOSED); + HDassert(shared->fs_state_md != H5F_FS_STATE_CLOSED); - if(H5FS_close(f, f->shared->fs_man_md) < 0) + if(H5FS_close(f, shared->fs_man_md) < 0) HGOTO_ERROR(H5E_RESOURCE, H5E_CANTRELEASE, FAIL, "can't release free space info") } - f->shared->fs_man_md = NULL; - f->shared->fs_state_md = H5F_FS_STATE_CLOSED; + shared->fs_man_md = NULL; + shared->fs_state_md = H5F_FS_STATE_CLOSED; done: FUNC_LEAVE_NOAPI(ret_value) @@ -275,6 +275,7 @@ done: haddr_t H5MV_alloc(H5F_t *f, hsize_t size) { + H5F_shared_t *shared = f->shared; haddr_t eoa; /* EOA for the file */ hsize_t frag_size = 0; /* Fragment size */ hsize_t misalign_size = 0; /* Mis-aligned size */ @@ -285,14 +286,12 @@ H5MV_alloc(H5F_t *f, hsize_t size) hlog_fast(h5mv, "%s: enter size %" PRIuHSIZE, __func__, size); /* check arguments */ - HDassert(f); - HDassert(f->shared); - HDassert(f->shared->vfd_swmr_md_fd >= 0); + HDassert(shared->vfd_swmr_md_fd >= 0); HDassert(size > 0); /* Search for large enough space in the free space manager */ - if(f->shared->fs_man_md != NULL) { - if(H5MV__find_sect(f, size, f->shared->fs_man_md, &ret_value) < 0) + if(shared->fs_man_md != NULL) { + if(H5MV__find_sect(f, size, shared->fs_man_md, &ret_value) < 0) HGOTO_ERROR(H5E_RESOURCE, H5E_CANTALLOC, HADDR_UNDEF, "error locating a node") } @@ -300,32 +299,32 @@ H5MV_alloc(H5F_t *f, hsize_t size) if(!H5F_addr_defined(ret_value)) { /* Get the EOA for the metadata file */ - if(HADDR_UNDEF == (eoa = H5MV_get_vfd_swmr_md_eoa(f))) + if(HADDR_UNDEF == (eoa = H5MV_get_vfd_swmr_md_eoa(shared))) HGOTO_ERROR(H5E_RESOURCE, H5E_CANTGET, HADDR_UNDEF, "Unable to get eoa for VFD SWMR metadata file") /* If EOA is mis-aligned, calculate the fragment size */ - if(H5F_addr_gt(eoa, 0) && (misalign_size = eoa % f->shared->fs_page_size)) - frag_size = f->shared->fs_page_size - misalign_size; + if(H5F_addr_gt(eoa, 0) && (misalign_size = eoa % shared->fs_page_size)) + frag_size = shared->fs_page_size - misalign_size; /* Allocate from end of file */ - if(HADDR_UNDEF == (ret_value = H5MV__alloc_md(f->shared, size + frag_size))) + if(HADDR_UNDEF == (ret_value = H5MV__alloc_md(shared, size + frag_size))) HGOTO_ERROR(H5E_RESOURCE, H5E_CANTALLOC, HADDR_UNDEF, "allocation failed") /* If there is a mis-aligned fragment at EOA */ if(frag_size) { /* Start up the free-space manager if not so */ - if(f->shared->fs_man_md == NULL) { + if(shared->fs_man_md == NULL) { if(H5MV__create(f) < 0) HGOTO_ERROR(H5E_RESOURCE, H5E_CANTINIT, HADDR_UNDEF, "can't initialize free space manager") } - HDassert(f->shared->fs_man_md); + HDassert(shared->fs_man_md); /* Create the free-space section for the fragment */ if(NULL == (node = H5MV__sect_new(eoa, frag_size))) HGOTO_ERROR(H5E_RESOURCE, H5E_CANTINIT, HADDR_UNDEF, "can't initialize free space section") /* Add the section */ - if(H5FS_sect_add(f, f->shared->fs_man_md, &node->sect_info, H5FS_ADD_RETURNED_SPACE, f) < 0) + if(H5FS_sect_add(f, shared->fs_man_md, &node->sect_info, H5FS_ADD_RETURNED_SPACE, f) < 0) HGOTO_ERROR(H5E_RESOURCE, H5E_CANTINSERT, HADDR_UNDEF, "can't re-add section to file free space") node = NULL; @@ -358,6 +357,7 @@ done: herr_t H5MV_free(H5F_t *f, haddr_t addr, hsize_t size) { + H5F_shared_t *shared = f->shared; H5MV_free_section_t *node = NULL; /* Free space section pointer */ herr_t ret_value = SUCCEED; /* Return value */ @@ -374,7 +374,7 @@ H5MV_free(H5F_t *f, haddr_t addr, hsize_t size) /* Check if the free space manager for the file has been initialized */ - if(f->shared->fs_man_md == NULL) { + if(shared->fs_man_md == NULL) { /* If there's no free space manager for objects of this type, * see if we can avoid creating one by checking if the freed * space is at the end of the file @@ -393,7 +393,7 @@ H5MV_free(H5F_t *f, haddr_t addr, hsize_t size) /* If we are deleting the free space manager, leave now, to avoid * [re-]starting it: dropping free space section on the floor. */ - if(f->shared->fs_state_md == H5F_FS_STATE_DELETING) { + if(shared->fs_state_md == H5F_FS_STATE_DELETING) { hlog_fast(h5mv, "%s: dropping addr %" PRIuHADDR " size %" PRIuHSIZE " on the floor!", __func__, addr, size); HGOTO_DONE(SUCCEED) @@ -411,13 +411,13 @@ H5MV_free(H5F_t *f, haddr_t addr, hsize_t size) if(NULL == (node = H5MV__sect_new(addr, size))) HGOTO_ERROR(H5E_RESOURCE, H5E_CANTINIT, FAIL, "can't initialize free space section") - HDassert(f->shared->fs_man_md); + HDassert(shared->fs_man_md); hlog_fast(h5mv, "%s: before H5FS_sect_add, addr %" PRIuHADDR " size %" PRIuHSIZE, __func__, addr, size); /* Add the section */ - if(H5FS_sect_add(f, f->shared->fs_man_md, &node->sect_info, H5FS_ADD_RETURNED_SPACE, f) < 0) + if(H5FS_sect_add(f, shared->fs_man_md, &node->sect_info, H5FS_ADD_RETURNED_SPACE, f) < 0) HGOTO_ERROR(H5E_RESOURCE, H5E_CANTINSERT, FAIL, "can't re-add section to file free space") node = NULL; @@ -450,6 +450,7 @@ done: htri_t H5MV_try_extend(H5F_t *f, haddr_t addr, hsize_t size, hsize_t extra_requested) { + H5F_shared_t *shared = f->shared; haddr_t end; /* End of block to extend */ htri_t ret_value = FALSE; /* Return value */ @@ -460,13 +461,13 @@ HDfprintf(stderr, "%s: Entering: addr = %a, size = %Hu, extra_requested = %Hu\n" /* Sanity check */ HDassert(f); - HDassert(H5F_INTENT(f) & H5F_ACC_RDWR); + HDassert(H5F_SHARED_INTENT(shared) & H5F_ACC_RDWR); /* Compute end of block to extend */ end = addr + size; /* Try extending the block at EOA */ - if((ret_value = H5MV__try_extend_md(f->shared, end, extra_requested)) < 0) + if((ret_value = H5MV__try_extend_md(shared, end, extra_requested)) < 0) HGOTO_ERROR(H5E_RESOURCE, H5E_CANTEXTEND, FAIL, "error extending file") #ifdef H5MV_VFD_SWMR_DEBUG HDfprintf(stderr, "%s: extended = %t\n", FUNC, ret_value); @@ -476,8 +477,8 @@ HDfprintf(stderr, "%s: extended = %t\n", FUNC, ret_value); if(ret_value == FALSE) { /* Try to extend the block into a free-space section */ - if(f->shared->fs_man_md) { - if((ret_value = H5FS_sect_try_extend(f, f->shared->fs_man_md, addr, size, extra_requested, H5FS_ADD_RETURNED_SPACE, NULL)) < 0) + if(shared->fs_man_md) { + if((ret_value = H5FS_sect_try_extend(f, shared->fs_man_md, addr, size, extra_requested, H5FS_ADD_RETURNED_SPACE, NULL)) < 0) HGOTO_ERROR(H5E_RESOURCE, H5E_CANTEXTEND, FAIL, "error extending block in free space manager") #ifdef H5MV_VFD_SWMR_DEBUG HDfprintf(stderr, "%s: Try to H5FS_sect_try_extend = %t\n", FUNC, ret_value); @@ -507,6 +508,7 @@ HDfprintf(stderr, "%s: Leaving: ret_value = %t\n", FUNC, ret_value); htri_t H5MV_try_shrink(H5F_t *f, haddr_t addr, hsize_t size) { + H5F_shared_t *shared = f->shared; H5MV_free_section_t *node = NULL; /* Free space section pointer */ htri_t ret_value = FALSE; /* Return value */ @@ -516,9 +518,7 @@ HDfprintf(stderr, "%s: Entering - addr = %a, size = %Hu\n", FUNC, addr, size); #endif /* check arguments */ - HDassert(f); - HDassert(f->shared); - HDassert(f->shared->lf); + HDassert(shared->lf); HDassert(H5F_addr_defined(addr)); HDassert(size > 0); @@ -710,14 +710,12 @@ done: *------------------------------------------------------------------------- */ haddr_t -H5MV_get_vfd_swmr_md_eoa(const H5F_t *f) +H5MV_get_vfd_swmr_md_eoa(const H5F_shared_t *shared) { /* Use FUNC_ENTER_NOAPI_NOINIT_NOERR here to avoid performance issues */ FUNC_ENTER_NOAPI_NOINIT_NOERR - HDassert(f); - HDassert(f->shared); - HDassert(f->shared->vfd_swmr); + HDassert(shared->vfd_swmr); - FUNC_LEAVE_NOAPI(f->shared->vfd_swmr_md_eoa) + FUNC_LEAVE_NOAPI(shared->vfd_swmr_md_eoa) } diff --git a/src/H5MVpkg.h b/src/H5MVpkg.h index f498e90..cb29879 100644 --- a/src/H5MVpkg.h +++ b/src/H5MVpkg.h @@ -73,7 +73,7 @@ H5_DLL H5MV_free_section_t *H5MV__sect_new(haddr_t sect_off, hsize_t sect_size); H5_DLL herr_t H5MV__sect_free(H5FS_section_info_t *sect); H5_DLL htri_t H5MV__sect_can_shrink(const H5FS_section_info_t *_sect, void *udata); H5_DLL herr_t H5MV__sect_shrink(H5FS_section_info_t **_sect, void *udata); -H5_DLL haddr_t H5MV_get_vfd_swmr_md_eoa(const H5F_t *); +H5_DLL haddr_t H5MV_get_vfd_swmr_md_eoa(const H5F_shared_t *); H5_DLL herr_t H5MV__free_md(H5F_shared_t *, haddr_t, hsize_t); diff --git a/src/H5MVsection.c b/src/H5MVsection.c index 104553f..81f1a00 100644 --- a/src/H5MVsection.c +++ b/src/H5MVsection.c @@ -274,6 +274,7 @@ H5MV__sect_can_shrink(const H5FS_section_info_t *_sect, void *_udata) { const H5MV_free_section_t *sect = (const H5MV_free_section_t *)_sect; /* File free section */ H5F_t *f = (H5F_t *)_udata; + H5F_shared_t *shared = f->shared; haddr_t eoa; /* End of address space in the file */ haddr_t end; /* End of section to extend */ htri_t ret_value = FALSE; /* Return value */ @@ -282,10 +283,9 @@ H5MV__sect_can_shrink(const H5FS_section_info_t *_sect, void *_udata) /* Check arguments. */ HDassert(sect); - HDassert(f); /* Retrieve the end oa the file's address space */ - if(HADDR_UNDEF == (eoa = H5MV_get_vfd_swmr_md_eoa(f))) + if(HADDR_UNDEF == (eoa = H5MV_get_vfd_swmr_md_eoa(shared))) HGOTO_ERROR(H5E_RESOURCE, H5E_CANTGET, FAIL, "get_eoa request for VFD SWMR metadata file failed") /* Compute address of end of section to check */ @@ -315,6 +315,7 @@ herr_t H5MV__sect_shrink(H5FS_section_info_t **_sect, void *_udata) { H5F_t *f = (H5F_t *)_udata; + H5F_shared_t *shared = f->shared; H5MV_free_section_t **sect = (H5MV_free_section_t **)_sect; /* File free section */ herr_t ret_value = SUCCEED; /* Return value */ @@ -322,14 +323,14 @@ H5MV__sect_shrink(H5FS_section_info_t **_sect, void *_udata) /* Check arguments. */ HDassert(sect); - HDassert(H5F_INTENT(f) & H5F_ACC_RDWR); + HDassert(H5F_SHARED_INTENT(shared) & H5F_ACC_RDWR); /* Release section's space at EOA */ - if(H5MV__free_md(f->shared, (*sect)->sect_info.addr, (*sect)->sect_info.size) < 0) + if(H5MV__free_md(shared, (*sect)->sect_info.addr, (*sect)->sect_info.size) < 0) HGOTO_ERROR(H5E_RESOURCE, H5E_CANTFREE, FAIL, "free request for VFD SWMR metadata file failed") /* Free the section */ - if(H5MV__sect_free((H5FS_section_info_t *)*sect) < 0) + if(H5MV__sect_free(&(*sect)->sect_info) < 0) HGOTO_ERROR(H5E_RESOURCE, H5E_CANTRELEASE, FAIL, "can't free simple section node") /* Mark section as freed, for free space manager */ -- cgit v0.12