From 0863d303729a1008b5954984adffa8223997fc2f Mon Sep 17 00:00:00 2001 From: Neil Fortner Date: Tue, 8 Feb 2011 12:32:56 -0500 Subject: [svn-r20064] Purpose: Implement external file cache Description: Implements a cache of files opened through external links. Adds the public functions H5Pset_elink_file_cache_size(), H5Pget_elink_file_cache_size(), and H5Frelease_file_cache(). Tested: jam, amani, heiwa (h5committest), fedora 64. --- MANIFEST | 2 + src/CMakeLists.txt | 1 + src/H5F.c | 62 + src/H5Fefc.c | 951 +++++++++++++++ src/H5Fpkg.h | 12 + src/H5Fprivate.h | 6 + src/H5Fpublic.h | 1 + src/H5Lexternal.c | 31 +- src/H5Pfapl.c | 85 ++ src/H5Ppublic.h | 2 + src/Makefile.am | 4 +- src/Makefile.in | 31 +- test/CMakeLists.txt | 8 + test/Makefile.am | 4 +- test/Makefile.in | 22 +- test/efc.c | 3213 +++++++++++++++++++++++++++++++++++++++++++++++++++ test/links.c | 528 ++++++++- 17 files changed, 4872 insertions(+), 91 deletions(-) create mode 100644 src/H5Fefc.c create mode 100644 test/efc.c diff --git a/MANIFEST b/MANIFEST index 790d556..dd9c0dc 100644 --- a/MANIFEST +++ b/MANIFEST @@ -523,6 +523,7 @@ ./src/H5Faccum.c ./src/H5Fdbg.c ./src/H5Fdeprec.c +./src/H5Fefc.c ./src/H5Ffake.c ./src/H5Fio.c ./src/H5Fmount.c @@ -830,6 +831,7 @@ ./test/dtypes.c ./test/dtransform.c ./test/earray.c +./test/efc.c ./test/enum.c ./test/extend.c ./test/external.c diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 3330b8b..93370c0 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -145,6 +145,7 @@ SET (H5F_SRCS ${HDF5_SRC_DIR}/H5Faccum.c ${HDF5_SRC_DIR}/H5Fdbg.c ${HDF5_SRC_DIR}/H5Fdeprec.c + ${HDF5_SRC_DIR}/H5Fefc.c ${HDF5_SRC_DIR}/H5Ffake.c ${HDF5_SRC_DIR}/H5Fio.c ${HDF5_SRC_DIR}/H5Fmount.c diff --git a/src/H5F.c b/src/H5F.c index 46d9407..f84dea2 100644 --- a/src/H5F.c +++ b/src/H5F.c @@ -292,6 +292,7 @@ H5F_get_access_plist(H5F_t *f, hbool_t app_ref) H5P_genplist_t *new_plist; /* New property list */ H5P_genplist_t *old_plist; /* Old property list */ void *driver_info=NULL; + unsigned efc_size = 0; hid_t ret_value = SUCCEED; FUNC_ENTER_NOAPI(H5F_get_access_plist, FAIL) @@ -330,6 +331,10 @@ H5F_get_access_plist(H5F_t *f, hbool_t app_ref) HGOTO_ERROR(H5E_PLIST, H5E_CANTSET, FAIL, "can't set 'small data' cache size") if(H5P_set(new_plist, H5F_ACS_LATEST_FORMAT_NAME, &(f->shared->latest_format)) < 0) HGOTO_ERROR(H5E_PLIST, H5E_CANTSET, FAIL, "can't set 'latest format' flag") + if(f->shared->efc) + efc_size = H5F_efc_max_nfiles(f->shared->efc); + if(H5P_set(new_plist, H5F_ACS_EFC_SIZE_NAME, &efc_size) < 0) + HGOTO_ERROR(H5E_PLIST, H5E_CANTGET, FAIL, "can't set elink file cache size") /* * Since we're resetting the driver ID and info, close them if they @@ -840,6 +845,7 @@ H5F_new(H5F_file_t *shared, hid_t fcpl_id, hid_t fapl_id, H5FD_t *lf) } /* end if */ else { H5P_genplist_t *plist; /* Property list */ + unsigned efc_size; /* External file cache size */ size_t u; /* Local index variable */ HDassert(lf != NULL); @@ -902,6 +908,11 @@ H5F_new(H5F_file_t *shared, hid_t fcpl_id, hid_t fapl_id, H5FD_t *lf) if(H5P_get(plist, H5F_ACS_SDATA_BLOCK_SIZE_NAME, &(f->shared->sdata_aggr.alloc_size)) < 0) HGOTO_ERROR(H5E_PLIST, H5E_CANTGET, NULL, "can't get 'small data' cache size") f->shared->sdata_aggr.feature_flag = H5FD_FEAT_AGGREGATE_SMALLDATA; + if(H5P_get(plist, H5F_ACS_EFC_SIZE_NAME, &efc_size) < 0) + HGOTO_ERROR(H5E_PLIST, H5E_CANTGET, NULL, "can't get elink file cache size") + if(efc_size > 0) + if(NULL == (f->shared->efc = H5F_efc_create(efc_size))) + HGOTO_ERROR(H5E_FILE, H5E_CANTINIT, NULL, "can't create external file cache") /* Get the VFD values to cache */ f->shared->maxaddr = H5FD_get_maxaddr(lf); @@ -998,6 +1009,13 @@ H5F_dest(H5F_t *f, hid_t dxpl_id, hbool_t flush) if(H5F_flush(f, dxpl_id) < 0) HDONE_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "unable to flush cache") + /* Release the external file cache */ + if(f->shared->efc) { + if(H5F_efc_destroy(f->shared->efc) < 0) + HDONE_ERROR(H5E_FILE, H5E_CANTRELEASE, FAIL, "can't destroy external file cache") + f->shared->efc = NULL; + } /* end if */ + /* Release objects that depend on the superblock being initialized */ if(f->shared->sblock) { /* Shutdown file free space manager(s) */ @@ -1903,6 +1921,13 @@ H5F_try_close(H5F_t *f) if(H5F_close_mounts(f) < 0) HGOTO_ERROR(H5E_FILE, H5E_CANTCLOSEFILE, FAIL, "can't unmount child files") + /* If there is more than one reference to the shared file struct and the + * file has an external file cache, we should see if it can be closed. This + * can happen if a cycle is formed with external file caches */ + if(f->shared->efc && (f->shared->nrefs > 1)) + if(H5F_efc_try_close(f) < 0) + HGOTO_ERROR(H5E_FILE, H5E_CANTRELEASE, FAIL, "can't attempt to close EFC") + /* Delay flush until the shared file struct is closed, in H5F_dest. If the * application called H5Fclose, it would have been flushed in that function * (unless it will have been flushed in H5F_dest anyways). */ @@ -2929,3 +2954,40 @@ done: FUNC_LEAVE_API(ret_value) } /* end H5Fget_free_sections() */ + +/*------------------------------------------------------------------------- + * Function: H5Frelease_file_cache + * + * Purpose: Releases the external file cache associated with the + * provided file, potentially closing any cached files + * unless they are held open from somewhere\ else. + * + * Return: Success: non-negative + * Failure: negative + * + * Programmer: Neil Fortner; December 30, 2010 + * + *------------------------------------------------------------------------- + */ +herr_t +H5Frelease_file_cache(hid_t file_id) +{ + H5F_t *file; /* File */ + herr_t ret_value = SUCCEED; /* Return value */ + + FUNC_ENTER_API(H5Frelease_file_cache, FAIL) + H5TRACE1("e", "i", file_id); + + /* Check args */ + if(NULL == (file = (H5F_t *)H5I_object_verify(file_id, H5I_FILE))) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "not a file ID") + + /* Release the EFC */ + if(file->shared->efc) + if(H5F_efc_release(file->shared->efc) < 0) + HGOTO_ERROR(H5E_FILE, H5E_CANTRELEASE, FAIL, "can't release external file cache") + +done: + FUNC_LEAVE_API(ret_value) +} /* end H5Frelease_file_cache() */ + diff --git a/src/H5Fefc.c b/src/H5Fefc.c new file mode 100644 index 0000000..eebf143 --- /dev/null +++ b/src/H5Fefc.c @@ -0,0 +1,951 @@ +/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * + * 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 files COPYING and Copyright.html. COPYING can be found at the root * + * of the source code distribution tree; Copyright.html can be found at the * + * root level of an installed copy of the electronic HDF5 document set and * + * is linked from the top-level documents page. It can also be found at * + * http://hdfgroup.org/HDF5/doc/Copyright.html. If you do not have * + * access to either file, you may request a copy from help@hdfgroup.org. * + * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ + +/*------------------------------------------------------------------------- + * + * Created: H5Defc.c + * December 13, 2010 + * Neil Fortner + * + * Purpose: External file caching routines - implements a + * cache of external files to minimize the number of + * file opens and closes. + * + *------------------------------------------------------------------------- + */ + +#define H5F_PACKAGE /*suppress error about including H5Fpkg */ + + +/* Packages needed by this file... */ +#include "H5private.h" /* Generic Functions */ +#include "H5Eprivate.h" /* Error handling */ +#include "H5Fpkg.h" /* File access */ +#include "H5MMprivate.h" /* Memory management */ +#include "H5Pprivate.h" /* Property lists */ + + +/* Special values for the "tag" field below */ +#define H5F_EFC_TAG_DEFAULT -1 +#define H5F_EFC_TAG_LOCK -2 +#define H5F_EFC_TAG_CLOSE -3 +#define H5F_EFC_TAG_DONTCLOSE -4 + +/* Structure for each entry in a file's external file cache */ +typedef struct H5F_efc_ent_t { + char *name; /* Name of the file */ + H5F_t *file; /* File object */ + struct H5F_efc_ent_t *LRU_next; /* Next item in LRU list */ + struct H5F_efc_ent_t *LRU_prev; /* Previous item in LRU list */ + unsigned nopen; /* Number of times this file is currently opened by an EFC client */ +} H5F_efc_ent_t; + +/* Structure for a shared file struct's external file cache */ +struct H5F_efc_t { + H5SL_t *slist; /* Skip list of cached external files */ + H5F_efc_ent_t *LRU_head; /* Head of LRU list. This is the least recently used file */ + H5F_efc_ent_t *LRU_tail; /* Tail of LRU list. This is the most recently used file */ + unsigned nfiles; /* Size of the external file cache */ + unsigned max_nfiles; /* Maximum size of the external file cache */ + unsigned nrefs; /* Number of times this file appears in another file's EFC */ + int tag; /* Temporary variable used by H5F_efc_try_close() */ + H5F_file_t *tmp_next; /* Next file in temporary list used by H5F_efc_try_close() */ +}; + +/* Private prototypes */ +static herr_t H5F_efc_remove_ent(H5F_efc_t *efc, H5F_efc_ent_t *ent); +static void H5F_efc_try_close_tag1(H5F_file_t *sf, H5F_file_t **tail); +static void H5F_efc_try_close_tag2(H5F_file_t *sf, H5F_file_t **tail); + +/* Free lists */ +H5FL_DEFINE_STATIC(H5F_efc_ent_t); +H5FL_DEFINE_STATIC(H5F_efc_t); + + +/*------------------------------------------------------------------------- + * Function: H5F_efc_create + * + * Purpose: Allocate and initialize a new external file cache object, + * which can the be used to cache open external files. + * the object must be freed with H5F_efc_destroy. + * + * Return: Pointer to new external file cache object on success + * NULL on failure + * + * Programmer: Neil Fortner + * Tuesday, December 14, 2010 + * + *------------------------------------------------------------------------- + */ +H5F_efc_t * +H5F_efc_create(unsigned max_nfiles) +{ + H5F_efc_t *efc = NULL; /* EFC object */ + H5F_efc_t *ret_value; /* Return value */ + + FUNC_ENTER_NOAPI(H5F_efc_create, NULL) + + /* Sanity checks */ + HDassert(max_nfiles > 0); + + /* Allocate EFC struct */ + if(NULL == (efc = H5FL_CALLOC(H5F_efc_t))) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed") + + /* Initialize maximum number of files */ + efc->max_nfiles = max_nfiles; + + /* Initialize temporary ref count */ + efc->tag = H5F_EFC_TAG_DEFAULT; + + /* Set the return value */ + ret_value = efc; + +done: + if(ret_value == NULL && efc) + efc = H5FL_FREE(H5F_efc_t, efc); + + FUNC_LEAVE_NOAPI(ret_value) +} /* end H5F_efc_create() */ + + +/*------------------------------------------------------------------------- + * Function: H5F_efc_open + * + * Purpose: Opens a file using the external file cache. The target + * file is added to the external file cache of the parent + * if it is not already present. If the target file is in + * the parent's EFC, simply returns the target file. When + * the file object is no longer in use, it should be closed + * with H5F_efc_close (will not actually close the file + * until it is evicted from the EFC). + * + * Return: Pointer to open file on success + * NULL on failure + * + * Programmer: Neil Fortner + * Tuesday, December 14, 2010 + * + *------------------------------------------------------------------------- + */ +H5F_t * +H5F_efc_open(H5F_t *parent, const char *name, unsigned flags, hid_t fcpl_id, + hid_t fapl_id, hid_t dxpl_id) +{ + H5F_efc_t *efc = NULL; /* External file cache for parent file */ + H5F_efc_ent_t *ent = NULL; /* Entry for target file in efc */ + hbool_t open_file = FALSE; /* Whether ent->file needs to be closed in case of error */ + H5F_t *ret_value; /* Return value */ + + FUNC_ENTER_NOAPI_NOINIT(H5F_efc_open) + + /* Sanity checks */ + HDassert(parent); + HDassert(parent->shared); + HDassert(name); + + /* Get external file cache */ + efc = parent->shared->efc; + + /* Check if the EFC exists. If it does not, just call H5F_open(). We + * support this so clients do not have to make 2 different calls depending + * on the state of the efc. */ + if(!efc) { + if(NULL == (ret_value = H5F_open(name, flags, fcpl_id, fapl_id, + dxpl_id))) + HGOTO_ERROR(H5E_FILE, H5E_CANTOPENFILE, NULL, "can't open file") + + /* Increment the number of open objects to prevent the file from being + * closed out from under us - "simulate" having an open file id. Note + * that this behaviour replaces the calls to H5F_incr_nopen_objs() and + * H5F_decr_nopen_objs() in H5L_extern_traverse(). */ + ret_value->nopen_objs++; + + HGOTO_DONE(ret_value) + } /* end if */ + + /* Search the skip list for name if the skip list exists, create the skip + * list otherwise */ + if(efc->slist) { + if(efc->nfiles > 0) + ent = (H5F_efc_ent_t *)H5SL_search(efc->slist, name); + } /* end if */ + else { + HDassert(efc->nfiles == 0); + if(NULL == (efc->slist = H5SL_create(H5SL_TYPE_STR))) + HGOTO_ERROR(H5E_FILE, H5E_CANTCREATE, NULL, "can't create skip list") + } /* end else */ + + /* If we found the file update the LRU list and return the cached file, + * otherwise open the file and cache it */ + if(ent) { + HDassert(efc->LRU_head); + HDassert(efc->LRU_tail); + + /* Move ent to the head of the LRU list, if it is not already there */ + if(ent->LRU_prev) { + HDassert(efc->LRU_head != ent); + + /* Remove from current position. Note that once we touch the LRU + * list we cannot revert to the previous state. Make sure there can + * be no errors between when we first touch the LRU list and when + * the cache is in a consistent state! */ + if(ent->LRU_next) + ent->LRU_next->LRU_prev = ent->LRU_prev; + else { + HDassert(efc->LRU_tail == ent); + efc->LRU_tail = ent->LRU_prev; + } /* end else */ + ent->LRU_prev->LRU_next = ent->LRU_next; + + /* Add to head of LRU list */ + ent->LRU_next = efc->LRU_head; + ent->LRU_next->LRU_prev = ent; + ent->LRU_prev = NULL; + efc->LRU_head = ent; + } /* end if */ + + /* Mark the file as open */ + ent->nopen++; + } /* end if */ + else { + /* Check if we need to evict something */ + if(efc->nfiles == efc->max_nfiles) { + /* Search for an unopened file from the tail */ + for(ent = efc->LRU_tail; ent && ent->nopen; ent = ent->LRU_prev); + + /* Evict the file if found, otherwise just open the target file and + * do not add it to cache */ + if(ent) { + if(H5F_efc_remove_ent(efc, ent) < 0) + HGOTO_ERROR(H5E_FILE, H5E_CANTREMOVE, NULL, "can't remove entry from external file cache") + + /* Do not free ent, we will recycle it below */ + } /* end if */ + else { + /* Cannot cache file, just open file and return */ + if(NULL == (ret_value = H5F_open(name, flags, fcpl_id, fapl_id, + dxpl_id))) + HGOTO_ERROR(H5E_FILE, H5E_CANTOPENFILE, NULL, "can't open file") + + /* Increment the number of open objects to prevent the file from + * being closed out from under us - "simulate" having an open + * file id */ + ret_value->nopen_objs++; + + HGOTO_DONE(ret_value) + } /* end else */ + } /* end if */ + else + /* Allocate new entry */ + if(NULL == (ent = H5FL_MALLOC(H5F_efc_ent_t))) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed") + + /* Build new entry */ + if(NULL == (ent->name = H5MM_strdup(name))) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed") + + /* Open the file */ + if(NULL == (ent->file = H5F_open(name, flags, fcpl_id, fapl_id, + dxpl_id))) + HGOTO_ERROR(H5E_FILE, H5E_CANTOPENFILE, NULL, "can't open file") + open_file = TRUE; + + /* Increment the number of open objects to prevent the file from being + * closed out from under us - "simulate" having an open file id */ + ent->file->nopen_objs++; + + /* Add the file to the cache */ + /* Skip list */ + if(H5SL_insert(efc->slist, ent, ent->name) < 0) + HGOTO_ERROR(H5E_FILE, H5E_CANTINSERT, NULL, "can't insert entry into skip list") + + /* Add to head of LRU list and update tail if necessary */ + ent->LRU_next = efc->LRU_head; + if(ent->LRU_next) + ent->LRU_next->LRU_prev = ent; + ent->LRU_prev = NULL; + efc->LRU_head = ent; + if(!efc->LRU_tail) { + HDassert(!ent->LRU_next); + efc->LRU_tail = ent; + } /* end if */ + + /* Mark the file as open */ + ent->nopen = 1; + + /* Update nfiles and nrefs */ + efc->nfiles++; + if(ent->file->shared->efc) + ent->file->shared->efc->nrefs++; + } /* end else */ + + HDassert(ent); + HDassert(ent->file); + HDassert(ent->name); + HDassert(ent->nopen); + + /* Set the return value */ + ret_value = ent->file; + +done: + if(!ret_value) + if(ent) { + if(open_file) { + ent->file->nopen_objs--; + if(H5F_try_close(ent->file) < 0) + HDONE_ERROR(H5E_FILE, H5E_CANTCLOSEFILE, NULL, "can't close external file") + } /* end if */ + ent->name = (char *)H5MM_xfree(ent->name); + ent = H5FL_FREE(H5F_efc_ent_t, ent); + } /* end if */ + + FUNC_LEAVE_NOAPI(ret_value) +} /* end H5F_efc_open() */ + + +/*------------------------------------------------------------------------- + * Function: H5F_efc_close + * + * Purpose: Closes (unlocks) a file opened using the external file + * cache. The target file is not immediately closed unless + * there is no external file cache for the parent file. + * + * Return: Non-negative on success + * Negative on failure + * + * Programmer: Neil Fortner + * Wednesday, December 15, 2010 + * + *------------------------------------------------------------------------- + */ +herr_t +H5F_efc_close(H5F_t *parent, H5F_t *file) +{ + H5F_efc_t *efc = NULL; /* External file cache for parent file */ + H5F_efc_ent_t *ent = NULL; /* Entry for target file in efc */ + herr_t ret_value = SUCCEED; /* Return value */ + + FUNC_ENTER_NOAPI_NOINIT(H5F_efc_close) + + /* Sanity checks */ + HDassert(parent); + HDassert(parent->shared); + HDassert(file); + HDassert(file->shared); + + /* Get external file cache */ + efc = parent->shared->efc; + + /* Check if the EFC exists. If it does not, just call H5F_try_close(). We + * support this so clients do not have to make 2 different calls depending + * on the state of the efc. */ + if(!efc) { + file->nopen_objs--; + if(H5F_try_close(file) < 0) + HGOTO_ERROR(H5E_FILE, H5E_CANTCLOSEFILE, FAIL, "can't close external file") + + HGOTO_DONE(SUCCEED) + } /* end if */ + + /* Scan the parent's LRU list from the head to file file. We do this + * instead of a skip list lookup because the file will almost always be at + * the head. In the unlikely case that the file is not found, just call + * H5F_try_close(). This could happen if the EFC was full of open files + * when the file was opened. */ + for(ent = efc->LRU_head; ent && ent->file != file; ent = ent->LRU_next); + if(!ent) { + file->nopen_objs--; + if(H5F_try_close(file) < 0) + HGOTO_ERROR(H5E_FILE, H5E_CANTCLOSEFILE, FAIL, "can't close external file") + } /* end if */ + else + /* Reduce the open count on this entry */ + ent->nopen--; + +done: + FUNC_LEAVE_NOAPI(ret_value) +} /* end H5F_efc_close() */ + + +/*------------------------------------------------------------------------- + * Function: H5F_efc_max_nfiles + * + * Purpose: Returns the maximum number of files in the provided + * external file cache. + * + * Return: Maximum number of files (never fails) + * + * Programmer: Neil Fortner + * Wednesday, December 15, 2010 + * + *------------------------------------------------------------------------- + */ +unsigned +H5F_efc_max_nfiles(H5F_efc_t *efc) +{ + FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5F_efc_max_nfiles) + + HDassert(efc); + HDassert(efc->max_nfiles > 0); + + FUNC_LEAVE_NOAPI(efc->max_nfiles) +} /* end H5F_efc_max_nfiles */ + + +/*------------------------------------------------------------------------- + * Function: H5F_efc_release + * + * Purpose: Releases the external file cache, potentially closing any + * cached files unless they are held open from somewhere + * else (or are currently opened by a client). + * + * Return: Non-negative on success + * Negative on failure + * + * Programmer: Neil Fortner + * Wednesday, December 15, 2010 + * + *------------------------------------------------------------------------- + */ +herr_t +H5F_efc_release(H5F_efc_t *efc) +{ + H5F_efc_ent_t *ent = NULL; /* EFC entry */ + H5F_efc_ent_t *prev_ent = NULL; /* Previous EFC entry */ + herr_t ret_value = SUCCEED; /* Return value */ + + FUNC_ENTER_NOAPI_NOINIT(H5F_efc_release) + + /* Sanity checks */ + HDassert(efc); + + /* Lock the EFC to prevent manipulation of the EFC wile we are releasing it. + * The EFC should never be locked when we enter this function because that + * would require a cycle, a cycle would necessarily invoke + * H5F_efc_try_close(), and that function checks the status of the lock + * before calling this one. */ + HDassert((efc->tag == H5F_EFC_TAG_DEFAULT) + || (efc->tag == H5F_EFC_TAG_CLOSE)); + efc->tag = H5F_EFC_TAG_LOCK; + + /* Walk down the LRU list, releasing any files that are not opened by an EFC + * client */ + ent = efc->LRU_head; + while(ent) + if(!ent->nopen) { + if(H5F_efc_remove_ent(efc, ent) < 0) + HGOTO_ERROR(H5E_FILE, H5E_CANTREMOVE, FAIL, "can't remove entry from external file cache") + + /* Free the entry and move to next entry in LRU list */ + prev_ent = ent; + ent = ent->LRU_next; + prev_ent = H5FL_FREE(H5F_efc_ent_t, prev_ent); + } /* end if */ + else + /* Can't release file because it's open; just advance the pointer */ + ent = ent->LRU_next; + + /* Reset tag. No need to reset to CLOSE if that was the original tag, as in + * that case the file must be getting closed anyways. */ + efc->tag = H5F_EFC_TAG_DEFAULT; + +done: + FUNC_LEAVE_NOAPI(ret_value); +} /* end H5F_efc_release() */ + + +/*------------------------------------------------------------------------- + * Function: H5F_efc_destroy + * + * Purpose: Frees an external file cache object, releasing it first + * if necessary. If it cannot be fully released, for example + * if there are open files, returns an error. + * + * Return: Non-negative on success + * Negative on failure + * + * Programmer: Neil Fortner + * Wednesday, December 15, 2010 + * + *------------------------------------------------------------------------- + */ +herr_t +H5F_efc_destroy(H5F_efc_t *efc) +{ + herr_t ret_value = SUCCEED; /* Return value */ + + FUNC_ENTER_NOAPI_NOINIT(H5F_efc_destroy) + + /* Sanity checks */ + HDassert(efc); + + if(efc->nfiles > 0) { + /* Release (clear) the efc */ + if(H5F_efc_release(efc) < 0) + HGOTO_ERROR(H5E_FILE, H5E_CANTRELEASE, FAIL, "can't release external file cache") + + /* If there are still cached files, return an error */ + if(efc->nfiles > 0) + HGOTO_ERROR(H5E_FILE, H5E_CANTFREE, FAIL, "can't destroy EFC after incomplete release") + } /* end if */ + + HDassert(efc->nfiles == 0); + HDassert(efc->LRU_head == NULL); + HDassert(efc->LRU_tail == NULL); + + /* Close skip list */ + if(efc->slist) + if(H5SL_close(efc->slist) < 0) + HGOTO_ERROR(H5E_FILE, H5E_CANTFREE, FAIL, "can't close skip list") + + /* Free EFC object */ + (void)H5FL_FREE(H5F_efc_t, efc); + +done: + FUNC_LEAVE_NOAPI(ret_value); +} /* end H5F_efc_destroy() */ + + +/*------------------------------------------------------------------------- + * Function: H5F_efc_remove_ent + * + * Purpose: Removes the specified entry from the specified EFC, + * closing the file if requested. Does not free the entry. + * + * Return: Non-negative on success + * Negative on failure + * + * Programmer: Neil Fortner + * Wednesday, December 15, 2010 + * + *------------------------------------------------------------------------- + */ +static herr_t +H5F_efc_remove_ent(H5F_efc_t *efc, H5F_efc_ent_t *ent) +{ + herr_t ret_value = SUCCEED; /* Return value */ + + FUNC_ENTER_NOAPI_NOINIT(H5F_efc_remove_ent) + + /* Sanity checks */ + HDassert(efc); + HDassert(efc->slist); + HDassert(ent); + + /* Remove from skip list */ + if(ent != H5SL_remove(efc->slist, ent->name)) + HGOTO_ERROR(H5E_FILE, H5E_CANTDELETE, FAIL, "can't delete entry from skip list") + + /* Remove from LRU list */ + if(ent->LRU_next) + ent->LRU_next->LRU_prev = ent->LRU_prev; + else { + HDassert(efc->LRU_tail == ent); + efc->LRU_tail = ent->LRU_prev; + } /* end else */ + if(ent->LRU_prev) + ent->LRU_prev->LRU_next = ent->LRU_next; + else { + HDassert(efc->LRU_head == ent); + efc->LRU_head = ent->LRU_next; + } /* end else */ + + /* Update nfiles and nrefs */ + efc->nfiles--; + if(ent->file->shared->efc) + ent->file->shared->efc->nrefs--; + + /* Free the name */ + ent->name = (char *)H5MM_xfree(ent->name); + + /* Close the file. Note that since H5F_t structs returned from H5F_open() + * are *always* unique, there is no need to reference count this struct. + * However we must still manipulate the nopen_objs field to prevent the file + * from being closed out from under us. */ + ent->file->nopen_objs--; + if(H5F_try_close(ent->file) < 0) + HGOTO_ERROR(H5E_FILE, H5E_CANTCLOSEFILE, FAIL, "can't close external file") + ent->file = NULL; + +done: + FUNC_LEAVE_NOAPI(ret_value) +} /* end H5F_efc_remove_ent() */ + + +/*------------------------------------------------------------------------- + * Function: H5F_efc_try_close_tag1 + * + * Purpose: Recursively traverse the EFC tree, keeping a temporary + * reference count on each file that assumes all reachable + * files will eventually be closed. + * + * Return: void (never fails) + * + * Programmer: Neil Fortner + * Monday, January 10, 2011 + * + *------------------------------------------------------------------------- + */ +static void +H5F_efc_try_close_tag1(H5F_file_t *sf, H5F_file_t **tail) +{ + H5F_efc_ent_t *ent = NULL; /* EFC entry */ + H5F_file_t *esf; /* Convenience pointer to ent->file->shared */ + + FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5F_efc_try_close_tag1) + + /* Sanity checks */ + HDassert(sf); + HDassert(sf->efc); + HDassert((sf->efc->tag > 0) || (sf->nrefs == sf->efc->nrefs)); + HDassert(sf->efc->tag != H5F_EFC_TAG_LOCK); + HDassert(tail); + HDassert(*tail); + + /* Recurse into this file's cached files */ + for(ent = sf->efc->LRU_head; ent; ent = ent->LRU_next) { + esf = ent->file->shared; + + if(esf->efc) { + /* If tag were 0, that would mean there are more actual references + * than are counted by nrefs */ + HDassert(esf->efc->tag != 0); + + /* If tag has been set, we have already visited this file so just + * decrement tag and continue */ + if(esf->efc->tag > 0) + esf->efc->tag--; + /* If there are references that are not from an EFC, it will never + * be possible to close the file. Just continue. Also continue if + * the EFC is locked or the file is open (through the EFC). Note + * that the reference counts will never match for the root file, but + * that's ok because the root file will always have a tag and enter + * the branch above. */ + else if((esf->nrefs == esf->efc->nrefs) + && (esf->efc->tag != H5F_EFC_TAG_LOCK) && !(ent->nopen)) { + /* If we get here, this file's "tmp_next" pointer must be NULL + */ + HDassert(esf->efc->tmp_next == NULL); + + /* If nrefs > 1, Add this file to the list of files with nrefs > + * 1 and initialize tag to the number of references (except this + * one) */ + if(esf->nrefs > 1) { + (*tail)->efc->tmp_next = esf; + *tail = esf; + esf->efc->tag = (int)esf->nrefs - 1; + } /* end if */ + + /* Recurse into the entry */ + H5F_efc_try_close_tag1(ent->file->shared, tail); + } /* end if */ + } /* end if */ + } /* end for */ + + FUNC_LEAVE_NOAPI_VOID +} /* end H5F_efc_try_close_tag1() */ + + +/*------------------------------------------------------------------------- + * Function: H5F_efc_try_close_tag2 + * + * Purpose: Recuresively mark all files reachable through this one as + * uncloseable, and add newly uncloseable files to the tail + * of the provided linked list. + * + * Return: void (never fails) + * + * Programmer: Neil Fortner + * Monday, January 10, 2011 + * + *------------------------------------------------------------------------- + */ +static void +H5F_efc_try_close_tag2(H5F_file_t *sf, H5F_file_t **tail) +{ + H5F_efc_ent_t *ent = NULL; /* EFC entry */ + H5F_file_t *esf; /* Convenience pointer to ent->file->shared */ + + FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5F_efc_try_close_tag2) + + /* Sanity checks */ + HDassert(sf); + HDassert(sf->efc); + + /* Recurse into this file's cached files */ + for(ent = sf->efc->LRU_head; ent; ent = ent->LRU_next) { + esf = ent->file->shared; + + /* Only recurse if the file is tagged CLOSE or DEFAULT. If it is tagged + * DONTCLOSE, we have already visited this file *or* it will be the + * start point of another iteration. No files should be tagged with a + * nonegative value at this point. If it is tagged as DEFAULT, we must + * apply the same conditions as in cb1 above for recursion in order to + * make sure we do not go off into somewhere cb1 didn't touch. The + * root file should never be tagged DEFAULT here, so the reference check + * is still appropriate. */ + if((esf->efc) && ((esf->efc->tag == H5F_EFC_TAG_CLOSE) + || ((esf->efc->tag == H5F_EFC_TAG_DEFAULT) + && (esf->nrefs == esf->efc->nrefs) && !(ent->nopen)))) { + /* tag should always be CLOSE is nrefs > 1 or DEFAULT if nrefs == 1 + * here */ + HDassert(((esf->nrefs > 1) + && ((esf->efc->tag == H5F_EFC_TAG_CLOSE))) + || ((esf->nrefs == 1) + && (esf->efc->tag == H5F_EFC_TAG_DEFAULT))); + + /* If tag is set to DONTCLOSE, we have already visited this file + * *or* it will be the start point of another iteration so just + * continue */ + if(esf->efc->tag != H5F_EFC_TAG_DONTCLOSE) { + /* If tag is CLOSE, set to DONTCLOSE and add to the list of + * uncloseable files. */ + if(esf->efc->tag == H5F_EFC_TAG_CLOSE) { + esf->efc->tag = H5F_EFC_TAG_DONTCLOSE; + esf->efc->tmp_next = NULL; + (*tail)->efc->tmp_next = esf; + *tail = esf; + } /* end if */ + + /* Recurse into the entry */ + H5F_efc_try_close_tag2(esf, tail); + } /* end if */ + } /* end if */ + } /* end for */ + + FUNC_LEAVE_NOAPI_VOID +} /* end H5F_efc_try_close_tag2() */ + + +/*------------------------------------------------------------------------- + * Function: H5F_efc_try_close + * + * Purpose: Attempts to close the provided (shared) file by checking + * to see if the releasing the EFC would cause its reference + * count to drop to 0. Necessary to handle the case where + * chained EFCs form a cycle. Note that this function does + * not actually close the file (though it closes all children + * as appropriate), as that is left up to the calling + * function H5F_try_close(). + * + * Because H5F_try_close() has no way of telling if it is + * called recursively from within this function, this + * function serves as both the root of iteration and the + * "callback" for the final pass (the one where the files are + * actually closed). The code for the callback case is at + * the top of this function; luckily it only consists of a + * (possible) call to H5F_efc_release(). + * + * The algorithm basically consists of 3 passes over the EFC + * tree. The first pass assumes that every reachable file is + * closed, and keeps track of what the final reference count + * would be for every reachable file. The files are then + * tagged as either closeable or uncloseable based on whether + * this reference count drops to 0. + * + * The second pass initiates a traversal from each file + * marked as uncloseable in the first pass, and marks every + * file reachable from the initial uncloseable file as + * uncloseable. This eliminates files that were marked as + * closeable only because the first pass assumed that an + * uncloseable file would be closed. + * + * The final pass exploits the H5F_efc_release()-> + * H5F_efc_remove_ent()->H5F_try_close()->H5F_efc_try_close() + * calling chain to recursively close the tree, but only the + * files that are still marked as closeable. All files + * marked as closeable have their EFCs released, and will + * eventually be closed when their last parent EFC is + * released (the last part is guaranteed to be true by the + * first 2 passes). + * + * Return: Non-negative on success + * Negative on failure + * + * Programmer: Neil Fortner + * Thursday, January 6, 2011 + * + *------------------------------------------------------------------------- + */ +herr_t +H5F_efc_try_close(H5F_t *f) +{ + H5F_file_t *tail; /* Tail of linked list of found files. Head will be f->shared. */ + H5F_file_t *uncloseable_head = NULL; /* Head of linked list of files found to be uncloseable by the first pass */ + H5F_file_t *uncloseable_tail = NULL; /* Tail of linked list of files found to be uncloseable by the first pass */ + H5F_file_t *sf; /* Temporary file pointer */ + H5F_file_t *next; /* Temporary file pointer */ + herr_t ret_value = SUCCEED; /* Return value */ + + FUNC_ENTER_NOAPI_NOINIT(H5F_efc_try_close) + + /* Sanity checks */ + HDassert(f); + HDassert(f->shared); + HDassert(f->shared->efc); + HDassert(f->shared->nrefs > f->shared->efc->nrefs); + HDassert(f->shared->nrefs > 1); + HDassert(f->shared->efc->tag < 0); + + if(f->shared->efc->tag == H5F_EFC_TAG_CLOSE) { + /* We must have reentered this function, and we should close this file. + * In actuality, we just release the EFC, the recursion should + * eventually reduce this file's reference count to 1 (though possibly + * not from this call to H5F_efc_release()). */ + if(H5F_efc_release(f->shared->efc) < 0) + HGOTO_ERROR(H5E_FILE, H5E_CANTRELEASE, FAIL, "can't release external file cache") + + /* If we marked the file as closeable, there must be no open files in + * its EFC. This is because, in order to close an open child file, the + * client must keep a copy of the parent file open. The algorithm + * detect that the parent file is open (directly or through an EFC) and + * refuse to close it. Verify that all files were released from this + * EFC (i.e. none were open). */ + HDassert(f->shared->efc->nfiles == 0); + + HGOTO_DONE(SUCCEED) + } /* end if */ + + /* Conditions where we should not do anything and just return immediately */ + /* If there are references that are not from an EFC or f, it will never + * be possible to close the file. Just return. Note that this holds true + * for the case that this file is being closed through H5F_efc_release() + * because that function (through H5F_efc_remove_ent()) decrements the EFC + * reference count before it calls H5F_try_close(). This may occur if this + * function is reentered. */ + /* If the tag is H5F_EFC_TAG_DONTCLOSE, then we have definitely reentered + * this function, and this file has been marked as uncloseable, so we should + * not close/release it */ + /* If nfiles is 0, then there is nothing to do. Just return. This may also + * occur on reentry (for example if this file was previously released). */ + if((f->shared->nrefs != f->shared->efc->nrefs + 1) + || (f->shared->efc->tag == H5F_EFC_TAG_DONTCLOSE) + || (f->shared->efc->nfiles == 0)) + /* We must have reentered this function, and we should not close this + * file. Just return. */ + HGOTO_DONE(SUCCEED) + + /* If the file EFC were locked, that should always mean that there exists + * a reference to this file that is not in an EFC (it may have just been + * removed from an EFC), and should have been caught by the above check */ + /* If we get here then we must be beginning a new run. Make sure that the + * temporary variables in f->shared->efc are at the default value */ + HDassert(f->shared->efc->tag == H5F_EFC_TAG_DEFAULT); + HDassert(f->shared->efc->tmp_next == NULL); + + /* Set up linked list for traversal into EFC tree. f->shared is guaranteed + * to always be at the head. */ + tail = f->shared; + + /* Set up temporary reference count on root file */ + f->shared->efc->tag = (int)f->shared->efc->nrefs; + + /* First Pass: simulate closing all files reachable from this one, use "tag" + * field to keep track of final reference count for each file (including + * this one). Keep list of files with starting reference count > 1 (head is + * f->shared). */ + H5F_efc_try_close_tag1(f->shared, &tail); + + /* Check if f->shared->efc->tag dropped to 0. If it did not, + * we cannot close anything. Just reset temporary values and return. */ + if(f->shared->efc->tag > 0) { + sf = f->shared; + while(sf) { + next = sf->efc->tmp_next; + sf->efc->tag = H5F_EFC_TAG_DEFAULT; + sf->efc->tmp_next = NULL; + sf = next; + } /* end while */ + HGOTO_DONE(SUCCEED) + } /* end if */ + + /* Run through the linked list , separating into two lists, one with tag == + * 0 and one with tag > 0. Mark them as either H5F_EFC_TAG_CLOSE or + * H5F_EFC_TAG_DONTCLOSE as appropriate. */ + sf = f->shared; + tail = NULL; + while(sf) { + HDassert(sf->efc->tag >= 0); + next = sf->efc->tmp_next; + if(sf->efc->tag > 0) { + /* Remove from main list */ + HDassert(tail); + tail->efc->tmp_next = sf->efc->tmp_next; + sf->efc->tmp_next = NULL; + + /* Add to uncloseable list */ + if(!uncloseable_head) + uncloseable_head = sf; + else + uncloseable_tail->efc->tmp_next = sf; + uncloseable_tail = sf; + + /* Mark as uncloseable */ + sf->efc->tag = H5F_EFC_TAG_DONTCLOSE; + } /* end if */ + else { + sf->efc->tag = H5F_EFC_TAG_CLOSE; + tail = sf; + } /* end else */ + sf = next; + } /* end while */ + + /* Second pass: Determine which of the reachable files found in pass 1 + * cannot be closed by releasing the root file's EFC. Run through the + * uncloseable list, for each item traverse the files reachable through the + * EFC, mark the file as uncloseable, and add it to the list of uncloseable + * files (for cleanup). Use "tail" to store the original uncloseable tail + * so we know when to stop. We do not need to keep track of the closeable + * list any more. */ + sf = uncloseable_head; + if(sf) { + tail = uncloseable_tail; + HDassert(tail); + while(sf != tail->efc->tmp_next) { + H5F_efc_try_close_tag2(sf, &uncloseable_tail); + sf = sf->efc->tmp_next; + } /* end while */ + } /* end if */ + + /* If the root file's tag is still H5F_EFC_TAG_CLOSE, release its EFC. This + * should start the recursive release that should close all closeable files. + * Also, see the top of this function. */ + if(f->shared->efc->tag == H5F_EFC_TAG_CLOSE) { + if(H5F_efc_release(f->shared->efc) < 0) + HGOTO_ERROR(H5E_FILE, H5E_CANTRELEASE, FAIL, "can't release external file cache") + + /* Make sure the file's reference count is now 1 and will be closed by + * H5F_dest(). */ + HDassert(f->shared->nrefs == 1); + } /* end if */ + + /* Clean up uncloseable files (reset tag and tmp_next). All closeable files + * should have been closed, and therefore do not need to be cleaned up. */ + if(uncloseable_head) { + sf = uncloseable_head; + while(sf) { + next = sf->efc->tmp_next; + HDassert(sf->efc->tag == H5F_EFC_TAG_DONTCLOSE); + sf->efc->tag = H5F_EFC_TAG_DEFAULT; + sf->efc->tmp_next = NULL; + sf = next; + } /* end while */ + } /* end if */ + +done: + FUNC_LEAVE_NOAPI(ret_value) +} /* end H5F_efc_try_close() */ + diff --git a/src/H5Fpkg.h b/src/H5Fpkg.h index c98bda4..f63fa98 100644 --- a/src/H5Fpkg.h +++ b/src/H5Fpkg.h @@ -127,6 +127,10 @@ + H5F_SUPERBLOCK_VARLEN_SIZE(v, f)) +/* Forward declaration external file cache struct used below (defined in + * H5Fefc.c) */ +typedef struct H5F_efc_t H5F_efc_t; + /* Structure for metadata & "small [raw] data" block aggregation fields */ struct H5F_blk_aggr_t { unsigned long feature_flag; /* Feature flag type */ @@ -200,6 +204,7 @@ typedef struct H5F_file_t { unsigned nrefs; /* Ref count for times file is opened */ unsigned flags; /* Access Permissions for file */ H5F_mtab_t mtab; /* File mount table */ + H5F_efc_t *efc; /* External file cache */ /* Cached values from FCPL/superblock */ uint8_t sizeof_addr; /* Size of addresses in file */ @@ -328,6 +333,13 @@ H5_DLL herr_t H5F_sfile_add(H5F_file_t *shared); H5_DLL H5F_file_t * H5F_sfile_search(H5FD_t *lf); H5_DLL herr_t H5F_sfile_remove(H5F_file_t *shared); +/* External file cache routines */ +H5_DLL H5F_efc_t *H5F_efc_create(unsigned max_nfiles); +H5_DLL unsigned H5F_efc_max_nfiles(H5F_efc_t *efc); +H5_DLL herr_t H5F_efc_release(H5F_efc_t *efc); +H5_DLL herr_t H5F_efc_destroy(H5F_efc_t *efc); +H5_DLL herr_t H5F_efc_try_close(H5F_t *f); + /* Testing functions */ #ifdef H5F_TESTING H5_DLL herr_t H5F_get_sohm_mesg_count_test(hid_t fid, unsigned type_id, diff --git a/src/H5Fprivate.h b/src/H5Fprivate.h index 10c2976..22d9acd 100644 --- a/src/H5Fprivate.h +++ b/src/H5Fprivate.h @@ -381,6 +381,7 @@ typedef struct H5F_blk_aggr_t H5F_blk_aggr_t; #define H5F_ACS_MULTI_TYPE_NAME "multi_type" /* Data type in multi file driver */ #define H5F_ACS_LATEST_FORMAT_NAME "latest_format" /* 'Use latest format version' flag */ #define H5F_ACS_WANT_POSIX_FD_NAME "want_posix_fd" /* Internal: query the file descriptor from the core VFD, instead of the memory address */ +#define H5F_ACS_EFC_SIZE_NAME "efc_size" /* Size of external file cache */ /* ======================== File Mount properties ====================*/ #define H5F_MNT_SYM_LOCAL_NAME "local" /* Whether absolute symlinks local to file. */ @@ -550,6 +551,11 @@ H5_DLL MPI_Comm H5F_mpi_get_comm(const H5F_t *f); H5_DLL int H5F_mpi_get_size(const H5F_t *f); #endif /* H5_HAVE_PARALLEL */ +/* External file cache routines */ +H5_DLL H5F_t *H5F_efc_open(H5F_t *parent, const char *name, unsigned flags, + hid_t fcpl_id, hid_t fapl_id, hid_t dxpl_id); +H5_DLL herr_t H5F_efc_close(H5F_t *parent, H5F_t *file); + /* Debugging functions */ H5_DLL herr_t H5F_debug(H5F_t *f, FILE * stream, int indent, int fwidth); diff --git a/src/H5Fpublic.h b/src/H5Fpublic.h index 5ca64dc..d87dae6 100644 --- a/src/H5Fpublic.h +++ b/src/H5Fpublic.h @@ -198,6 +198,7 @@ H5_DLL ssize_t H5Fget_name(hid_t obj_id, char *name, size_t size); H5_DLL herr_t H5Fget_info2(hid_t obj_id, H5F_info2_t *finfo); H5_DLL ssize_t H5Fget_free_sections(hid_t file_id, H5F_mem_t type, size_t nsects, H5F_sect_info_t *sect_info/*out*/); +H5_DLL herr_t H5Frelease_file_cache(hid_t file_id); /* Symbols defined for compatibility with previous versions of the HDF5 API. * diff --git a/src/H5Lexternal.c b/src/H5Lexternal.c index eb2ffe5..03f2e15 100644 --- a/src/H5Lexternal.c +++ b/src/H5Lexternal.c @@ -322,7 +322,7 @@ H5L_extern_traverse(const char UNUSED *link_name, hid_t cur_group, /* target file_name is an absolute pathname: see RM for detailed description */ if(CHECK_ABSOLUTE(file_name) || CHECK_ABS_PATH(file_name)) { /* Try opening file */ - if(NULL == (ext_file = H5F_open(file_name, intent, H5P_FILE_CREATE_DEFAULT, fapl_id, H5AC_dxpl_id))) { + if(NULL == (ext_file = H5F_efc_open(loc.oloc->file, file_name, intent, H5P_FILE_CREATE_DEFAULT, fapl_id, H5AC_dxpl_id))) { char *ptr = NULL; H5E_clear_stack(NULL); @@ -334,7 +334,7 @@ H5L_extern_traverse(const char UNUSED *link_name, hid_t cur_group, } /* end if */ } /* end if */ else if(CHECK_ABS_DRIVE(file_name)) { - if(NULL == (ext_file = H5F_open(file_name, intent, H5P_FILE_CREATE_DEFAULT, fapl_id, H5AC_dxpl_id))) { + if(NULL == (ext_file = H5F_efc_open(loc.oloc->file, file_name, intent, H5P_FILE_CREATE_DEFAULT, fapl_id, H5AC_dxpl_id))) { H5E_clear_stack(NULL); /* strip ":" */ HDstrcpy(temp_file_name, &file_name[2]); @@ -361,7 +361,7 @@ H5L_extern_traverse(const char UNUSED *link_name, hid_t cur_group, HGOTO_ERROR(H5E_LINK, H5E_CANTGET, FAIL, "can't prepend prefix to filename") } - ext_file = H5F_open(full_name, intent, H5P_FILE_CREATE_DEFAULT, fapl_id, H5AC_dxpl_id); + ext_file = H5F_efc_open(loc.oloc->file, full_name, intent, H5P_FILE_CREATE_DEFAULT, fapl_id, H5AC_dxpl_id); full_name = (char *)H5MM_xfree(full_name); if(ext_file != NULL) break; @@ -379,7 +379,7 @@ H5L_extern_traverse(const char UNUSED *link_name, hid_t cur_group, if(my_prefix) { if(H5L_build_name(my_prefix, temp_file_name, &full_name/*out*/) < 0) HGOTO_ERROR(H5E_LINK, H5E_CANTGET, FAIL, "can't prepend prefix to filename") - if(NULL == (ext_file = H5F_open(full_name, intent, H5P_FILE_CREATE_DEFAULT, fapl_id, H5AC_dxpl_id))) + if(NULL == (ext_file = H5F_efc_open(loc.oloc->file, full_name, intent, H5P_FILE_CREATE_DEFAULT, fapl_id, H5AC_dxpl_id))) H5E_clear_stack(NULL); full_name = (char *)H5MM_xfree(full_name); } /* end if */ @@ -392,7 +392,7 @@ H5L_extern_traverse(const char UNUSED *link_name, hid_t cur_group, if(NULL != (extpath = H5F_EXTPATH(loc.oloc->file))) { if(H5L_build_name(extpath, temp_file_name, &full_name/*out*/) < 0) HGOTO_ERROR(H5E_LINK, H5E_CANTGET, FAIL, "can't prepend prefix to filename") - if(NULL == (ext_file = H5F_open(full_name, intent, H5P_FILE_CREATE_DEFAULT, fapl_id, H5AC_dxpl_id))) + if(NULL == (ext_file = H5F_efc_open(loc.oloc->file, full_name, intent, H5P_FILE_CREATE_DEFAULT, fapl_id, H5AC_dxpl_id))) H5E_clear_stack(NULL); full_name = (char *)H5MM_xfree(full_name); } /* end if */ @@ -400,7 +400,7 @@ H5L_extern_traverse(const char UNUSED *link_name, hid_t cur_group, /* try the relative file_name stored in temp_file_name */ if(ext_file == NULL) { - if(NULL == (ext_file = H5F_open(temp_file_name, intent, H5P_FILE_CREATE_DEFAULT, fapl_id, H5AC_dxpl_id))) + if(NULL == (ext_file = H5F_efc_open(loc.oloc->file, temp_file_name, intent, H5P_FILE_CREATE_DEFAULT, fapl_id, H5AC_dxpl_id))) H5E_clear_stack(NULL); } /* end if */ @@ -427,32 +427,19 @@ H5L_extern_traverse(const char UNUSED *link_name, hid_t cur_group, HGOTO_ERROR(H5E_LINK, H5E_CANTGET, FAIL, "can't prepend prefix to filename") /* Try opening with the resolved name */ - if(NULL == (ext_file = H5F_open(full_name, intent, H5P_FILE_CREATE_DEFAULT, fapl_id, H5AC_dxpl_id))) + if(NULL == (ext_file = H5F_efc_open(loc.oloc->file, full_name, intent, H5P_FILE_CREATE_DEFAULT, fapl_id, H5AC_dxpl_id))) HGOTO_ERROR(H5E_LINK, H5E_CANTOPENFILE, FAIL, "unable to open external file, external link file name = '%s', temp_file_name = '%s'", file_name, temp_file_name) full_name = (char *)H5MM_xfree(full_name); } /* end if */ - /* Increment the number of open objects, to hold the file open */ - H5F_incr_nopen_objs(ext_file); - /* Retrieve the "group location" for the file's root group */ if(H5G_loc_root(ext_file, &root_loc) < 0) HGOTO_ERROR(H5E_SYM, H5E_BADVALUE, FAIL, "unable to create location for file") /* Open the object referenced in the external file */ - if((ext_obj = H5O_open_name(&root_loc, obj_name, lapl_id, FALSE)) < 0) { - H5F_decr_nopen_objs(ext_file); + if((ext_obj = H5O_open_name(&root_loc, obj_name, lapl_id, FALSE)) < 0) HGOTO_ERROR(H5E_SYM, H5E_CANTOPENOBJ, FAIL, "unable to open object") - } /* end if */ - - /* Decrement the number of open objects, to let the file close */ - H5F_decr_nopen_objs(ext_file); - - /* Close the external file */ - if(H5F_try_close(ext_file) < 0) - HGOTO_ERROR(H5E_LINK, H5E_CANTCLOSEFILE, FAIL, "problem closing external file") - ext_file = NULL; /* Set return value */ ret_value = ext_obj; @@ -461,7 +448,7 @@ done: /* Release resources */ if(fapl_id > 0 && H5I_dec_ref(fapl_id) < 0) HDONE_ERROR(H5E_ATOM, H5E_CANTRELEASE, FAIL, "unable to close atom for file access property list") - if(ext_file && H5F_try_close(ext_file) < 0) + if(ext_file && H5F_efc_close(loc.oloc->file, ext_file) < 0) HDONE_ERROR(H5E_LINK, H5E_CANTCLOSEFILE, FAIL, "problem closing external file") if(parent_group_name && parent_group_name != local_group_name) parent_group_name = (char *)H5MM_xfree(parent_group_name); diff --git a/src/H5Pfapl.c b/src/H5Pfapl.c index 10922da..7dea0b2 100644 --- a/src/H5Pfapl.c +++ b/src/H5Pfapl.c @@ -119,6 +119,9 @@ */ #define H5F_ACS_WANT_POSIX_FD_SIZE sizeof(hbool_t) #define H5F_ACS_WANT_POSIX_FD_DEF FALSE +/* Definition for external file cache size */ +#define H5F_ACS_EFC_SIZE_SIZE sizeof(unsigned) +#define H5F_ACS_EFC_SIZE_DEF 0 /******************/ @@ -211,6 +214,7 @@ H5P_facc_reg_prop(H5P_genclass_t *pclass) H5FD_mem_t mem_type = H5F_ACS_MULTI_TYPE_DEF; /* Default file space type for multi VFD */ hbool_t latest_format = H5F_ACS_LATEST_FORMAT_DEF; /* Default setting for "use the latest version of the format" flag */ hbool_t want_posix_fd = H5F_ACS_WANT_POSIX_FD_DEF; /* Default setting for retrieving 'handle' from core VFD */ + unsigned efc_size = H5F_ACS_EFC_SIZE_DEF; /* Default external file cache size */ herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_NOAPI_NOINIT(H5P_facc_reg_prop) @@ -292,6 +296,10 @@ H5P_facc_reg_prop(H5P_genclass_t *pclass) if(H5P_register_real(pclass, H5F_ACS_WANT_POSIX_FD_NAME, H5F_ACS_WANT_POSIX_FD_SIZE, &want_posix_fd, NULL, NULL, NULL, NULL, NULL, NULL, NULL) < 0) HGOTO_ERROR(H5E_PLIST, H5E_CANTINSERT, FAIL, "can't insert property into class") + /* Register the external file cache size */ + if(H5P_register_real(pclass, H5F_ACS_EFC_SIZE_NAME, H5F_ACS_EFC_SIZE_SIZE, &efc_size, NULL, NULL, NULL, NULL, NULL, NULL, NULL) < 0) + HGOTO_ERROR(H5E_PLIST, H5E_CANTINSERT, FAIL, "can't insert property into class") + done: FUNC_LEAVE_NOAPI(ret_value) } /* end H5P_facc_reg_prop() */ @@ -2016,3 +2024,80 @@ done: FUNC_LEAVE_API(ret_value) } /* end H5Pget_libver_bounds() */ + +/*------------------------------------------------------------------------- + * Function: H5Pset_elink_file_cache_size + * + * Purpose: Sets the number of files opened through external links + * from the file associated with this fapl to be held open + * in that file's external file cache. When the maximum + * number of files is reached, the least recently used file + * is closed (unless it is opened from somewhere else). + * + * Return: Non-negative on success/Negative on failure + * + * Programmer: Neil Fortner + * Friday, December 17, 2010 + * + *------------------------------------------------------------------------- + */ +herr_t +H5Pset_elink_file_cache_size(hid_t plist_id, unsigned efc_size) +{ + H5P_genplist_t *plist; /* Property list pointer */ + herr_t ret_value = SUCCEED; /* return value */ + + FUNC_ENTER_API(H5Pset_elink_file_cache_size, FAIL) + H5TRACE2("e", "iIu", plist_id, efc_size); + + /* Get the plist structure */ + if(NULL == (plist = H5P_object_verify(plist_id, H5P_FILE_ACCESS))) + HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, FAIL, "can't find object for ID") + + /* Set value */ + if(H5P_set(plist, H5F_ACS_EFC_SIZE_NAME, &efc_size) < 0) + HGOTO_ERROR(H5E_PLIST, H5E_CANTSET, FAIL, "can't set elink file cache size") + +done: + FUNC_LEAVE_API(ret_value) +} /* end H5Pset_elink_file_cache_size() */ + + +/*------------------------------------------------------------------------- + * Function: H5Pget_elink_file_cache_size + * + * Purpose: Gets the number of files opened through external links + * from the file associated with this fapl to be held open + * in that file's external file cache. When the maximum + * number of files is reached, the least recently used file + * is closed (unless it is opened from somewhere else). + * + * Return: Non-negative on success/Negative on failure + * + * Programmer: Neil Fortner + * Friday, December 17, 2010 + * + *------------------------------------------------------------------------- + */ +herr_t +H5Pget_elink_file_cache_size(hid_t plist_id, unsigned *efc_size) +{ + H5P_genplist_t *plist; /* Property list pointer */ + herr_t ret_value = SUCCEED; /* return value */ + + FUNC_ENTER_API(H5Pget_elink_file_cache_size, FAIL) + H5TRACE2("e", "i*Iu", plist_id, efc_size); + + /* Get the plist structure */ + if(NULL == (plist = H5P_object_verify(plist_id, H5P_FILE_ACCESS))) + HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, FAIL, "can't find object for ID") + + /* Get value */ + if(efc_size) + if(H5P_get(plist, H5F_ACS_EFC_SIZE_NAME, efc_size) < 0) + HGOTO_ERROR(H5E_PLIST, H5E_CANTGET, FAIL, "can't get elink file cache size") + +done: + FUNC_LEAVE_API(ret_value) +} /* end H5Pget_elink_file_cache_size() */ + diff --git a/src/H5Ppublic.h b/src/H5Ppublic.h index 09eb796..6867b63 100644 --- a/src/H5Ppublic.h +++ b/src/H5Ppublic.h @@ -287,6 +287,8 @@ H5_DLL herr_t H5Pset_libver_bounds(hid_t plist_id, H5F_libver_t low, H5F_libver_t high); H5_DLL herr_t H5Pget_libver_bounds(hid_t plist_id, H5F_libver_t *low, H5F_libver_t *high); +H5_DLL herr_t H5Pset_elink_file_cache_size(hid_t plist_id, unsigned efc_size); +H5_DLL herr_t H5Pget_elink_file_cache_size(hid_t plist_id, unsigned *efc_size); /* Dataset creation property list (DCPL) routines */ H5_DLL herr_t H5Pset_layout(hid_t plist_id, H5D_layout_t layout); diff --git a/src/Makefile.am b/src/Makefile.am index dc0edb3..ee0a3f5 100755 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -53,8 +53,8 @@ libhdf5_la_SOURCES= H5.c H5checksum.c H5dbg.c H5system.c H5timer.c H5trace.c \ H5E.c H5Edeprec.c H5Eint.c \ H5EA.c H5EAcache.c H5EAdbg.c H5EAdblkpage.c H5EAdblock.c H5EAhdr.c \ H5EAiblock.c H5EAint.c H5EAsblock.c H5EAstat.c H5EAtest.c \ - H5F.c H5Faccum.c H5Fdbg.c H5Fdeprec.c H5Ffake.c H5Fio.c H5Fmount.c \ - H5Fmpi.c H5Fquery.c \ + H5F.c H5Faccum.c H5Fdbg.c H5Fdeprec.c H5Fefc.c H5Ffake.c H5Fio.c \ + H5Fmount.c H5Fmpi.c H5Fquery.c \ H5Fsfile.c H5Fsuper.c H5Fsuper_cache.c H5Ftest.c \ H5FA.c H5FAcache.c H5FAdbg.c H5FAdblock.c H5FAdblkpage.c H5FAhdr.c \ H5FAstat.c H5FAtest.c \ diff --git a/src/Makefile.in b/src/Makefile.in index 55e52ae..51003a0 100644 --- a/src/Makefile.in +++ b/src/Makefile.in @@ -106,19 +106,19 @@ am_libhdf5_la_OBJECTS = H5.lo H5checksum.lo H5dbg.lo H5system.lo \ H5Dtest.lo H5E.lo H5Edeprec.lo H5Eint.lo H5EA.lo H5EAcache.lo \ H5EAdbg.lo H5EAdblkpage.lo H5EAdblock.lo H5EAhdr.lo \ H5EAiblock.lo H5EAint.lo H5EAsblock.lo H5EAstat.lo H5EAtest.lo \ - H5F.lo H5Faccum.lo H5Fdbg.lo H5Fdeprec.lo H5Ffake.lo H5Fio.lo \ - H5Fmount.lo H5Fmpi.lo H5Fquery.lo H5Fsfile.lo H5Fsuper.lo \ - H5Fsuper_cache.lo H5Ftest.lo H5FA.lo H5FAcache.lo H5FAdbg.lo \ - H5FAdblock.lo H5FAdblkpage.lo H5FAhdr.lo H5FAstat.lo \ - H5FAtest.lo H5FD.lo H5FDcore.lo H5FDdirect.lo H5FDfamily.lo \ - H5FDint.lo H5FDlog.lo H5FDmpi.lo H5FDmpio.lo H5FDmpiposix.lo \ - H5FDmulti.lo H5FDsec2.lo H5FDspace.lo H5FDstdio.lo H5FL.lo \ - H5FO.lo H5FS.lo H5FScache.lo H5FSdbg.lo H5FSsection.lo \ - H5FSstat.lo H5FStest.lo H5G.lo H5Gbtree2.lo H5Gcache.lo \ - H5Gcompact.lo H5Gdense.lo H5Gdeprec.lo H5Gent.lo H5Gint.lo \ - H5Glink.lo H5Gloc.lo H5Gname.lo H5Gnode.lo H5Gobj.lo H5Goh.lo \ - H5Groot.lo H5Gstab.lo H5Gtest.lo H5Gtraverse.lo H5HF.lo \ - H5HFbtree2.lo H5HFcache.lo H5HFdbg.lo H5HFdblock.lo \ + H5F.lo H5Faccum.lo H5Fdbg.lo H5Fdeprec.lo H5Fefc.lo H5Ffake.lo \ + H5Fio.lo H5Fmount.lo H5Fmpi.lo H5Fquery.lo H5Fsfile.lo \ + H5Fsuper.lo H5Fsuper_cache.lo H5Ftest.lo H5FA.lo H5FAcache.lo \ + H5FAdbg.lo H5FAdblock.lo H5FAdblkpage.lo H5FAhdr.lo \ + H5FAstat.lo H5FAtest.lo H5FD.lo H5FDcore.lo H5FDdirect.lo \ + H5FDfamily.lo H5FDint.lo H5FDlog.lo H5FDmpi.lo H5FDmpio.lo \ + H5FDmpiposix.lo H5FDmulti.lo H5FDsec2.lo H5FDspace.lo \ + H5FDstdio.lo H5FL.lo H5FO.lo H5FS.lo H5FScache.lo H5FSdbg.lo \ + H5FSsection.lo H5FSstat.lo H5FStest.lo H5G.lo H5Gbtree2.lo \ + H5Gcache.lo H5Gcompact.lo H5Gdense.lo H5Gdeprec.lo H5Gent.lo \ + H5Gint.lo H5Glink.lo H5Gloc.lo H5Gname.lo H5Gnode.lo H5Gobj.lo \ + H5Goh.lo H5Groot.lo H5Gstab.lo H5Gtest.lo H5Gtraverse.lo \ + H5HF.lo H5HFbtree2.lo H5HFcache.lo H5HFdbg.lo H5HFdblock.lo \ H5HFdtable.lo H5HFhdr.lo H5HFhuge.lo H5HFiblock.lo H5HFiter.lo \ H5HFman.lo H5HFsection.lo H5HFspace.lo H5HFstat.lo H5HFtest.lo \ H5HFtiny.lo H5HG.lo H5HGcache.lo H5HGdbg.lo H5HL.lo \ @@ -486,8 +486,8 @@ libhdf5_la_SOURCES = H5.c H5checksum.c H5dbg.c H5system.c H5timer.c H5trace.c \ H5E.c H5Edeprec.c H5Eint.c \ H5EA.c H5EAcache.c H5EAdbg.c H5EAdblkpage.c H5EAdblock.c H5EAhdr.c \ H5EAiblock.c H5EAint.c H5EAsblock.c H5EAstat.c H5EAtest.c \ - H5F.c H5Faccum.c H5Fdbg.c H5Fdeprec.c H5Ffake.c H5Fio.c H5Fmount.c \ - H5Fmpi.c H5Fquery.c \ + H5F.c H5Faccum.c H5Fdbg.c H5Fdeprec.c H5Fefc.c H5Ffake.c H5Fio.c \ + H5Fmount.c H5Fmpi.c H5Fquery.c \ H5Fsfile.c H5Fsuper.c H5Fsuper_cache.c H5Ftest.c \ H5FA.c H5FAcache.c H5FAdbg.c H5FAdblock.c H5FAdblkpage.c H5FAhdr.c \ H5FAstat.c H5FAtest.c \ @@ -764,6 +764,7 @@ distclean-compile: @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5Faccum.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5Fdbg.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5Fdeprec.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5Fefc.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5Ffake.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5Fio.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5Fmount.Plo@am__quote@ diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index 98fffe0..9a2dd88 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -177,6 +177,12 @@ ADD_TEST ( dtransform.h5 dtypes4.h5 dtypes5.h5 + efc0.h5 + efc1.h5 + efc2.h5 + efc3.h5 + efc4.h5 + efc5.h5 extlinks16A00000.h5 extlinks16A00001.h5 extlinks16A00002.h5 @@ -256,6 +262,7 @@ SET (H5_TESTS filter_fail extend external + efc objcopy links unlink @@ -415,6 +422,7 @@ IF (HDF5_TEST_VFD) filter_fail extend external + efc objcopy links unlink diff --git a/test/Makefile.am b/test/Makefile.am index 06c56f8..6f4a46a 100644 --- a/test/Makefile.am +++ b/test/Makefile.am @@ -38,7 +38,7 @@ SCRIPT_DEPEND = error_test$(EXEEXT) err_compat$(EXEEXT) links_env$(EXEEXT) # other current library code tests. TEST_PROG= testhdf5 lheap ohdr stab gheap cache cache_api cache_tagging \ pool accum hyperslab istore bittests dt_arith \ - dtypes dsets cmpd_dset filter_fail extend external objcopy links unlink \ + dtypes dsets cmpd_dset filter_fail extend external efc objcopy links unlink \ big mtime fillval mount flush1 flush2 app_ref enum \ set_extent ttsafe \ getname vfd ntypes dangle dtransform reserved cross_read \ @@ -125,7 +125,7 @@ CHECK_CLEANFILES+=accum.h5 cmpd_dset.h5 compact_dataset.h5 dataset.h5 dset_offse dtransform.h5 test_filters.h5 get_file_name.h5 tstint[1-2].h5 \ unlink_chunked.h5 btree2.h5 objcopy_src.h5 objcopy_dst.h5 \ objcopy_ext.dat trefer1.h5 trefer2.h5 app_ref.h5 farray.h5 \ - earray.h5 + earray.h5 efc[0-5].h5 # Sources for testhdf5 executable testhdf5_SOURCES=testhdf5.c tarray.c tattr.c tchecksum.c tconfig.c tfile.c \ diff --git a/test/Makefile.in b/test/Makefile.in index a734045..98fa754 100644 --- a/test/Makefile.in +++ b/test/Makefile.in @@ -82,7 +82,7 @@ am__EXEEXT_1 = testhdf5$(EXEEXT) lheap$(EXEEXT) ohdr$(EXEEXT) \ hyperslab$(EXEEXT) istore$(EXEEXT) bittests$(EXEEXT) \ dt_arith$(EXEEXT) dtypes$(EXEEXT) dsets$(EXEEXT) \ cmpd_dset$(EXEEXT) filter_fail$(EXEEXT) extend$(EXEEXT) \ - external$(EXEEXT) objcopy$(EXEEXT) links$(EXEEXT) \ + external$(EXEEXT) efc$(EXEEXT) objcopy$(EXEEXT) links$(EXEEXT) \ unlink$(EXEEXT) big$(EXEEXT) mtime$(EXEEXT) fillval$(EXEEXT) \ mount$(EXEEXT) flush1$(EXEEXT) flush2$(EXEEXT) \ app_ref$(EXEEXT) enum$(EXEEXT) set_extent$(EXEEXT) \ @@ -163,6 +163,10 @@ earray_SOURCES = earray.c earray_OBJECTS = earray.$(OBJEXT) earray_LDADD = $(LDADD) earray_DEPENDENCIES = libh5test.la $(LIBHDF5) +efc_SOURCES = efc.c +efc_OBJECTS = efc.$(OBJEXT) +efc_LDADD = $(LDADD) +efc_DEPENDENCIES = libh5test.la $(LIBHDF5) enum_SOURCES = enum.c enum_OBJECTS = enum.$(OBJEXT) enum_LDADD = $(LDADD) @@ -397,9 +401,9 @@ LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \ SOURCES = $(libh5test_la_SOURCES) accum.c app_ref.c big.c bittests.c \ btree2.c cache.c cache_api.c cache_tagging.c cmpd_dset.c \ cross_read.c dangle.c dsets.c dt_arith.c dtransform.c dtypes.c \ - earray.c enum.c err_compat.c error_test.c extend.c external.c \ - farray.c fheap.c fillval.c filter_fail.c flush1.c flush2.c \ - freespace.c gen_bad_ohdr.c gen_bogus.c gen_cross.c \ + earray.c efc.c enum.c err_compat.c error_test.c extend.c \ + external.c farray.c fheap.c fillval.c filter_fail.c flush1.c \ + flush2.c freespace.c gen_bad_ohdr.c gen_bogus.c gen_cross.c \ gen_deflate.c gen_filespace.c gen_filters.c gen_new_array.c \ gen_new_fill.c gen_new_group.c gen_new_mtime.c gen_new_super.c \ gen_noencoder.c gen_nullspace.c gen_sizes_lheap.c \ @@ -411,7 +415,7 @@ SOURCES = $(libh5test_la_SOURCES) accum.c app_ref.c big.c bittests.c \ DIST_SOURCES = $(libh5test_la_SOURCES) accum.c app_ref.c big.c \ bittests.c btree2.c cache.c cache_api.c cache_tagging.c \ cmpd_dset.c cross_read.c dangle.c dsets.c dt_arith.c \ - dtransform.c dtypes.c earray.c enum.c err_compat.c \ + dtransform.c dtypes.c earray.c efc.c enum.c err_compat.c \ error_test.c extend.c external.c farray.c fheap.c fillval.c \ filter_fail.c flush1.c flush2.c freespace.c gen_bad_ohdr.c \ gen_bogus.c gen_cross.c gen_deflate.c gen_filespace.c \ @@ -727,7 +731,7 @@ CHECK_CLEANFILES = *.chkexe *.chklog *.clog accum.h5 cmpd_dset.h5 \ err_compat.h5 dtransform.h5 test_filters.h5 get_file_name.h5 \ tstint[1-2].h5 unlink_chunked.h5 btree2.h5 objcopy_src.h5 \ objcopy_dst.h5 objcopy_ext.dat trefer1.h5 trefer2.h5 \ - app_ref.h5 farray.h5 earray.h5 + app_ref.h5 farray.h5 earray.h5 efc[0-5].h5 INCLUDES = -I$(top_srcdir)/src -I$(top_builddir)/src # Test script for error_test and err_compat @@ -744,7 +748,7 @@ SCRIPT_DEPEND = error_test$(EXEEXT) err_compat$(EXEEXT) links_env$(EXEEXT) # other current library code tests. TEST_PROG = testhdf5 lheap ohdr stab gheap cache cache_api cache_tagging \ pool accum hyperslab istore bittests dt_arith \ - dtypes dsets cmpd_dset filter_fail extend external objcopy links unlink \ + dtypes dsets cmpd_dset filter_fail extend external efc objcopy links unlink \ big mtime fillval mount flush1 flush2 app_ref enum \ set_extent ttsafe \ getname vfd ntypes dangle dtransform reserved cross_read \ @@ -924,6 +928,9 @@ dtypes$(EXEEXT): $(dtypes_OBJECTS) $(dtypes_DEPENDENCIES) earray$(EXEEXT): $(earray_OBJECTS) $(earray_DEPENDENCIES) @rm -f earray$(EXEEXT) $(LINK) $(earray_OBJECTS) $(earray_LDADD) $(LIBS) +efc$(EXEEXT): $(efc_OBJECTS) $(efc_DEPENDENCIES) + @rm -f efc$(EXEEXT) + $(LINK) $(efc_OBJECTS) $(efc_LDADD) $(LIBS) enum$(EXEEXT): $(enum_OBJECTS) $(enum_DEPENDENCIES) @rm -f enum$(EXEEXT) $(LINK) $(enum_OBJECTS) $(enum_LDADD) $(LIBS) @@ -1104,6 +1111,7 @@ distclean-compile: @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/dtransform.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/dtypes.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/earray.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/efc.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/enum.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/err_compat.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/error_test.Po@am__quote@ diff --git a/test/efc.c b/test/efc.c new file mode 100644 index 0000000..1ee7ce3 --- /dev/null +++ b/test/efc.c @@ -0,0 +1,3213 @@ +/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * + * 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 files COPYING and Copyright.html. COPYING can be found at the root * + * of the source code distribution tree; Copyright.html can be found at the * + * root level of an installed copy of the electronic HDF5 document set and * + * is linked from the top-level documents page. It can also be found at * + * http://hdfgroup.org/HDF5/doc/Copyright.html. If you do not have * + * access to either file, you may request a copy from help@hdfgroup.org. * + * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ + +/* Programmer: Neil Fortner + * December 16, 2010 + */ + +#include "h5test.h" + +#define H5F_PACKAGE +#include "H5Fpkg.h" +#include "H5Iprivate.h" + +const char *FILENAME[] = { + "efc0", + "efc1", + "efc2", + "efc3", + "efc4", + "efc5", + NULL +}; + +/* Global patched filename buffer */ +static char filename[6][1024]; + +/* Global property lists - just copies of the defaults (necessary to use + * internal functions */ +hid_t fcpl_id = -1; +hid_t fapl_id = -1; +hid_t dxpl_id = -1; + + +/*------------------------------------------------------------------------- + * Function: test_single + * + * Purpose: Tests manipulations on a single external file cache. + * + * Return: Success: 0 + * Failure: Number of errors + * + * Programmer: Neil Fortner + * December 16, 2010 + * + *------------------------------------------------------------------------- + */ +static unsigned +test_single(void) +{ + H5F_t *f0 = NULL; /* Parent file containing EFC */ + H5F_t *f1 = NULL; /* Child file */ + H5F_t *f2 = NULL; /* Child file */ + H5F_t *f3 = NULL; /* Child file */ + H5F_t *f4 = NULL; /* Child file */ + H5F_t *ftmp1 = NULL; /* Temp file */ + H5F_t *ftmp2 = NULL; /* Temp file */ + H5F_t *ftmp3 = NULL; /* Temp file */ + H5F_t *ftmp4 = NULL; /* Temp file */ + + TESTING("single EFC"); + + /* Set EFC size to 3. Do this instead of H5F_efc_create() so we can pass + * a file pointer to H5F_efc_open containing the EFC. */ + if(H5Pset_elink_file_cache_size(fapl_id, 3) < 0) + TEST_ERROR + + /* Open parent file */ + if(NULL == (f0 = H5F_open(filename[0], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + + /* Disable EFC for child files */ + if(H5Pset_elink_file_cache_size(fapl_id, 0) < 0) + TEST_ERROR + + + /* Test 1: Open file 1 through EFC, close, then open normally, verify ref + * count = 2, release EFC, verify ref count = 1. Verifies a file can be + * held open by the EFC. */ + if(NULL == (f1 = H5F_efc_open(f0, filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f1) < 0) + FAIL_STACK_ERROR + if(NULL == (ftmp1 = H5F_open(filename[1], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(ftmp1->shared->nrefs != 2) + TEST_ERROR + if(H5F_efc_release(f0->shared->efc) < 0) + FAIL_STACK_ERROR + if(ftmp1->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(ftmp1) < 0) + FAIL_STACK_ERROR + + + /* Test 2: Verify that subsequent efc_open requests return the cached top + * level file pointer. Open file 1 through EFC, close, open again, verify + * file pointers are the same. */ + if(NULL == (f1 = H5F_efc_open(f0, filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + ftmp1 = f1; + if(H5F_efc_close(f0, f1) < 0) + FAIL_STACK_ERROR + if(NULL == (f1 = H5F_efc_open(f0, filename[1], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(f1 != ftmp1) + TEST_ERROR + if(f1->shared->nrefs != 1) + TEST_ERROR + if(H5F_efc_close(f0, f1) < 0) + FAIL_STACK_ERROR + if(H5F_efc_release(f0->shared->efc) < 0) + FAIL_STACK_ERROR + + + /* Test 3: Verify LRU functionality. Add four files to the EFC and verify + * that the one added first is evicted. Then reopen files in a different + * order. Open each file normally after closing through EFC the first time + * to track ref counts. */ + if(NULL == (f1 = H5F_efc_open(f0, filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f1) < 0) + FAIL_STACK_ERROR + if(NULL == (f1 = H5F_open(filename[1], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f1->shared->nrefs != 2) + TEST_ERROR + + if(NULL == (f2 = H5F_efc_open(f0, filename[2], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f2) < 0) + FAIL_STACK_ERROR + if(NULL == (f2 = H5F_open(filename[2], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f1->shared->nrefs != 2) + TEST_ERROR + if(f2->shared->nrefs != 2) + TEST_ERROR + + if(NULL == (f3 = H5F_efc_open(f0, filename[3], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f3) < 0) + FAIL_STACK_ERROR + if(NULL == (f3 = H5F_open(filename[3], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f1->shared->nrefs != 2) + TEST_ERROR + if(f2->shared->nrefs != 2) + TEST_ERROR + if(f3->shared->nrefs != 2) + TEST_ERROR + + if(NULL == (f4 = H5F_efc_open(f0, filename[4], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f4) < 0) + FAIL_STACK_ERROR + if(NULL == (f4 = H5F_open(filename[4], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f1->shared->nrefs != 1) + TEST_ERROR + if(f2->shared->nrefs != 2) + TEST_ERROR + if(f3->shared->nrefs != 2) + TEST_ERROR + if(f4->shared->nrefs != 2) + TEST_ERROR + + if(NULL == (ftmp3 = H5F_efc_open(f0, filename[3], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, ftmp3) < 0) + FAIL_STACK_ERROR + if(f1->shared->nrefs != 1) + TEST_ERROR + if(f2->shared->nrefs != 2) + TEST_ERROR + if(f3->shared->nrefs != 2) + TEST_ERROR + if(f4->shared->nrefs != 2) + TEST_ERROR + + if(NULL == (ftmp2 = H5F_efc_open(f0, filename[2], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, ftmp2) < 0) + FAIL_STACK_ERROR + if(f1->shared->nrefs != 1) + TEST_ERROR + if(f2->shared->nrefs != 2) + TEST_ERROR + if(f3->shared->nrefs != 2) + TEST_ERROR + if(f4->shared->nrefs != 2) + TEST_ERROR + + if(NULL == (ftmp1 = H5F_efc_open(f0, filename[1], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, ftmp1) < 0) + FAIL_STACK_ERROR + if(f1->shared->nrefs != 2) + TEST_ERROR + if(f2->shared->nrefs != 2) + TEST_ERROR + if(f3->shared->nrefs != 2) + TEST_ERROR + if(f4->shared->nrefs != 1) + TEST_ERROR + + if(NULL == (ftmp4 = H5F_efc_open(f0, filename[4], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, ftmp4) < 0) + FAIL_STACK_ERROR + if(f1->shared->nrefs != 2) + TEST_ERROR + if(f2->shared->nrefs != 2) + TEST_ERROR + if(f3->shared->nrefs != 1) + TEST_ERROR + if(f4->shared->nrefs != 2) + TEST_ERROR + + if(H5F_efc_release(f0->shared->efc) < 0) + FAIL_STACK_ERROR + if(f1->shared->nrefs != 1) + TEST_ERROR + if(f2->shared->nrefs != 1) + TEST_ERROR + if(f3->shared->nrefs != 1) + TEST_ERROR + if(f4->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f1) < 0) + FAIL_STACK_ERROR + if(H5F_try_close(f2) < 0) + FAIL_STACK_ERROR + if(H5F_try_close(f3) < 0) + FAIL_STACK_ERROR + if(H5F_try_close(f4) < 0) + FAIL_STACK_ERROR + + + /* Test 4: Verify that files kept open through the EFC are not evicted by + * H5F_efc_release(). */ + if(NULL == (f1 = H5F_efc_open(f0, filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp1 = H5F_open(filename[1], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(ftmp1->shared->nrefs != 2) + TEST_ERROR + if(H5F_efc_release(f0->shared->efc) < 0) + FAIL_STACK_ERROR + if(ftmp1->shared->nrefs != 2) + TEST_ERROR + if(H5F_efc_close(f0, f1) < 0) + FAIL_STACK_ERROR + if(ftmp1->shared->nrefs != 2) + TEST_ERROR + if(H5F_efc_release(f0->shared->efc) < 0) + FAIL_STACK_ERROR + if(ftmp1->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(ftmp1) < 0) + FAIL_STACK_ERROR + + + /* Test 5: Verify that files kept open through the EFC are not evicted by + * filling up the cache. Open 4 files while holding the first open. Verify + * that the second file is evicted. Close the first file, reopen the + * second, and verify that the first file is evicted. */ + if(NULL == (f1 = H5F_efc_open(f0, filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp1 = H5F_open(filename[1], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(ftmp1->shared != f1->shared) + TEST_ERROR + if(ftmp1->shared->nrefs != 2) + TEST_ERROR + + if(NULL == (f2 = H5F_efc_open(f0, filename[2], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f2) < 0) + FAIL_STACK_ERROR + if(NULL == (ftmp2 = H5F_open(filename[2], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(ftmp2->shared->nrefs != 2) + TEST_ERROR + + if(NULL == (f3 = H5F_efc_open(f0, filename[3], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f3) < 0) + FAIL_STACK_ERROR + if(ftmp2->shared->nrefs != 2) + TEST_ERROR + + if(NULL == (f4 = H5F_efc_open(f0, filename[4], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f4) < 0) + FAIL_STACK_ERROR + if(ftmp1->shared->nrefs != 2) + TEST_ERROR + if(ftmp2->shared->nrefs != 1) + TEST_ERROR + + if(H5F_efc_close(f0, f1) < 0) + FAIL_STACK_ERROR + if(ftmp1->shared->nrefs != 2) + TEST_ERROR + if(NULL == (f2 = H5F_efc_open(f0, filename[2], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f2) < 0) + FAIL_STACK_ERROR + if(ftmp1->shared->nrefs != 1) + TEST_ERROR + if(ftmp2->shared->nrefs != 2) + TEST_ERROR + if(NULL == (f1 = H5F_efc_open(f0, filename[1], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f1) < 0) + FAIL_STACK_ERROR + if(ftmp1->shared->nrefs != 2) + TEST_ERROR + if(ftmp2->shared->nrefs != 2) + TEST_ERROR + + if(H5F_efc_release(f0->shared->efc) < 0) + FAIL_STACK_ERROR + if(ftmp1->shared->nrefs != 1) + TEST_ERROR + if(ftmp2->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(ftmp1) < 0) + FAIL_STACK_ERROR + if(H5F_try_close(ftmp2) < 0) + FAIL_STACK_ERROR + + + /* Test 6: Verify that having a full EFC filled only with open files + * prevents further files from being cached. Open and hold open 3 files + * through the EFC, then open the fourth and verify that it was not added to + * the EFC. */ + if(NULL == (f1 = H5F_efc_open(f0, filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp1 = H5F_open(filename[1], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(ftmp1->shared != f1->shared) + TEST_ERROR + if(ftmp1->shared->nrefs != 2) + TEST_ERROR + + if(NULL == (f2 = H5F_efc_open(f0, filename[2], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp2 = H5F_open(filename[2], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(ftmp2->shared != f2->shared) + TEST_ERROR + if(ftmp2->shared->nrefs != 2) + TEST_ERROR + + if(NULL == (f3 = H5F_efc_open(f0, filename[3], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp3 = H5F_open(filename[3], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(ftmp3->shared != f3->shared) + TEST_ERROR + if(ftmp3->shared->nrefs != 2) + TEST_ERROR + + if(NULL == (f4 = H5F_efc_open(f0, filename[4], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f4) < 0) + FAIL_STACK_ERROR + if(NULL == (ftmp4 = H5F_open(filename[4], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(ftmp4->shared->nrefs != 1) + TEST_ERROR + + if(H5F_efc_close(f0, f1) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f2) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f3) < 0) + FAIL_STACK_ERROR + if(ftmp1->shared->nrefs != 2) + TEST_ERROR + if(ftmp2->shared->nrefs != 2) + TEST_ERROR + if(ftmp3->shared->nrefs != 2) + TEST_ERROR + if(H5F_efc_release(f0->shared->efc) < 0) + FAIL_STACK_ERROR + if(ftmp1->shared->nrefs != 1) + TEST_ERROR + if(ftmp2->shared->nrefs != 1) + TEST_ERROR + if(ftmp3->shared->nrefs != 1) + TEST_ERROR + if(ftmp4->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(ftmp1) < 0) + FAIL_STACK_ERROR + if(H5F_try_close(ftmp2) < 0) + FAIL_STACK_ERROR + if(H5F_try_close(ftmp3) < 0) + FAIL_STACK_ERROR + if(H5F_try_close(ftmp4) < 0) + FAIL_STACK_ERROR + + + /* Test 7: Test multiple file opens. Open a file twice, close it once, then + * verify that it is not evicted by H5F_efc_release(). */ + if(NULL == (f1 = H5F_efc_open(f0, filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f2 = H5F_efc_open(f0, filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp1 = H5F_open(filename[1], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(ftmp1->shared->nrefs != 2) + TEST_ERROR + if(H5F_efc_close(f0, f2) < 0) + FAIL_STACK_ERROR + if(H5F_efc_release(f0->shared->efc) < 0) + FAIL_STACK_ERROR + if(ftmp1->shared->nrefs != 2) + TEST_ERROR + if(H5F_efc_close(f0, f1) < 0) + FAIL_STACK_ERROR + if(ftmp1->shared->nrefs != 2) + TEST_ERROR + if(H5F_efc_release(f0->shared->efc) < 0) + FAIL_STACK_ERROR + if(ftmp1->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(ftmp1) < 0) + FAIL_STACK_ERROR + + + /* Close parent file */ + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + + PASSED(); + + return 0; + +error: + return 1; +} /* test_single */ + + +/*------------------------------------------------------------------------- + * Function: test_graph_nocycle + * + * Purpose: Tests manipulations on a graph of files with external file + * caches. The graph does not contain cycles. + * + * Return: Success: 0 + * Failure: Number of errors + * + * Programmer: Neil Fortner + * January 4, 2011 + * + *------------------------------------------------------------------------- + */ +static unsigned +test_graph_nocycle(void) +{ + H5F_t *f0 = NULL; /* Parent file containing EFC */ + H5F_t *f1 = NULL; /* Child file */ + H5F_t *f2 = NULL; /* Child file */ + H5F_t *f3 = NULL; /* Child file */ + H5F_t *f4 = NULL; /* Child file */ + H5F_t *ftmp1 = NULL; /* Temp file */ + H5F_t *ftmp2 = NULL; /* Temp file */ + H5F_t *ftmp3 = NULL; /* Temp file */ + H5F_t *ftmp4 = NULL; /* Temp file */ + + TESTING("graph of EFCs without cycles"); + + /* Set EFC size to 8. Do this instead of H5F_efc_create() so we can pass + * a file pointer to H5F_efc_open containing the EFC. Set to a high number + * because we don't test the EFC becoming too large in this test. */ + if(H5Pset_elink_file_cache_size(fapl_id, 8) < 0) + TEST_ERROR + + + /* Test 1: Simple 3 file chain. Open file 1 through file 0, then open file + * 2 through file 1. Release file 0's EFC and verify that file 2 gets its + * ref count reduced (implying file 1 was closed). Do the same with the + * opening order reversed. */ + if(NULL == (f0 = H5F_open(filename[0], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f1 = H5F_efc_open(f0, filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f2 = H5F_efc_open(f1, filename[2], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f1, f2) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f1) < 0) + FAIL_STACK_ERROR + if(NULL == (ftmp2 = H5F_open(filename[2], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(ftmp2->shared->nrefs != 2) + TEST_ERROR + if(H5F_efc_release(f0->shared->efc) < 0) + FAIL_STACK_ERROR + if(ftmp2->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(ftmp2) < 0) + FAIL_STACK_ERROR + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + + if(NULL == (f0 = H5F_open(filename[0], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp1 = H5F_open(filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f2 = H5F_efc_open(ftmp1, filename[2], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f1 = H5F_efc_open(f0, filename[1], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_try_close(ftmp1) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f1, f2) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f1) < 0) + FAIL_STACK_ERROR + if(NULL == (ftmp2 = H5F_open(filename[2], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(ftmp2->shared->nrefs != 2) + TEST_ERROR + if(H5F_efc_release(f0->shared->efc) < 0) + FAIL_STACK_ERROR + if(ftmp2->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(ftmp2) < 0) + FAIL_STACK_ERROR + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + + + /* Test 2: 5 file chain. The parent file has 2 child files, each of which + * has their own child file. Verifies that releasing the parent's EFC + * closes all 4 children. */ + if(NULL == (f0 = H5F_open(filename[0], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + + if(NULL == (f1 = H5F_efc_open(f0, filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f2 = H5F_efc_open(f1, filename[2], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f1, f2) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f1) < 0) + FAIL_STACK_ERROR + if(NULL == (ftmp2 = H5F_open(filename[2], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(ftmp2->shared->nrefs != 2) + TEST_ERROR + + if(NULL == (f3 = H5F_efc_open(f0, filename[3], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f4 = H5F_efc_open(f3, filename[4], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f3, f4) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f3) < 0) + FAIL_STACK_ERROR + if(NULL == (ftmp4 = H5F_open(filename[4], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(ftmp4->shared->nrefs != 2) + TEST_ERROR + + if(H5F_efc_release(f0->shared->efc) < 0) + FAIL_STACK_ERROR + if(ftmp2->shared->nrefs != 1) + TEST_ERROR + if(ftmp4->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(ftmp2) < 0) + FAIL_STACK_ERROR + if(H5F_try_close(ftmp4) < 0) + FAIL_STACK_ERROR + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + + + /* Test 3: Simple "inverted" tree. Two parent files share a child file, + * which has its own child file. Verify that the child's child is not + * closed until both parents' EFCs are released. First release through one + * parent, then reopen through that parent and release the other, then + * re-release the first parent. */ + if(NULL == (f0 = H5F_open(filename[0], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f1 = H5F_open(filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f2 = H5F_efc_open(f0, filename[2], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp2 = H5F_efc_open(f1, filename[2], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f3 = H5F_efc_open(f2, filename[3], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f2, f3) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f2) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f1, ftmp2) < 0) + FAIL_STACK_ERROR + if(NULL == (ftmp3 = H5F_open(filename[3], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(ftmp3->shared->nrefs != 2) + TEST_ERROR + + if(H5F_efc_release(f0->shared->efc) < 0) + FAIL_STACK_ERROR + if(ftmp3->shared->nrefs != 2) + TEST_ERROR + + if(NULL == (f2 = H5F_efc_open(f0, filename[2], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f2) < 0) + FAIL_STACK_ERROR + if(H5F_efc_release(f1->shared->efc) < 0) + FAIL_STACK_ERROR + if(ftmp3->shared->nrefs != 2) + TEST_ERROR + + if(H5F_efc_release(f0->shared->efc) < 0) + FAIL_STACK_ERROR + if(ftmp3->shared->nrefs != 1) + TEST_ERROR + + if(H5F_try_close(ftmp3) < 0) + FAIL_STACK_ERROR + if(H5F_try_close(f1) < 0) + FAIL_STACK_ERROR + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + + + /* Test 4: Simple "diamond" tree. The parent file has two children, which + * shared the same child. Verify that releasing the parent file closes all + * files. */ + if(NULL == (f0 = H5F_open(filename[0], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f1 = H5F_efc_open(f0, filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f2 = H5F_efc_open(f0, filename[2], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f3 = H5F_efc_open(f2, filename[3], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f2, f3) < 0) + FAIL_STACK_ERROR + if(NULL == (f3 = H5F_efc_open(f1, filename[3], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f1, f3) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f2) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f1) < 0) + FAIL_STACK_ERROR + if(NULL == (ftmp3 = H5F_open(filename[3], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(ftmp3->shared->nrefs != 3) + TEST_ERROR + + if(H5F_efc_release(f0->shared->efc) < 0) + FAIL_STACK_ERROR + if(ftmp3->shared->nrefs != 1) + TEST_ERROR + + if(H5F_try_close(ftmp3) < 0) + FAIL_STACK_ERROR + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + + + /* Test 5: Dense 5 file graph. f0 caches f1, f2, f3 and f4. f1 and f2 + * each cache f3 and f4. f3 caches f4. Verify that releasing f0 closes all + * files. */ + if(NULL == (f0 = H5F_open(filename[0], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f1 = H5F_efc_open(f0, filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f2 = H5F_efc_open(f0, filename[2], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f3 = H5F_efc_open(f0, filename[3], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f4 = H5F_efc_open(f0, filename[4], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f4) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f3) < 0) + FAIL_STACK_ERROR + if(NULL == (f3 = H5F_efc_open(f1, filename[3], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f4 = H5F_efc_open(f1, filename[4], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f1, f4) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f1, f3) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f1) < 0) + FAIL_STACK_ERROR + if(NULL == (f3 = H5F_efc_open(f2, filename[3], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f4 = H5F_efc_open(f2, filename[4], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f2, f4) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f2) < 0) + FAIL_STACK_ERROR + if(NULL == (f4 = H5F_efc_open(f3, filename[4], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f3, f4) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f2, f3) < 0) + FAIL_STACK_ERROR + if(NULL == (ftmp4 = H5F_open(filename[4], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(ftmp4->shared->nrefs != 5) + TEST_ERROR + + if(H5F_efc_release(f0->shared->efc) < 0) + FAIL_STACK_ERROR + if(ftmp4->shared->nrefs != 1) + TEST_ERROR + if(NULL == (ftmp1 = H5F_open(filename[1], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(ftmp1->shared->nrefs != 1) + TEST_ERROR + if(NULL == (ftmp2 = H5F_open(filename[2], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(ftmp2->shared->nrefs != 1) + TEST_ERROR + if(NULL == (ftmp3 = H5F_open(filename[3], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(ftmp3->shared->nrefs != 1) + TEST_ERROR + + if(H5F_try_close(ftmp1) < 0) + FAIL_STACK_ERROR + if(H5F_try_close(ftmp2) < 0) + FAIL_STACK_ERROR + if(H5F_try_close(ftmp3) < 0) + FAIL_STACK_ERROR + if(H5F_try_close(ftmp4) < 0) + FAIL_STACK_ERROR + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + + + PASSED(); + + return 0; + +error: + return 1; +} /* test_graph_nocycle */ + + +/*------------------------------------------------------------------------- + * Function: test_graph_cycle + * + * Purpose: Tests manipulations on a graph of files with external file + * caches containing cycles. + * + * Return: Success: 0 + * Failure: Number of errors + * + * Programmer: Neil Fortner + * January 6, 2011 + * + *------------------------------------------------------------------------- + */ +static unsigned +test_graph_cycle(void) +{ + H5F_t *f0 = NULL; /* File */ + H5F_t *f1 = NULL; /* File */ + H5F_t *f2 = NULL; /* File */ + H5F_t *f3 = NULL; /* File */ + H5F_t *f4 = NULL; /* File */ + H5F_t *f5 = NULL; /* File */ + H5F_t *ftmp0 = NULL; /* Temp file */ + H5F_t *ftmp1 = NULL; /* Temp file */ + H5F_t *ftmp2 = NULL; /* Temp file */ + H5F_t *ftmp3 = NULL; /* Temp file */ + + TESTING("graph of EFCs with cycles"); + + /* Set EFC size to 8. Do this instead of H5F_efc_create() so we can pass + * a file pointer to H5F_efc_open containing the EFC. Set to a high number + * because we don't test the EFC becoming too large in this test. */ + if(H5Pset_elink_file_cache_size(fapl_id, 8) < 0) + TEST_ERROR + + + /* Test 1: File caches itself. Verify that closing the file causes it to be + * actually closed, and there is no other unexpected behavior. */ + if(NULL == (f0 = H5F_open(filename[0], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp0 = H5F_efc_open(f0, filename[0], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, ftmp0) < 0) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 2) + TEST_ERROR + if(H5F_efc_release(f0->shared->efc) < 0) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 1) + TEST_ERROR + + if(NULL == (ftmp0 = H5F_efc_open(f0, filename[0], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, ftmp0) < 0) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 2) + TEST_ERROR + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + if(NULL == (f0 = H5F_open(filename[0], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 1) + TEST_ERROR + + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + + + /* Test 2: Indirectly referenced file caches itself. Same as above except + * the file is part of another file's EFC. */ + if(NULL == (f0 = H5F_open(filename[0], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f1 = H5F_efc_open(f0, filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp1 = H5F_efc_open(f1, filename[1], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f1, ftmp1) < 0) + FAIL_STACK_ERROR + if(f1->shared->nrefs != 2) + TEST_ERROR + if(H5F_efc_close(f0, f1) < 0) + FAIL_STACK_ERROR + if(H5F_efc_release(f0->shared->efc) < 0) + FAIL_STACK_ERROR + if(NULL == (f1 = H5F_open(filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f1->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f1) < 0) + FAIL_STACK_ERROR + + if(NULL == (f1 = H5F_efc_open(f0, filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp1 = H5F_efc_open(f1, filename[1], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f1, ftmp1) < 0) + FAIL_STACK_ERROR + if(f1->shared->nrefs != 2) + TEST_ERROR + if(H5F_efc_close(f0, f1) < 0) + FAIL_STACK_ERROR + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + if(NULL == (f1 = H5F_open(filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f1->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f1) < 0) + FAIL_STACK_ERROR + + + /* Test 3: Simple 2 file cycle */ + if(NULL == (f0 = H5F_open(filename[0], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f1 = H5F_efc_open(f0, filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp0 = H5F_efc_open(f1, filename[0], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f1, ftmp0) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f1) < 0) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 2) + TEST_ERROR + if(H5F_efc_release(f0->shared->efc) < 0) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 1) + TEST_ERROR + + if(NULL == (f1 = H5F_efc_open(f0, filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp0 = H5F_efc_open(f1, filename[0], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f1, ftmp0) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f1) < 0) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 2) + TEST_ERROR + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + if(NULL == (f0 = H5F_open(filename[0], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + + + /* Test 4: Simple 2 file cycle (indirectly referenced) */ + if(NULL == (f0 = H5F_open(filename[0], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f1 = H5F_efc_open(f0, filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f2 = H5F_efc_open(f1, filename[2], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp1 = H5F_efc_open(f2, filename[1], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f2, ftmp1) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f1, f2) < 0) + FAIL_STACK_ERROR + if(f1->shared->nrefs != 2) + TEST_ERROR + if(H5F_efc_close(f0, f1) < 0) + FAIL_STACK_ERROR + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + if(NULL == (f1 = H5F_open(filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f1->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f1) < 0) + FAIL_STACK_ERROR + + + /* Test 5: Parallel double cycle */ + if(NULL == (f0 = H5F_open(filename[0], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f1 = H5F_efc_open(f0, filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp0 = H5F_efc_open(f1, filename[0], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f1, ftmp0) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f1) < 0) + FAIL_STACK_ERROR + if(NULL == (f2 = H5F_efc_open(f0, filename[2], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp0 = H5F_efc_open(f2, filename[0], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f2, ftmp0) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f2) < 0) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 3) + TEST_ERROR + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + if(NULL == (f0 = H5F_open(filename[0], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + + + /* Test 6: Parallel double cycle with release */ + if(NULL == (f0 = H5F_open(filename[0], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f1 = H5F_efc_open(f0, filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp0 = H5F_efc_open(f1, filename[0], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f1, ftmp0) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f1) < 0) + FAIL_STACK_ERROR + if(NULL == (f2 = H5F_efc_open(f0, filename[2], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp0 = H5F_efc_open(f2, filename[0], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f2, ftmp0) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f2) < 0) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 3) + TEST_ERROR + if(H5F_efc_release(f0->shared->efc) < 0) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + + + /* Test 7: Chained parallel double cycle */ + if(NULL == (f0 = H5F_open(filename[0], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f1 = H5F_efc_open(f0, filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp0 = H5F_efc_open(f1, filename[0], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f2 = H5F_efc_open(f1, filename[2], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp1 = H5F_efc_open(f2, filename[1], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f2, ftmp1) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f1, f2) < 0) + FAIL_STACK_ERROR + if(NULL == (f3 = H5F_efc_open(f1, filename[3], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp1 = H5F_efc_open(f3, filename[1], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f3, ftmp1) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f1, f3) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f1, ftmp0) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f1) < 0) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 2) + TEST_ERROR + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + if(NULL == (f0 = H5F_open(filename[0], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + + + /* Test 8: Chained parallel double cycle with release */ + if(NULL == (f0 = H5F_open(filename[0], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f1 = H5F_efc_open(f0, filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp0 = H5F_efc_open(f1, filename[0], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f2 = H5F_efc_open(f1, filename[2], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp1 = H5F_efc_open(f2, filename[1], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f2, ftmp1) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f1, f2) < 0) + FAIL_STACK_ERROR + if(NULL == (f3 = H5F_efc_open(f1, filename[3], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp1 = H5F_efc_open(f3, filename[1], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f3, ftmp1) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f1, f3) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f1, ftmp0) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f1) < 0) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 2) + TEST_ERROR + if(H5F_efc_release(f0->shared->efc) < 0) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + + + /* Test 9: Simple 2 file cycle, extra ID on root */ + if(NULL == (f0 = H5F_open(filename[0], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp0 = H5F_open(filename[0], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f1 = H5F_efc_open(f0, filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp1 = H5F_efc_open(f1, filename[0], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f1, ftmp1) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f1) < 0) + FAIL_STACK_ERROR + if(f0->shared != ftmp0->shared) + TEST_ERROR + if(f0->shared->nrefs != 3) + TEST_ERROR + if(H5F_try_close(ftmp0) < 0) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 2) + TEST_ERROR + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + if(NULL == (f0 = H5F_open(filename[0], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + + + /* Test 10: Simple 2 file cycle, extra ID on second file */ + if(NULL == (f0 = H5F_open(filename[0], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f1 = H5F_efc_open(f0, filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp1 = H5F_open(filename[1], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp0 = H5F_efc_open(f1, filename[0], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f1, ftmp0) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f1) < 0) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 2) + TEST_ERROR + if(ftmp1->shared->nrefs != 2) + TEST_ERROR + + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + if(ftmp1->shared->nrefs != 2) + TEST_ERROR + if(NULL == (f0 = H5F_open(filename[0], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 2) + TEST_ERROR + + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + if(H5F_try_close(ftmp1) < 0) + FAIL_STACK_ERROR + if(NULL == (f0 = H5F_open(filename[0], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + if(NULL == (f1 = H5F_open(filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f1->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f1) < 0) + FAIL_STACK_ERROR + + + /* Test 11: Parallel double cycle, extra ID on a child file */ + if(NULL == (f0 = H5F_open(filename[0], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f1 = H5F_efc_open(f0, filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp0 = H5F_efc_open(f1, filename[0], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f1, ftmp0) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f1) < 0) + FAIL_STACK_ERROR + if(NULL == (f2 = H5F_efc_open(f0, filename[2], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp2 = H5F_open(filename[2], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp0 = H5F_efc_open(f2, filename[0], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f2, ftmp0) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f2) < 0) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 3) + TEST_ERROR + if(ftmp2->shared->nrefs != 2) + TEST_ERROR + + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + if(ftmp2->shared->nrefs != 2) + TEST_ERROR + if(NULL == (f0 = H5F_open(filename[0], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 3) + TEST_ERROR + + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + if(H5F_try_close(ftmp2) < 0) + FAIL_STACK_ERROR + if(NULL == (f0 = H5F_open(filename[0], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + if(NULL == (f1 = H5F_open(filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f1->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f1) < 0) + FAIL_STACK_ERROR + if(NULL == (f2 = H5F_open(filename[2], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f2->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f2) < 0) + FAIL_STACK_ERROR + + + /* Test 12: Parallel double cycle, extra ID on a child file, with release */ + if(NULL == (f0 = H5F_open(filename[0], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f1 = H5F_efc_open(f0, filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp0 = H5F_efc_open(f1, filename[0], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f1, ftmp0) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f1) < 0) + FAIL_STACK_ERROR + if(NULL == (f2 = H5F_efc_open(f0, filename[2], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp2 = H5F_open(filename[2], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp0 = H5F_efc_open(f2, filename[0], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f2, ftmp0) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f2) < 0) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 3) + TEST_ERROR + if(ftmp2->shared->nrefs != 2) + TEST_ERROR + + if(H5F_efc_release(f0->shared->efc) < 0) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 2) + TEST_ERROR + if(ftmp2->shared->nrefs != 1) + TEST_ERROR + + if(H5F_efc_release(ftmp2->shared->efc) < 0) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 1) + TEST_ERROR + if(ftmp2->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + if(H5F_try_close(ftmp2) < 0) + FAIL_STACK_ERROR + + + /* Test 13: Chained parallel double cycle, extra ID on a child file */ + if(NULL == (f0 = H5F_open(filename[0], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f1 = H5F_efc_open(f0, filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp0 = H5F_efc_open(f1, filename[0], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f2 = H5F_efc_open(f1, filename[2], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp1 = H5F_efc_open(f2, filename[1], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f2, ftmp1) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f1, f2) < 0) + FAIL_STACK_ERROR + if(NULL == (f3 = H5F_efc_open(f1, filename[3], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp3 = H5F_open(filename[3], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp1 = H5F_efc_open(f3, filename[1], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f3, ftmp1) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f1, f3) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f1, ftmp0) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f1) < 0) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 2) + TEST_ERROR + if(ftmp3->shared->nrefs != 2) + TEST_ERROR + + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + if(ftmp3->shared->nrefs != 2) + TEST_ERROR + if(NULL == (f0 = H5F_open(filename[0], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 2) + TEST_ERROR + + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + if(H5F_try_close(ftmp3) < 0) + FAIL_STACK_ERROR + if(NULL == (f0 = H5F_open(filename[0], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + if(NULL == (f1 = H5F_open(filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f1->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f1) < 0) + FAIL_STACK_ERROR + if(NULL == (f2 = H5F_open(filename[2], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f2->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f2) < 0) + FAIL_STACK_ERROR + if(NULL == (f3 = H5F_open(filename[3], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f3->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f3) < 0) + FAIL_STACK_ERROR + + + /* Test 14: Chained parallel double cycle, extra ID on a child file, with + * release */ + if(NULL == (f0 = H5F_open(filename[0], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f1 = H5F_efc_open(f0, filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp0 = H5F_efc_open(f1, filename[0], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f2 = H5F_efc_open(f1, filename[2], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp1 = H5F_efc_open(f2, filename[1], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f2, ftmp1) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f1, f2) < 0) + FAIL_STACK_ERROR + if(NULL == (f3 = H5F_efc_open(f1, filename[3], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp3 = H5F_open(filename[3], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp1 = H5F_efc_open(f3, filename[1], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f3, ftmp1) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f1, f3) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f1, ftmp0) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f1) < 0) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 2) + TEST_ERROR + if(ftmp3->shared->nrefs != 2) + TEST_ERROR + + if(H5F_efc_release(f0->shared->efc) < 0) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 2) + TEST_ERROR + if(ftmp3->shared->nrefs != 2) + TEST_ERROR + + if(H5F_efc_release(ftmp3->shared->efc) < 0) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 1) + TEST_ERROR + if(ftmp3->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + if(H5F_try_close(ftmp3) < 0) + FAIL_STACK_ERROR + + + /* Test 15: One local and one remote cycle */ + if(NULL == (f0 = H5F_open(filename[0], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f1 = H5F_efc_open(f0, filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp0 = H5F_efc_open(f1, filename[0], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f1, ftmp0) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f1) < 0) + FAIL_STACK_ERROR + if(NULL == (f2 = H5F_efc_open(f0, filename[2], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f3 = H5F_efc_open(f2, filename[3], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp2 = H5F_efc_open(f3, filename[2], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f3, ftmp2) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f2, f3) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f2) < 0) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 2) + TEST_ERROR + + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + if(NULL == (f0 = H5F_open(filename[0], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + if(NULL == (f1 = H5F_open(filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f1->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f1) < 0) + FAIL_STACK_ERROR + if(NULL == (f2 = H5F_open(filename[2], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f2->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f2) < 0) + FAIL_STACK_ERROR + if(NULL == (f3 = H5F_open(filename[3], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f3->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f3) < 0) + FAIL_STACK_ERROR + + + /* Test 16: One local and one remote cycle, with release */ + if(NULL == (f0 = H5F_open(filename[0], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f1 = H5F_efc_open(f0, filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp0 = H5F_efc_open(f1, filename[0], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f1, ftmp0) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f1) < 0) + FAIL_STACK_ERROR + if(NULL == (f2 = H5F_efc_open(f0, filename[2], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f3 = H5F_efc_open(f2, filename[3], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp2 = H5F_efc_open(f3, filename[2], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f3, ftmp2) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f2, f3) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f2) < 0) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 2) + TEST_ERROR + + if(H5F_efc_release(f0->shared->efc) < 0) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + if(NULL == (f1 = H5F_open(filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f1->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f1) < 0) + FAIL_STACK_ERROR + if(NULL == (f2 = H5F_open(filename[2], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f2->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f2) < 0) + FAIL_STACK_ERROR + if(NULL == (f3 = H5F_open(filename[3], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f3->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f3) < 0) + FAIL_STACK_ERROR + + + /* Test 17: One local and one remote cycle, remote cycle held open */ + if(NULL == (f0 = H5F_open(filename[0], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f1 = H5F_efc_open(f0, filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp0 = H5F_efc_open(f1, filename[0], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f1, ftmp0) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f1) < 0) + FAIL_STACK_ERROR + if(NULL == (f2 = H5F_efc_open(f0, filename[2], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f3 = H5F_efc_open(f2, filename[3], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp3 = H5F_open(filename[3], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp2 = H5F_efc_open(f3, filename[2], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f3, ftmp2) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f2, f3) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f2) < 0) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 2) + TEST_ERROR + + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + if(NULL == (f0 = H5F_open(filename[0], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + if(ftmp3->shared->nrefs != 2) + TEST_ERROR + + if(H5F_try_close(ftmp3) < 0) + FAIL_STACK_ERROR + if(NULL == (f1 = H5F_open(filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f1->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f1) < 0) + FAIL_STACK_ERROR + if(NULL == (f2 = H5F_open(filename[2], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f2->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f2) < 0) + FAIL_STACK_ERROR + if(NULL == (f3 = H5F_open(filename[3], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f3->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f3) < 0) + FAIL_STACK_ERROR + + + /* Test 18: One local and one remote cycle, remote cycle held open, with + * release */ + if(NULL == (f0 = H5F_open(filename[0], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f1 = H5F_efc_open(f0, filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp0 = H5F_efc_open(f1, filename[0], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f1, ftmp0) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f1) < 0) + FAIL_STACK_ERROR + if(NULL == (f2 = H5F_efc_open(f0, filename[2], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f3 = H5F_efc_open(f2, filename[3], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp3 = H5F_open(filename[3], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp2 = H5F_efc_open(f3, filename[2], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f3, ftmp2) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f2, f3) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f2) < 0) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 2) + TEST_ERROR + + if(H5F_efc_release(f0->shared->efc) < 0) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 1) + TEST_ERROR + if(ftmp3->shared->nrefs != 2) + TEST_ERROR + if(NULL == (f1 = H5F_open(filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f1->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f1) < 0) + FAIL_STACK_ERROR + if(NULL == (f2 = H5F_open(filename[2], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f2->shared->nrefs != 2) + TEST_ERROR + if(H5F_try_close(f2) < 0) + FAIL_STACK_ERROR + + if(H5F_efc_release(ftmp3->shared->efc) < 0) + FAIL_STACK_ERROR + if(ftmp3->shared->nrefs != 1) + TEST_ERROR + if(NULL == (f2 = H5F_open(filename[2], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f2->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f2) < 0) + FAIL_STACK_ERROR + + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + if(H5F_try_close(ftmp3) < 0) + FAIL_STACK_ERROR + + + /* Test 19: "Diamond" shape with links moving from bottom (root) to top. + * Also cycle between bottom (root) and top and cycles on the sides. */ + if(NULL == (f0 = H5F_open(filename[0], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f1 = H5F_efc_open(f0, filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f2 = H5F_efc_open(f0, filename[2], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f3 = H5F_efc_open(f1, filename[3], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f1, f3) < 0) + FAIL_STACK_ERROR + if(NULL == (f3 = H5F_efc_open(f2, filename[3], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f2, f3) < 0) + FAIL_STACK_ERROR + if(NULL == (f3 = H5F_efc_open(f0, filename[3], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp0 = H5F_efc_open(f3, filename[0], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f3, ftmp0) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f3) < 0) + FAIL_STACK_ERROR + if(NULL == (f4 = H5F_efc_open(f1, filename[4], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp1 = H5F_efc_open(f4, filename[1], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f4, ftmp1) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f1, f4) < 0) + FAIL_STACK_ERROR + if(NULL == (f5 = H5F_efc_open(f2, filename[5], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp2 = H5F_efc_open(f5, filename[2], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f5, ftmp2) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f2, f5) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f1) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f2) < 0) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 2) + TEST_ERROR + + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + if(NULL == (f0 = H5F_open(filename[0], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + if(NULL == (f1 = H5F_open(filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f1->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f1) < 0) + FAIL_STACK_ERROR + if(NULL == (f2 = H5F_open(filename[2], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f2->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f2) < 0) + FAIL_STACK_ERROR + if(NULL == (f3 = H5F_open(filename[3], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f3->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f3) < 0) + FAIL_STACK_ERROR + if(NULL == (f4 = H5F_open(filename[4], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f4->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f4) < 0) + FAIL_STACK_ERROR + if(NULL == (f5 = H5F_open(filename[5], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f5->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f5) < 0) + FAIL_STACK_ERROR + + + /* Test 20: "Diamond" shape with links moving from bottom (root) to top. + * Also cycle between bottom (root) and top, cycles on the sides, and + * release the files instead of closing. */ + if(NULL == (f0 = H5F_open(filename[0], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f1 = H5F_efc_open(f0, filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f2 = H5F_efc_open(f0, filename[2], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f3 = H5F_efc_open(f1, filename[3], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f1, f3) < 0) + FAIL_STACK_ERROR + if(NULL == (f3 = H5F_efc_open(f2, filename[3], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f2, f3) < 0) + FAIL_STACK_ERROR + if(NULL == (f3 = H5F_efc_open(f0, filename[3], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp0 = H5F_efc_open(f3, filename[0], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f3, ftmp0) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f3) < 0) + FAIL_STACK_ERROR + if(NULL == (f4 = H5F_efc_open(f1, filename[4], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp1 = H5F_efc_open(f4, filename[1], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f4, ftmp1) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f1, f4) < 0) + FAIL_STACK_ERROR + if(NULL == (f5 = H5F_efc_open(f2, filename[5], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp2 = H5F_efc_open(f5, filename[2], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f5, ftmp2) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f2, f5) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f1) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f2) < 0) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 2) + TEST_ERROR + + if(H5F_efc_release(f0->shared->efc) < 0) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + if(NULL == (f1 = H5F_open(filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f1->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f1) < 0) + FAIL_STACK_ERROR + if(NULL == (f2 = H5F_open(filename[2], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f2->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f2) < 0) + FAIL_STACK_ERROR + if(NULL == (f3 = H5F_open(filename[3], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f3->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f3) < 0) + FAIL_STACK_ERROR + if(NULL == (f4 = H5F_open(filename[4], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f4->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f4) < 0) + FAIL_STACK_ERROR + if(NULL == (f5 = H5F_open(filename[5], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f5->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f5) < 0) + FAIL_STACK_ERROR + + + /* Test 21: "Diamond" shape with links moving from bottom (root) to top. + * Also cycle between bottom (root) and top, cycles on sides held open. */ + if(NULL == (f0 = H5F_open(filename[0], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f1 = H5F_efc_open(f0, filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f2 = H5F_efc_open(f0, filename[2], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f3 = H5F_efc_open(f1, filename[3], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f1, f3) < 0) + FAIL_STACK_ERROR + if(NULL == (f3 = H5F_efc_open(f2, filename[3], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f2, f3) < 0) + FAIL_STACK_ERROR + if(NULL == (f3 = H5F_efc_open(f0, filename[3], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp0 = H5F_efc_open(f3, filename[0], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f3, ftmp0) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f3) < 0) + FAIL_STACK_ERROR + if(NULL == (f4 = H5F_efc_open(f1, filename[4], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp1 = H5F_efc_open(f4, filename[1], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f4, ftmp1) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f1, f4) < 0) + FAIL_STACK_ERROR + if(NULL == (f4 = H5F_open(filename[4], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f5 = H5F_efc_open(f2, filename[5], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp2 = H5F_efc_open(f5, filename[2], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f5, ftmp2) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f2, f5) < 0) + FAIL_STACK_ERROR + if(NULL == (f5 = H5F_open(filename[5], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f1) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f2) < 0) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 2) + TEST_ERROR + if(f4->shared->nrefs != 2) + TEST_ERROR + if(f5->shared->nrefs != 2) + TEST_ERROR + + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + if(f4->shared->nrefs != 2) + TEST_ERROR + if(f5->shared->nrefs != 2) + TEST_ERROR + if(NULL == (f0 = H5F_open(filename[0], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 2) + TEST_ERROR + + if(H5F_try_close(f4) < 0) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 2) + TEST_ERROR + if(f5->shared->nrefs != 2) + TEST_ERROR + + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + if(f5->shared->nrefs != 2) + TEST_ERROR + if(NULL == (f0 = H5F_open(filename[0], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 2) + TEST_ERROR + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + + if(H5F_try_close(f5) < 0) + FAIL_STACK_ERROR + + if(NULL == (f0 = H5F_open(filename[0], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + if(NULL == (f1 = H5F_open(filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f1->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f1) < 0) + FAIL_STACK_ERROR + if(NULL == (f2 = H5F_open(filename[2], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f2->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f2) < 0) + FAIL_STACK_ERROR + if(NULL == (f3 = H5F_open(filename[3], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f3->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f3) < 0) + FAIL_STACK_ERROR + if(NULL == (f4 = H5F_open(filename[4], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f4->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f4) < 0) + FAIL_STACK_ERROR + if(NULL == (f5 = H5F_open(filename[5], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f5->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f5) < 0) + FAIL_STACK_ERROR + + + /* Test 22: "Diamond" shape with links moving from bottom (root) to top. + * Also cycle between bottom (root) and top, cycles on sides held open. + * Also release the files instead of closing. */ + if(NULL == (f0 = H5F_open(filename[0], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f1 = H5F_efc_open(f0, filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f2 = H5F_efc_open(f0, filename[2], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f3 = H5F_efc_open(f1, filename[3], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f1, f3) < 0) + FAIL_STACK_ERROR + if(NULL == (f3 = H5F_efc_open(f2, filename[3], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f2, f3) < 0) + FAIL_STACK_ERROR + if(NULL == (f3 = H5F_efc_open(f0, filename[3], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp0 = H5F_efc_open(f3, filename[0], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f3, ftmp0) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f3) < 0) + FAIL_STACK_ERROR + if(NULL == (f4 = H5F_efc_open(f1, filename[4], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp1 = H5F_efc_open(f4, filename[1], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f4, ftmp1) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f1, f4) < 0) + FAIL_STACK_ERROR + if(NULL == (f4 = H5F_open(filename[4], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f5 = H5F_efc_open(f2, filename[5], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp2 = H5F_efc_open(f5, filename[2], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f5, ftmp2) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f2, f5) < 0) + FAIL_STACK_ERROR + if(NULL == (f5 = H5F_open(filename[5], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f1) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f2) < 0) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 2) + TEST_ERROR + if(f4->shared->nrefs != 2) + TEST_ERROR + if(f5->shared->nrefs != 2) + TEST_ERROR + + if(H5F_efc_release(f0->shared->efc) < 0) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 2) + TEST_ERROR + if(f4->shared->nrefs != 2) + TEST_ERROR + if(f5->shared->nrefs != 2) + TEST_ERROR + if(NULL == (f3 = H5F_open(filename[3], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f3->shared->nrefs != 3) + TEST_ERROR + if(H5F_try_close(f3) < 0) + FAIL_STACK_ERROR + + if(H5F_efc_release(f4->shared->efc) < 0) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 2) + TEST_ERROR + if(f4->shared->nrefs != 1) + TEST_ERROR + if(f5->shared->nrefs != 2) + TEST_ERROR + if(NULL == (f3 = H5F_open(filename[3], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f3->shared->nrefs != 2) + TEST_ERROR + if(H5F_try_close(f3) < 0) + FAIL_STACK_ERROR + + if(H5F_efc_release(f5->shared->efc) < 0) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 1) + TEST_ERROR + if(f4->shared->nrefs != 1) + TEST_ERROR + if(f5->shared->nrefs != 1) + TEST_ERROR + if(NULL == (f3 = H5F_open(filename[3], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f3->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f3) < 0) + FAIL_STACK_ERROR + + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + if(H5F_try_close(f4) < 0) + FAIL_STACK_ERROR + if(H5F_try_close(f5) < 0) + FAIL_STACK_ERROR + + + /* Test 23: Dense "ball" of files. 4 files each cache all files (including + * itself). */ + if(NULL == (f0 = H5F_open(filename[0], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp0 = H5F_efc_open(f0, filename[0], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, ftmp0) < 0) + FAIL_STACK_ERROR + if(NULL == (f1 = H5F_efc_open(f0, filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f2 = H5F_efc_open(f0, filename[2], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f3 = H5F_efc_open(f0, filename[3], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + + if(NULL == (ftmp0 = H5F_efc_open(f1, filename[0], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f1, ftmp0) < 0) + FAIL_STACK_ERROR + if(NULL == (ftmp1 = H5F_efc_open(f1, filename[1], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f1, ftmp1) < 0) + FAIL_STACK_ERROR + if(NULL == (ftmp2 = H5F_efc_open(f1, filename[2], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f1, ftmp2) < 0) + FAIL_STACK_ERROR + if(NULL == (ftmp3 = H5F_efc_open(f1, filename[3], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f1, ftmp3) < 0) + FAIL_STACK_ERROR + + if(NULL == (ftmp0 = H5F_efc_open(f2, filename[0], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f2, ftmp0) < 0) + FAIL_STACK_ERROR + if(NULL == (ftmp1 = H5F_efc_open(f2, filename[1], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f2, ftmp1) < 0) + FAIL_STACK_ERROR + if(NULL == (ftmp2 = H5F_efc_open(f2, filename[2], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f2, ftmp2) < 0) + FAIL_STACK_ERROR + if(NULL == (ftmp3 = H5F_efc_open(f2, filename[3], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f2, ftmp3) < 0) + FAIL_STACK_ERROR + + if(NULL == (ftmp0 = H5F_efc_open(f3, filename[0], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f3, ftmp0) < 0) + FAIL_STACK_ERROR + if(NULL == (ftmp1 = H5F_efc_open(f3, filename[1], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f3, ftmp1) < 0) + FAIL_STACK_ERROR + if(NULL == (ftmp2 = H5F_efc_open(f3, filename[2], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f3, ftmp2) < 0) + FAIL_STACK_ERROR + if(NULL == (ftmp3 = H5F_efc_open(f3, filename[3], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f3, ftmp3) < 0) + FAIL_STACK_ERROR + + if(H5F_efc_close(f0, f1) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f2) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f3) < 0) + FAIL_STACK_ERROR + + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + if(NULL == (f0 = H5F_open(filename[0], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + if(NULL == (f1 = H5F_open(filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f1->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f1) < 0) + FAIL_STACK_ERROR + if(NULL == (f2 = H5F_open(filename[2], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f2->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f2) < 0) + FAIL_STACK_ERROR + if(NULL == (f3 = H5F_open(filename[3], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f3->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f3) < 0) + FAIL_STACK_ERROR + + + /* Test 24: Dense "ball" of files. 4 files each cache all files (including + * itself). Release the files instead of closing. */ + if(NULL == (f0 = H5F_open(filename[0], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp0 = H5F_efc_open(f0, filename[0], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, ftmp0) < 0) + FAIL_STACK_ERROR + if(NULL == (f1 = H5F_efc_open(f0, filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f2 = H5F_efc_open(f0, filename[2], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f3 = H5F_efc_open(f0, filename[3], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + + if(NULL == (ftmp0 = H5F_efc_open(f1, filename[0], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f1, ftmp0) < 0) + FAIL_STACK_ERROR + if(NULL == (ftmp1 = H5F_efc_open(f1, filename[1], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f1, ftmp1) < 0) + FAIL_STACK_ERROR + if(NULL == (ftmp2 = H5F_efc_open(f1, filename[2], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f1, ftmp2) < 0) + FAIL_STACK_ERROR + if(NULL == (ftmp3 = H5F_efc_open(f1, filename[3], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f1, ftmp3) < 0) + FAIL_STACK_ERROR + + if(NULL == (ftmp0 = H5F_efc_open(f2, filename[0], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f2, ftmp0) < 0) + FAIL_STACK_ERROR + if(NULL == (ftmp1 = H5F_efc_open(f2, filename[1], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f2, ftmp1) < 0) + FAIL_STACK_ERROR + if(NULL == (ftmp2 = H5F_efc_open(f2, filename[2], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f2, ftmp2) < 0) + FAIL_STACK_ERROR + if(NULL == (ftmp3 = H5F_efc_open(f2, filename[3], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f2, ftmp3) < 0) + FAIL_STACK_ERROR + + if(NULL == (ftmp0 = H5F_efc_open(f3, filename[0], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f3, ftmp0) < 0) + FAIL_STACK_ERROR + if(NULL == (ftmp1 = H5F_efc_open(f3, filename[1], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f3, ftmp1) < 0) + FAIL_STACK_ERROR + if(NULL == (ftmp2 = H5F_efc_open(f3, filename[2], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f3, ftmp2) < 0) + FAIL_STACK_ERROR + if(NULL == (ftmp3 = H5F_efc_open(f3, filename[3], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f3, ftmp3) < 0) + FAIL_STACK_ERROR + + if(H5F_efc_close(f0, f1) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f2) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f3) < 0) + FAIL_STACK_ERROR + + if(H5F_efc_release(f0->shared->efc) < 0) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + if(NULL == (f1 = H5F_open(filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f1->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f1) < 0) + FAIL_STACK_ERROR + if(NULL == (f2 = H5F_open(filename[2], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f2->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f2) < 0) + FAIL_STACK_ERROR + if(NULL == (f3 = H5F_open(filename[3], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f3->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f3) < 0) + FAIL_STACK_ERROR + + + /* Test 25: File held open by EFC client interrupts cycle, with release */ + if(NULL == (f0 = H5F_open(filename[0], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f1 = H5F_efc_open(f0, filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp0 = H5F_efc_open(f1, filename[0], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f1, ftmp0) < 0) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 2) + TEST_ERROR + if(f1->shared->nrefs != 1) + TEST_ERROR + + if(H5F_efc_release(f0->shared->efc) < 0) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 2) + TEST_ERROR + if(f1->shared->nrefs != 1) + TEST_ERROR + if(H5F_efc_close(f0, f1) < 0) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 2) + TEST_ERROR + + if(H5F_efc_release(f0->shared->efc) < 0) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + + + /* Test 26: File held open by EFC does not interrupt cycle, with release */ + if(NULL == (f0 = H5F_open(filename[0], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f1 = H5F_efc_open(f0, filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp0 = H5F_efc_open(f1, filename[0], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f1, ftmp0) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f1) < 0) + FAIL_STACK_ERROR + if(NULL == (f2 = H5F_efc_open(f0, filename[2], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 2) + TEST_ERROR + if(f2->shared->nrefs != 1) + TEST_ERROR + + if(H5F_efc_release(f0->shared->efc) < 0) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 1) + TEST_ERROR + if(f2->shared->nrefs != 1) + TEST_ERROR + if(H5F_efc_close(f0, f2) < 0) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + + + /* Test 27: File held open by EFC client through non-parent file does not + * interrupt cycle, but parent file does (no valid way around it) */ + if(NULL == (f0 = H5F_open(filename[0], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f1 = H5F_efc_open(f0, filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp0 = H5F_efc_open(f1, filename[0], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f1, ftmp0) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f1) < 0) + FAIL_STACK_ERROR + if(NULL == (f2 = H5F_open(filename[2], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f1 = H5F_efc_open(f2, filename[1], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f3 = H5F_efc_open(f1, filename[3], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 2) + TEST_ERROR + if(f1->shared->nrefs != 2) + TEST_ERROR + if(f2->shared->nrefs != 1) + TEST_ERROR + if(f3->shared->nrefs != 1) + TEST_ERROR + + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + if(f1->shared->nrefs != 2) + TEST_ERROR + if(f2->shared->nrefs != 1) + TEST_ERROR + if(f3->shared->nrefs != 1) + TEST_ERROR + if(NULL == (f0 = H5F_open(filename[0], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 2) + TEST_ERROR + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + + if(H5F_efc_close(f1, f3) < 0) + FAIL_STACK_ERROR + if(f1->shared->nrefs != 2) + TEST_ERROR + if(f2->shared->nrefs != 1) + TEST_ERROR + if(NULL == (f0 = H5F_open(filename[0], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 2) + TEST_ERROR + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + if(NULL == (f3 = H5F_open(filename[3], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f3->shared->nrefs != 2) + TEST_ERROR + if(H5F_try_close(f3) < 0) + FAIL_STACK_ERROR + + if(H5F_efc_close(f2, f1) < 0) + FAIL_STACK_ERROR + if(f2->shared->nrefs != 1) + TEST_ERROR + if(NULL == (f0 = H5F_open(filename[0], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 2) + TEST_ERROR + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + if(NULL == (f1 = H5F_open(filename[1], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f1->shared->nrefs != 3) + TEST_ERROR + if(H5F_try_close(f1) < 0) + FAIL_STACK_ERROR + if(NULL == (f3 = H5F_open(filename[3], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f3->shared->nrefs != 2) + TEST_ERROR + if(H5F_try_close(f3) < 0) + FAIL_STACK_ERROR + + if(H5F_try_close(f2) < 0) + FAIL_STACK_ERROR + if(NULL == (f0 = H5F_open(filename[0], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + if(NULL == (f1 = H5F_open(filename[1], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f1->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f1) < 0) + FAIL_STACK_ERROR + if(NULL == (f2 = H5F_open(filename[2], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f2->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f2) < 0) + FAIL_STACK_ERROR + if(NULL == (f3 = H5F_open(filename[3], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f3->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f3) < 0) + FAIL_STACK_ERROR + + + /* Test 28: File held open by EFC client through non-parent file does not + * interrupt cycle, but parent file does (no valid way around it), with + * release */ + if(NULL == (f0 = H5F_open(filename[0], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f1 = H5F_efc_open(f0, filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp0 = H5F_efc_open(f1, filename[0], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f1, ftmp0) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f1) < 0) + FAIL_STACK_ERROR + if(NULL == (f2 = H5F_open(filename[2], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f1 = H5F_efc_open(f2, filename[1], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f3 = H5F_efc_open(f1, filename[3], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 2) + TEST_ERROR + if(f1->shared->nrefs != 2) + TEST_ERROR + if(f2->shared->nrefs != 1) + TEST_ERROR + if(f3->shared->nrefs != 1) + TEST_ERROR + + if(H5F_efc_release(f0->shared->efc) < 0) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 2) + TEST_ERROR + if(f1->shared->nrefs != 1) + TEST_ERROR + if(f2->shared->nrefs != 1) + TEST_ERROR + if(f3->shared->nrefs != 1) + TEST_ERROR + + if(H5F_efc_release(f2->shared->efc) < 0) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 2) + TEST_ERROR + if(f1->shared->nrefs != 1) + TEST_ERROR + if(f2->shared->nrefs != 1) + TEST_ERROR + if(f3->shared->nrefs != 1) + TEST_ERROR + + if(H5F_efc_close(f1, f3) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f2, f1) < 0) + FAIL_STACK_ERROR + if(H5F_efc_release(f2->shared->efc) < 0) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 1) + TEST_ERROR + if(f2->shared->nrefs != 1) + TEST_ERROR + if(NULL == (f1 = H5F_open(filename[1], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f1->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f1) < 0) + FAIL_STACK_ERROR + if(NULL == (f3 = H5F_open(filename[3], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f3->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f3) < 0) + FAIL_STACK_ERROR + + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + if(H5F_try_close(f2) < 0) + FAIL_STACK_ERROR + + + /* Test 29: File without EFC interrupts cycle */ + if(NULL == (f0 = H5F_open(filename[0], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(H5Pset_elink_file_cache_size(fapl_id, 0) < 0) + TEST_ERROR + if(NULL == (f1 = H5F_efc_open(f0, filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(H5Pset_elink_file_cache_size(fapl_id, 8) < 0) + TEST_ERROR + if(NULL == (ftmp0 = H5F_efc_open(f1, filename[0], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 2) + TEST_ERROR + if(H5F_efc_close(f1, ftmp0) < 0) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 1) + TEST_ERROR + if(H5F_efc_close(f0, f1) < 0) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 1) + TEST_ERROR + + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + if(NULL == (f0 = H5F_open(filename[0], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + if(NULL == (f1 = H5F_open(filename[1], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f1->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f1) < 0) + FAIL_STACK_ERROR + + + /* Test 30: File without EFC does not interrupt cycle */ + if(NULL == (f0 = H5F_open(filename[0], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (f1 = H5F_efc_open(f0, filename[1], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(NULL == (ftmp0 = H5F_efc_open(f1, filename[0], H5F_ACC_RDWR, fcpl_id, + fapl_id, dxpl_id))) + FAIL_STACK_ERROR + if(H5F_efc_close(f1, ftmp0) < 0) + FAIL_STACK_ERROR + if(H5F_efc_close(f0, f1) < 0) + FAIL_STACK_ERROR + if(H5Pset_elink_file_cache_size(fapl_id, 0) < 0) + TEST_ERROR + if(NULL == (f2 = H5F_efc_open(f1, filename[2], + H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(H5Pset_elink_file_cache_size(fapl_id, 8) < 0) + TEST_ERROR + if(H5F_efc_close(f1, f2) < 0) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 2) + TEST_ERROR + + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + if(NULL == (f0 = H5F_open(filename[0], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f0->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f0) < 0) + FAIL_STACK_ERROR + if(NULL == (f1 = H5F_open(filename[1], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f1->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f1) < 0) + FAIL_STACK_ERROR + if(NULL == (f2 = H5F_open(filename[2], H5F_ACC_RDWR, fcpl_id, fapl_id, + dxpl_id))) + FAIL_STACK_ERROR + if(f2->shared->nrefs != 1) + TEST_ERROR + if(H5F_try_close(f2) < 0) + FAIL_STACK_ERROR + + + PASSED(); + + return 0; + +error: + return 1; +} /* test_graph_cycle */ + + +/*------------------------------------------------------------------------- + * Function: main + * + * Purpose: Test the external file cache code + * + * Return: Success: SUCCEED + * Failure: FAIL + * + * Programmer: Neil Fortner + * December 16, 2010 + * + *------------------------------------------------------------------------- + */ +int +main(void) +{ + unsigned nerrors = 0; /* track errors */ + + /* Test Setup */ + puts("Testing the external file cache"); + + /* Create property lists */ + fcpl_id = H5Pcreate(H5P_FILE_CREATE); + fapl_id = h5_fileaccess(); + dxpl_id = H5Pcreate(H5P_DATASET_XFER); + + /* Patch filenames */ + h5_fixname(FILENAME[0], fapl_id, filename[0], sizeof(filename[0])); + h5_fixname(FILENAME[1], fapl_id, filename[1], sizeof(filename[1])); + h5_fixname(FILENAME[2], fapl_id, filename[2], sizeof(filename[2])); + h5_fixname(FILENAME[3], fapl_id, filename[3], sizeof(filename[3])); + h5_fixname(FILENAME[4], fapl_id, filename[4], sizeof(filename[4])); + h5_fixname(FILENAME[5], fapl_id, filename[5], sizeof(filename[5])); + + /* Test Functions */ + nerrors += test_single(); + nerrors += test_graph_nocycle(); + nerrors += test_graph_cycle(); + + /* Close property lists */ + if(H5Pclose(dxpl_id) < 0) + TEST_ERROR + if(H5Pclose(fcpl_id) < 0) + TEST_ERROR + + if(nerrors) + goto error; + + puts("All external file cache tests passed."); + + h5_cleanup(FILENAME, fapl_id); + + return 0; + +error: + puts("*** TESTS FAILED ***"); + + H5E_BEGIN_TRY { + H5Pclose(fapl_id); + } H5E_END_TRY + + return 1; +} /* end main() */ + diff --git a/test/links.c b/test/links.c index c8ece99..54b4a1b 100644 --- a/test/links.c +++ b/test/links.c @@ -6666,6 +6666,421 @@ error: /*------------------------------------------------------------------------- + * Function: external_file_cache + * + * Purpose: Tests that the external file cache works with external + * links in a few basic cases. More complicated cases are + * tested by interfacing directly with the cache in efc.c. + * + * Return: Success: 0 + * Failure: -1 + * + * Programmer: Neil Fortner + * Thursday, January 13, 2011 + * + *------------------------------------------------------------------------- + */ +static int +external_file_cache(hid_t fapl, hbool_t new_format) +{ + hid_t my_fapl = (-1); /* Temporary FAPL */ + hid_t fid1 = (-1); /* File ID */ + hid_t fid2 = (-1); /* File ID */ + hid_t fid3 = (-1); /* File ID */ + hid_t fid4 = (-1); /* File ID */ + hid_t oid = (-1); /* Object ID */ + unsigned efc_size; + char filename1[NAME_BUF_SIZE]; + char filename2[NAME_BUF_SIZE]; + char filename3[NAME_BUF_SIZE]; + char filename4[NAME_BUF_SIZE]; + + if(new_format) + TESTING("external file cache with external links (w/new group format)") + else + TESTING("external file cache with external links") + + /* Set up filenames */ + h5_fixname(FILENAME[0], fapl, filename1, sizeof filename1); + h5_fixname(FILENAME[1], fapl, filename2, sizeof filename2); + h5_fixname(FILENAME[2], fapl, filename3, sizeof filename3); + h5_fixname(FILENAME[3], fapl, filename4, sizeof filename4); + + /* Verify that the default EFC size is 0 */ + if(H5Pget_elink_file_cache_size(fapl, &efc_size) < 0) + TEST_ERROR + if(efc_size != 0) + FAIL_PUTS_ERROR("default external file cache size is not 0") + + /* Copy FAPL and enable external file caching */ + if((my_fapl = H5Pcopy(fapl)) < 0) + TEST_ERROR + if(H5Pset_elink_file_cache_size(my_fapl, 8) < 0) + TEST_ERROR + + /* Verify that the external file cache size has been set */ + if(H5Pget_elink_file_cache_size(my_fapl, &efc_size) < 0) + TEST_ERROR + if(efc_size != 8) + FAIL_PUTS_ERROR("external file cache size different from expected") + + + /* + * Test 1: One file caches another + */ + /* Create files */ + if((fid1 = H5Fcreate(filename1, H5F_ACC_TRUNC, H5P_DEFAULT, my_fapl)) < 0) + TEST_ERROR + if((fid2 = H5Fcreate(filename2, H5F_ACC_TRUNC, H5P_DEFAULT, my_fapl)) < 0) + TEST_ERROR + + /* Create link */ + if(H5Lcreate_external(filename2, "/", fid1, "link_to_2", H5P_DEFAULT, + H5P_DEFAULT) < 0) + TEST_ERROR + + /* Close file 2 */ + if(H5Fclose(fid2) < 0) + TEST_ERROR + + /* Verify that only 1 file is open */ + if(H5F_sfile_assert_num(1) < 0) + TEST_ERROR + + /* Open and close the target of the external link */ + if((oid = H5Oopen(fid1, "link_to_2", H5P_DEFAULT)) < 0) + TEST_ERROR + if(H5Oclose(oid) < 0) + TEST_ERROR + + /* Verify that both files are now open */ + if(H5F_sfile_assert_num(2) < 0) + TEST_ERROR + + /* Close file 1 */ + if(H5Fclose(fid1) < 0) + TEST_ERROR + + /* Verify that both files are now closed */ + if(H5F_sfile_assert_num(0) < 0) + TEST_ERROR + + + /* + * Test 2: One file caches another, release parent's EFC + */ + /* Create files */ + if((fid1 = H5Fcreate(filename1, H5F_ACC_TRUNC, H5P_DEFAULT, my_fapl)) < 0) + TEST_ERROR + if((fid2 = H5Fcreate(filename2, H5F_ACC_TRUNC, H5P_DEFAULT, my_fapl)) < 0) + TEST_ERROR + + /* Create link */ + if(H5Lcreate_external(filename2, "/", fid1, "link_to_2", H5P_DEFAULT, + H5P_DEFAULT) < 0) + TEST_ERROR + + /* Close file 2 */ + if(H5Fclose(fid2) < 0) + TEST_ERROR + + /* Verify that only 1 file is open */ + if(H5F_sfile_assert_num(1) < 0) + TEST_ERROR + + /* Open and close the target of the external link */ + if((oid = H5Oopen(fid1, "link_to_2", H5P_DEFAULT)) < 0) + TEST_ERROR + if(H5Oclose(oid) < 0) + TEST_ERROR + + /* Verify that both files are now open */ + if(H5F_sfile_assert_num(2) < 0) + TEST_ERROR + + /* Release file 1's EFC */ + if(H5Frelease_file_cache(fid1) < 0) + TEST_ERROR + + /* Verify that only the parent file is now open */ + if(H5F_sfile_assert_num(1) < 0) + TEST_ERROR + + /* Close file 1 */ + if(H5Fclose(fid1) < 0) + TEST_ERROR + + /* Verify that both files are now closed */ + if(H5F_sfile_assert_num(0) < 0) + TEST_ERROR + + + /* + * Test 3: "Y" shaped tree + */ + /* Create files */ + if((fid1 = H5Fcreate(filename1, H5F_ACC_TRUNC, H5P_DEFAULT, my_fapl)) < 0) + TEST_ERROR + if((fid2 = H5Fcreate(filename2, H5F_ACC_TRUNC, H5P_DEFAULT, my_fapl)) < 0) + TEST_ERROR + if((fid3 = H5Fcreate(filename3, H5F_ACC_TRUNC, H5P_DEFAULT, my_fapl)) < 0) + TEST_ERROR + if((fid4 = H5Fcreate(filename4, H5F_ACC_TRUNC, H5P_DEFAULT, my_fapl)) < 0) + TEST_ERROR + + /* Create links */ + if(H5Lcreate_external(filename2, "/", fid1, "link_to_2", H5P_DEFAULT, + H5P_DEFAULT) < 0) + TEST_ERROR + if(H5Lcreate_external(filename3, "/", fid2, "link_to_3", H5P_DEFAULT, + H5P_DEFAULT) < 0) + TEST_ERROR + if(H5Lcreate_external(filename4, "/", fid2, "link_to_4", H5P_DEFAULT, + H5P_DEFAULT) < 0) + TEST_ERROR + + /* Close files 2-4 */ + if(H5Fclose(fid2) < 0) + TEST_ERROR + if(H5Fclose(fid3) < 0) + TEST_ERROR + if(H5Fclose(fid4) < 0) + TEST_ERROR + + /* Verify that only 1 file is open */ + if(H5F_sfile_assert_num(1) < 0) + TEST_ERROR + + /* Open and close one branch of the tree */ + if((oid = H5Oopen(fid1, "link_to_2/link_to_3", H5P_DEFAULT)) < 0) + TEST_ERROR + if(H5Oclose(oid) < 0) + TEST_ERROR + + /* Verify that files 2 and 3 are now open */ + if(H5F_sfile_assert_num(3) < 0) + TEST_ERROR + + /* Open and close the other branch of the tree */ + if((oid = H5Oopen(fid1, "link_to_2/link_to_4", H5P_DEFAULT)) < 0) + TEST_ERROR + if(H5Oclose(oid) < 0) + TEST_ERROR + + /* Verify that all files are now open */ + if(H5F_sfile_assert_num(4) < 0) + TEST_ERROR + + /* Close file 1 */ + if(H5Fclose(fid1) < 0) + TEST_ERROR + + /* Verify that all files are now closed */ + if(H5F_sfile_assert_num(0) < 0) + TEST_ERROR + + + /* + * Test 4: "Y" shaped tree, release parent's EFC + */ + /* Create files */ + if((fid1 = H5Fcreate(filename1, H5F_ACC_TRUNC, H5P_DEFAULT, my_fapl)) < 0) + TEST_ERROR + if((fid2 = H5Fcreate(filename2, H5F_ACC_TRUNC, H5P_DEFAULT, my_fapl)) < 0) + TEST_ERROR + if((fid3 = H5Fcreate(filename3, H5F_ACC_TRUNC, H5P_DEFAULT, my_fapl)) < 0) + TEST_ERROR + if((fid4 = H5Fcreate(filename4, H5F_ACC_TRUNC, H5P_DEFAULT, my_fapl)) < 0) + TEST_ERROR + + /* Create links */ + if(H5Lcreate_external(filename2, "/", fid1, "link_to_2", H5P_DEFAULT, + H5P_DEFAULT) < 0) + TEST_ERROR + if(H5Lcreate_external(filename3, "/", fid2, "link_to_3", H5P_DEFAULT, + H5P_DEFAULT) < 0) + TEST_ERROR + if(H5Lcreate_external(filename4, "/", fid2, "link_to_4", H5P_DEFAULT, + H5P_DEFAULT) < 0) + TEST_ERROR + + /* Close files 2-4 */ + if(H5Fclose(fid2) < 0) + TEST_ERROR + if(H5Fclose(fid3) < 0) + TEST_ERROR + if(H5Fclose(fid4) < 0) + TEST_ERROR + + /* Verify that only 1 file is open */ + if(H5F_sfile_assert_num(1) < 0) + TEST_ERROR + + /* Open and close one branch of the tree */ + if((oid = H5Oopen(fid1, "link_to_2/link_to_3", H5P_DEFAULT)) < 0) + TEST_ERROR + if(H5Oclose(oid) < 0) + TEST_ERROR + + /* Verify that files 2 and 3 are now open */ + if(H5F_sfile_assert_num(3) < 0) + TEST_ERROR + + /* Open and close the other branch of the tree */ + if((oid = H5Oopen(fid1, "link_to_2/link_to_4", H5P_DEFAULT)) < 0) + TEST_ERROR + if(H5Oclose(oid) < 0) + TEST_ERROR + + /* Verify that all files are now open */ + if(H5F_sfile_assert_num(4) < 0) + TEST_ERROR + + /* Release file 1's EFC */ + if(H5Frelease_file_cache(fid1) < 0) + TEST_ERROR + + /* Verify that only file 1 is now open */ + if(H5F_sfile_assert_num(1) < 0) + TEST_ERROR + + /* Close file 1 */ + if(H5Fclose(fid1) < 0) + TEST_ERROR + + /* Verify that all files are now closed */ + if(H5F_sfile_assert_num(0) < 0) + TEST_ERROR + + + /* + * Test 3: 3 file cycle + */ + /* Create files */ + if((fid1 = H5Fcreate(filename1, H5F_ACC_TRUNC, H5P_DEFAULT, my_fapl)) < 0) + TEST_ERROR + if((fid2 = H5Fcreate(filename2, H5F_ACC_TRUNC, H5P_DEFAULT, my_fapl)) < 0) + TEST_ERROR + if((fid3 = H5Fcreate(filename3, H5F_ACC_TRUNC, H5P_DEFAULT, my_fapl)) < 0) + TEST_ERROR + + /* Create links */ + if(H5Lcreate_external(filename2, "/", fid1, "link_to_2", H5P_DEFAULT, + H5P_DEFAULT) < 0) + TEST_ERROR + if(H5Lcreate_external(filename3, "/", fid2, "link_to_3", H5P_DEFAULT, + H5P_DEFAULT) < 0) + TEST_ERROR + if(H5Lcreate_external(filename1, "/", fid3, "link_to_1", H5P_DEFAULT, + H5P_DEFAULT) < 0) + TEST_ERROR + + /* Close files 2-3 */ + if(H5Fclose(fid2) < 0) + TEST_ERROR + if(H5Fclose(fid3) < 0) + TEST_ERROR + + /* Verify that only 1 file is open */ + if(H5F_sfile_assert_num(1) < 0) + TEST_ERROR + + /* Open and close one complete cycle */ + if((oid = H5Oopen(fid1, "link_to_2/link_to_3/link_to_1", H5P_DEFAULT)) < 0) + TEST_ERROR + if(H5Oclose(oid) < 0) + TEST_ERROR + + /* Verify that all files are now open */ + if(H5F_sfile_assert_num(3) < 0) + TEST_ERROR + + /* Close file 1 */ + if(H5Fclose(fid1) < 0) + TEST_ERROR + + /* Verify that all files are now closed */ + if(H5F_sfile_assert_num(0) < 0) + TEST_ERROR + + + /* + * Test 3: 3 file cycle, release parent's EFC + */ + /* Create files */ + if((fid1 = H5Fcreate(filename1, H5F_ACC_TRUNC, H5P_DEFAULT, my_fapl)) < 0) + TEST_ERROR + if((fid2 = H5Fcreate(filename2, H5F_ACC_TRUNC, H5P_DEFAULT, my_fapl)) < 0) + TEST_ERROR + if((fid3 = H5Fcreate(filename3, H5F_ACC_TRUNC, H5P_DEFAULT, my_fapl)) < 0) + TEST_ERROR + + /* Create links */ + if(H5Lcreate_external(filename2, "/", fid1, "link_to_2", H5P_DEFAULT, + H5P_DEFAULT) < 0) + TEST_ERROR + if(H5Lcreate_external(filename3, "/", fid2, "link_to_3", H5P_DEFAULT, + H5P_DEFAULT) < 0) + TEST_ERROR + if(H5Lcreate_external(filename1, "/", fid3, "link_to_1", H5P_DEFAULT, + H5P_DEFAULT) < 0) + TEST_ERROR + + /* Close files 2-3 */ + if(H5Fclose(fid2) < 0) + TEST_ERROR + if(H5Fclose(fid3) < 0) + TEST_ERROR + + /* Verify that only 1 file is open */ + if(H5F_sfile_assert_num(1) < 0) + TEST_ERROR + + /* Open and close one complete cycle */ + if((oid = H5Oopen(fid1, "link_to_2/link_to_3/link_to_1", H5P_DEFAULT)) < 0) + TEST_ERROR + if(H5Oclose(oid) < 0) + TEST_ERROR + + /* Verify that all files are now open */ + if(H5F_sfile_assert_num(3) < 0) + TEST_ERROR + + /* Release file 1's EFC */ + if(H5Frelease_file_cache(fid1) < 0) + TEST_ERROR + + /* Verify that only file 1 is now open */ + if(H5F_sfile_assert_num(1) < 0) + TEST_ERROR + + /* Close file 1 */ + if(H5Fclose(fid1) < 0) + TEST_ERROR + + /* Verify that all files are now closed */ + if(H5F_sfile_assert_num(0) < 0) + TEST_ERROR + + + PASSED(); + return 0; + +error: + H5E_BEGIN_TRY { + H5Oclose(oid); + H5Fclose(fid1); + H5Fclose(fid2); + H5Fclose(fid3); + H5Fclose(fid4); + H5Pclose(my_fapl); + } H5E_END_TRY + + return -1; +} /* end external_file_cache */ + + +/*------------------------------------------------------------------------- * Function: ud_hard_links * * Purpose: Check that the functionality of hard links can be duplicated @@ -13866,6 +14281,7 @@ main(void) hid_t fapl, fapl2; /* File access property lists */ int nerrors = 0; hbool_t new_format; /* Whether to use the new format or not */ + hbool_t efc; /* Whether to use the external file cache */ const char *env_h5_drvr; /* File Driver value from environment */ env_h5_drvr = HDgetenv("HDF5_DRIVER"); @@ -13907,57 +14323,83 @@ main(void) #ifndef H5_NO_DEPRECATED_SYMBOLS nerrors += test_deprec(my_fapl, new_format); #endif /* H5_NO_DEPRECATED_SYMBOLS */ + + /* tests for external link */ + /* Test external file cache first, so it sees the default efc setting on + * the fapl */ + nerrors += external_file_cache(my_fapl, new_format) < 0 ? 1 : 0; + + /* This test cannot run with the EFC because it assumes that an + * intermediate file is not held open */ + nerrors += external_link_mult(my_fapl, new_format) < 0 ? 1 : 0; + + /* This test cannot run with the EFC because the EFC cannot currently + * reopen a cached file with a different intent */ + nerrors += external_set_elink_acc_flags(my_fapl, new_format) < 0 ? 1 : 0; + + /* Try external link tests both with and without the external file cache + */ + for(efc = FALSE; efc <= TRUE; efc++) { + if(efc) { + if(H5Pset_elink_file_cache_size(my_fapl, 8) < 0) + TEST_ERROR + printf("\n---Testing with external file cache---\n"); + } /* end if */ + else { + if(H5Pset_elink_file_cache_size(my_fapl, 0) < 0) + TEST_ERROR + printf("\n---Testing without external file cache---\n"); + } /* end else */ + #ifndef H5_CANNOT_OPEN_TWICE - nerrors += external_link_root(my_fapl, new_format) < 0 ? 1 : 0; + nerrors += external_link_root(my_fapl, new_format) < 0 ? 1 : 0; #endif /* H5_CANNOT_OPEN_TWICE */ - nerrors += external_link_path(my_fapl, new_format) < 0 ? 1 : 0; - nerrors += external_link_mult(my_fapl, new_format) < 0 ? 1 : 0; + nerrors += external_link_path(my_fapl, new_format) < 0 ? 1 : 0; #ifndef H5_CANNOT_OPEN_TWICE - nerrors += external_link_self(my_fapl, new_format) < 0 ? 1 : 0; - nerrors += external_link_pingpong(my_fapl, new_format) < 0 ? 1 : 0; - nerrors += external_link_toomany(my_fapl, new_format) < 0 ? 1 : 0; + nerrors += external_link_self(my_fapl, new_format) < 0 ? 1 : 0; + nerrors += external_link_pingpong(my_fapl, new_format) < 0 ? 1 : 0; + nerrors += external_link_toomany(my_fapl, new_format) < 0 ? 1 : 0; #endif /* H5_CANNOT_OPEN_TWICE */ - nerrors += external_link_dangling(my_fapl, new_format) < 0 ? 1 : 0; - nerrors += external_link_recursive(my_fapl, new_format) < 0 ? 1 : 0; - nerrors += external_link_query(my_fapl, new_format) < 0 ? 1 : 0; - nerrors += external_link_unlink_compact(my_fapl, new_format) < 0 ? 1 : 0; - nerrors += external_link_unlink_dense(my_fapl, new_format) < 0 ? 1 : 0; - nerrors += external_link_move(my_fapl, new_format) < 0 ? 1 : 0; - nerrors += external_link_ride(my_fapl, new_format) < 0 ? 1 : 0; + nerrors += external_link_dangling(my_fapl, new_format) < 0 ? 1 : 0; + nerrors += external_link_recursive(my_fapl, new_format) < 0 ? 1 : 0; + nerrors += external_link_query(my_fapl, new_format) < 0 ? 1 : 0; + nerrors += external_link_unlink_compact(my_fapl, new_format) < 0 ? 1 : 0; + nerrors += external_link_unlink_dense(my_fapl, new_format) < 0 ? 1 : 0; + nerrors += external_link_move(my_fapl, new_format) < 0 ? 1 : 0; + nerrors += external_link_ride(my_fapl, new_format) < 0 ? 1 : 0; #ifndef H5_CANNOT_OPEN_TWICE - nerrors += external_link_closing(my_fapl, new_format) < 0 ? 1 : 0; + nerrors += external_link_closing(my_fapl, new_format) < 0 ? 1 : 0; #endif /* H5_CANNOT_OPEN_TWICE */ - nerrors += external_link_endian(new_format) < 0 ? 1 : 0; - nerrors += external_link_strong(my_fapl, new_format) < 0 ? 1 : 0; - - /* tests for external link */ - nerrors += external_link_prefix(my_fapl, new_format) < 0 ? 1 : 0; - nerrors += external_link_abs_mainpath(my_fapl, new_format) < 0 ? 1 : 0; - nerrors += external_link_rel_mainpath(my_fapl, new_format) < 0 ? 1 : 0; - nerrors += external_link_cwd(my_fapl, new_format) < 0 ? 1 : 0; - nerrors += external_link_abstar(my_fapl, new_format) < 0 ? 1 : 0; - nerrors += external_link_abstar_cur(my_fapl, new_format) < 0 ? 1 : 0; - nerrors += external_link_reltar(my_fapl, new_format) < 0 ? 1 : 0; - nerrors += external_link_chdir(my_fapl, new_format) < 0 ? 1 : 0; - nerrors += external_set_elink_fapl1(my_fapl, new_format) < 0 ? 1 : 0; - nerrors += external_set_elink_fapl2(my_fapl, new_format) < 0 ? 1 : 0; - nerrors += external_set_elink_fapl3(new_format) < 0 ? 1 : 0; - nerrors += external_set_elink_acc_flags(my_fapl, new_format) < 0 ? 1 : 0; - nerrors += external_set_elink_cb(my_fapl, new_format) < 0 ? 1 : 0; + nerrors += external_link_endian(new_format) < 0 ? 1 : 0; + nerrors += external_link_strong(my_fapl, new_format) < 0 ? 1 : 0; + + nerrors += external_link_prefix(my_fapl, new_format) < 0 ? 1 : 0; + nerrors += external_link_abs_mainpath(my_fapl, new_format) < 0 ? 1 : 0; + nerrors += external_link_rel_mainpath(my_fapl, new_format) < 0 ? 1 : 0; + nerrors += external_link_cwd(my_fapl, new_format) < 0 ? 1 : 0; + nerrors += external_link_abstar(my_fapl, new_format) < 0 ? 1 : 0; + nerrors += external_link_abstar_cur(my_fapl, new_format) < 0 ? 1 : 0; + nerrors += external_link_reltar(my_fapl, new_format) < 0 ? 1 : 0; + nerrors += external_link_chdir(my_fapl, new_format) < 0 ? 1 : 0; + nerrors += external_set_elink_fapl1(my_fapl, new_format) < 0 ? 1 : 0; + nerrors += external_set_elink_fapl2(my_fapl, new_format) < 0 ? 1 : 0; + nerrors += external_set_elink_fapl3(new_format) < 0 ? 1 : 0; + nerrors += external_set_elink_cb(my_fapl, new_format) < 0 ? 1 : 0; #ifdef H5_HAVE_WINDOW_PATH - nerrors += external_link_win1(my_fapl, new_format) < 0 ? 1 : 0; - nerrors += external_link_win2(my_fapl, new_format) < 0 ? 1 : 0; - nerrors += external_link_win3(my_fapl, new_format) < 0 ? 1 : 0; - nerrors += external_link_win4(my_fapl, new_format) < 0 ? 1 : 0; - nerrors += external_link_win5(my_fapl, new_format) < 0 ? 1 : 0; - nerrors += external_link_win6(my_fapl, new_format) < 0 ? 1 : 0; - nerrors += external_link_win7(my_fapl, new_format) < 0 ? 1 : 0; - nerrors += external_link_win8(my_fapl, new_format) < 0 ? 1 : 0; - nerrors += external_link_win9(my_fapl, new_format) < 0 ? 1 : 0; + nerrors += external_link_win1(my_fapl, new_format) < 0 ? 1 : 0; + nerrors += external_link_win2(my_fapl, new_format) < 0 ? 1 : 0; + nerrors += external_link_win3(my_fapl, new_format) < 0 ? 1 : 0; + nerrors += external_link_win4(my_fapl, new_format) < 0 ? 1 : 0; + nerrors += external_link_win5(my_fapl, new_format) < 0 ? 1 : 0; + nerrors += external_link_win6(my_fapl, new_format) < 0 ? 1 : 0; + nerrors += external_link_win7(my_fapl, new_format) < 0 ? 1 : 0; + nerrors += external_link_win8(my_fapl, new_format) < 0 ? 1 : 0; + nerrors += external_link_win9(my_fapl, new_format) < 0 ? 1 : 0; #endif - nerrors += external_symlink(env_h5_drvr, my_fapl, new_format) < 0 ? 1 : 0; - nerrors += external_copy_invalid_object(my_fapl, new_format) < 0 ? 1 : 0; - nerrors += external_dont_fail_to_source(my_fapl, new_format) < 0 ? 1 : 0; + nerrors += external_symlink(env_h5_drvr, my_fapl, new_format) < 0 ? 1 : 0; + nerrors += external_copy_invalid_object(my_fapl, new_format) < 0 ? 1 : 0; + nerrors += external_dont_fail_to_source(my_fapl, new_format) < 0 ? 1 : 0; + } /* end for */ /* These tests assume that external links are a form of UD links, * so assume that everything that passed for external links -- cgit v0.12