mirror of
https://github.com/HDFGroup/hdf5.git
synced 2024-12-21 07:51:46 +08:00
25ec07450a
and replace it with new url for COPYING file. Fix 2 lines in java error test expected output file where messages include line numbers changed by reducing the copyright header by 2 lines.
493 lines
15 KiB
C
493 lines
15 KiB
C
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
|
||
* Copyright by The HDF Group. *
|
||
* Copyright by the Board of Trustees of the University of Illinois. *
|
||
* All rights reserved. *
|
||
* *
|
||
* This file is part of HDF5. The full HDF5 copyright notice, including *
|
||
* terms governing use, modification, and redistribution, is contained in *
|
||
* the COPYING file, which can be found at the root of the source code *
|
||
* distribution tree, or in https://support.hdfgroup.org/ftp/HDF5/releases. *
|
||
* If you do not have access to either file, you may request a copy from *
|
||
* help@hdfgroup.org. *
|
||
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
|
||
|
||
/*-------------------------------------------------------------------------
|
||
*
|
||
* Created: H5ACdbg.c
|
||
*
|
||
* Purpose: Functions for debugging the metadata cache
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
|
||
/****************/
|
||
/* Module Setup */
|
||
/****************/
|
||
#include "H5ACmodule.h" /* This source code file is part of the H5AC module */
|
||
#define H5F_FRIEND /* Suppress error about including H5Fpkg */
|
||
|
||
/***********/
|
||
/* Headers */
|
||
/***********/
|
||
#include "H5private.h" /* Generic Functions */
|
||
#include "H5ACpkg.h" /* Metadata cache */
|
||
#include "H5Eprivate.h" /* Error handling */
|
||
#include "H5Fpkg.h" /* Files */
|
||
|
||
|
||
/****************/
|
||
/* Local Macros */
|
||
/****************/
|
||
|
||
|
||
/******************/
|
||
/* Local Typedefs */
|
||
/******************/
|
||
|
||
|
||
/********************/
|
||
/* Package Typedefs */
|
||
/********************/
|
||
|
||
|
||
/********************/
|
||
/* Local Prototypes */
|
||
/********************/
|
||
|
||
|
||
/*********************/
|
||
/* Package Variables */
|
||
/*********************/
|
||
|
||
|
||
/*****************************/
|
||
/* Library Private Variables */
|
||
/*****************************/
|
||
|
||
|
||
/*******************/
|
||
/* Local Variables */
|
||
/*******************/
|
||
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: H5AC_stats
|
||
*
|
||
* Purpose: Prints statistics about the cache.
|
||
*
|
||
* Return: Non-negative on success/Negative on failure
|
||
*
|
||
* Programmer: Robb Matzke
|
||
* Thursday, October 30, 1997
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
herr_t
|
||
H5AC_stats(const H5F_t *f)
|
||
{
|
||
FUNC_ENTER_NOAPI_NOINIT_NOERR
|
||
|
||
/* Sanity checks */
|
||
HDassert(f);
|
||
HDassert(f->shared);
|
||
HDassert(f->shared->cache);
|
||
|
||
/* at present, this can't fail */
|
||
(void)H5C_stats(f->shared->cache, H5F_OPEN_NAME(f), FALSE);
|
||
|
||
FUNC_LEAVE_NOAPI(SUCCEED)
|
||
} /* H5AC_stats() */
|
||
|
||
#ifndef NDEBUG
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: H5AC_dump_cache
|
||
*
|
||
* Purpose: Dumps a summary of the contents of the metadata cache
|
||
* to stdout.
|
||
*
|
||
* Return: Non-negative on success/Negative on failure
|
||
*
|
||
* Programmer: John Mainzer
|
||
* Sunday, October 10, 2010
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
herr_t
|
||
H5AC_dump_cache(const H5F_t *f)
|
||
{
|
||
herr_t ret_value = SUCCEED; /* Return value */
|
||
|
||
FUNC_ENTER_NOAPI(FAIL)
|
||
|
||
/* Sanity checks */
|
||
HDassert(f);
|
||
HDassert(f->shared);
|
||
HDassert(f->shared->cache);
|
||
|
||
if(H5C_dump_cache(f->shared->cache, H5F_OPEN_NAME(f)) < 0)
|
||
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "H5C_dump_cache() failed.")
|
||
|
||
done:
|
||
FUNC_LEAVE_NOAPI(ret_value)
|
||
} /* H5AC_dump_cache() */
|
||
#endif /* NDEBUG */
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: H5AC__close_trace_file()
|
||
*
|
||
* Purpose: If a trace file is open, stop logging calls to the cache,
|
||
* and close the file.
|
||
*
|
||
* Note that the function does nothing if there is no trace
|
||
* file.
|
||
*
|
||
* Return: Non-negative on success/Negative on failure
|
||
*
|
||
* Programmer: John Mainzer
|
||
* 6/2/06
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
herr_t
|
||
H5AC__close_trace_file(H5AC_t *cache_ptr)
|
||
{
|
||
FILE * trace_file_ptr;
|
||
herr_t ret_value = SUCCEED; /* Return value */
|
||
|
||
FUNC_ENTER_PACKAGE
|
||
|
||
if(cache_ptr == NULL)
|
||
HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, FAIL, "NULL cache_ptr on entry.")
|
||
|
||
if(NULL == (trace_file_ptr = H5C_get_trace_file_ptr(cache_ptr)))
|
||
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "H5C_get_trace_file_ptr() failed.")
|
||
|
||
if(trace_file_ptr != NULL) {
|
||
if(H5C_set_trace_file_ptr(cache_ptr, NULL) < 0)
|
||
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "H5C_set_trace_file_ptr() failed.")
|
||
|
||
if(HDfclose(trace_file_ptr) != 0)
|
||
HGOTO_ERROR(H5E_FILE, H5E_CANTCLOSEFILE, FAIL, "can't close metadata cache trace file")
|
||
} /* end if */
|
||
|
||
done:
|
||
FUNC_LEAVE_NOAPI(ret_value)
|
||
} /* H5AC__close_trace_file() */
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: H5AC__open_trace_file()
|
||
*
|
||
* Purpose: Open a trace file, and start logging calls to the cache.
|
||
*
|
||
* This logging is done at the H5C level, and will only take
|
||
* place if H5C_TRACE_FILE_ENABLED (defined in H5Cprivate.h)
|
||
* is TRUE.
|
||
*
|
||
* Return: Non-negative on success/Negative on failure
|
||
*
|
||
* Programmer: John Mainzer
|
||
* 6/1/06
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
herr_t
|
||
H5AC__open_trace_file(H5AC_t *cache_ptr, const char *trace_file_name)
|
||
{
|
||
char file_name[H5AC__MAX_TRACE_FILE_NAME_LEN + H5C__PREFIX_LEN + 2];
|
||
FILE * file_ptr;
|
||
herr_t ret_value = SUCCEED; /* Return value */
|
||
|
||
FUNC_ENTER_PACKAGE
|
||
|
||
HDassert(cache_ptr);
|
||
|
||
/* Check args */
|
||
if(cache_ptr == NULL)
|
||
HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, FAIL, "cache_ptr NULL on entry.")
|
||
if(trace_file_name == NULL)
|
||
HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, FAIL, "NULL trace_file_name on entry.")
|
||
if(HDstrlen(trace_file_name) > H5AC__MAX_TRACE_FILE_NAME_LEN)
|
||
HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, FAIL, "trace file name too long.")
|
||
if(NULL != (file_ptr = H5C_get_trace_file_ptr(cache_ptr)))
|
||
HGOTO_ERROR(H5E_CACHE, H5E_FILEOPEN, FAIL, "trace file already open.")
|
||
|
||
#ifdef H5_HAVE_PARALLEL
|
||
{
|
||
H5AC_aux_t * aux_ptr;
|
||
|
||
aux_ptr = (H5AC_aux_t *)H5C_get_aux_ptr(cache_ptr);
|
||
if(aux_ptr == NULL)
|
||
sprintf(file_name, "%s", trace_file_name);
|
||
else {
|
||
if(aux_ptr->magic != H5AC__H5AC_AUX_T_MAGIC)
|
||
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Bad aux_ptr->magic.")
|
||
|
||
sprintf(file_name, "%s.%d", trace_file_name, aux_ptr->mpi_rank);
|
||
} /* end else */
|
||
|
||
if(HDstrlen(file_name) > H5AC__MAX_TRACE_FILE_NAME_LEN + H5C__PREFIX_LEN + 1)
|
||
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "cooked trace file name too long.")
|
||
}
|
||
#else /* H5_HAVE_PARALLEL */
|
||
HDsnprintf(file_name, (size_t)(H5AC__MAX_TRACE_FILE_NAME_LEN + H5C__PREFIX_LEN + 1),
|
||
"%s", trace_file_name);
|
||
#endif /* H5_HAVE_PARALLEL */
|
||
|
||
if((file_ptr = HDfopen(file_name, "w")) == NULL)
|
||
HGOTO_ERROR(H5E_FILE, H5E_CANTOPENFILE, FAIL, "trace file open failed.")
|
||
|
||
HDfprintf(file_ptr, "### HDF5 metadata cache trace file version 1 ###\n");
|
||
|
||
if(H5C_set_trace_file_ptr(cache_ptr, file_ptr) < 0)
|
||
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "H5C_set_trace_file_ptr() failed.")
|
||
|
||
done:
|
||
FUNC_LEAVE_NOAPI(ret_value)
|
||
} /* H5AC__open_trace_file() */
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
*
|
||
* Function: H5AC_get_entry_ptr_from_addr()
|
||
*
|
||
* Purpose: Debugging function that attempts to look up an entry in the
|
||
* cache by its file address, and if found, returns a pointer
|
||
* to the entry in *entry_ptr_ptr. If the entry is not in the
|
||
* cache, *entry_ptr_ptr is set to NULL.
|
||
*
|
||
* WARNING: This call should be used only in debugging
|
||
* routines, and it should be avoided when
|
||
* possible.
|
||
*
|
||
* Further, if we ever multi-thread the cache,
|
||
* this routine will have to be either discarded
|
||
* or heavily re-worked.
|
||
*
|
||
* Finally, keep in mind that the entry whose
|
||
* pointer is obtained in this fashion may not
|
||
* be in a stable state.
|
||
*
|
||
* Note that this function is only defined if NDEBUG
|
||
* is not defined.
|
||
*
|
||
* As heavy use of this function is almost certainly a
|
||
* bad idea, the metadata cache tracks the number of
|
||
* successful calls to this function, and (if
|
||
* H5C_DO_SANITY_CHECKS is defined) displays any
|
||
* non-zero count on cache shutdown.
|
||
*
|
||
* This function is just a wrapper that calls the H5C
|
||
* version of the function.
|
||
*
|
||
* Return: FAIL if error is detected, SUCCEED otherwise.
|
||
*
|
||
* Programmer: John Mainzer, 5/30/14
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
#ifndef NDEBUG
|
||
herr_t
|
||
H5AC_get_entry_ptr_from_addr(const H5F_t *f, haddr_t addr, void **entry_ptr_ptr)
|
||
{
|
||
H5C_t *cache_ptr; /* Ptr to cache */
|
||
herr_t ret_value = SUCCEED; /* Return value */
|
||
|
||
FUNC_ENTER_NOAPI(FAIL)
|
||
|
||
/* Sanity checks */
|
||
HDassert(f);
|
||
HDassert(f->shared);
|
||
cache_ptr = f->shared->cache;
|
||
|
||
if(H5C_get_entry_ptr_from_addr(cache_ptr, addr, entry_ptr_ptr) < 0)
|
||
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "H5C_get_entry_ptr_from_addr() failed")
|
||
|
||
done:
|
||
FUNC_LEAVE_NOAPI(ret_value)
|
||
} /* H5AC_get_entry_ptr_from_addr() */
|
||
#endif /* NDEBUG */
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: H5AC_flush_dependency_exists()
|
||
*
|
||
* Purpose: Test to see if a flush dependency relationship exists
|
||
* between the supplied parent and child. Both parties
|
||
* are indicated by addresses so as to avoid the necessity
|
||
* of protect / unprotect calls prior to this call.
|
||
*
|
||
* If either the parent or the child is not in the metadata
|
||
* cache, the function sets *fd_exists_ptr to FALSE.
|
||
*
|
||
* If both are in the cache, the childs list of parents is
|
||
* searched for the proposed parent. If the proposed parent
|
||
* is found in the childs parent list, the function sets
|
||
* *fd_exists_ptr to TRUE. In all other non-error cases,
|
||
* the function sets *fd_exists_ptr FALSE.
|
||
*
|
||
* Return: SUCCEED on success/FAIL on failure. Note that
|
||
* *fd_exists_ptr is undefined on failure.
|
||
*
|
||
* Programmer: John Mainzer
|
||
* 9/28/16
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
#ifndef NDEBUG
|
||
herr_t
|
||
H5AC_flush_dependency_exists(H5F_t *f, haddr_t parent_addr, haddr_t child_addr,
|
||
hbool_t *fd_exists_ptr)
|
||
{
|
||
H5C_t *cache_ptr; /* Ptr to cache */
|
||
herr_t ret_value = FAIL; /* Return value */
|
||
|
||
FUNC_ENTER_NOAPI_NOINIT_NOERR
|
||
|
||
/* Sanity checks */
|
||
HDassert(f);
|
||
HDassert(f->shared);
|
||
cache_ptr = f->shared->cache;
|
||
|
||
ret_value = H5C_flush_dependency_exists(cache_ptr, parent_addr, child_addr, fd_exists_ptr);
|
||
|
||
FUNC_LEAVE_NOAPI(ret_value)
|
||
} /* H5AC_flush_dependency_exists() */
|
||
#endif /* NDEBUG */
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
*
|
||
* Function: H5AC_verify_entry_type()
|
||
*
|
||
* Purpose: Debugging function that attempts to look up an entry in the
|
||
* cache by its file address, and if found, test to see if its
|
||
* type field contains the expected value.
|
||
*
|
||
* If the specified entry is in cache, *in_cache_ptr is set
|
||
* to TRUE, and *type_ok_ptr is set to TRUE or FALSE depending
|
||
* on whether the entries type field matches the
|
||
* expected_type parameter
|
||
*
|
||
* If the target entry is not in cache, *in_cache_ptr is
|
||
* set to FALSE, and *type_ok_ptr is undefined.
|
||
*
|
||
* Note that this function is only defined if NDEBUG
|
||
* is not defined.
|
||
*
|
||
* This function is just a wrapper that calls the H5C
|
||
* version of the function.
|
||
*
|
||
* Return: FAIL if error is detected, SUCCEED otherwise.
|
||
*
|
||
* Programmer: John Mainzer, 5/30/14
|
||
*
|
||
* Changes: None.
|
||
*
|
||
* JRM -- 9/17/16
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
#ifndef NDEBUG
|
||
herr_t
|
||
H5AC_verify_entry_type(const H5F_t *f, haddr_t addr,
|
||
const H5AC_class_t *expected_type, hbool_t *in_cache_ptr,
|
||
hbool_t *type_ok_ptr)
|
||
{
|
||
H5C_t * cache_ptr;
|
||
herr_t ret_value = SUCCEED; /* Return value */
|
||
|
||
FUNC_ENTER_NOAPI(FAIL)
|
||
|
||
/* Sanity checks */
|
||
HDassert(f);
|
||
HDassert(f->shared);
|
||
cache_ptr = f->shared->cache;
|
||
|
||
if(H5C_verify_entry_type(cache_ptr, addr, expected_type, in_cache_ptr, type_ok_ptr) < 0)
|
||
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "H5C_verify_entry_type() failed")
|
||
|
||
done:
|
||
FUNC_LEAVE_NOAPI(ret_value)
|
||
} /* H5AC_verify_entry_type() */
|
||
#endif /* NDEBUG */
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: H5AC_get_serialization_in_progress
|
||
*
|
||
* Purpose: Return the current value of
|
||
* cache_ptr->serialization_in_progress.
|
||
*
|
||
* Return: Current value of cache_ptr->serialization_in_progress.
|
||
*
|
||
* Programmer: John Mainzer
|
||
* 8/24/15
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
#ifndef NDEBUG
|
||
hbool_t
|
||
H5AC_get_serialization_in_progress(H5F_t *f)
|
||
{
|
||
H5C_t * cache_ptr;
|
||
hbool_t ret_value = FALSE; /* Return value */
|
||
|
||
FUNC_ENTER_NOAPI_NOINIT_NOERR
|
||
|
||
/* Sanity check */
|
||
HDassert(f);
|
||
HDassert(f->shared);
|
||
cache_ptr = f->shared->cache;
|
||
|
||
/* Set return value */
|
||
ret_value = H5C_get_serialization_in_progress(cache_ptr);
|
||
|
||
FUNC_LEAVE_NOAPI(ret_value)
|
||
} /* H5AC_get_serialization_in_progress() */
|
||
#endif /* NDEBUG */
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
*
|
||
* Function: H5AC_cache_is_clean()
|
||
*
|
||
* Purpose: Debugging function that verifies that all rings in the
|
||
* metadata cache are clean from the outermost ring, inwards
|
||
* to the inner ring specified.
|
||
*
|
||
* Returns TRUE if all specified rings are clean, and FALSE
|
||
* if not. Throws an assertion failure on error.
|
||
*
|
||
* Return: TRUE if the indicated ring(s) are clean, and FALSE otherwise.
|
||
*
|
||
* Programmer: John Mainzer, 6/18/16
|
||
*
|
||
* Changes: None.
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
#ifndef NDEBUG
|
||
hbool_t
|
||
H5AC_cache_is_clean(const H5F_t *f, H5AC_ring_t inner_ring)
|
||
{
|
||
H5C_t *cache_ptr;
|
||
hbool_t ret_value = FALSE; /* Return value */
|
||
|
||
FUNC_ENTER_NOAPI_NOINIT_NOERR
|
||
|
||
/* Sanity checks */
|
||
HDassert(f);
|
||
HDassert(f->shared);
|
||
cache_ptr = f->shared->cache;
|
||
|
||
ret_value = H5C_cache_is_clean(cache_ptr, inner_ring);
|
||
|
||
FUNC_LEAVE_NOAPI(ret_value)
|
||
} /* H5AC_cache_is_clean() */
|
||
#endif /* NDEBUG */
|
||
|