diff options
author | Quincey Koziol <koziol@koziol.gov> | 2020-04-20 23:12:00 (GMT) |
---|---|---|
committer | David Young <dyoung@hdfgroup.org> | 2020-05-20 14:37:19 (GMT) |
commit | d35daa45e90c46670ee160fa7437a573b24a90ad (patch) | |
tree | bd8d903e14d2f230caabdd48a39a1d3e19cb4237 /src/H5MF.c | |
parent | 071fe1dc3979932b12f23cb7cc5a61f860367cf2 (diff) | |
download | hdf5-d35daa45e90c46670ee160fa7437a573b24a90ad.zip hdf5-d35daa45e90c46670ee160fa7437a573b24a90ad.tar.gz hdf5-d35daa45e90c46670ee160fa7437a573b24a90ad.tar.bz2 |
Trim trailing whitespace
Diffstat (limited to 'src/H5MF.c')
-rw-r--r-- | src/H5MF.c | 210 |
1 files changed, 105 insertions, 105 deletions
@@ -105,7 +105,7 @@ static herr_t H5MF__close_shrink_eoa(H5F_t *f); static herr_t H5MF__get_free_sects(H5F_t *f, H5FS_t *fspace, H5MF_sect_iter_ud_t *sect_udata, size_t *nums); static hbool_t H5MF__fsm_type_is_self_referential(H5F_shared_t *f_sh, H5F_mem_page_t fsm_type); static hbool_t H5MF__fsm_is_self_referential(H5F_shared_t *f_sh, H5FS_t *fspace); -static herr_t H5MF__continue_alloc_fsm(H5F_shared_t *f_sh, H5FS_t *sm_hdr_fspace, H5FS_t *sm_sinfo_fspace, +static herr_t H5MF__continue_alloc_fsm(H5F_shared_t *f_sh, H5FS_t *sm_hdr_fspace, H5FS_t *sm_sinfo_fspace, H5FS_t *lg_hdr_fspace, H5FS_t *lg_sinfo_fspace, hbool_t *continue_alloc_fsm); /* Free-space type manager routines */ @@ -1473,7 +1473,7 @@ H5MF_try_extend(H5F_t *f, H5FD_mem_t alloc_type, haddr_t addr, hsize_t size, end = addr + size; /* For paged aggregation: - * To extend a small block: can only extend if not crossing page boundary + * To extend a small block: can only extend if not crossing page boundary * To extend a large block at EOA: calculate in advance mis-aligned fragment so EOA will still end at page boundary */ if(H5F_PAGED_AGGR(f)) { @@ -1822,8 +1822,8 @@ HDfprintf(stderr, "%s: Entering\n", FUNC); /* check args */ HDassert(f); - /* If there have been no file space allocations / deallocation so - * far, must call H5MF_tidy_self_referential_fsm_hack() to float + /* If there have been no file space allocations / deallocation so + * far, must call H5MF_tidy_self_referential_fsm_hack() to float * all self referential FSMs and release file space allocated to * them. Otherwise, the function will be called after the format * conversion, and will become very confused. @@ -1961,9 +1961,9 @@ HDfprintf(stderr, "%s: Entering\n", FUNC); */ HDassert(H5F_addr_defined(f->shared->sblock->ext_addr)); - /* file space for all non-empty free space managers should be + /* file space for all non-empty free space managers should be * allocated at this point, and these free space managers should - * be written to file and thus their headers and section info + * be written to file and thus their headers and section info * entries in the metadata cache should be clean. */ @@ -2034,8 +2034,8 @@ HDfprintf(stderr, "%s: Entering\n", FUNC); if(HADDR_UNDEF == (final_eoa = H5FD_get_eoa(f->shared->lf, H5FD_MEM_DEFAULT)) ) HGOTO_ERROR(H5E_FILE, H5E_CANTGET, FAIL, "unable to get file size") - /* f->shared->eoa_post_fsm_fsalloc is undefined if there has - * been no file space allocation or deallocation since file + /* f->shared->eoa_post_fsm_fsalloc is undefined if there has + * been no file space allocation or deallocation since file * open. */ HDassert(H5F_NULL_FSM_ADDR(f) || final_eoa == f->shared->eoa_fsm_fsalloc); @@ -2195,13 +2195,13 @@ HDfprintf(stderr, "%s: Entering\n", FUNC); * been no file space allocation or deallocation since file * open. * - * If there is a cache image in the file at file open, - * f->shared->first_alloc_dealloc will always be FALSE unless + * If there is a cache image in the file at file open, + * f->shared->first_alloc_dealloc will always be FALSE unless * the file is opened R/O, as otherwise, the image will have been * read and discarded by this point. * - * If a cache image was created on file close, the actual EOA - * should be in f->shared->eoa_post_mdci_fsalloc. Note that in + * If a cache image was created on file close, the actual EOA + * should be in f->shared->eoa_post_mdci_fsalloc. Note that in * this case, it is conceivable that f->shared->first_alloc_dealloc * will still be TRUE, as the cache image is allocated directly from * the file driver layer. However, as this possibility seems remote, @@ -2213,8 +2213,8 @@ HDfprintf(stderr, "%s: Entering\n", FUNC); (final_eoa == f->shared->eoa_post_mdci_fsalloc))); } /* end if */ else { - /* Iterate over all the free space types that have managers - * and get each free list's space + /* Iterate over all the free space types that have managers + * and get each free list's space */ for(ptype = H5F_MEM_PAGE_META; ptype < H5F_MEM_PAGE_NTYPES; ptype++) if(H5MF__close_delete_fstype(f, ptype) < 0) @@ -2529,16 +2529,16 @@ H5MF_get_free_sections(H5F_t *f, H5FD_mem_t type, size_t nsects, H5F_sect_info_t HDassert(f->shared); HDassert(f->shared->lf); - /* H5MF_tidy_self_referential_fsm_hack() will fail if any self + /* H5MF_tidy_self_referential_fsm_hack() will fail if any self * referential FSM is opened prior to the call to it. Thus call * it here if necessary and if it hasn't been called already. * * The situation is further complicated if a cache image exists * and had not yet been loaded into the metadata cache. In this - * case, call H5AC_force_cache_image_load() instead of + * case, call H5AC_force_cache_image_load() instead of * H5MF_tidy_self_referential_fsm_hack(). H5AC_force_cache_image_load() - * will load the cache image, and then call - * H5MF_tidy_self_referential_fsm_hack() to discard the cache image + * will load the cache image, and then call + * H5MF_tidy_self_referential_fsm_hack() to discard the cache image * block. */ @@ -2693,50 +2693,50 @@ done: /*------------------------------------------------------------------------- * Function: H5MF_settle_raw_data_fsm() * - * Purpose: Handle any tasks required before the metadata cache + * Purpose: Handle any tasks required before the metadata cache * can serialize or flush the raw data free space manager - * and any metadata free space managers that reside in the + * and any metadata free space managers that reside in the * raw data free space manager ring. * - * Specifically, this means any metadata managers that DON'T - * handle space allocation for free space manager header or - * section info will reside in the raw data free space manager + * Specifically, this means any metadata managers that DON'T + * handle space allocation for free space manager header or + * section info will reside in the raw data free space manager * ring. * - * In the absence of page allocation, there is at most one + * In the absence of page allocation, there is at most one * free space manager per memory type defined in H5F_mem_t. - * Of these, the one that allocates H5FD_MEM_DRAW will + * Of these, the one that allocates H5FD_MEM_DRAW will * always reside in the raw data free space manager ring. - * If there is more than one metadata free space manager, - * all that don't handle H5FD_MEM_FSPACE_HDR or - * H5FD_MEM_FSPACE_SINFO (which map to H5FD_MEM_OHDR and - * H5FD_MEM_LHEAP respectively) will reside in the raw + * If there is more than one metadata free space manager, + * all that don't handle H5FD_MEM_FSPACE_HDR or + * H5FD_MEM_FSPACE_SINFO (which map to H5FD_MEM_OHDR and + * H5FD_MEM_LHEAP respectively) will reside in the raw * data free space manager ring as well * - * With page allocation, the situation is conceptually + * With page allocation, the situation is conceptually * identical, but more complex in practice. * - * In the worst case (multi file driver) page allocation - * can result in two free space managers for each memory + * In the worst case (multi file driver) page allocation + * can result in two free space managers for each memory * type -- one for small (less than on equal to one page) * allocations, and one for large (greater than one page) * allocations. * * In the more common one file case, page allocation will - * result in a total of three free space managers -- one for - * small (<= one page) raw data allocations, one for small - * metadata allocations (i.e, all memory types other than - * H5FD_MEM_DRAW), and one for all large (> one page) + * result in a total of three free space managers -- one for + * small (<= one page) raw data allocations, one for small + * metadata allocations (i.e, all memory types other than + * H5FD_MEM_DRAW), and one for all large (> one page) * allocations. * * Despite these complications, the solution is the same in - * the page allocation case -- free space managers (be they - * small data or large) are assigned to the raw data free + * the page allocation case -- free space managers (be they + * small data or large) are assigned to the raw data free * space manager ring if they don't allocate file space for - * free space managers. Note that in the one file case, the + * free space managers. Note that in the one file case, the * large free space manager must be assigned to the metadata - * free space manager ring, as it both allocates pages for - * the metadata free space manager, and allocates space for + * free space manager ring, as it both allocates pages for + * the metadata free space manager, and allocates space for * large (> 1 page) metadata cache entries. * * At present, the task list for this routine is: @@ -2746,14 +2746,14 @@ done: * a) Free both aggregators. Space not at EOA will be * added to the appropriate free space manager. * - * The raw data aggregator should not be restarted + * The raw data aggregator should not be restarted * after this point. It is possible that the metadata * aggregator will be. * * b) Free all file space currently allocated to free * space managers. * - * c) Delete the free space manager superblock + * c) Delete the free space manager superblock * extension message if allocated. * * This done, reduce the EOA by moving it to just before @@ -2761,23 +2761,23 @@ done: * * 2) Ensure that space is allocated for the free space * manager superblock extension message. Must do this - * now, before reallocating file space for free space + * now, before reallocating file space for free space * managers, as it is possible that this allocation may * grab the last section in a FSM -- making it unnecessary * to re-allocate file space for it. * * 3) Scan all free space managers not involved in allocating * space for free space managers. For each such free space - * manager, test to see if it contains free space. If + * manager, test to see if it contains free space. If * it does, allocate file space for its header and section - * data. If it contains no free space, leave it without - * allocated file space as there is no need to save it to + * data. If it contains no free space, leave it without + * allocated file space as there is no need to save it to * file. * * Note that all free space managers in this class should - * see no further space allocations / deallocations as - * at this point, all raw data allocations should be - * finalized, as should all metadata allocations not + * see no further space allocations / deallocations as + * at this point, all raw data allocations should be + * finalized, as should all metadata allocations not * involving free space managers. * * We will allocate space for free space managers involved @@ -2812,7 +2812,7 @@ H5MF_settle_raw_data_fsm(H5F_t *f, hbool_t *fsm_settled) HDassert(f->shared); HDassert(fsm_settled); - /* + /* * Only need to settle things if we are persisting free space and * the private property in f->shared->null_fsm_addr is not enabled. */ @@ -2847,7 +2847,7 @@ H5MF_settle_raw_data_fsm(H5F_t *f, hbool_t *fsm_settled) * Note that while the raw data aggregator should not be restarted during * the close process, this need not be the case for the metadata aggregator. * - * Note also that the aggregators will not exist if page aggregation + * Note also that the aggregators will not exist if page aggregation * is enabled -- skip this if so. */ /* Vailin -- is this correct? */ @@ -2883,10 +2883,10 @@ H5MF_settle_raw_data_fsm(H5F_t *f, hbool_t *fsm_settled) * referential nature of the problem. These FSMs are dealt with in * H5MF_settle_meta_data_fsm(). * - * Since paged allocation may be enabled, there may be up to two + * Since paged allocation may be enabled, there may be up to two * free space managers per memory type -- one for small and one for * large allocation. Hence we must loop over the memory types twice - * setting the allocation size accordingly if paged allocation is + * setting the allocation size accordingly if paged allocation is * enabled. */ for(pass_count = 0; pass_count <= 1; pass_count++) { @@ -2947,7 +2947,7 @@ H5MF_settle_raw_data_fsm(H5F_t *f, hbool_t *fsm_settled) /* Check if the free space manager has space in the file */ if(H5F_addr_defined(fs_stat.addr) || H5F_addr_defined(fs_stat.sect_addr)) { - /* Delete the free space manager in the file. Will + /* Delete the free space manager in the file. Will * reallocate later if the free space manager contains * any free space. */ @@ -2972,7 +2972,7 @@ H5MF_settle_raw_data_fsm(H5F_t *f, hbool_t *fsm_settled) * extension messages will choke if the target message is * unexpectedly either absent or present. * - * Update: This is probably unnecessary, as I gather that the + * Update: This is probably unnecessary, as I gather that the * file space manager info message is guaranteed to exist. * Leave it in for now, but consider removing it. */ @@ -3075,9 +3075,9 @@ H5MF_settle_raw_data_fsm(H5F_t *f, hbool_t *fsm_settled) fsm_visited[fsm_type] = TRUE; if(f->shared->fs_man[fsm_type]) { - /* Only allocate file space if the target free space manager - * doesn't allocate file space for free space managers. Note - * that this is also the deciding factor as to whether a FSM + /* Only allocate file space if the target free space manager + * doesn't allocate file space for free space managers. Note + * that this is also the deciding factor as to whether a FSM * in in the raw data FSM ring. */ if(!H5MF__fsm_type_is_self_referential(f->shared, fsm_type)) { @@ -3159,15 +3159,15 @@ done: /*------------------------------------------------------------------------- * Function: H5MF_settle_meta_data_fsm() * - * Purpose: If the free space manager is persistent, handle any tasks - * required before the metadata cache can serialize or flush - * the metadata free space manager(s) that handle file space + * Purpose: If the free space manager is persistent, handle any tasks + * required before the metadata cache can serialize or flush + * the metadata free space manager(s) that handle file space * allocation for free space managers. * - * In most cases, there will be only one manager assigned + * In most cases, there will be only one manager assigned * to this role. However, since for reasons unknown, - * free space manager headers and section info blocks are - * different classes of memory, it is possible that two free + * free space manager headers and section info blocks are + * different classes of memory, it is possible that two free * space managers will be involved. * * On entry to this function, the raw data settle routine @@ -3184,23 +3184,23 @@ done: * 5) Re-created the free space manager superblock extension * message. * - * 6) Reallocated file space for all non-empty free space - * managers NOT involved in allocation of space for free + * 6) Reallocated file space for all non-empty free space + * managers NOT involved in allocation of space for free * space managers. * * Note that these free space managers (if not empty) should * have been written to file by this point, and that no - * further space allocations involving them should take + * further space allocations involving them should take * place during file close. * * On entry to this routine, the free space manager(s) involved * in allocation of file space for free space managers should - * still be floating. (i.e. should not have any file space + * still be floating. (i.e. should not have any file space * allocated to them.) * - * Similarly, the raw data aggregator should not have been - * restarted. Note that it is probable that reallocation of - * space in 5) and 6) above will have re-started the metadata + * Similarly, the raw data aggregator should not have been + * restarted. Note that it is probable that reallocation of + * space in 5) and 6) above will have re-started the metadata * aggregator. * * @@ -3212,35 +3212,35 @@ done: * 2) Free the aggregators. * * 3) Reduce the EOA to the extent possible, and make note - * of the resulting value. This value will be stored + * of the resulting value. This value will be stored * in the fsinfo superblock extension message and be used * in the subsequent file open. * * 4) Re-allocate space for any free space manager(s) that: * - * a) are involved in allocation of space for free space - * managers, and + * a) are involved in allocation of space for free space + * managers, and * * b) contain free space. * - * It is possible that we could allocate space for one - * of these free space manager(s) only to have the allocation - * result in the free space manager being empty and thus + * It is possible that we could allocate space for one + * of these free space manager(s) only to have the allocation + * result in the free space manager being empty and thus * obliging us to free the space again. Thus there is the * potential for an infinite loop if we want to avoid saving * empty free space managers. * - * Similarly, it is possible that we could allocate space - * for a section info block, only to discover that this - * allocation has changed the size of the section info -- + * Similarly, it is possible that we could allocate space + * for a section info block, only to discover that this + * allocation has changed the size of the section info -- * forcing us to deallocate and start the loop over again. * - * The solution is to modify the FSM code to + * The solution is to modify the FSM code to * save empty FSMs to file, and to allow section info blocks * to be oversized. That is, only allow section info to increase * in size, not shrink. The solution is now implemented. * - * 5) Make note of the EOA -- used for sanity checking on + * 5) Make note of the EOA -- used for sanity checking on * FSM shutdown. This is saved as eoa_pre_fsm_fsalloc in * the free-space info message for backward compatibility * with the 1.10 library that has the hack. @@ -3276,7 +3276,7 @@ H5MF_settle_meta_data_fsm(H5F_t *f, hbool_t *fsm_settled) HDassert(f->shared); HDassert(fsm_settled); - /* + /* * Only need to settle things if we are persisting free space and * the private property in f->shared->null_fsm_addr is not enabled. */ @@ -3361,8 +3361,8 @@ H5MF_settle_meta_data_fsm(H5F_t *f, hbool_t *fsm_settled) HDassert(fs_stat.alloc_sect_size == 0); } /* end if */ - /* Verify that lg_sinfo_fspace is floating if it - * exists and is distinct + /* Verify that lg_sinfo_fspace is floating if it + * exists and is distinct */ if((lg_sinfo_fspace) && (lg_hdr_fspace != lg_sinfo_fspace)) { /* Query free space manager info for this type */ @@ -3381,7 +3381,7 @@ H5MF_settle_meta_data_fsm(H5F_t *f, hbool_t *fsm_settled) * H5MF_free_aggrs() call. Note that the raw data aggregator must * have already been freed. Sanity checks for this? * - * Note that the aggregators will not exist if paged aggregation + * Note that the aggregators will not exist if paged aggregation * is enabled -- don't attempt to free if this is the case. */ /* (for space not at EOF, it may be put into free space managers) */ @@ -3392,30 +3392,30 @@ H5MF_settle_meta_data_fsm(H5F_t *f, hbool_t *fsm_settled) if(H5MF__close_shrink_eoa(f) < 0) HGOTO_ERROR(H5E_RESOURCE, H5E_CANTSHRINK, FAIL, "can't shrink eoa") - /* WARNING: This approach settling the self referential free space - * managers and allocating space for them in the file will - * not work as currently implemented with the split and - * multi file drivers, as the self referential free space - * manager header and section info can be stored in up to - * two different files -- requiring that up to two EOA's - * be stored in the the free space managers super block - * extension message. + /* WARNING: This approach settling the self referential free space + * managers and allocating space for them in the file will + * not work as currently implemented with the split and + * multi file drivers, as the self referential free space + * manager header and section info can be stored in up to + * two different files -- requiring that up to two EOA's + * be stored in the the free space managers super block + * extension message. * - * As of this writing, we are solving this problem by - * simply not supporting persistent FSMs with the split + * As of this writing, we are solving this problem by + * simply not supporting persistent FSMs with the split * and multi file drivers. * - * Current plans are to do away with the multi file + * Current plans are to do away with the multi file * driver, so this should be a non-issue in this case. * - * We should be able to support the split file driver - * without a file format change. However, the code to + * We should be able to support the split file driver + * without a file format change. However, the code to * do so does not exist at present. * NOTE: not sure whether to remove or keep the above comments */ - /* - * Continue allocating file space for the header and section info until + /* + * Continue allocating file space for the header and section info until * they are all settled, */ do { @@ -3452,8 +3452,8 @@ H5MF_settle_meta_data_fsm(H5F_t *f, hbool_t *fsm_settled) /* All free space managers should have file space allocated for them * now, and should see no further allocations / deallocations. - * For backward compatibility, store the eoa in f->shared->eoa_fsm_fsalloc - * which will be set to fsinfo.eoa_pre_fsm_fsalloc when we actually write + * For backward compatibility, store the eoa in f->shared->eoa_fsm_fsalloc + * which will be set to fsinfo.eoa_pre_fsm_fsalloc when we actually write * the free-space info message to the superblock extension. * This will allow the 1.10 library with the hack to open the file with * the new solution. @@ -3494,7 +3494,7 @@ done: *------------------------------------------------------------------------- */ static herr_t -H5MF__continue_alloc_fsm(H5F_shared_t *f_sh, H5FS_t *sm_hdr_fspace, H5FS_t *sm_sinfo_fspace, +H5MF__continue_alloc_fsm(H5F_shared_t *f_sh, H5FS_t *sm_hdr_fspace, H5FS_t *sm_sinfo_fspace, H5FS_t *lg_hdr_fspace, H5FS_t *lg_sinfo_fspace, hbool_t *continue_alloc_fsm) { FUNC_ENTER_NOAPI_NOINIT_NOERR |