hdf5.git - Mirror from: https://github.com/HDFGroup/hdf5.git

diff options

author	Allen Byrne <byrn@hdfgroup.org>	2013-08-22 19:57:31 (GMT)
committer	Allen Byrne <byrn@hdfgroup.org>	2013-08-22 19:57:31 (GMT)
commit	e86655bbf4e707ba93406022350f15688f85c0d7 (patch)
tree	636a3cabc3cbbf3d68ea0f230b54d0b0575c9b8a /MANIFEST
parent	7e0bc290129ac8b90a43b563294db4e7eb359078 (diff)
download	hdf5-e86655bbf4e707ba93406022350f15688f85c0d7.zip hdf5-e86655bbf4e707ba93406022350f15688f85c0d7.tar.gz hdf5-e86655bbf4e707ba93406022350f15688f85c0d7.tar.bz2

[svn-r24057] Add --superblock long name to parser and add tests for both --boot-block and --superblock.

Tested: local linux

Diffstat (limited to 'MANIFEST')

-rw-r--r--

MANIFEST

133

1 files changed, 68 insertions, 65 deletions

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Copyright by The HDF Group. * * Copyright by the Board of Trustees of the University of Illinois. * * All rights reserved. * * * * This file is part of HDF5. The full HDF5 copyright notice, including * * terms governing use, modification, and redistribution, is contained in * * the COPYING file, which can be found at the root of the source code * * distribution tree, or in https://support.hdfgroup.org/ftp/HDF5/releases. * * If you do not have access to either file, you may request a copy from * * help@hdfgroup.org. * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* * Programmer: Quincey Koziol <koziol@hdfgroup.org> * Monday, July 31, 2006 * * Purpose: Free space tracking functions. * */ /****************/ /* Module Setup */ /****************/ #define H5F_FRIEND /*suppress error about including H5Fpkg */ #include "H5FSmodule.h" /* This source code file is part of the H5FS module */ /***********/ /* Headers */ /***********/ #include "H5private.h" /* Generic Functions */ #include "H5Eprivate.h" /* Error handling */ #include "H5Fpkg.h" /* File access */ #include "H5FSpkg.h" /* File free space */ #include "H5MFprivate.h" /* File memory management */ #include "H5VMprivate.h" /* Vectors and arrays */ /****************/ /* Local Macros */ /****************/ /******************/ /* Local Typedefs */ /******************/ /* User data for skip list iterator callback for iterating over section size nodes */ typedef struct { H5FS_t *fspace; /* Free space manager info */ H5FS_operator_t op; /* Operator for the iteration */ void *op_data; /* Information to pass to the operator */ } H5FS_iter_ud_t; /********************/ /* Package Typedefs */ /********************/ /********************/ /* Local Prototypes */ /********************/ static herr_t H5FS__sect_increase(H5FS_t *fspace, const H5FS_section_class_t *cls, unsigned flags); static herr_t H5FS__sect_decrease(H5FS_t *fspace, const H5FS_section_class_t *cls); static herr_t H5FS__size_node_decr(H5FS_sinfo_t *sinfo, unsigned bin, H5FS_node_t *fspace_node, const H5FS_section_class_t *cls); static herr_t H5FS__sect_unlink_size(H5FS_sinfo_t *sinfo, const H5FS_section_class_t *cls, H5FS_section_info_t *sect); static herr_t H5FS__sect_unlink_rest(H5FS_t *fspace, const H5FS_section_class_t *cls, H5FS_section_info_t *sect); static herr_t H5FS__sect_remove_real(H5FS_t *fspace, H5FS_section_info_t *sect); static herr_t H5FS__sect_link_size(H5FS_sinfo_t *sinfo, const H5FS_section_class_t *cls, H5FS_section_info_t *sect); static herr_t H5FS__sect_link_rest(H5FS_t *fspace, const H5FS_section_class_t *cls, H5FS_section_info_t *sect, unsigned flags); static herr_t H5FS__sect_link(H5FS_t *fspace, H5FS_section_info_t *sect, unsigned flags); static herr_t H5FS__sect_merge(H5FS_t *fspace, H5FS_section_info_t **sect, void *op_data); static htri_t H5FS__sect_find_node(H5FS_t *fspace, hsize_t request, H5FS_section_info_t **node); static herr_t H5FS__sect_serialize_size(H5FS_t *fspace); /*********************/ /* Package Variables */ /*********************/ /* Declare a free list to manage the H5FS_node_t struct */ H5FL_DEFINE(H5FS_node_t); /* Declare a free list to manage the H5FS_bin_t sequence information */ H5FL_SEQ_DEFINE(H5FS_bin_t); /* Declare a free list to manage the H5FS_sinfo_t struct */ H5FL_DEFINE(H5FS_sinfo_t); /*****************************/ /* Library Private Variables */ /*****************************/ /*******************/ /* Local Variables */ /*******************/ /*------------------------------------------------------------------------- * Function: H5FS__sinfo_new * * Purpose: Create new section info structure * * Return: Success: non-NULL, pointer to new section info struct * Failure: NULL * * Programmer: Quincey Koziol * Monday, July 31, 2006 * *------------------------------------------------------------------------- */ H5FS_sinfo_t * H5FS__sinfo_new(H5F_t *f, H5FS_t *fspace) { H5FS_sinfo_t *sinfo = NULL; /* Section information struct created */ H5FS_sinfo_t *ret_value = NULL; /* Return value */ FUNC_ENTER_PACKAGE /* Check arguments. */ HDassert(f); HDassert(fspace); #ifdef H5FS_SINFO_DEBUG HDfprintf(stderr, "%s: fspace->addr = %a\n", FUNC, fspace->addr); #endif /* H5FS_SINFO_DEBUG */ /* Allocate the free space header */ if(NULL == (sinfo = H5FL_CALLOC(H5FS_sinfo_t))) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed") /* Set non-zero values */ sinfo->nbins = H5VM_log2_gen(fspace->max_sect_size); sinfo->sect_prefix_size = H5FS_SINFO_PREFIX_SIZE(f); sinfo->sect_off_size = (fspace->max_sect_addr + 7) / 8; sinfo->sect_len_size = H5VM_limit_enc_size((uint64_t)fspace->max_sect_size); #ifdef H5FS_SINFO_DEBUG HDfprintf(stderr, "%s: fspace->max_sect_size = %Hu\n", FUNC, fspace->max_sect_size); HDfprintf(stderr, "%s: fspace->max_sect_addr = %u\n", FUNC, fspace->max_sect_addr); HDfprintf(stderr, "%s: sinfo->nbins = %u\n", FUNC, sinfo->nbins); HDfprintf(stderr, "%s: sinfo->sect_off_size = %u, sinfo->sect_len_size = %u\n", FUNC, sinfo->sect_off_size, sinfo->sect_len_size); #endif /* H5FS_SINFO_DEBUG */ /* Allocate space for the section size bins */ if(NULL == (sinfo->bins = H5FL_SEQ_CALLOC(H5FS_bin_t, (size_t)sinfo->nbins))) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed for free space section bin array") /* Increment the reference count on the free space manager header */ if(H5FS__incr(fspace) < 0) HGOTO_ERROR(H5E_FSPACE, H5E_CANTINC, NULL, "unable to increment ref. count on free space header") sinfo->fspace = fspace; /* Link free space manager to section info */ /* (for deserializing sections) */ HDassert(fspace->sinfo == NULL); fspace->sinfo = sinfo; /* Set return value */ ret_value = sinfo; done: if(ret_value == NULL && sinfo) { /* Release bins for skip lists */ if(sinfo->bins) sinfo->bins = H5FL_SEQ_FREE(H5FS_bin_t, sinfo->bins); /* Release free space section info */ sinfo = H5FL_FREE(H5FS_sinfo_t, sinfo); } /* end if */ FUNC_LEAVE_NOAPI(ret_value) } /* H5FS__sinfo_new() */ /*------------------------------------------------------------------------- * Function: H5FS__sinfo_lock * * Purpose: Make certain the section info for the free space manager is * in memory. * * Either uses existing section info owned by the free space * header, loads section info from disk, or creates new section * info * * Return: SUCCEED/FAIL * * Programmer: Quincey Koziol * Thursday, February 7, 2008 * *------------------------------------------------------------------------- */ static herr_t H5FS__sinfo_lock(H5F_t *f, H5FS_t *fspace, unsigned accmode) { H5FS_sinfo_cache_ud_t cache_udata; /* User-data for cache callback */ herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_STATIC #ifdef H5FS_SINFO_DEBUG HDfprintf(stderr, "%s: Called, fspace->addr = %a, fspace->sinfo = %p, fspace->sect_addr = %a\n", FUNC, fspace->addr, fspace->sinfo, fspace->sect_addr); HDfprintf(stderr, "%s: fspace->alloc_sect_size = %Hu, fspace->sect_size = %Hu\n", FUNC, fspace->alloc_sect_size, fspace->sect_size); #endif /* H5FS_SINFO_DEBUG */ /* Check arguments. */ HDassert(f); HDassert(fspace); /* only H5AC__READ_ONLY_FLAG may appear in accmode */ HDassert((accmode & (unsigned)(~H5AC__READ_ONLY_FLAG)) == 0); /* If the free space header doesn't already "own" the section info, load * section info or create it */ if(fspace->sinfo) { /* Check if the section info was protected & we want a different access mode */ /* only H5AC__READ_ONLY_FLAG may appear in fspace->sinfo_accmode */ HDassert(((fspace->sinfo_accmode) & (unsigned)(~H5AC__READ_ONLY_FLAG)) == 0); if(fspace->sinfo_protected && accmode != fspace->sinfo_accmode) { /* Check if we need to switch from read-only access to read-write */ if(0 == (accmode & (unsigned)(~H5AC__READ_ONLY_FLAG))) { /* Unprotect the read-only section info */ if(H5AC_unprotect(f, H5AC_FSPACE_SINFO, fspace->sect_addr, fspace->sinfo, H5AC__NO_FLAGS_SET) < 0) HGOTO_ERROR(H5E_FSPACE, H5E_CANTUNPROTECT, FAIL, "unable to release free space section info") /* Re-protect the section info with read-write access */ cache_udata.f = f; cache_udata.fspace = fspace; if(NULL == (fspace->sinfo = (H5FS_sinfo_t *)H5AC_protect(f, H5AC_FSPACE_SINFO, fspace->sect_addr, &cache_udata, H5AC__NO_FLAGS_SET))) HGOTO_ERROR(H5E_FSPACE, H5E_CANTPROTECT, FAIL, "unable to load free space sections") /* Switch the access mode we have */ fspace->sinfo_accmode = H5AC__NO_FLAGS_SET; } /* end if */ } /* end if */ } /* end if */ else { /* If the section address is defined, load it from the file */ if(H5F_addr_defined(fspace->sect_addr)) { /* Sanity check */ HDassert(fspace->sinfo_protected == FALSE); HDassert(H5F_addr_defined(fspace->addr)); #ifdef H5FS_SINFO_DEBUG HDfprintf(stderr, "%s: Reading in existing sections, fspace->sect_addr = %a\n", FUNC, fspace->sect_addr); #endif /* H5FS_SINFO_DEBUG */ /* Protect the free space sections */ cache_udata.f = f; cache_udata.fspace = fspace; if(NULL == (fspace->sinfo = (H5FS_sinfo_t *)H5AC_protect(f, H5AC_FSPACE_SINFO, fspace->sect_addr, &cache_udata, accmode))) HGOTO_ERROR(H5E_FSPACE, H5E_CANTPROTECT, FAIL, "unable to load free space sections") /* Remember that we protected the section info & the access mode */ fspace->sinfo_protected = TRUE; fspace->sinfo_accmode = accmode; } /* end if */ else { #ifdef H5FS_SINFO_DEBUG HDfprintf(stderr, "%s: Creating new section info\n", FUNC); #endif /* H5FS_SINFO_DEBUG */ /* Sanity check */ HDassert(fspace->tot_sect_count == 0); HDassert(fspace->serial_sect_count == 0); HDassert(fspace->ghost_sect_count == 0); /* Allocate and initialize free space section info */ if(NULL == (fspace->sinfo = H5FS__sinfo_new(f, fspace))) HGOTO_ERROR(H5E_FSPACE, H5E_CANTCREATE, FAIL, "can't create section info") /* Set initial size of section info to 0 */ fspace->sect_size = fspace->alloc_sect_size = 0; } /* end if */ } /* end if */ HDassert(fspace->rc == 2); /* Increment the section info lock count */ fspace->sinfo_lock_count++; done: #ifdef H5FS_SINFO_DEBUG HDfprintf(stderr, "%s: Leaving, fspace->addr = %a, fspace->sinfo = %p, fspace->sect_addr = %a\n", FUNC, fspace->addr, fspace->sinfo, fspace->sect_addr); HDfprintf(stderr, "%s: fspace->alloc_sect_size = %Hu, fspace->sect_size = %Hu\n", FUNC, fspace->alloc_sect_size, fspace->sect_size); #endif /* H5FS_SINFO_DEBUG */ FUNC_LEAVE_NOAPI(ret_value) } /* H5FS__sinfo_lock() */ /*------------------------------------------------------------------------- * Function: H5FS__sinfo_unlock * * Purpose: Release the section info, either giving ownership back to * the cache or letting the free space header keep it. * * Add the fix in this routine to resolve the potential infinite loop * problem when allocating file space for the meta data of the * self-referential free-space managers at file closing. * * On file close or flushing, when the section info is modified * and protected/unprotected, does not allow the section info size * to shrink: * --if the current allocated section info size in fspace->sect_size is * larger than the previous section info size in fpsace->alloc_sect_size, * release the section info * --Otherwise, set the fspace->sect_size to be the same as * fpsace->alloc_sect_size. This means fspace->sect_size may be larger * than what is actually needed. * * Return: SUCCEED/FAIL * * Programmer: Quincey Koziol * Thursday, February 7, 2008 * *------------------------------------------------------------------------- */ static herr_t H5FS__sinfo_unlock(H5F_t *f, H5FS_t *fspace, hbool_t modified) { herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_STATIC #ifdef H5FS_SINFO_DEBUG HDfprintf(stderr, "%s: Called, modified = %t, fspace->addr = %a, fspace->sect_addr = %a\n", FUNC, modified, fspace->addr, fspace->sect_addr); HDfprintf(stderr, "%s: fspace->sinfo_lock_count = %u, fspace->sinfo_modified = %t, fspace->sinfo_protected = %t\n", FUNC, fspace->sinfo_lock_count, fspace->sinfo_modified, fspace->sinfo_protected); HDfprintf(stderr, "%s: fspace->alloc_sect_size = %Hu, fspace->sect_size = %Hu\n", FUNC, fspace->alloc_sect_size, fspace->sect_size); #endif /* H5FS_SINFO_DEBUG */ /* Check arguments. */ HDassert(f); HDassert(fspace); HDassert(fspace->rc == 2); HDassert(fspace->sinfo); /* Check if we modified any section */ if(modified) { /* Check if the section info was protected with a different access mode */ if(fspace->sinfo_protected && (0 != ((fspace->sinfo_accmode) & H5AC__READ_ONLY_FLAG))) HGOTO_ERROR(H5E_FSPACE, H5E_CANTDIRTY, FAIL, "attempt to modify read-only section info") /* If we modified the section info, mark it dirty */ fspace->sinfo->dirty = TRUE; /* Remember that the section info was modified while locked */ fspace->sinfo_modified = TRUE; /* Assume that the modification will affect the statistics in the header * and mark that dirty also */ if(H5FS__dirty(fspace) < 0) HGOTO_ERROR(H5E_FSPACE, H5E_CANTMARKDIRTY, FAIL, "unable to mark free space header as dirty") } /* end if */ /* Decrement the lock count on the section info */ fspace->sinfo_lock_count--; /* Check if section info lock count dropped to zero */ if(fspace->sinfo_lock_count == 0) { hbool_t release_sinfo_space = FALSE; /* Flag to indicate section info space in file should be released */ hbool_t closing_or_flushing = f->shared->closing; /* Is closing or flushing in progress */ /* Check whether cache-flush is in progress if closing is not. */ if(!closing_or_flushing && H5AC_get_cache_flush_in_progress(f->shared->cache, &closing_or_flushing) < 0) HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Can't get flush_in_progress") /* Check if we actually protected the section info */ if(fspace->sinfo_protected) { unsigned cache_flags = H5AC__NO_FLAGS_SET; /* Flags for unprotecting heap */ /* Sanity check */ HDassert(H5F_addr_defined(fspace->addr)); /* Check if we've made new changes to the section info while locked */ if(fspace->sinfo_modified) { /* Note that we've modified the section info */ cache_flags |= H5AC__DIRTIED_FLAG; /* On file close or flushing, does not allow section info to shrink in size */ if(closing_or_flushing) { if(fspace->sect_size > fspace->alloc_sect_size) cache_flags |= H5AC__DELETED_FLAG | H5AC__TAKE_OWNERSHIP_FLAG; else fspace->sect_size = fspace->alloc_sect_size; /* Check if the section info size in the file has changed */ } else if(fspace->sect_size != fspace->alloc_sect_size) cache_flags |= H5AC__DELETED_FLAG | H5AC__TAKE_OWNERSHIP_FLAG; } /* end if */ /* Sanity check */ HDassert(H5F_addr_defined(fspace->sect_addr)); /* Unprotect section info in cache */ /* (Possibly dirty) */ /* (Possibly taking ownership from the cache) */ #ifdef H5FS_SINFO_DEBUG HDfprintf(stderr, "%s: Unprotecting section info, cache_flags = %u\n", FUNC, cache_flags); #endif /* H5FS_SINFO_DEBUG */ if(H5AC_unprotect(f, H5AC_FSPACE_SINFO, fspace->sect_addr, fspace->sinfo, cache_flags) < 0) HGOTO_ERROR(H5E_FSPACE, H5E_CANTUNPROTECT, FAIL, "unable to release free space section info") /* Reset the protected flag on the section info */ fspace->sinfo_protected = FALSE; /* Check if header is taking ownership of section info */ if((cache_flags & H5AC__TAKE_OWNERSHIP_FLAG)) { #ifdef H5FS_SINFO_DEBUG HDfprintf(stderr, "%s: Taking ownership of section info\n", FUNC); #endif /* H5FS_SINFO_DEBUG */ /* Set flag to release section info space in file */ release_sinfo_space = TRUE; } /* end if */ else { #ifdef H5FS_SINFO_DEBUG HDfprintf(stderr, "%s: Relinquishing section info ownership\n", FUNC); #endif /* H5FS_SINFO_DEBUG */ /* Free space header relinquished ownership of section info */ fspace->sinfo = NULL; } /* end else */ } /* end if */ else { /* Check if the section info was modified */ if(fspace->sinfo_modified) { /* Check if we need to release section info in the file */ if(H5F_addr_defined(fspace->sect_addr)) { /* Set flag to release section info space in file */ /* On file close or flushing, only need to release section info with size bigger than previous section */ if(closing_or_flushing) { if(fspace->sect_size > fspace->alloc_sect_size) release_sinfo_space = TRUE; else fspace->sect_size = fspace->alloc_sect_size; } else release_sinfo_space = TRUE; } else HDassert(fspace->alloc_sect_size == 0); } /* end if */ else { /* Sanity checks... */ if(H5F_addr_defined(fspace->sect_addr)) HDassert(fspace->alloc_sect_size == fspace->sect_size); else HDassert(fspace->alloc_sect_size == 0); } /* end else */ } /* end else */ /* Reset the "section info modified" flag */ fspace->sinfo_modified = FALSE; /* Check if header needs to release section info in the file */ if(release_sinfo_space) { haddr_t old_sect_addr = fspace->sect_addr; /* Previous location of section info in file */ hsize_t old_alloc_sect_size = fspace->alloc_sect_size; /* Previous size of section info in file */ /* Sanity check */ HDassert(H5F_addr_defined(fspace->addr)); /* Reset section info in header */ fspace->sect_addr = HADDR_UNDEF; fspace->alloc_sect_size = 0; /* If we haven't already marked the header dirty, do so now */ if(!modified) if(H5FS__dirty(fspace) < 0) HGOTO_ERROR(H5E_FSPACE, H5E_CANTMARKDIRTY, FAIL, "unable to mark free space header as dirty") #ifdef H5FS_SINFO_DEBUG HDfprintf(stderr, "%s: Freeing section info on disk, old_sect_addr = %a, old_alloc_sect_size = %Hu\n", FUNC, old_sect_addr, old_alloc_sect_size); #endif /* H5FS_SINFO_DEBUG */ /* Release space for section info in file */ if(!H5F_IS_TMP_ADDR(f, old_sect_addr)) if(H5MF_xfree(f, H5FD_MEM_FSPACE_SINFO, old_sect_addr, old_alloc_sect_size) < 0) HGOTO_ERROR(H5E_FSPACE, H5E_CANTFREE, FAIL, "unable to free free space sections") } /* end if */ } /* end if */ done: #ifdef H5FS_SINFO_DEBUG HDfprintf(stderr, "%s: Leaving, ret_value = %d\n", FUNC, ret_value); #endif /* H5FS_SINFO_DEBUG */ FUNC_LEAVE_NOAPI(ret_value) } /* H5FS__sinfo_unlock() */ /*------------------------------------------------------------------------- * Function: H5FS__sect_serialize_size * * Purpose: Determine serialized size of all sections in free space manager * * Return: SUCCEED/FAIL * * Programmer: Quincey Koziol * Monday, May 8, 2006 * *------------------------------------------------------------------------- */ static herr_t H5FS__sect_serialize_size(H5FS_t *fspace) { FUNC_ENTER_STATIC_NOERR /* Check arguments. */ HDassert(fspace); #ifdef QAK HDfprintf(stderr, "%s: Check 1.0 - fspace->sect_size = %Hu\n", "H5FS__sect_serialize_size", fspace->sect_size); HDfprintf(stderr, "%s: fspace->serial_sect_count = %Zu\n", "H5FS__sect_serialize_size", fspace->serial_sect_count); HDfprintf(stderr, "%s: fspace->alloc_sect_size = %Hu\n", "H5FS__sect_serialize_size", fspace->alloc_sect_size); HDfprintf(stderr, "%s: fspace->sinfo->serial_size_count = %Zu\n", "H5FS__sect_serialize_size", fspace->sinfo->serial_size_count); #endif /* QAK */ /* Compute the size of the buffer required to serialize all the sections */ if(fspace->serial_sect_count > 0) { size_t sect_buf_size; /* Section buffer size */ /* Serialized sections prefix */ sect_buf_size = fspace->sinfo->sect_prefix_size; /* Count for each differently sized serializable section */ #ifdef QAK HDfprintf(stderr, "%s: fspace->sinfo->serial_size_count = %Zu\n", "H5FS__sect_serialize_size", fspace->sinfo->serial_size_count); HDfprintf(stderr, "%s: fspace->serial_sect_count = %Hu\n", "H5FS__sect_serialize_size", fspace->serial_sect_count); #endif /* QAK */ sect_buf_size += fspace->sinfo->serial_size_count * H5VM_limit_enc_size((uint64_t)fspace->serial_sect_count); /* Size for each differently sized serializable section */ sect_buf_size += fspace->sinfo->serial_size_count * fspace->sinfo->sect_len_size; /* Offsets of each section in address space */ sect_buf_size += fspace->serial_sect_count * fspace->sinfo->sect_off_size; /* Class of each section */ sect_buf_size += fspace->serial_sect_count * 1 /* byte */; /* Extra space required to serialize each section */ sect_buf_size += fspace->sinfo->serial_size; /* Update section size in header */ fspace->sect_size = sect_buf_size; } /* end if */ else /* Reset section size in header */ fspace->sect_size = fspace->sinfo->sect_prefix_size; FUNC_LEAVE_NOAPI(SUCCEED) } /* H5FS__sect_serialize_size() */ /*------------------------------------------------------------------------- * Function: H5FS__sect_increase * * Purpose: Increase the size of the serialized free space section info * on disk * * Return: SUCCEED/FAIL * * Programmer: Quincey Koziol * Monday, May 8, 2006 * *------------------------------------------------------------------------- */ static herr_t H5FS__sect_increase(H5FS_t *fspace, const H5FS_section_class_t *cls, unsigned flags) { herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_STATIC /* Check arguments. */ HDassert(fspace); HDassert(fspace->sinfo); HDassert(cls); /* Increment total # of sections on free space list */ fspace->tot_sect_count++; /* Check for serializable or 'ghost' section */ if(cls->flags & H5FS_CLS_GHOST_OBJ) { /* Sanity check */ HDassert(cls->serial_size == 0); /* Increment # of ghost sections */ fspace->ghost_sect_count++; } /* end if */ else { /* Increment # of serializable sections */ fspace->serial_sect_count++; /* Increment amount of space required to serialize all sections */ #ifdef QAK HDfprintf(stderr, "%s: sinfo->serial_size = %Zu\n", FUNC, fspace->sinfo->serial_size); HDfprintf(stderr, "%s: cls->serial_size = %Zu\n", FUNC, cls->serial_size); #endif /* QAK */ fspace->sinfo->serial_size += cls->serial_size; /* Update the free space sections' serialized size */ /* (if we're not deserializing the sections from disk) */ if(!(flags & H5FS_ADD_DESERIALIZING)) { if(H5FS__sect_serialize_size(fspace) < 0) HGOTO_ERROR(H5E_FSPACE, H5E_CANTCOMPUTE, FAIL, "can't adjust free space section size on disk") } /* end if */ } /* end else */ done: FUNC_LEAVE_NOAPI(ret_value) } /* H5FS__sect_increase() */ /*------------------------------------------------------------------------- * Function: H5FS__sect_decrease * * Purpose: Decrease the size of the serialized free space section info * on disk * * Return: SUCCEED/FAIL * * Programmer: Quincey Koziol * Monday, May 8, 2006 * *------------------------------------------------------------------------- */ static herr_t H5FS__sect_decrease(H5FS_t *fspace, const H5FS_section_class_t *cls) { herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_STATIC /* Check arguments. */ HDassert(fspace); HDassert(fspace->sinfo); HDassert(cls); /* Decrement total # of sections in free space manager */ fspace->tot_sect_count--; /* Check for serializable or 'ghost' section */ if(cls->flags & H5FS_CLS_GHOST_OBJ) { /* Sanity check */ HDassert(cls->serial_size == 0); /* Decrement # of ghost sections */ fspace->ghost_sect_count--; } /* end if */ else { /* Decrement # of serializable sections */ fspace->serial_sect_count--; /* Decrement amount of space required to serialize all sections */ #ifdef QAK HDfprintf(stderr, "%s: fspace->serial_size = %Zu\n", FUNC, fspace->sinfo->serial_size); HDfprintf(stderr, "%s: cls->serial_size = %Zu\n", FUNC, cls->serial_size); #endif /* QAK */ fspace->sinfo->serial_size -= cls->serial_size; /* Update the free space sections' serialized size */ if(H5FS__sect_serialize_size(fspace) < 0) HGOTO_ERROR(H5E_FSPACE, H5E_CANTCOMPUTE, FAIL, "can't adjust free space section size on disk") } /* end else */ done: FUNC_LEAVE_NOAPI(ret_value) } /* H5FS__sect_decrease() */ /*------------------------------------------------------------------------- * Function: H5FS__size_node_decr * * Purpose: Decrement the number of sections of a particular size * * Return: SUCCEED/FAIL * * Programmer: Quincey Koziol * Wednesday, May 17, 2006 * *------------------------------------------------------------------------- */ static herr_t H5FS__size_node_decr(H5FS_sinfo_t *sinfo, unsigned bin, H5FS_node_t *fspace_node, const H5FS_section_class_t *cls) { herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_STATIC /* Check arguments. */ HDassert(sinfo); HDassert(fspace_node); HDassert(cls); /* Decrement the # of sections in this bin */ /* (Different from the # of items in the bin's skiplist, since each node on * the bin's skiplist is also a skiplist...) */ sinfo->bins[bin].tot_sect_count--; #ifdef QAK HDfprintf(stderr, "%s: sinfo->bins[%u].sect_count = %Zu\n", FUNC, bin, sinfo->bins[bin].sect_count); #endif /* QAK */ /* Check for 'ghost' or 'serializable' section */ if(cls->flags & H5FS_CLS_GHOST_OBJ) { /* Decrement node's ghost section count */ fspace_node->ghost_count--; /* Decrement bin's ghost section count */ sinfo->bins[bin].ghost_sect_count--; /* If the node has no more ghost sections, decrement number of ghost section sizes managed */ if(fspace_node->ghost_count == 0) sinfo->ghost_size_count--; } /* end if */ else { /* Decrement node's serializable section count */ fspace_node->serial_count--; /* Decrement bin's serializable section count */ sinfo->bins[bin].serial_sect_count--; /* If the node has no more serializable sections, decrement number of serializable section sizes managed */ if(fspace_node->serial_count == 0) sinfo->serial_size_count--; } /* end else */ /* Check for no more nodes on list of that size */ if(H5SL_count(fspace_node->sect_list) == 0) { H5FS_node_t *tmp_fspace_node; /* Free space list size node */ /* Sanity checks */ HDassert(fspace_node->ghost_count == 0); HDassert(fspace_node->serial_count == 0); /* Remove size tracking list from bin */ tmp_fspace_node = (H5FS_node_t *)H5SL_remove(sinfo->bins[bin].bin_list, &fspace_node->sect_size); if(tmp_fspace_node == NULL || tmp_fspace_node != fspace_node) HGOTO_ERROR(H5E_FSPACE, H5E_CANTREMOVE, FAIL, "can't remove free space node from skip list") /* Destroy skip list for size tracking node */ if(H5SL_close(fspace_node->sect_list) < 0) HGOTO_ERROR(H5E_FSPACE, H5E_CANTCLOSEOBJ, FAIL, "can't destroy size tracking node's skip list") /* Release free space list node */ fspace_node = H5FL_FREE(H5FS_node_t, fspace_node); /* Decrement total number of section sizes managed */ sinfo->tot_size_count--; } /* end if */ done: FUNC_LEAVE_NOAPI(ret_value) } /* H5FS__size_node_decr() */ /*------------------------------------------------------------------------- * Function: H5FS__sect_unlink_size * * Purpose: Remove a section node from size tracking data structures for * a free space manager * * Return: SUCCEED/FAIL * * Programmer: Quincey Koziol * Wednesday, May 17, 2006 * *------------------------------------------------------------------------- */ static herr_t H5FS__sect_unlink_size(H5FS_sinfo_t *sinfo, const H5FS_section_class_t *cls, H5FS_section_info_t *sect) { H5FS_node_t *fspace_node; /* Free list size node */ H5FS_section_info_t *tmp_sect_node; /* Temporary section node */ unsigned bin; /* Bin to put the free space section in */ herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_STATIC /* Check arguments. */ HDassert(sinfo); HDassert(sinfo->bins); HDassert(sect); HDassert(cls); /* Determine correct bin which holds items of at least the section's size */ bin = H5VM_log2_gen(sect->size); HDassert(bin < sinfo->nbins); if(sinfo->bins[bin].bin_list == NULL) HGOTO_ERROR(H5E_FSPACE, H5E_NOTFOUND, FAIL, "node's bin is empty?") /* Find space node for section's size */ if((fspace_node = (H5FS_node_t *)H5SL_search(sinfo->bins[bin].bin_list, &sect->size)) == NULL) HGOTO_ERROR(H5E_FSPACE, H5E_NOTFOUND, FAIL, "can't find section size node") /* Remove the section's node from the list */ tmp_sect_node = (H5FS_section_info_t *)H5SL_remove(fspace_node->sect_list, &sect->addr); if(tmp_sect_node == NULL || tmp_sect_node != sect) HGOTO_ERROR(H5E_FSPACE, H5E_NOTFOUND, FAIL, "can't find section node on size list") /* Decrement # of sections in section size node */ if(H5FS__size_node_decr(sinfo, bin, fspace_node, cls) < 0) HGOTO_ERROR(H5E_FSPACE, H5E_CANTREMOVE, FAIL, "can't remove free space size node from skip list") done: FUNC_LEAVE_NOAPI(ret_value) } /* H5FS__sect_unlink_size() */ /*------------------------------------------------------------------------- * Function: H5FS__sect_unlink_rest * * Purpose: Finish unlinking a section from the rest of the free space * manager's data structures, after the section has been removed * from the size tracking data structures * * Return: SUCCEED/FAIL * * Programmer: Quincey Koziol * Wednesday, May 17, 2006 * *------------------------------------------------------------------------- */ static herr_t H5FS__sect_unlink_rest(H5FS_t *fspace, const H5FS_section_class_t *cls, H5FS_section_info_t *sect) { herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_STATIC /* Check arguments. */ HDassert(fspace); HDassert(fspace->sinfo); HDassert(cls); HDassert(sect); /* Remove node from merge list, if it was entered there */ if(!(cls->flags & H5FS_CLS_SEPAR_OBJ)) { H5FS_section_info_t *tmp_sect_node; /* Temporary section node */ #ifdef QAK HDfprintf(stderr, "%s: removing object from merge list, sect->type = %u\n", FUNC, (unsigned)sect->type); #endif /* QAK */ tmp_sect_node = (H5FS_section_info_t *)H5SL_remove(fspace->sinfo->merge_list, &sect->addr); if(tmp_sect_node == NULL || tmp_sect_node != sect) HGOTO_ERROR(H5E_FSPACE, H5E_NOTFOUND, FAIL, "can't find section node on size list") } /* end if */ /* Update section info & check if we need less room for the serialized free space sections */ if(H5FS__sect_decrease(fspace, cls) < 0) HGOTO_ERROR(H5E_FSPACE, H5E_CANTINSERT, FAIL, "can't increase free space section size on disk") /* Decrement amount of free space managed */ #ifdef QAK HDfprintf(stderr, "%s: fspace->tot_space = %Hu\n", FUNC, fspace->tot_space); #endif /* QAK */ fspace->tot_space -= sect->size; done: FUNC_LEAVE_NOAPI(ret_value) } /* H5FS__sect_unlink_rest() */ /*------------------------------------------------------------------------- * Function: H5FS__sect_remove_real * * Purpose: Remove a section from the free space manager * * Return: SUCCEED/FAIL * * Programmer: Quincey Koziol * Wednesday, May 17, 2006 * *------------------------------------------------------------------------- */ static herr_t H5FS__sect_remove_real(H5FS_t *fspace, H5FS_section_info_t *sect) { const H5FS_section_class_t *cls; /* Class of section */ herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_STATIC /* Check arguments. */ HDassert(fspace); HDassert(fspace->sinfo); HDassert(sect); /* Get section's class */ cls = &fspace->sect_cls[sect->type]; /* Remove node from size tracked data structures */ if(H5FS__sect_unlink_size(fspace->sinfo, cls, sect) < 0) HGOTO_ERROR(H5E_FSPACE, H5E_CANTFREE, FAIL, "can't remove section from size tracking data structures") /* Update rest of free space manager data structures for node removal */ if(H5FS__sect_unlink_rest(fspace, cls, sect) < 0) HGOTO_ERROR(H5E_FSPACE, H5E_CANTFREE, FAIL, "can't remove section from non-size tracking data structures") done: FUNC_LEAVE_NOAPI(ret_value) } /* H5FS__sect_remove_real() */ /*------------------------------------------------------------------------- * Function: H5FS_sect_remove * * Purpose: Remove a section from the free space manager * * Return: SUCCEED/FAIL * * Programmer: Quincey Koziol * Wednesday, May 17, 2006 * *------------------------------------------------------------------------- */ herr_t H5FS_sect_remove(H5F_t *f, H5FS_t *fspace, H5FS_section_info_t *sect) { hbool_t sinfo_valid = FALSE; /* Whether the section info is valid */ herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_NOAPI_NOINIT /* Check arguments. */ HDassert(f); HDassert(fspace); HDassert(sect); /* Get a pointer to the section info */ if(H5FS__sinfo_lock(f, fspace, H5AC__NO_FLAGS_SET) < 0) HGOTO_ERROR(H5E_FSPACE, H5E_CANTGET, FAIL, "can't get section info") sinfo_valid = TRUE; /* Perform actual section removal */ if(H5FS__sect_remove_real(fspace, sect) < 0) HGOTO_ERROR(H5E_FSPACE, H5E_CANTREMOVE, FAIL, "can't remove section") done: /* Release the section info */ if(sinfo_valid && H5FS__sinfo_unlock(f, fspace, TRUE) < 0) HDONE_ERROR(H5E_FSPACE, H5E_CANTRELEASE, FAIL, "can't release section info") FUNC_LEAVE_NOAPI(ret_value) } /* H5FS_sect_remove() */ /*------------------------------------------------------------------------- * Function: H5FS__sect_link_size * * Purpose: Add a section of free space to the free list bins * * Return: SUCCEED/FAIL * * Programmer: Quincey Koziol * Monday, March 20, 2006 * *------------------------------------------------------------------------- */ static herr_t H5FS__sect_link_size(H5FS_sinfo_t *sinfo, const H5FS_section_class_t *cls, H5FS_section_info_t *sect) { H5FS_node_t *fspace_node = NULL; /* Pointer to free space node of the correct size */ hbool_t fspace_node_alloc = FALSE; /* Whether the free space node was allocated */ unsigned bin; /* Bin to put the free space section in */ herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_STATIC #ifdef QAK HDfprintf(stderr, "%s: sect->size = %Hu, sect->addr = %a\n", FUNC, sect->size, sect->addr); #endif /* QAK */ /* Check arguments. */ HDassert(sinfo); HDassert(sect); HDassert(H5F_addr_defined(sect->addr)); HDassert(sect->size); /* Determine correct bin which holds items of the section's size */ bin = H5VM_log2_gen(sect->size); HDassert(bin < sinfo->nbins); if(sinfo->bins[bin].bin_list == NULL) { if(NULL == (sinfo->bins[bin].bin_list = H5SL_create(H5SL_TYPE_HSIZE, NULL))) HGOTO_ERROR(H5E_FSPACE, H5E_CANTCREATE, FAIL, "can't create skip list for free space nodes") } /* end if */ else { /* Check for node list of the correct size already */ fspace_node = (H5FS_node_t *)H5SL_search(sinfo->bins[bin].bin_list, &sect->size); } /* end else */ /* Check if we need to create a new skip list for nodes of this size */ if(fspace_node == NULL) { /* Allocate new free list size node */ if(NULL == (fspace_node = H5FL_MALLOC(H5FS_node_t))) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for free space node") fspace_node_alloc = TRUE; /* Initialize the free list size node */ fspace_node->sect_size = sect->size; fspace_node->serial_count = fspace_node->ghost_count = 0; if(NULL == (fspace_node->sect_list = H5SL_create(H5SL_TYPE_HADDR, NULL))) HGOTO_ERROR(H5E_FSPACE, H5E_CANTCREATE, FAIL, "can't create skip list for free space nodes") /* Insert new free space size node into bin's list */ if(H5SL_insert(sinfo->bins[bin].bin_list, fspace_node, &fspace_node->sect_size) < 0) HGOTO_ERROR(H5E_FSPACE, H5E_CANTINSERT, FAIL, "can't insert free space node into skip list") fspace_node_alloc = FALSE; /* (owned by the bin skip list now, don't need to free on error) */ /* Increment number of section sizes */ sinfo->tot_size_count++; } /* end if */ /* Increment # of section in bin */ /* (Different from the # of items in the bin's skiplist, since each node on * the bin's skiplist is also a skiplist...) */ #ifdef QAK HDfprintf(stderr, "%s: sinfo->bins[%u].sect_count = %Zu\n", FUNC, bin, sinfo->bins[bin].sect_count); #endif /* QAK */ sinfo->bins[bin].tot_sect_count++; if(cls->flags & H5FS_CLS_GHOST_OBJ) { sinfo->bins[bin].ghost_sect_count++; fspace_node->ghost_count++; /* Check for first ghost section in node */ if(fspace_node->ghost_count == 1) sinfo->ghost_size_count++; } /* end if */ else { sinfo->bins[bin].serial_sect_count++; fspace_node->serial_count++; /* Check for first serializable section in node */ if(fspace_node->serial_count == 1) sinfo->serial_size_count++; } /* end else */ /* Insert free space node into correct skip list */ if(H5SL_insert(fspace_node->sect_list, sect, &sect->addr) < 0) HGOTO_ERROR(H5E_FSPACE, H5E_CANTINSERT, FAIL, "can't insert free space node into skip list") done: if(ret_value < 0) if(fspace_node && fspace_node_alloc) { if(fspace_node->sect_list && H5SL_close(fspace_node->sect_list) < 0) HDONE_ERROR(H5E_FSPACE, H5E_CANTCLOSEOBJ, FAIL, "can't destroy size free space node's skip list") fspace_node = H5FL_FREE(H5FS_node_t, fspace_node); } /* end if */ FUNC_LEAVE_NOAPI(ret_value) } /* H5FS__sect_link_size() */ /*------------------------------------------------------------------------- * Function: H5FS__sect_link_rest * * Purpose: Link a section into the rest of the non-size tracking * free space manager data structures * * Return: SUCCEED/FAIL * * Programmer: Quincey Koziol * Wednesday, May 17, 2006 * *------------------------------------------------------------------------- */ static herr_t H5FS__sect_link_rest(H5FS_t *fspace, const H5FS_section_class_t *cls, H5FS_section_info_t *sect, unsigned flags) { herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_STATIC /* Check arguments. */ HDassert(fspace); HDassert(fspace->sinfo); HDassert(sect); /* Add section to the address-ordered list of sections, if allowed */ if(!(cls->flags & H5FS_CLS_SEPAR_OBJ)) { #ifdef QAK HDfprintf(stderr, "%s: inserting object into merge list, sect->type = %u\n", FUNC, (unsigned)sect->type); #endif /* QAK */ if(fspace->sinfo->merge_list == NULL) if(NULL == (fspace->sinfo->merge_list = H5SL_create(H5SL_TYPE_HADDR, NULL))) HGOTO_ERROR(H5E_FSPACE, H5E_CANTCREATE, FAIL, "can't create skip list for merging free space sections") if(H5SL_insert(fspace->sinfo->merge_list, sect, &sect->addr) < 0) HGOTO_ERROR(H5E_FSPACE, H5E_CANTINSERT, FAIL, "can't insert free space node into merging skip list") } /* end if */ /* Update section info & check if we need more room for the serialized free space sections */ if(H5FS__sect_increase(fspace, cls, flags) < 0) HGOTO_ERROR(H5E_FSPACE, H5E_CANTINSERT, FAIL, "can't increase free space section size on disk") /* Increment amount of free space managed */ fspace->tot_space += sect->size; done: FUNC_LEAVE_NOAPI(ret_value) } /* H5FS__sect_link_rest() */ /*------------------------------------------------------------------------- * Function: H5FS__sect_link * * Purpose: Link a section into the internal data structures * * Return: SUCCEED/FAIL * * Programmer: Quincey Koziol * Wednesday, May 17, 2006 * *------------------------------------------------------------------------- */ static herr_t H5FS__sect_link(H5FS_t *fspace, H5FS_section_info_t *sect, unsigned flags) { const H5FS_section_class_t *cls; /* Class of section */ herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_STATIC /* Check arguments. */ HDassert(fspace); HDassert(fspace->sinfo); HDassert(sect); /* Get section's class */ cls = &fspace->sect_cls[sect->type]; /* Add section to size tracked data structures */ #ifdef QAK HDfprintf(stderr, "%s: Check 1.0 - fspace->tot_space = %Hu\n", FUNC, fspace->tot_space); #endif /* QAK */ if(H5FS__sect_link_size(fspace->sinfo, cls, sect) < 0) HGOTO_ERROR(H5E_FSPACE, H5E_CANTINSERT, FAIL, "can't add section to size tracking data structures") #ifdef QAK HDfprintf(stderr, "%s: Check 2.0 - fspace->tot_space = %Hu\n", FUNC, fspace->tot_space); #endif /* QAK */ /* Update rest of free space manager data structures for section addition */ if(H5FS__sect_link_rest(fspace, cls, sect, flags) < 0) HGOTO_ERROR(H5E_FSPACE, H5E_CANTINSERT, FAIL, "can't add section to non-size tracking data structures") #ifdef QAK HDfprintf(stderr, "%s: Check 3.0 - fspace->tot_space = %Hu\n", FUNC, fspace->tot_space); #endif /* QAK */ done: FUNC_LEAVE_NOAPI(ret_value) } /* H5FS__sect_link() */ /*------------------------------------------------------------------------- * Function: H5FS__sect_merge * * Purpose: Attempt to merge a returned free space section with existing * free space. * * Return: SUCCEED/FAIL * * Programmer: Quincey Koziol * Wednesday, May 17, 2006 * *------------------------------------------------------------------------- */ static herr_t H5FS__sect_merge(H5FS_t *fspace, H5FS_section_info_t **sect, void *op_data) { H5FS_section_class_t *sect_cls; /* Section's class */ hbool_t modified; /* Flag to indicate merge or shrink occurred */ hbool_t remove_sect = FALSE; /* Whether a section should be removed before shrinking */ htri_t status; /* Status value */ herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_STATIC /* Check arguments. */ HDassert(fspace); HDassert(*sect); HDassert(H5F_addr_defined((*sect)->addr)); HDassert((*sect)->size); /* Loop until no more merging */ if(fspace->sinfo->merge_list) { do { H5SL_node_t *less_sect_node; /* Skip list node for section less than new section */ H5SL_node_t *greater_sect_node; /* Skip list node for section greater than new section */ H5FS_section_info_t *tmp_sect; /* Temporary free space section */ H5FS_section_class_t *tmp_sect_cls; /* Temporary section's class */ hbool_t greater_sect_node_valid = FALSE; /* Indicate if 'greater than' section node is valid */ /* Reset 'modification occurred' flag */ modified = FALSE; /* Look for neighboring section before new section */ less_sect_node = H5SL_below(fspace->sinfo->merge_list, &(*sect)->addr); /* Check for node before new node able to merge with new node */ if(less_sect_node) { /* Check for node greater than section */ greater_sect_node = H5SL_next(less_sect_node); greater_sect_node_valid = TRUE; /* Get section for 'less than' skip list node */ tmp_sect = (H5FS_section_info_t *)H5SL_item(less_sect_node); /* Get classes for right & left sections */ tmp_sect_cls = &fspace->sect_cls[tmp_sect->type]; sect_cls = &fspace->sect_cls[(*sect)->type]; /* Check if sections of the left most class can merge with sections * of another class & whether the sections are the same type, * then check for 'can merge' callback */ if((!(tmp_sect_cls->flags & H5FS_CLS_MERGE_SYM) || (tmp_sect->type == (*sect)->type)) && tmp_sect_cls->can_merge) { /* Determine if the sections can merge */ if((status = (*tmp_sect_cls->can_merge)(tmp_sect, *sect, op_data)) < 0) HGOTO_ERROR(H5E_FSPACE, H5E_CANTMERGE, FAIL, "can't check for merging sections") if(status > 0) { /* Sanity check */ HDassert(tmp_sect_cls->merge); /* Remove 'less than' node from data structures */ if(H5FS__sect_remove_real(fspace, tmp_sect) < 0) HGOTO_ERROR(H5E_FSPACE, H5E_CANTRELEASE, FAIL, "can't remove section from internal data structures") /* Merge the two sections together */ if((*tmp_sect_cls->merge)(&tmp_sect, *sect, op_data) < 0) HGOTO_ERROR(H5E_FSPACE, H5E_CANTINSERT, FAIL, "can't merge two sections") /* Retarget section pointer to 'less than' node that was merged into */ *sect = tmp_sect; if(*sect == NULL) HGOTO_DONE(ret_value); /* Indicate successful merge occurred */ modified = TRUE; } /* end if */ } /* end if */ } /* end if */ /* Look for section after new (or merged) section, if not already determined */ if(!greater_sect_node_valid) greater_sect_node = H5SL_above(fspace->sinfo->merge_list, &(*sect)->addr); /* Check for node after new node able to merge with new node */ if(greater_sect_node) { /* Get section for 'greater than' skip list node */ tmp_sect = (H5FS_section_info_t *)H5SL_item(greater_sect_node); /* Get classes for right & left sections */ sect_cls = &fspace->sect_cls[(*sect)->type]; tmp_sect_cls = &fspace->sect_cls[tmp_sect->type]; /* Check if sections of the left most class can merge with sections * of another class & whether the sections are the same type, * then check for 'can merge' callback */ if((!(sect_cls->flags & H5FS_CLS_MERGE_SYM) || ((*sect)->type == tmp_sect->type)) && sect_cls->can_merge) { /* Determine if the sections can merge */ if((status = (*sect_cls->can_merge)(*sect, tmp_sect, op_data)) < 0) HGOTO_ERROR(H5E_FSPACE, H5E_CANTMERGE, FAIL, "can't check for merging sections") if(status > 0) { /* Sanity check */ HDassert(sect_cls->merge); /* Remove 'greater than' node from data structures */ if(H5FS__sect_remove_real(fspace, tmp_sect) < 0) HGOTO_ERROR(H5E_FSPACE, H5E_CANTRELEASE, FAIL, "can't remove section from internal data structures") /* Merge the two sections together */ if((*sect_cls->merge)(sect, tmp_sect, op_data) < 0) HGOTO_ERROR(H5E_FSPACE, H5E_CANTINSERT, FAIL, "can't merge two sections") /* It's possible that the merge caused the section to be deleted (particularly in the paged allocation case) */ if(*sect == NULL) HGOTO_DONE(ret_value); /* Indicate successful merge occurred */ modified = TRUE; } /* end if */ } /* end if */ } /* end if */ } while(modified); } /* end if */ HDassert(*sect); #ifdef QAK HDfprintf(stderr, "%s: Done merging, (*sect) = {%a, %Hu, %u, %s}\n", FUNC, (*sect)->addr, (*sect)->size, (*sect)->type, ((*sect)->state == H5FS_SECT_LIVE ? "H5FS_SECT_LIVE" : "H5FS_SECT_SERIALIZED")); #endif /* QAK */ /* Loop until no more shrinking */ do { /* Reset 'modification occurred' flag */ modified = FALSE; /* Check for (possibly merged) section able to shrink the size of the container */ sect_cls = &fspace->sect_cls[(*sect)->type]; if(sect_cls->can_shrink) { if((status = (*sect_cls->can_shrink)(*sect, op_data)) < 0) HGOTO_ERROR(H5E_FSPACE, H5E_CANTSHRINK, FAIL, "can't check for shrinking container") if(status > 0) { #ifdef QAK HDfprintf(stderr, "%s: Can shrink!\n", FUNC); #endif /* QAK */ /* Remove SECT from free-space manager */ /* (only possible to happen on second+ pass through loop) */ if(remove_sect) { if(H5FS__sect_remove_real(fspace, *sect) < 0) HGOTO_ERROR(H5E_FSPACE, H5E_CANTRELEASE, FAIL, "can't remove section from internal data structures") remove_sect = FALSE; } /* end if */ /* Shrink the container */ /* (callback can indicate that it has discarded the section by setting *sect to NULL) */ HDassert(sect_cls->shrink); if((*sect_cls->shrink)(sect, op_data) < 0) HGOTO_ERROR(H5E_FSPACE, H5E_CANTINSERT, FAIL, "can't shrink free space container") /* If this section was shrunk away, we may need to shrink another section */ if(*sect == NULL) { /* Check for sections on merge list */ if(fspace->sinfo->merge_list) { H5SL_node_t *last_node; /* Last node in merge list */ /* Check for last node in the merge list */ if(NULL != (last_node = H5SL_last(fspace->sinfo->merge_list))) { /* Get the pointer to the last section, from the last node */ *sect = (H5FS_section_info_t *)H5SL_item(last_node); HDassert(*sect); /* Indicate that this section needs to be removed if it causes a shrink */ remove_sect = TRUE; } /* end if */ } /* end if */ } /* end if */ /* Indicate successful merge occurred */ modified = TRUE; } /* end if */ } /* end if */ } while(modified && *sect); /* Check for section that was shrunk away and next section not shrinking */ if(remove_sect && (*sect != NULL)) *sect = NULL; #ifdef QAK HDfprintf(stderr, "%s: Done shrinking\n", FUNC); if(*sect) HDfprintf(stderr, "%s: (*sect) = {%a, %Hu, %u, %s}\n", FUNC, (*sect)->addr, (*sect)->size, (*sect)->type, ((*sect)->state == H5FS_SECT_LIVE ? "H5FS_SECT_LIVE" : "H5FS_SECT_SERIALIZED")); else HDfprintf(stderr, "%s: *sect = %p\n", FUNC, *sect); #endif /* QAK */ done: #ifdef QAK HDfprintf(stderr, "%s: Leaving, ret_value = %d\n", FUNC, ret_value); #endif /* QAK */ FUNC_LEAVE_NOAPI(ret_value) } /* H5FS__sect_merge() */ /*------------------------------------------------------------------------- * Function: H5FS_sect_add * * Purpose: Add a section of free space to the free list * * Return: SUCCEED/FAIL * * Programmer: Quincey Koziol * Tuesday, March 7, 2006 * *------------------------------------------------------------------------- */ herr_t H5FS_sect_add(H5F_t *f, H5FS_t *fspace, H5FS_section_info_t *sect, unsigned flags, void *op_data) { H5FS_section_class_t *cls; /* Section's class */ hbool_t sinfo_valid = FALSE; /* Whether the section info is valid */ hbool_t sinfo_modified = FALSE; /* Whether the section info was modified */ herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_NOAPI(FAIL) #ifdef H5FS_SINFO_DEBUG HDfprintf(stderr, "%s: *sect = {%a, %Hu, %u, %s}\n", FUNC, sect->addr, sect->size, sect->type, (sect->state == H5FS_SECT_LIVE ? "H5FS_SECT_LIVE" : "H5FS_SECT_SERIALIZED")); #endif /* H5FS_SINFO_DEBUG */ /* Check arguments. */ HDassert(fspace); HDassert(sect); HDassert(H5F_addr_defined(sect->addr)); HDassert(sect->size); /* Get a pointer to the section info */ if(H5FS__sinfo_lock(f, fspace, H5AC__NO_FLAGS_SET) < 0) HGOTO_ERROR(H5E_FSPACE, H5E_CANTGET, FAIL, "can't get section info") sinfo_valid = TRUE; /* Call "add" section class callback, if there is one */ cls = &fspace->sect_cls[sect->type]; if(cls->add) if((*cls->add)(&sect, &flags, op_data) < 0) HGOTO_ERROR(H5E_FSPACE, H5E_CANTINSERT, FAIL, "'add' section class callback failed") /* Check for merging returned space with existing section node */ if(flags & H5FS_ADD_RETURNED_SPACE) { #ifdef H5FS_SINFO_DEBUG HDfprintf(stderr, "%s: Returning space\n", FUNC); #endif /* H5FS_SINFO_DEBUG */ /* Attempt to merge returned section with existing sections */ if(H5FS__sect_merge(fspace, &sect, op_data) < 0) HGOTO_ERROR(H5E_FSPACE, H5E_CANTMERGE, FAIL, "can't merge sections") } /* end if */ /* Add new (possibly merged) node to free sections data structures */ /* (If section has been completely merged or shrunk away, 'sect' will * be NULL at this point - QAK) */ if(sect) if(H5FS__sect_link(fspace, sect, flags) < 0) HGOTO_ERROR(H5E_FSPACE, H5E_CANTINSERT, FAIL, "can't insert free space section into skip list") #ifdef H5FS_SINFO_DEBUG HDfprintf(stderr, "%s: fspace->tot_space = %Hu\n", FUNC, fspace->tot_space); #endif /* H5FS_SINFO_DEBUG */ /* Mark free space sections as changed */ /* (if adding sections while deserializing sections, don't set the flag) */ if(!(flags & (H5FS_ADD_DESERIALIZING | H5FS_PAGE_END_NO_ADD))) sinfo_modified = TRUE; done: /* Release the section info */ if(sinfo_valid && H5FS__sinfo_unlock(f, fspace, sinfo_modified) < 0) HDONE_ERROR(H5E_FSPACE, H5E_CANTRELEASE, FAIL, "can't release section info") #ifdef H5FS_DEBUG_ASSERT if(!(flags & (H5FS_ADD_DESERIALIZING | H5FS_ADD_SKIP_VALID))) H5FS__assert(fspace); #endif /* H5FS_DEBUG_ASSERT */ #ifdef H5FS_SINFO_DEBUG HDfprintf(stderr, "%s: Leaving, ret_value = %d\n", FUNC, ret_value); #endif /* H5FS_SINFO_DEBUG */ FUNC_LEAVE_NOAPI(ret_value) } /* H5FS_sect_add() */ /*------------------------------------------------------------------------- * Function: H5FS_sect_try_extend * * Purpose: Try to extend a block using space from a section on the free list * * Return: SUCCEED/FAIL * * Programmer: Quincey Koziol * Tuesday, January 8, 2008 * *------------------------------------------------------------------------- */ htri_t H5FS_sect_try_extend(H5F_t *f, H5FS_t *fspace, haddr_t addr, hsize_t size, hsize_t extra_requested, unsigned flags, void *op_data) { hbool_t sinfo_valid = FALSE; /* Whether the section info is valid */ hbool_t sinfo_modified = FALSE; /* Whether the section info was modified */ htri_t ret_value = FALSE; /* Return value */ FUNC_ENTER_NOAPI(FAIL) #ifdef H5FS_SINFO_DEBUG HDfprintf(stderr, "%s: addr = %a, size = %Hu, extra_requested = %hu\n", FUNC, addr, size, extra_requested); #endif /* H5FS_SINFO_DEBUG */ /* Check arguments. */ HDassert(f); HDassert(fspace); HDassert(H5F_addr_defined(addr)); HDassert(size > 0); HDassert(extra_requested > 0); /* Check for any sections on free space list */ #ifdef H5FS_SINFO_DEBUG HDfprintf(stderr, "%s: fspace->tot_sect_count = %Hu\n", FUNC, fspace->tot_sect_count); HDfprintf(stderr, "%s: fspace->serial_sect_count = %Hu\n", FUNC, fspace->serial_sect_count); HDfprintf(stderr, "%s: fspace->ghost_sect_count = %Hu\n", FUNC, fspace->ghost_sect_count); #endif /* H5FS_SINFO_DEBUG */ if(fspace->tot_sect_count > 0) { H5FS_section_info_t *sect; /* Temporary free space section */ /* Get a pointer to the section info */ if(H5FS__sinfo_lock(f, fspace, H5AC__NO_FLAGS_SET) < 0) HGOTO_ERROR(H5E_FSPACE, H5E_CANTGET, FAIL, "can't get section info") sinfo_valid = TRUE; /* Pseudo-code for algorithm: _section_ = <Get pointer to section with address > _region.addr_> if(_section_) if(_section_ adjoins _region_ && _section.size_ >= _extra_requested_) <remove section from data structures> if(_section.size_ > _extra_requested_) if(<can adjust _section_>) <adjust _section_ by _extra_requested_> <add adjusted section back to data structures> else <re-add UNadjusted section back to data structures> <error> <mark free space sections as changed in metadata cache> */ /* Look for a section after block to extend */ if((sect = (H5FS_section_info_t *)H5SL_greater(fspace->sinfo->merge_list, &addr))) { /* Check if this section adjoins the block and is large enough to * fulfill extension request. * * (Note: we assume that the section is fully merged with any * possible neighboring nodes and is not at the end of the file * (or it would have been eliminated), etc) */ if(sect->size >= extra_requested && (addr + size) == sect->addr) { H5FS_section_class_t *cls; /* Section's class */ /* Remove section from data structures */ if(H5FS__sect_remove_real(fspace, sect) < 0) HGOTO_ERROR(H5E_FSPACE, H5E_CANTRELEASE, FAIL, "can't remove section from internal data structures") /* Get class for section */ cls = &fspace->sect_cls[sect->type]; /* Check for the section needing to be adjusted and re-added */ /* (Note: we should probably add a can_adjust/adjust callback * to the section class structure, but we don't need it * for the current usage, so I've deferred messing with * it. - QAK - 2008/01/08) */ if(sect->size > extra_requested) { /* Sanity check (for now) */ HDassert(cls->flags & H5FS_CLS_ADJUST_OK); /* Adjust section by amount requested */ sect->addr += extra_requested; sect->size -= extra_requested; if(cls->add) if((*cls->add)(&sect, &flags, op_data) < 0) HGOTO_ERROR(H5E_FSPACE, H5E_CANTINSERT, FAIL, "'add' section class callback failed") /* Re-adding the section could cause it to disappear (particularly when paging) */ if(sect) { /* Re-add adjusted section to free sections data structures */ if(H5FS__sect_link(fspace, sect, 0) < 0) HGOTO_ERROR(H5E_FSPACE, H5E_CANTINSERT, FAIL, "can't insert free space section into skip list") } /* end if */ } /* end if */ else { /* Sanity check */ HDassert(sect->size == extra_requested); /* Exact match, so just free section */ if((*cls->free)(sect) < 0) HGOTO_ERROR(H5E_FSPACE, H5E_CANTFREE, FAIL, "can't free section") } /* end else */ /* Note that we modified the section info */ sinfo_modified = TRUE; /* Indicate success */ HGOTO_DONE(TRUE); } /* end if */ } /* end if */ } /* end if */ done: /* Release the section info */ if(sinfo_valid && H5FS__sinfo_unlock(f, fspace, sinfo_modified) < 0) HDONE_ERROR(H5E_FSPACE, H5E_CANTRELEASE, FAIL, "can't release section info") FUNC_LEAVE_NOAPI(ret_value) } /* H5FS_sect_try_extend() */ /*------------------------------------------------------------------------- * Function: H5FS_sect_try_merge * * Purpose: Try to merge/shrink a block * * Return: TRUE: merged/shrunk * FALSE: not merged/not shrunk * Failure: negative * * Programmer: Vailin Choi * June 10, 2009 * *------------------------------------------------------------------------- */ htri_t H5FS_sect_try_merge(H5F_t *f, H5FS_t *fspace, H5FS_section_info_t *sect, unsigned flags, void *op_data) { hbool_t sinfo_valid = FALSE; /* Whether the section info is valid */ hbool_t sinfo_modified = FALSE; /* Whether the section info was modified */ hsize_t saved_fs_size; /* Copy of the free-space section size */ htri_t ret_value = FALSE; /* Return value */ FUNC_ENTER_NOAPI(FAIL) /* Check arguments. */ HDassert(f); HDassert(fspace); HDassert(sect); HDassert(H5F_addr_defined(sect->addr)); HDassert(sect->size); /* Get a pointer to the section info */ if(H5FS__sinfo_lock(f, fspace, H5AC__NO_FLAGS_SET) < 0) HGOTO_ERROR(H5E_FSPACE, H5E_CANTGET, FAIL, "can't get section info") sinfo_valid = TRUE; saved_fs_size = sect->size; /* Attempt to merge/shrink section with existing sections */ if(H5FS__sect_merge(fspace, &sect, op_data) < 0) HGOTO_ERROR(H5E_FSPACE, H5E_CANTMERGE, FAIL, "can't merge sections") /* Check if section is shrunk and/or merged away completely */ if(!sect) { sinfo_modified = TRUE; HGOTO_DONE(TRUE) } /* end if */ else { /* Check if section is merged */ if(sect->size > saved_fs_size) { if(H5FS__sect_link(fspace, sect, flags) < 0) HGOTO_ERROR(H5E_FSPACE, H5E_CANTINSERT, FAIL, "can't insert free space section into skip list") sinfo_modified = TRUE; HGOTO_DONE(TRUE) } /* end if */ } /* end else */ done: /* Release the section info */ if(sinfo_valid && H5FS__sinfo_unlock(f, fspace, sinfo_modified) < 0) HDONE_ERROR(H5E_FSPACE, H5E_CANTRELEASE, FAIL, "can't release section info") FUNC_LEAVE_NOAPI(ret_value) } /* H5FS_sect_try_merge() */ /*-------------------------------------------------------------------------


context:
space:
mode: