summaryrefslogtreecommitdiffstats
path: root/test
diff options
context:
space:
mode:
authorDana Robinson <derobins@hdfgroup.org>2015-08-14 19:58:54 (GMT)
committerDana Robinson <derobins@hdfgroup.org>2015-08-14 19:58:54 (GMT)
commitc27d1808480a4ffae4af5ff5384993f63ea6b5d4 (patch)
tree251081393f02ad4fb6767af9d23be50971761d79 /test
parent37b14fd3ed8aae8f3b83df03ca29f82178c25f8f (diff)
parentd3e931c772a1fea1d8d0676dd6dd3fe95b000d9e (diff)
downloadhdf5-c27d1808480a4ffae4af5ff5384993f63ea6b5d4.zip
hdf5-c27d1808480a4ffae4af5ff5384993f63ea6b5d4.tar.gz
hdf5-c27d1808480a4ffae4af5ff5384993f63ea6b5d4.tar.bz2
[svn-r27507] Merge of r27237-27500 from the trunk.
Tested w/ h5committest NOTES: - The manifest may still be messed up. - Cmake fails since the dual binary work needs to be merged with this repo's CMake externals.
Diffstat (limited to 'test')
-rw-r--r--test/CMakeLists.txt156
-rw-r--r--test/CMakeTests.cmake570
-rw-r--r--test/cache.c9036
-rw-r--r--test/cache_api.c3
-rw-r--r--test/cache_common.c2328
-rw-r--r--test/cache_common.h88
-rw-r--r--test/cache_tagging.c6
-rw-r--r--test/dt_arith.c56
-rw-r--r--test/earray.c335
-rw-r--r--test/gen_bogus.c14
-rw-r--r--test/gen_plist.c16
-rw-r--r--test/h5test.h2
-rw-r--r--test/lheap.c4
-rw-r--r--test/mf.c70
-rw-r--r--test/ohdr.c48
-rw-r--r--test/tbogus.h5bin1944 -> 2216 bytes
-rw-r--r--test/testfiles/plist_files/dxpl_bebin229 -> 229 bytes
-rw-r--r--test/testfiles/plist_files/dxpl_lebin229 -> 229 bytes
-rw-r--r--test/testfiles/plist_files/fapl_bebin1462 -> 1462 bytes
-rw-r--r--test/testfiles/plist_files/fapl_lebin1462 -> 1462 bytes
-rw-r--r--test/testfiles/plist_files/lapl_bebin1562 -> 1565 bytes
-rw-r--r--test/testfiles/plist_files/lapl_lebin1562 -> 1565 bytes
-rw-r--r--test/tid.c199
-rw-r--r--test/trefer.c6
-rw-r--r--test/tskiplist.c203
25 files changed, 8497 insertions, 4643 deletions
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 651e4eb..c94b880 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -26,8 +26,8 @@ set (TEST_LIB_HEADERS
${HDF5_TEST_SOURCE_DIR}/h5test.h
)
-add_library (${HDF5_TEST_LIB_TARGET} ${LIB_TYPE} ${TEST_LIB_SRCS} ${TEST_LIB_HEADERS})
-TARGET_C_PROPERTIES (${HDF5_TEST_LIB_TARGET} ${LIB_TYPE} " " " ")
+add_library (${HDF5_TEST_LIB_TARGET} STATIC ${TEST_LIB_SRCS} ${TEST_LIB_HEADERS})
+TARGET_C_PROPERTIES (${HDF5_TEST_LIB_TARGET} STATIC " " " ")
if (MSVC)
target_link_libraries (${HDF5_TEST_LIB_TARGET} "ws2_32.lib")
endif (MSVC)
@@ -35,16 +35,34 @@ if (MINGW)
target_link_libraries (${HDF5_TEST_LIB_TARGET} "wsock32.lib")
endif (MINGW)
target_link_libraries (${HDF5_TEST_LIB_TARGET} ${HDF5_LIB_TARGET})
-H5_SET_LIB_OPTIONS (${HDF5_TEST_LIB_TARGET} ${HDF5_TEST_LIB_NAME} ${LIB_TYPE})
+H5_SET_LIB_OPTIONS (${HDF5_TEST_LIB_TARGET} ${HDF5_TEST_LIB_NAME} STATIC)
set_target_properties (${HDF5_TEST_LIB_TARGET} PROPERTIES
FOLDER libraries/test
INTERFACE_INCLUDE_DIRECTORIES "$<INSTALL_INTERFACE:$<INSTALL_PREFIX>/include>"
)
+if (BUILD_SHARED_LIBS)
+ add_library (${HDF5_TEST_LIBSH_TARGET} SHARED ${TEST_LIB_SRCS} ${TEST_LIB_HEADERS})
+ TARGET_C_PROPERTIES (${HDF5_TEST_LIBSH_TARGET} SHARED " " " ")
+ if (MSVC)
+ target_link_libraries (${HDF5_TEST_LIBSH_TARGET} "ws2_32.lib")
+ endif (MSVC)
+ if (MINGW)
+ target_link_libraries (${HDF5_TEST_LIBSH_TARGET} "wsock32.lib")
+ endif (MINGW)
+ target_link_libraries (${HDF5_TEST_LIBSH_TARGET} ${HDF5_LIBSH_TARGET})
+ H5_SET_LIB_OPTIONS (${HDF5_TEST_LIBSH_TARGET} ${HDF5_TEST_LIB_NAME} SHARED)
+ set_target_properties (${HDF5_TEST_LIBSH_TARGET} PROPERTIES
+ FOLDER libraries/test
+ COMPILE_DEFINITIONS "H5_BUILT_AS_DYNAMIC_LIB"
+ INTERFACE_INCLUDE_DIRECTORIES "$<INSTALL_INTERFACE:$<INSTALL_PREFIX>/include>"
+ INTERFACE_COMPILE_DEFINITIONS H5_BUILT_AS_DYNAMIC_LIB=1
+ )
+endif (BUILD_SHARED_LIBS)
+
#-----------------------------------------------------------------------------
# If plugin library tests can be tested
#-----------------------------------------------------------------------------
-if (BUILD_SHARED_LIBS)
# make plugins dir
file (MAKE_DIRECTORY "${CMAKE_BINARY_DIR}/testdir1")
file (MAKE_DIRECTORY "${CMAKE_BINARY_DIR}/testdir2")
@@ -67,12 +85,12 @@ if (BUILD_SHARED_LIBS)
add_definitions (${HDF_EXTRA_C_FLAGS})
INCLUDE_DIRECTORIES (${HDF5_SRC_DIR})
- add_library (${HDF5_TEST_PLUGIN_LIB_TARGET} ${LIB_TYPE} ${HDF5_TEST_SOURCE_DIR}/${test_lib}.c)
- TARGET_C_PROPERTIES (${HDF5_TEST_PLUGIN_LIB_TARGET} ${LIB_TYPE} " " " ")
+ add_library (${HDF5_TEST_PLUGIN_LIB_TARGET} SHARED ${HDF5_TEST_SOURCE_DIR}/${test_lib}.c)
+ TARGET_C_PROPERTIES (${HDF5_TEST_PLUGIN_LIB_TARGET} SHARED " " " ")
target_link_libraries (${HDF5_TEST_PLUGIN_LIB_TARGET} ${HDF5_TEST_LIB_TARGET})
H5_SET_LIB_OPTIONS (
${HDF5_TEST_PLUGIN_LIB_TARGET} ${HDF5_TEST_PLUGIN_LIB_NAME}
- ${LIB_TYPE}
+ SHARED
HDF5_TEST_PLUGIN_LIB_NAME_RELEASE
HDF5_TEST_PLUGIN_LIB_NAME_DEBUG
)
@@ -85,7 +103,7 @@ if (BUILD_SHARED_LIBS)
TARGET ${HDF5_TEST_PLUGIN_LIB_TARGET}
POST_BUILD
COMMAND ${CMAKE_COMMAND}
- ARGS -E copy_if_different
+ ARGS -E copy_if_different
"$<TARGET_FILE:${HDF5_TEST_PLUGIN_LIB_TARGET}>"
"${CMAKE_BINARY_DIR}/testdir1/$<TARGET_FILE_NAME:${HDF5_TEST_PLUGIN_LIB_TARGET}>"
)
@@ -98,12 +116,12 @@ if (BUILD_SHARED_LIBS)
add_definitions (${HDF_EXTRA_C_FLAGS})
INCLUDE_DIRECTORIES (${HDF5_SRC_DIR})
- add_library (${HDF5_TEST_PLUGIN_LIB_TARGET} ${LIB_TYPE} ${HDF5_TEST_SOURCE_DIR}/${test_lib}.c)
- TARGET_C_PROPERTIES (${HDF5_TEST_PLUGIN_LIB_TARGET} ${LIB_TYPE} " " " ")
+ add_library (${HDF5_TEST_PLUGIN_LIB_TARGET} SHARED ${HDF5_TEST_SOURCE_DIR}/${test_lib}.c)
+ TARGET_C_PROPERTIES (${HDF5_TEST_PLUGIN_LIB_TARGET} SHARED " " " ")
target_link_libraries (${HDF5_TEST_PLUGIN_LIB_TARGET} ${HDF5_TEST_LIB_TARGET})
H5_SET_LIB_OPTIONS (
${HDF5_TEST_PLUGIN_LIB_TARGET} ${HDF5_TEST_PLUGIN_LIB_NAME}
- ${LIB_TYPE}
+ SHARED
HDF5_TEST_PLUGIN_LIB_NAME_RELEASE
HDF5_TEST_PLUGIN_LIB_NAME_DEBUG
)
@@ -116,12 +134,11 @@ if (BUILD_SHARED_LIBS)
TARGET ${HDF5_TEST_PLUGIN_LIB_TARGET}
POST_BUILD
COMMAND ${CMAKE_COMMAND}
- ARGS -E copy_if_different
+ ARGS -E copy_if_different
"$<TARGET_FILE:${HDF5_TEST_PLUGIN_LIB_TARGET}>"
"${CMAKE_BINARY_DIR}/testdir2/$<TARGET_FILE_NAME:${HDF5_TEST_PLUGIN_LIB_TARGET}>"
)
endforeach (test_lib ${TEST2_PLUGIN_LIBS})
-endif (BUILD_SHARED_LIBS)
set (testhdf5_SRCS
${HDF5_TEST_SOURCE_DIR}/testhdf5.c
@@ -153,17 +170,31 @@ set (testhdf5_SRCS
#-- Adding test for testhdf5
add_executable (testhdf5 ${testhdf5_SRCS})
-TARGET_NAMING (testhdf5 ${LIB_TYPE})
-TARGET_C_PROPERTIES (testhdf5 ${LIB_TYPE} " " " ")
+TARGET_NAMING (testhdf5 STATIC)
+TARGET_C_PROPERTIES (testhdf5 STATIC " " " ")
target_link_libraries (testhdf5 ${HDF5_TEST_LIB_TARGET} ${HDF5_LIB_TARGET})
set_target_properties (testhdf5 PROPERTIES FOLDER test)
+if (BUILD_SHARED_LIBS)
+ add_executable (testhdf5-shared ${testhdf5_SRCS})
+ TARGET_NAMING (testhdf5-shared SHARED)
+ TARGET_C_PROPERTIES (testhdf5-shared SHARED " " " ")
+ target_link_libraries (testhdf5-shared ${HDF5_TEST_LIBSH_TARGET} ${HDF5_LIBSH_TARGET})
+ set_target_properties (testhdf5-shared PROPERTIES FOLDER test)
+endif (BUILD_SHARED_LIBS)
MACRO (ADD_H5_EXE file)
add_executable (${file} ${HDF5_TEST_SOURCE_DIR}/${file}.c)
- TARGET_NAMING (${file} ${LIB_TYPE})
- TARGET_C_PROPERTIES (${file} ${LIB_TYPE} " " " ")
+ TARGET_NAMING (${file} STATIC)
+ TARGET_C_PROPERTIES (${file} STATIC " " " ")
target_link_libraries (${file} ${HDF5_TEST_LIB_TARGET} ${HDF5_LIB_TARGET})
set_target_properties (${file} PROPERTIES FOLDER test)
+ if (BUILD_SHARED_LIBS)
+ add_executable (${file}-shared ${HDF5_TEST_SOURCE_DIR}/${file}.c)
+ TARGET_NAMING (${file}-shared SHARED)
+ TARGET_C_PROPERTIES (${file}-shared SHARED " " " ")
+ target_link_libraries (${file}-shared ${HDF5_TEST_LIBSH_TARGET} ${HDF5_LIBSH_TARGET})
+ set_target_properties (${file}-shared PROPERTIES FOLDER test)
+ endif (BUILD_SHARED_LIBS)
ENDMACRO (ADD_H5_EXE file)
set (H5_TESTS
@@ -236,24 +267,45 @@ endforeach (test ${H5_TESTS})
#-- Adding test for cache
add_executable (cache ${HDF5_TEST_SOURCE_DIR}/cache.c ${HDF5_TEST_SOURCE_DIR}/cache_common.c)
-TARGET_NAMING (cache ${LIB_TYPE})
-TARGET_C_PROPERTIES (cache ${LIB_TYPE} " " " ")
+TARGET_NAMING (cache STATIC)
+TARGET_C_PROPERTIES (cache STATIC " " " ")
target_link_libraries (cache ${HDF5_LIB_TARGET} ${HDF5_TEST_LIB_TARGET})
set_target_properties (cache PROPERTIES FOLDER test)
+if (BUILD_SHARED_LIBS)
+ add_executable (cache-shared ${HDF5_TEST_SOURCE_DIR}/cache.c ${HDF5_TEST_SOURCE_DIR}/cache_common.c)
+ TARGET_NAMING (cache-shared SHARED)
+ TARGET_C_PROPERTIES (cache-shared SHARED " " " ")
+ target_link_libraries (cache-shared ${HDF5_TEST_LIBSH_TARGET} ${HDF5_LIBSH_TARGET})
+ set_target_properties (cache-shared PROPERTIES FOLDER test)
+endif (BUILD_SHARED_LIBS)
#-- Adding test for cache_api
add_executable (cache_api ${HDF5_TEST_SOURCE_DIR}/cache_api.c ${HDF5_TEST_SOURCE_DIR}/cache_common.c)
-TARGET_NAMING (cache_api ${LIB_TYPE})
-TARGET_C_PROPERTIES (cache_api ${LIB_TYPE} " " " ")
+TARGET_NAMING (cache_api STATIC)
+TARGET_C_PROPERTIES (cache_api STATIC " " " ")
target_link_libraries (cache_api ${HDF5_LIB_TARGET} ${HDF5_TEST_LIB_TARGET})
set_target_properties (cache_api PROPERTIES FOLDER test)
+if (BUILD_SHARED_LIBS)
+ add_executable (cache_api-shared ${HDF5_TEST_SOURCE_DIR}/cache_api.c ${HDF5_TEST_SOURCE_DIR}/cache_common.c)
+ TARGET_NAMING (cache_api-shared SHARED)
+ TARGET_C_PROPERTIES (cache_api-shared SHARED " " " ")
+ target_link_libraries (cache_api-shared ${HDF5_TEST_LIBSH_TARGET} ${HDF5_LIBSH_TARGET})
+ set_target_properties (cache_api-shared PROPERTIES FOLDER test)
+endif (BUILD_SHARED_LIBS)
#-- Adding test for cache_tagging
add_executable (cache_tagging ${HDF5_TEST_SOURCE_DIR}/cache_tagging.c ${HDF5_TEST_SOURCE_DIR}/cache_common.c)
-TARGET_NAMING (cache_tagging ${LIB_TYPE})
-TARGET_C_PROPERTIES (cache_tagging ${LIB_TYPE} " " " ")
+TARGET_NAMING (cache_tagging STATIC)
+TARGET_C_PROPERTIES (cache_tagging STATIC " " " ")
target_link_libraries (cache_tagging ${HDF5_LIB_TARGET} ${HDF5_TEST_LIB_TARGET})
set_target_properties (cache_tagging PROPERTIES FOLDER test)
+if (BUILD_SHARED_LIBS)
+ add_executable (cache_tagging-shared ${HDF5_TEST_SOURCE_DIR}/cache_tagging.c ${HDF5_TEST_SOURCE_DIR}/cache_common.c)
+ TARGET_NAMING (cache_tagging-shared SHARED)
+ TARGET_C_PROPERTIES (cache_tagging-shared SHARED " " " ")
+ target_link_libraries (cache_tagging-shared ${HDF5_TEST_LIBSH_TARGET} ${HDF5_LIBSH_TARGET})
+ set_target_properties (cache_tagging-shared PROPERTIES FOLDER test)
+endif (BUILD_SHARED_LIBS)
#-- Adding test for ttsafe
add_executable (ttsafe
@@ -263,37 +315,71 @@ add_executable (ttsafe
${HDF5_TEST_SOURCE_DIR}/ttsafe_cancel.c
${HDF5_TEST_SOURCE_DIR}/ttsafe_acreate.c
)
-TARGET_NAMING (ttsafe ${LIB_TYPE})
-TARGET_C_PROPERTIES (ttsafe ${LIB_TYPE} " " " ")
+TARGET_NAMING (ttsafe STATIC)
+TARGET_C_PROPERTIES (ttsafe STATIC " " " ")
target_link_libraries (ttsafe ${HDF5_LIB_TARGET} ${HDF5_TEST_LIB_TARGET})
set_target_properties (ttsafe PROPERTIES FOLDER test)
+if (BUILD_SHARED_LIBS)
+ add_executable (ttsafe-shared
+ ${HDF5_TEST_SOURCE_DIR}/ttsafe.c
+ ${HDF5_TEST_SOURCE_DIR}/ttsafe_dcreate.c
+ ${HDF5_TEST_SOURCE_DIR}/ttsafe_error.c
+ ${HDF5_TEST_SOURCE_DIR}/ttsafe_cancel.c
+ ${HDF5_TEST_SOURCE_DIR}/ttsafe_acreate.c
+ )
+ TARGET_NAMING (ttsafe-shared SHARED)
+ TARGET_C_PROPERTIES (ttsafe-shared SHARED " " " ")
+ target_link_libraries (ttsafe-shared ${HDF5_TEST_LIBSH_TARGET} ${HDF5_LIBSH_TARGET})
+ set_target_properties (ttsafe-shared PROPERTIES FOLDER test)
+endif (BUILD_SHARED_LIBS)
#-- Adding test for err_compat
if (HDF5_ENABLE_DEPRECATED_SYMBOLS)
add_executable (err_compat ${HDF5_TEST_SOURCE_DIR}/err_compat.c)
- TARGET_NAMING (err_compat ${LIB_TYPE})
- TARGET_C_PROPERTIES (err_compat ${LIB_TYPE} " " " ")
+ TARGET_NAMING (err_compat STATIC)
+ TARGET_C_PROPERTIES (err_compat STATIC " " " ")
target_link_libraries (err_compat ${HDF5_LIB_TARGET} ${HDF5_TEST_LIB_TARGET})
set_target_properties (err_compat PROPERTIES FOLDER test)
+ if (BUILD_SHARED_LIBS)
+ add_executable (err_compat-shared ${HDF5_TEST_SOURCE_DIR}/err_compat.c)
+ TARGET_NAMING (err_compat-shared SHARED)
+ TARGET_C_PROPERTIES (err_compat-shared SHARED " " " ")
+ target_link_libraries (err_compat-shared ${HDF5_TEST_LIBSH_TARGET} ${HDF5_LIBSH_TARGET})
+ set_target_properties (err_compat-shared PROPERTIES FOLDER test)
+ endif (BUILD_SHARED_LIBS)
endif (HDF5_ENABLE_DEPRECATED_SYMBOLS)
#-- Adding test for error_test
add_executable (error_test ${HDF5_TEST_SOURCE_DIR}/error_test.c)
-TARGET_NAMING (error_test ${LIB_TYPE})
-TARGET_C_PROPERTIES (error_test ${LIB_TYPE} " " " ")
+TARGET_NAMING (error_test STATIC)
+TARGET_C_PROPERTIES (error_test STATIC " " " ")
target_link_libraries (error_test ${HDF5_LIB_TARGET} ${HDF5_TEST_LIB_TARGET})
set_target_properties (error_test PROPERTIES FOLDER test)
+if (BUILD_SHARED_LIBS)
+ add_executable (error_test-shared ${HDF5_TEST_SOURCE_DIR}/error_test.c)
+ TARGET_NAMING (error_test-shared SHARED)
+ TARGET_C_PROPERTIES (error_test-shared SHARED " " " ")
+ target_link_libraries (error_test-shared ${HDF5_TEST_LIBSH_TARGET} ${HDF5_LIBSH_TARGET})
+ set_target_properties (error_test-shared PROPERTIES FOLDER test)
+endif (BUILD_SHARED_LIBS)
#-- Adding test for links_env
add_executable (links_env ${HDF5_TEST_SOURCE_DIR}/links_env.c)
-TARGET_NAMING (links_env ${LIB_TYPE})
-TARGET_C_PROPERTIES (links_env ${LIB_TYPE} " " " ")
+TARGET_NAMING (links_env STATIC)
+TARGET_C_PROPERTIES (links_env STATIC " " " ")
target_link_libraries (links_env ${HDF5_LIB_TARGET} ${HDF5_TEST_LIB_TARGET})
set_target_properties (links_env PROPERTIES FOLDER test)
+if (BUILD_SHARED_LIBS)
+ add_executable (links_env-shared ${HDF5_TEST_SOURCE_DIR}/links_env.c)
+ TARGET_NAMING (links_env-shared SHARED)
+ TARGET_C_PROPERTIES (links_env-shared SHARED " " " ")
+ target_link_libraries (links_env-shared ${HDF5_TEST_LIBSH_TARGET} ${HDF5_LIBSH_TARGET})
+ set_target_properties (links_env-shared PROPERTIES FOLDER test)
+endif (BUILD_SHARED_LIBS)
#-- Adding test for libinfo
set (GREP_RUNNER ${PROJECT_BINARY_DIR}/GrepRunner.cmake)
-file (WRITE ${GREP_RUNNER}
+file (WRITE ${GREP_RUNNER}
"file (STRINGS \${TEST_PROGRAM} TEST_RESULT REGEX \"SUMMARY OF THE HDF5 CONFIGURATION\")
if (\${TEST_RESULT} STREQUAL \"0\")
message (FATAL_ERROR \"Failed: The output: \${TEST_RESULT} of \${TEST_PROGRAM} did not contain SUMMARY OF THE HDF5 CONFIGURATION\")
@@ -312,6 +398,12 @@ if (BUILD_SHARED_LIBS)
TARGET_C_PROPERTIES (plugin SHARED " " " ")
target_link_libraries (plugin ${HDF5_TEST_PLUGIN_LIB_TARGET})
set_target_properties (plugin PROPERTIES FOLDER test)
+else (BUILD_SHARED_LIBS)
+ add_executable (plugin ${HDF5_TEST_SOURCE_DIR}/plugin.c)
+ TARGET_NAMING (plugin STATIC)
+ TARGET_C_PROPERTIES (plugin STATIC " " " ")
+ target_link_libraries (plugin ${HDF5_TEST_PLUGIN_LIB_TARGET})
+ set_target_properties (plugin PROPERTIES FOLDER test)
endif (BUILD_SHARED_LIBS)
include (CMakeTests.cmake)
diff --git a/test/CMakeTests.cmake b/test/CMakeTests.cmake
index c7803f6..5fe51ed 100644
--- a/test/CMakeTests.cmake
+++ b/test/CMakeTests.cmake
@@ -9,6 +9,12 @@
file (MAKE_DIRECTORY "${PROJECT_BINARY_DIR}/H5TEST")
file (MAKE_DIRECTORY "${PROJECT_BINARY_DIR}/H5TEST/testfiles")
file (MAKE_DIRECTORY "${PROJECT_BINARY_DIR}/H5TEST/testfiles/plist_files")
+if (BUILD_SHARED_LIBS)
+ file (MAKE_DIRECTORY "${PROJECT_BINARY_DIR}/H5TEST-shared")
+ file (MAKE_DIRECTORY "${PROJECT_BINARY_DIR}/H5TEST-shared/testfiles")
+ file (MAKE_DIRECTORY "${PROJECT_BINARY_DIR}/H5TEST-shared/testfiles/plist_files")
+endif (BUILD_SHARED_LIBS)
+
if (HDF5_TEST_VFD)
set (VFD_LIST
sec2
@@ -23,6 +29,9 @@ if (HDF5_TEST_VFD)
endif (DIRECT_VFD)
foreach (vfdtest ${VFD_LIST})
file (MAKE_DIRECTORY "${PROJECT_BINARY_DIR}/${vfdtest}")
+ #if (BUILD_SHARED_LIBS)
+ # file (MAKE_DIRECTORY "${PROJECT_BINARY_DIR}/${vfdtest}-shared")
+ #endif (BUILD_SHARED_LIBS)
endforeach (vfdtest ${VFD_LIST})
endif (HDF5_TEST_VFD)
@@ -35,25 +44,41 @@ set (HDF5_TEST_FILES
foreach (h5_tfile ${HDF5_TEST_FILES})
set (dest "${PROJECT_BINARY_DIR}/H5TEST/${h5_tfile}")
- #message (STATUS " Copying ${h5_tfile}")
add_custom_command (
TARGET ${HDF5_TEST_LIB_TARGET}
POST_BUILD
COMMAND ${CMAKE_COMMAND}
ARGS -E copy_if_different ${HDF5_TOOLS_SRC_DIR}/testfiles/${h5_tfile} ${dest}
)
+ if (BUILD_SHARED_LIBS)
+ set (dest "${PROJECT_BINARY_DIR}/H5TEST-shared/${h5_tfile}")
+ add_custom_command (
+ TARGET ${HDF5_TEST_LIBSH_TARGET}
+ POST_BUILD
+ COMMAND ${CMAKE_COMMAND}
+ ARGS -E copy_if_different ${HDF5_TOOLS_SRC_DIR}/testfiles/${h5_tfile} ${dest}
+ )
+ endif (BUILD_SHARED_LIBS)
endforeach (h5_tfile ${HDF5_TEST_FILES})
if (HDF5_TEST_VFD)
foreach (vfdtest ${VFD_LIST})
foreach (h5_tfile ${HDF5_TEST_FILES})
set (dest "${PROJECT_BINARY_DIR}/${vfdtest}/${h5_tfile}")
- #message (STATUS " Copying ${h5_tfile}")
add_custom_command (
TARGET ${HDF5_TEST_LIB_TARGET}
POST_BUILD
COMMAND ${CMAKE_COMMAND}
ARGS -E copy_if_different ${HDF5_TOOLS_SRC_DIR}/testfiles/${h5_tfile} ${dest}
)
+ if (BUILD_SHARED_LIBS)
+ set (dest "${PROJECT_BINARY_DIR}/${vfdtest}-shared/${h5_tfile}")
+ add_custom_command (
+ TARGET ${HDF5_TEST_LIBSH_TARGET}
+ POST_BUILD
+ COMMAND ${CMAKE_COMMAND}
+ ARGS -E copy_if_different ${HDF5_TOOLS_SRC_DIR}/testfiles/${h5_tfile} ${dest}
+ )
+ endif (BUILD_SHARED_LIBS)
endforeach (h5_tfile ${HDF5_TEST_FILES})
endforeach (vfdtest ${VFD_LIST})
endif (HDF5_TEST_VFD)
@@ -71,25 +96,41 @@ set (HDF5_REFERENCE_FILES
foreach (ref_file ${HDF5_REFERENCE_FILES})
set (dest "${PROJECT_BINARY_DIR}/H5TEST/${ref_file}")
- #message (STATUS " Copying ${h5_file}")
add_custom_command (
TARGET ${HDF5_TEST_LIB_TARGET}
POST_BUILD
COMMAND ${CMAKE_COMMAND}
ARGS -E copy_if_different ${HDF5_TEST_SOURCE_DIR}/testfiles/${ref_file} ${dest}
)
+ if (BUILD_SHARED_LIBS)
+ set (dest "${PROJECT_BINARY_DIR}/H5TEST-shared/${ref_file}")
+ add_custom_command (
+ TARGET ${HDF5_TEST_LIBSH_TARGET}
+ POST_BUILD
+ COMMAND ${CMAKE_COMMAND}
+ ARGS -E copy_if_different ${HDF5_TEST_SOURCE_DIR}/testfiles/${ref_file} ${dest}
+ )
+ endif (BUILD_SHARED_LIBS)
endforeach (ref_file ${HDF5_REFERENCE_FILES})
if (HDF5_TEST_VFD)
foreach (vfdtest ${VFD_LIST})
foreach (ref_file ${HDF5_REFERENCE_FILES})
set (dest "${PROJECT_BINARY_DIR}/${vfdtest}/${ref_file}")
- #message (STATUS " Copying ${h5_file}")
add_custom_command (
TARGET ${HDF5_TEST_LIB_TARGET}
POST_BUILD
COMMAND ${CMAKE_COMMAND}
ARGS -E copy_if_different ${HDF5_TEST_SOURCE_DIR}/testfiles/${ref_file} ${dest}
)
+ if (BUILD_SHARED_LIBS)
+ set (dest "${PROJECT_BINARY_DIR}/${vfdtest}-shared/${ref_file}")
+ add_custom_command (
+ TARGET ${HDF5_TEST_LIB_TARGET}
+ POST_BUILD
+ COMMAND ${CMAKE_COMMAND}
+ ARGS -E copy_if_different ${HDF5_TEST_SOURCE_DIR}/testfiles/${ref_file} ${dest}
+ )
+ endif (BUILD_SHARED_LIBS)
endforeach (ref_file ${HDF5_REFERENCE_FILES})
endforeach (vfdtest ${VFD_LIST})
endif (HDF5_TEST_VFD)
@@ -126,13 +167,21 @@ set (HDF5_REFERENCE_PLIST_FILES
foreach (plistfile ${HDF5_REFERENCE_PLIST_FILES})
set (dest "${PROJECT_BINARY_DIR}/H5TEST/testfiles/plist_files/${plistfile}")
- #message (STATUS " Copying ${plistfile} to ${dset}")
add_custom_command (
TARGET ${HDF5_TEST_LIB_TARGET}
POST_BUILD
COMMAND ${CMAKE_COMMAND}
ARGS -E copy_if_different ${HDF5_TEST_SOURCE_DIR}/testfiles/plist_files/${plistfile} ${dest}
)
+ if (BUILD_SHARED_LIBS)
+ set (dest "${PROJECT_BINARY_DIR}/H5TEST-shared/testfiles/plist_files/${plistfile}")
+ add_custom_command (
+ TARGET ${HDF5_TEST_LIBSH_TARGET}
+ POST_BUILD
+ COMMAND ${CMAKE_COMMAND}
+ ARGS -E copy_if_different ${HDF5_TEST_SOURCE_DIR}/testfiles/plist_files/${plistfile} ${dest}
+ )
+ endif (BUILD_SHARED_LIBS)
endforeach (plistfile ${HDF5_REFERENCE_PLIST_FILES})
# --------------------------------------------------------------------
@@ -177,25 +226,41 @@ set (HDF5_REFERENCE_TEST_FILES
foreach (h5_file ${HDF5_REFERENCE_TEST_FILES})
set (dest "${HDF5_TEST_BINARY_DIR}/H5TEST/${h5_file}")
- #message (STATUS " Copying ${h5_file} to ${dest}")
add_custom_command (
TARGET ${HDF5_TEST_LIB_TARGET}
POST_BUILD
COMMAND ${CMAKE_COMMAND}
ARGS -E copy_if_different ${HDF5_TEST_SOURCE_DIR}/${h5_file} ${dest}
)
+ if (BUILD_SHARED_LIBS)
+ set (dest "${HDF5_TEST_BINARY_DIR}/H5TEST-shared/${h5_file}")
+ add_custom_command (
+ TARGET ${HDF5_TEST_LIBSH_TARGET}
+ POST_BUILD
+ COMMAND ${CMAKE_COMMAND}
+ ARGS -E copy_if_different ${HDF5_TEST_SOURCE_DIR}/${h5_file} ${dest}
+ )
+ endif (BUILD_SHARED_LIBS)
endforeach (h5_file ${HDF5_REFERENCE_TEST_FILES})
if (HDF5_TEST_VFD)
foreach (vfdtest ${VFD_LIST})
foreach (h5_file ${HDF5_REFERENCE_TEST_FILES})
set (dest "${HDF5_TEST_BINARY_DIR}/${vfdtest}/${h5_file}")
- #message (STATUS " Copying ${h5_file} to ${dest}")
add_custom_command (
TARGET ${HDF5_TEST_LIB_TARGET}
POST_BUILD
COMMAND ${CMAKE_COMMAND}
ARGS -E copy_if_different ${HDF5_TEST_SOURCE_DIR}/${h5_file} ${dest}
)
+ if (BUILD_SHARED_LIBS)
+ set (dest "${HDF5_TEST_BINARY_DIR}/${vfdtest}-shared/${h5_file}")
+ add_custom_command (
+ TARGET ${HDF5_TEST_LIB_TARGET}
+ POST_BUILD
+ COMMAND ${CMAKE_COMMAND}
+ ARGS -E copy_if_different ${HDF5_TEST_SOURCE_DIR}/${h5_file} ${dest}
+ )
+ endif (BUILD_SHARED_LIBS)
endforeach (h5_file ${HDF5_REFERENCE_TEST_FILES})
endforeach (vfdtest ${VFD_LIST})
endif (HDF5_TEST_VFD)
@@ -258,6 +323,38 @@ else (HDF5_ENABLE_USING_MEMCHECKER)
ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/H5TEST"
WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}/H5TEST
)
+ if (BUILD_SHARED_LIBS)
+ add_test (
+ NAME H5TEST-shared-clear-testhdf5-objects
+ COMMAND ${CMAKE_COMMAND}
+ -E remove
+ coord.h5
+ dtypes10.h5
+ sys_file1
+ tattr.h5
+ tfile1.h5
+ tfile2.h5
+ tfile3.h5
+ tfile4.h5
+ tfile5.h5
+ tfile6.h5
+ tfile7.h5
+ th5o_file
+ th5s1.h5
+ tselect.h5
+ tsohm.h5
+ tsohm_dst.h5
+ tsohm_src.h5
+ WORKING_DIRECTORY
+ ${HDF5_TEST_BINARY_DIR}/H5TEST-shared
+ )
+ add_test (NAME H5TEST-shared-testhdf5 COMMAND $<TARGET_FILE:testhdf5-shared>)
+ set_tests_properties (H5TEST-shared-testhdf5 PROPERTIES
+ DEPENDS H5TEST-shared-clear-testhdf5-objects
+ ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/H5TEST-shared"
+ WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}/H5TEST-shared
+ )
+ endif (BUILD_SHARED_LIBS)
endif (HDF5_ENABLE_USING_MEMCHECKER)
##############################################################################
@@ -355,6 +452,97 @@ set_tests_properties (H5TEST-fheap PROPERTIES TIMEOUT 1800)
set_tests_properties (H5TEST-testmeta PROPERTIES TIMEOUT 1800)
set_tests_properties (H5TEST-big PROPERTIES TIMEOUT 1800)
+if (BUILD_SHARED_LIBS)
+ # Remove any output file left over from previous test run
+ add_test (
+ NAME H5TEST-shared-clear-objects
+ COMMAND ${CMAKE_COMMAND}
+ -E remove
+ dt_arith1.h5
+ dt_arith2.h5
+ dtransform.h5
+ dtypes3.h5
+ dtypes4.h5
+ dtypes5.h5
+ efc0.h5
+ efc1.h5
+ efc2.h5
+ efc3.h5
+ efc4.h5
+ efc5.h5
+ extlinks16A00000.h5
+ extlinks16A00001.h5
+ extlinks16A00002.h5
+ extlinks16B-b.h5
+ extlinks16B-g.h5
+ extlinks16B-l.h5
+ extlinks16B-r.h5
+ extlinks16B-s.h5
+ extlinks19B00000.h5
+ extlinks19B00001.h5
+ extlinks19B00002.h5
+ extlinks19B00003.h5
+ extlinks19B00004.h5
+ extlinks19B00005.h5
+ extlinks19B00006.h5
+ extlinks19B00007.h5
+ extlinks19B00008.h5
+ extlinks19B00009.h5
+ extlinks19B00010.h5
+ extlinks19B00011.h5
+ extlinks19B00012.h5
+ extlinks19B00013.h5
+ extlinks19B00014.h5
+ extlinks19B00015.h5
+ extlinks19B00016.h5
+ extlinks19B00017.h5
+ extlinks19B00018.h5
+ extlinks19B00019.h5
+ extlinks19B00020.h5
+ extlinks19B00021.h5
+ extlinks19B00022.h5
+ extlinks19B00023.h5
+ extlinks19B00024.h5
+ extlinks19B00025.h5
+ extlinks19B00026.h5
+ extlinks19B00027.h5
+ extlinks19B00028.h5
+ fheap.h5
+ log_vfd_out.log
+ new_multi_file_v16-r.h5
+ new_multi_file_v16-s.h5
+ objcopy_ext.dat
+ testmeta.h5
+ tstint1.h5
+ tstint2.h5
+ unregister_filter_1.h5
+ unregister_filter_2.h5
+ WORKING_DIRECTORY
+ ${HDF5_TEST_BINARY_DIR}/H5TEST-shared
+ )
+
+ foreach (test ${H5_TESTS})
+ if (${test} STREQUAL "big" AND CYGWIN)
+ add_test (
+ NAME H5TEST-shared-${test}
+ COMMAND ${CMAKE_COMMAND} -E echo "SKIP ${test}-shared"
+ )
+ else (${test} STREQUAL "big" AND CYGWIN)
+ add_test (NAME H5TEST-shared-${test} COMMAND $<TARGET_FILE:${test}-shared>)
+ endif (${test} STREQUAL "big" AND CYGWIN)
+ set_tests_properties (H5TEST-shared-${test} PROPERTIES
+ DEPENDS H5TEST-shared-clear-objects
+ ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/H5TEST-shared"
+ WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}/H5TEST-shared
+ )
+ endforeach (test ${H5_TESTS})
+
+ set_tests_properties (H5TEST-shared-flush2 PROPERTIES DEPENDS H5TEST-shared-flush1)
+ set_tests_properties (H5TEST-shared-fheap PROPERTIES TIMEOUT 1800)
+ set_tests_properties (H5TEST-shared-testmeta PROPERTIES TIMEOUT 1800)
+ set_tests_properties (H5TEST-shared-big PROPERTIES TIMEOUT 1800)
+endif (BUILD_SHARED_LIBS)
+
##############################################################################
##############################################################################
### A D D I T I O N A L T E S T S ###
@@ -362,20 +550,22 @@ set_tests_properties (H5TEST-big PROPERTIES TIMEOUT 1800)
##############################################################################
#-- Adding test for cache
-add_test (
- NAME H5TEST-clear-cache-objects
- COMMAND ${CMAKE_COMMAND}
- -E remove
- cache_test.h5
- WORKING_DIRECTORY
- ${HDF5_TEST_BINARY_DIR}/H5TEST
-)
-add_test (NAME H5TEST-cache COMMAND $<TARGET_FILE:cache>)
-set_tests_properties (H5TEST-cache PROPERTIES
- DEPENDS H5TEST-clear-cache-objects
- ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/H5TEST"
- WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}/H5TEST
-)
+if (NOT CYGWIN)
+ add_test (
+ NAME H5TEST-clear-cache-objects
+ COMMAND ${CMAKE_COMMAND}
+ -E remove
+ cache_test.h5
+ WORKING_DIRECTORY
+ ${HDF5_TEST_BINARY_DIR}/H5TEST
+ )
+ add_test (NAME H5TEST-cache COMMAND $<TARGET_FILE:cache>)
+ set_tests_properties (H5TEST-cache PROPERTIES
+ DEPENDS H5TEST-clear-cache-objects
+ ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/H5TEST;HDF5TestExpress=2"
+ WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}/H5TEST
+ )
+endif (NOT CYGWIN)
#-- Adding test for cache_api
add_test (
@@ -521,31 +711,186 @@ add_test (
${HDF5_TEST_BINARY_DIR}/H5TEST
)
-##############################################################################
-### P L U G I N T E S T S
-##############################################################################
if (BUILD_SHARED_LIBS)
+ #-- Adding test for cache
+ if (NOT CYGWIN)
+ add_test (
+ NAME H5TEST-shared-clear-cache-objects
+ COMMAND ${CMAKE_COMMAND}
+ -E remove
+ cache_test.h5
+ WORKING_DIRECTORY
+ ${HDF5_TEST_BINARY_DIR}/H5TEST-shared
+ )
+ add_test (NAME H5TEST-shared-cache COMMAND $<TARGET_FILE:cache-shared>)
+ set_tests_properties (H5TEST-shared-cache PROPERTIES
+ DEPENDS H5TEST-shared-clear-cache-objects
+ ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/H5TEST-shared;HDF5TestExpress=2"
+ WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}/H5TEST-shared
+ )
+ endif (NOT CYGWIN)
+
+ #-- Adding test for cache_api
+ add_test (
+ NAME H5TEST-shared-clear-cache_api-objects
+ COMMAND ${CMAKE_COMMAND}
+ -E remove
+ cache_api_test.h5
+ WORKING_DIRECTORY
+ ${HDF5_TEST_BINARY_DIR}/H5TEST-shared
+ )
+ add_test (NAME H5TEST-shared-cache_api COMMAND $<TARGET_FILE:cache_api-shared>)
+ set_tests_properties (H5TEST-shared-cache_api PROPERTIES
+ DEPENDS H5TEST-shared-clear-cache_api-objects
+ ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/H5TEST-shared"
+ WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}/H5TEST-shared
+ )
- if (WIN32)
- set (CMAKE_SEP "\;")
- else (WIN32)
- set (CMAKE_SEP ":")
- endif (WIN32)
+ #-- Adding test for cache_tagging
+ add_test (
+ NAME H5TEST-shared-clear-cache_tagging-objects
+ COMMAND ${CMAKE_COMMAND}
+ -E remove
+ tagging_test.h5
+ tagging_ext_test.h5
+ WORKING_DIRECTORY
+ ${HDF5_TEST_BINARY_DIR}/H5TEST-shared
+ )
+ add_test (NAME H5TEST-shared-cache_tagging COMMAND $<TARGET_FILE:cache_tagging-shared>)
+ set_tests_properties (H5TEST-shared-cache_tagging PROPERTIES
+ DEPENDS H5TEST-shared-clear-cache_tagging-objects
+ ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/H5TEST-shared"
+ WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}/H5TEST-shared
+ )
+
+ #-- Adding test for ttsafe
+ add_test (
+ NAME H5TEST-shared-clear-ttsafe-objects
+ COMMAND ${CMAKE_COMMAND}
+ -E remove
+ ttsafe_error.h5
+ ttsafe_dcreate.h5
+ ttsafe_cancel.h5
+ ttsafe_acreate.h5
+ WORKING_DIRECTORY
+ ${HDF5_TEST_BINARY_DIR}/H5TEST-shared
+ )
+ add_test (NAME H5TEST-shared-ttsafe COMMAND $<TARGET_FILE:ttsafe-shared>)
+ set_tests_properties (H5TEST-shared-ttsafe PROPERTIES
+ DEPENDS H5TEST-shared-clear-ttsafe-objects
+ ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/H5TEST-shared"
+ WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}/H5TEST-shared
+ )
+
+ #-- Adding test for err_compat
+ if (HDF5_ENABLE_DEPRECATED_SYMBOLS)
+ add_test (
+ NAME H5TEST-shared-clear-err_compat-objects
+ COMMAND ${CMAKE_COMMAND}
+ -E remove
+ err_compat.txt
+ err_compat.txt.err
+ WORKING_DIRECTORY
+ ${HDF5_TEST_BINARY_DIR}/H5TEST-shared
+ )
+ add_test (NAME H5TEST-shared-err_compat COMMAND "${CMAKE_COMMAND}"
+ -D "TEST_PROGRAM=$<TARGET_FILE:err_compat-shared>"
+ -D "TEST_ARGS:STRING="
+ -D "TEST_EXPECT=0"
+ -D "TEST_MASK_ERROR=true"
+ -D "TEST_OUTPUT=err_compat.txt"
+ -D "TEST_REFERENCE=err_compat_1"
+ -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/H5TEST-shared"
+ -P "${HDF_RESOURCES_EXT_DIR}/runTest.cmake"
+ )
+ set_tests_properties (H5TEST-shared-err_compat PROPERTIES
+ DEPENDS H5TEST-shared-clear-err_compat-objects
+ ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/H5TEST-shared"
+ WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}/H5TEST-shared
+ )
+ endif (HDF5_ENABLE_DEPRECATED_SYMBOLS)
+
+ #-- Adding test for error_test
+ add_test (
+ NAME H5TEST-shared-clear-error_test-objects
+ COMMAND ${CMAKE_COMMAND}
+ -E remove
+ error_test.txt
+ error_test.txt.err
+ WORKING_DIRECTORY
+ ${HDF5_TEST_BINARY_DIR}/H5TEST-shared
+ )
+ add_test (NAME H5TEST-shared-error_test COMMAND "${CMAKE_COMMAND}"
+ -D "TEST_PROGRAM=$<TARGET_FILE:error_test-shared>"
+ -D "TEST_ARGS:STRING="
+ -D "TEST_EXPECT=0"
+ -D "TEST_MASK_ERROR=true"
+ -D "TEST_OUTPUT=error_test.txt"
+ -D "TEST_REFERENCE=error_test_1"
+ -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/H5TEST-shared"
+ -P "${HDF_RESOURCES_EXT_DIR}/runTest.cmake"
+ )
+ set_tests_properties (H5TEST-shared-error_test PROPERTIES
+ DEPENDS H5TEST-shared-clear-error_test-objects
+ ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/H5TEST-shared;HDF5_PLUGIN_PRELOAD=::"
+ WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}/H5TEST-shared
+ )
- add_test (NAME H5PLUGIN-plugin COMMAND $<TARGET_FILE:plugin>)
- set_tests_properties (H5PLUGIN-plugin PROPERTIES
- ENVIRONMENT "HDF5_PLUGIN_PATH=${CMAKE_BINARY_DIR}/testdir1${CMAKE_SEP}${CMAKE_BINARY_DIR}/testdir2;srcdir=${HDF5_TEST_BINARY_DIR}"
- WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}
+ #-- Adding test for links_env
+ add_test (
+ NAME H5TEST-shared-clear-links_env-objects
+ COMMAND ${CMAKE_COMMAND}
+ -E remove
+ links_env.txt
+ links_env.txt.err
+ extlinks_env0.h5
+ extlinks_env1.h5
+ tmp/extlinks_env1.h5
+ WORKING_DIRECTORY
+ ${HDF5_TEST_BINARY_DIR}/H5TEST-shared
+ )
+ add_test (NAME H5TEST-shared-links_env COMMAND "${CMAKE_COMMAND}"
+ -D "TEST_PROGRAM=$<TARGET_FILE:links_env-shared>"
+ -D "TEST_ARGS:STRING="
+ -D "TEST_ENV_VAR:STRING=HDF5_EXT_PREFIX"
+ -D "TEST_ENV_VALUE:STRING=.:tmp"
+ -D "TEST_EXPECT=0"
+ -D "TEST_OUTPUT=links_env.txt"
+ -D "TEST_REFERENCE=links_env.out"
+ -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/H5TEST-shared"
+ -P "${HDF_RESOURCES_EXT_DIR}/runTest.cmake"
)
-else (BUILD_SHARED_LIBS)
- message (STATUS " **** Plugins libraries must be built as shared libraries **** ")
+ set_tests_properties (H5TEST-shared-links_env PROPERTIES
+ DEPENDS H5TEST-shared-clear-links_env-objects
+ ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/H5TEST-shared"
+ WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}/H5TEST-shared
+ )
+
+ #-- Adding test for libinfo
add_test (
- NAME H5PLUGIN-SKIPPED
- COMMAND ${CMAKE_COMMAND} -E echo "SKIP H5PLUGIN TESTING"
+ NAME H5TEST-shared-testlibinfo
+ COMMAND ${CMAKE_COMMAND} -D "TEST_PROGRAM=$<TARGET_FILE:${HDF5_LIBSH_TARGET}>" -P "${GREP_RUNNER}"
+ WORKING_DIRECTORY
+ ${HDF5_TEST_BINARY_DIR}/H5TEST-shared
)
endif (BUILD_SHARED_LIBS)
##############################################################################
+### P L U G I N T E S T S
+##############################################################################
+if (WIN32)
+ set (CMAKE_SEP "\;")
+else (WIN32)
+ set (CMAKE_SEP ":")
+endif (WIN32)
+
+add_test (NAME H5PLUGIN-plugin COMMAND $<TARGET_FILE:plugin>)
+set_tests_properties (H5PLUGIN-plugin PROPERTIES
+ ENVIRONMENT "HDF5_PLUGIN_PATH=${CMAKE_BINARY_DIR}/testdir1${CMAKE_SEP}${CMAKE_BINARY_DIR}/testdir2;srcdir=${HDF5_TEST_BINARY_DIR}"
+ WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}
+)
+
+##############################################################################
##############################################################################
### V F D T E S T S ###
##############################################################################
@@ -560,7 +905,7 @@ if (HDF5_TEST_VFD)
ohdr
stab
gheap
- cache
+# cache
cache_api
cache_tagging
pool
@@ -609,7 +954,7 @@ if (HDF5_TEST_VFD)
unregister
)
if (NOT CYGWIN)
- set (H5_VFD_TESTS ${H5_VFD_TESTS} big)
+ set (H5_VFD_TESTS ${H5_VFD_TESTS} big cache)
endif (NOT CYGWIN)
MACRO (CHECK_VFD_TEST vfdtest vfdname resultcode)
@@ -623,7 +968,7 @@ if (HDF5_TEST_VFD)
-D "TEST_ARGS:STRING="
-D "TEST_VFD:STRING=${vfdname}"
-D "TEST_EXPECT=${resultcode}"
- -D "TEST_OUTPUT=${vfdtest}"
+ -D "TEST_OUTPUT=${vfdname}-${vfdtest}"
-D "TEST_FOLDER=${PROJECT_BINARY_DIR}/${vfdname}"
-P "${HDF_RESOURCES_DIR}/vfdTest.cmake"
)
@@ -631,11 +976,34 @@ if (HDF5_TEST_VFD)
ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/${vfdname}"
WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}/${vfdname}
)
+ if (BUILD_SHARED_LIBS)
+ add_test (
+ NAME VFD-${vfdname}-${test}-shared
+ COMMAND "${CMAKE_COMMAND}"
+ -D "TEST_PROGRAM=$<TARGET_FILE:${vfdtest}-shared>"
+ -D "TEST_ARGS:STRING="
+ -D "TEST_VFD:STRING=${vfdname}"
+ -D "TEST_EXPECT=${resultcode}"
+ -D "TEST_OUTPUT=${vfdname}-${vfdtest}-shared"
+ -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/${vfdname}-shared"
+ -P "${HDF_RESOURCES_DIR}/vfdTest.cmake"
+ )
+ set_tests_properties (VFD-${vfdname}-${vfdtest}-shared PROPERTIES
+ ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/${vfdname}-shared"
+ WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}/${vfdname}-shared
+ )
+ endif (BUILD_SHARED_LIBS)
else (NOT BUILD_SHARED_LIBS AND NOT CMAKE_BUILD_TYPE MATCHES Debug)
add_test (
NAME VFD-${vfdname}-${vfdtest}
COMMAND ${CMAKE_COMMAND} -E echo "SKIP VFD-${vfdname}-${vfdtest}"
)
+ if (BUILD_SHARED_LIBS)
+ add_test (
+ NAME VFD-${vfdname}-${test}-shared
+ COMMAND ${CMAKE_COMMAND} -E echo "SKIP VFD-${vfdname}-${vfdtest}-shared"
+ )
+ endif (BUILD_SHARED_LIBS)
endif(NOT BUILD_SHARED_LIBS AND NOT CMAKE_BUILD_TYPE MATCHES Debug)
else (${vfdname} STREQUAL "multi" OR ${vfdname} STREQUAL "split")
add_test (
@@ -645,7 +1013,7 @@ if (HDF5_TEST_VFD)
-D "TEST_ARGS:STRING="
-D "TEST_VFD:STRING=${vfdname}"
-D "TEST_EXPECT=${resultcode}"
- -D "TEST_OUTPUT=${vfdtest}"
+ -D "TEST_OUTPUT=${vfdname}-${vfdtest}"
-D "TEST_FOLDER=${PROJECT_BINARY_DIR}/${vfdname}"
-P "${HDF_RESOURCES_DIR}/vfdTest.cmake"
)
@@ -653,6 +1021,23 @@ if (HDF5_TEST_VFD)
ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/${vfdname}"
WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}/${vfdname}
)
+ if (BUILD_SHARED_LIBS)
+ add_test (
+ NAME VFD-${vfdname}-${test}-shared
+ COMMAND "${CMAKE_COMMAND}"
+ -D "TEST_PROGRAM=$<TARGET_FILE:${vfdtest}-shared>"
+ -D "TEST_ARGS:STRING="
+ -D "TEST_VFD:STRING=${vfdname}"
+ -D "TEST_EXPECT=${resultcode}"
+ -D "TEST_OUTPUT=${vfdname}-${vfdtest}-shared"
+ -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/${vfdname}-shared"
+ -P "${HDF_RESOURCES_DIR}/vfdTest.cmake"
+ )
+ set_tests_properties (VFD-${vfdname}-${vfdtest}-shared PROPERTIES
+ ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/${vfdname}-shared"
+ WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}/${vfdname}-shared
+ )
+ endif (BUILD_SHARED_LIBS)
endif (${vfdname} STREQUAL "multi" OR ${vfdname} STREQUAL "split")
else (${vfdtest} STREQUAL "flush1" OR ${vfdtest} STREQUAL "flush2")
add_test (
@@ -662,14 +1047,31 @@ if (HDF5_TEST_VFD)
-D "TEST_ARGS:STRING="
-D "TEST_VFD:STRING=${vfdname}"
-D "TEST_EXPECT=${resultcode}"
- -D "TEST_OUTPUT=${vfdtest}"
+ -D "TEST_OUTPUT=${vfdname}-${vfdtest}"
-D "TEST_FOLDER=${PROJECT_BINARY_DIR}/${vfdname}"
-P "${HDF_RESOURCES_DIR}/vfdTest.cmake"
)
set_tests_properties (VFD-${vfdname}-${vfdtest} PROPERTIES
- ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/${vfdname}"
+ ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/${vfdname};HDF5TestExpress=2"
WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}/${vfdname}
)
+ if (BUILD_SHARED_LIBS)
+ add_test (
+ NAME VFD-${vfdname}-${vfdtest}-shared
+ COMMAND "${CMAKE_COMMAND}"
+ -D "TEST_PROGRAM=$<TARGET_FILE:${vfdtest}-shared>"
+ -D "TEST_ARGS:STRING="
+ -D "TEST_VFD:STRING=${vfdname}"
+ -D "TEST_EXPECT=${resultcode}"
+ -D "TEST_OUTPUT=${vfdname}-${vfdtest}-shared"
+ -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/${vfdname}-shared"
+ -P "${HDF_RESOURCES_DIR}/vfdTest.cmake"
+ )
+ set_tests_properties (VFD-${vfdname}-${vfdtest}-shared PROPERTIES
+ ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/${vfdname}-shared;HDF5TestExpress=2"
+ WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}/${vfdname}-shared
+ )
+ endif (BUILD_SHARED_LIBS)
endif (${vfdtest} STREQUAL "flush1" OR ${vfdtest} STREQUAL "flush2")
ENDMACRO (CHECK_VFD_TEST vfdtest vfdname resultcode)
@@ -679,42 +1081,82 @@ if (HDF5_TEST_VFD)
CHECK_VFD_TEST (${test} ${vfdname} ${resultcode})
else (WIN32)
add_test (
- NAME VFD-${vfdname}-${test}
- COMMAND "${CMAKE_COMMAND}"
- -D "TEST_PROGRAM=$<TARGET_FILE:${test}>"
- -D "TEST_ARGS:STRING="
- -D "TEST_VFD:STRING=${vfdname}"
- -D "TEST_EXPECT=${resultcode}"
- -D "TEST_OUTPUT=${vfdname}-${test}"
- -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/${vfdname}"
- -P "${HDF_RESOURCES_DIR}/vfdTest.cmake"
+ NAME VFD-${vfdname}-${test}
+ COMMAND "${CMAKE_COMMAND}"
+ -D "TEST_PROGRAM=$<TARGET_FILE:${test}>"
+ -D "TEST_ARGS:STRING="
+ -D "TEST_VFD:STRING=${vfdname}"
+ -D "TEST_EXPECT=${resultcode}"
+ -D "TEST_OUTPUT=${vfdname}-${test}"
+ -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/${vfdname}"
+ -P "${HDF_RESOURCES_DIR}/vfdTest.cmake"
)
set_tests_properties (VFD-${vfdname}-${test} PROPERTIES
ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/${vfdname}"
WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}/${vfdname}
)
+ if (BUILD_SHARED_LIBS)
+ add_test (
+ NAME VFD-${vfdname}-${test}-shared
+ COMMAND "${CMAKE_COMMAND}"
+ -D "TEST_PROGRAM=$<TARGET_FILE:${test}-shared>"
+ -D "TEST_ARGS:STRING="
+ -D "TEST_VFD:STRING=${vfdname}"
+ -D "TEST_EXPECT=${resultcode}"
+ -D "TEST_OUTPUT=${vfdname}-${test}-shared"
+ -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/${vfdname}-shared"
+ -P "${HDF_RESOURCES_DIR}/vfdTest.cmake"
+ )
+ set_tests_properties (VFD-${vfdname}-${test}-shared PROPERTIES
+ ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/${vfdname}-shared"
+ WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}/${vfdname}-shared
+ )
+ endif (BUILD_SHARED_LIBS)
endif (WIN32)
endforeach (test ${H5_VFD_TESTS})
set_tests_properties (VFD-${vfdname}-flush2 PROPERTIES DEPENDS VFD-${vfdname}-flush1)
set_tests_properties (VFD-${vfdname}-flush1 PROPERTIES TIMEOUT 10)
set_tests_properties (VFD-${vfdname}-flush2 PROPERTIES TIMEOUT 10)
+ if (BUILD_SHARED_LIBS)
+ set_tests_properties (VFD-${vfdname}-flush2-shared PROPERTIES DEPENDS VFD-${vfdname}-flush1-shared)
+ set_tests_properties (VFD-${vfdname}-flush1-shared PROPERTIES TIMEOUT 10)
+ set_tests_properties (VFD-${vfdname}-flush2-shared PROPERTIES TIMEOUT 10)
+ endif (BUILD_SHARED_LIBS)
if (HDF5_TEST_FHEAP_VFD)
add_test (
- NAME VFD-${vfdname}-fheap
- COMMAND "${CMAKE_COMMAND}"
- -D "TEST_PROGRAM=$<TARGET_FILE:fheap>"
- -D "TEST_ARGS:STRING="
- -D "TEST_VFD:STRING=${vfdname}"
- -D "TEST_EXPECT=${resultcode}"
- -D "TEST_OUTPUT=${vfdname}-fheap"
- -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/${vfdname}"
- -P "${HDF_RESOURCES_DIR}/vfdTest.cmake"
+ NAME VFD-${vfdname}-fheap
+ COMMAND "${CMAKE_COMMAND}"
+ -D "TEST_PROGRAM=$<TARGET_FILE:fheap>"
+ -D "TEST_ARGS:STRING="
+ -D "TEST_VFD:STRING=${vfdname}"
+ -D "TEST_EXPECT=${resultcode}"
+ -D "TEST_OUTPUT=${vfdname}-fheap"
+ -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/${vfdname}"
+ -P "${HDF_RESOURCES_DIR}/vfdTest.cmake"
)
set_tests_properties (VFD-${vfdname}-fheap PROPERTIES
TIMEOUT 1800
- ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/${vfdname}"
+ ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/${vfdname};HDF5TestExpress=2"
WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}/${vfdname}
)
+ if (BUILD_SHARED_LIBS)
+ add_test (
+ NAME VFD-${vfdname}-fheap-shared
+ COMMAND "${CMAKE_COMMAND}"
+ -D "TEST_PROGRAM=$<TARGET_FILE:fheap-shared>"
+ -D "TEST_ARGS:STRING="
+ -D "TEST_VFD:STRING=${vfdname}"
+ -D "TEST_EXPECT=${resultcode}"
+ -D "TEST_OUTPUT=${vfdname}-fheap-shared"
+ -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/${vfdname}-shared"
+ -P "${HDF_RESOURCES_DIR}/vfdTest.cmake"
+ )
+ set_tests_properties (VFD-${vfdname}-fheap-shared PROPERTIES
+ TIMEOUT 1800
+ ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/${vfdname}-shared;HDF5TestExpress=2"
+ WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}/${vfdname}-shared
+ )
+ endif (BUILD_SHARED_LIBS)
endif (HDF5_TEST_FHEAP_VFD)
ENDMACRO (ADD_VFD_TEST)
@@ -731,7 +1173,7 @@ endif (HDF5_TEST_VFD)
##############################################################################
##############################################################################
-if (HDF5_BUILD_GENERATORS AND NOT BUILD_SHARED_LIBS)
+if (HDF5_BUILD_GENERATORS)
MACRO (ADD_H5_GENERATOR genfile)
add_executable (${genfile} ${HDF5_TEST_SOURCE_DIR}/${genfile}.c)
TARGET_NAMING (${genfile} STATIC)
@@ -767,4 +1209,4 @@ if (HDF5_BUILD_GENERATORS AND NOT BUILD_SHARED_LIBS)
ADD_H5_GENERATOR (${gen})
endforeach (gen ${H5_GENERATORS})
-endif (HDF5_BUILD_GENERATORS AND NOT BUILD_SHARED_LIBS)
+endif (HDF5_BUILD_GENERATORS)
diff --git a/test/cache.c b/test/cache.c
index 85fbadb..38adbda 100644
--- a/test/cache.c
+++ b/test/cache.c
@@ -19,7 +19,6 @@
* This file contains tests for the cache implemented in
* H5C.c
*/
-#include "H5private.h" /* Put this first, so H5open() isn't invoked in public macros */
#include "h5test.h"
#include "H5Iprivate.h"
#include "H5ACprivate.h"
@@ -35,9 +34,8 @@ struct flush_cache_test_spec
int entry_index;
hbool_t insert_flag;
unsigned int flags;
- hbool_t expected_loaded;
- hbool_t expected_cleared;
- hbool_t expected_flushed;
+ hbool_t expected_deserialized;
+ hbool_t expected_serialized;
hbool_t expected_destroyed;
};
@@ -51,9 +49,8 @@ struct pe_flush_cache_test_spec
int num_pins;
int pin_type[MAX_PINS];
int pin_idx[MAX_PINS];
- hbool_t expected_loaded;
- hbool_t expected_cleared;
- hbool_t expected_flushed;
+ hbool_t expected_deserialized;
+ hbool_t expected_serialized;
hbool_t expected_destroyed;
};
@@ -68,9 +65,8 @@ struct fo_flush_entry_check
hbool_t is_dirty;
hbool_t is_protected;
hbool_t is_pinned;
- hbool_t expected_loaded;
- hbool_t expected_cleared;
- hbool_t expected_flushed;
+ hbool_t expected_deserialized;
+ hbool_t expected_serialized;
hbool_t expected_destroyed;
};
@@ -88,9 +84,8 @@ struct fo_flush_cache_test_spec
int pin_idx[MAX_PINS];
int num_flush_ops;
struct flush_op flush_ops[MAX_FLUSH_OPS];
- hbool_t expected_loaded;
- hbool_t expected_cleared;
- hbool_t expected_flushed;
+ hbool_t expected_deserialized;
+ hbool_t expected_serialized;
hbool_t expected_destroyed;
};
@@ -105,17 +100,17 @@ struct move_entry_test_spec
/* private function declarations: */
-static unsigned smoke_check_1(void);
-static unsigned smoke_check_2(void);
-static unsigned smoke_check_3(void);
-static unsigned smoke_check_4(void);
-static unsigned smoke_check_5(void);
-static unsigned smoke_check_6(void);
-static unsigned smoke_check_7(void);
-static unsigned smoke_check_8(void);
-static unsigned smoke_check_9(void);
-static unsigned smoke_check_10(void);
-static unsigned write_permitted_check(void);
+static unsigned smoke_check_1(int express_test);
+static unsigned smoke_check_2(int express_test);
+static unsigned smoke_check_3(int express_test);
+static unsigned smoke_check_4(int express_test);
+static unsigned smoke_check_5(int express_test);
+static unsigned smoke_check_6(int express_test);
+static unsigned smoke_check_7(int express_test);
+static unsigned smoke_check_8(int express_test);
+static unsigned smoke_check_9(int express_test);
+static unsigned smoke_check_10(int express_test);
+static unsigned write_permitted_check(int express_test);
static unsigned check_insert_entry(void);
static unsigned check_flush_cache(void);
static void check_flush_cache__empty_cache(H5F_t * file_ptr);
@@ -138,22 +133,21 @@ static void check_flush_cache__single_entry_test(H5F_t * file_ptr,
hbool_t insert_flag,
unsigned int flags,
unsigned int flush_flags,
- hbool_t expected_loaded,
- hbool_t expected_cleared,
- hbool_t expected_flushed,
+ hbool_t expected_deserialized,
+ hbool_t expected_serialized,
hbool_t expected_destroyed);
static void check_flush_cache__pinned_single_entry_test(H5F_t * file_ptr,
int test_num,
int entry_type,
int entry_idx,
+ hbool_t unprot_dirty_flag,
hbool_t mark_dirty,
hbool_t pop_mark_dirty_prot,
hbool_t pop_mark_dirty_pinned,
hbool_t unprotect_unpin,
unsigned int flags,
unsigned int flush_flags,
- hbool_t expected_cleared,
- hbool_t expected_flushed,
+ hbool_t expected_serialized,
hbool_t expected_destroyed);
static void check_flush_cache__flush_ops(H5F_t * file_ptr);
static void check_flush_cache__flush_op_test(H5F_t * file_ptr,
@@ -168,7 +162,6 @@ static void check_flush_cache__flush_op_test(H5F_t * file_ptr,
int check_size,
struct fo_flush_entry_check check[]);
static void check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr);
-static unsigned check_flush_protected_err(void);
static unsigned check_get_entry_status(void);
static unsigned check_expunge_entry(void);
static unsigned check_multiple_read_protect(void);
@@ -178,6 +171,7 @@ static void check_move_entry__run_test(H5F_t * file_ptr, int test_num,
static unsigned check_pin_protected_entry(void);
static unsigned check_resize_entry(void);
static unsigned check_evictions_enabled(void);
+static unsigned check_flush_protected_err(void);
static unsigned check_destroy_pinned_err(void);
static unsigned check_destroy_protected_err(void);
static unsigned check_duplicate_insert_err(void);
@@ -203,6 +197,15 @@ static unsigned check_flush_deps(void);
static unsigned check_flush_deps_err(void);
static unsigned check_flush_deps_order(void);
static unsigned check_notify_cb(void);
+static unsigned check_entry_deletions_during_scans(void);
+static void cedds__expunge_dirty_entry_in_flush_test(H5F_t * file_ptr);
+static void cedds__H5C_make_space_in_cache(H5F_t * file_ptr);
+static void cedds__H5C__autoadjust__ageout__evict_aged_out_entries(H5F_t * file_ptr);
+static void cedds__H5C_flush_invalidate_cache__bucket_scan(H5F_t * file_ptr);
+static unsigned check_stats(void);
+#if H5C_COLLECT_CACHE_STATS
+static void check_stats__smoke_check_1(H5F_t * file_ptr);
+#endif /* H5C_COLLECT_CACHE_STATS */
/**************************************************************************/
@@ -223,32 +226,42 @@ static unsigned check_notify_cb(void);
* Programmer: John Mainzer
* 6/16/04
*
- * Modifications:
- *
- * JRM -- 1/18/05
- * Added code to skip this test if the skip_long_tests global
- * is true.
- *
*-------------------------------------------------------------------------
*/
static unsigned
-smoke_check_1(void)
+smoke_check_1(int express_test)
{
hbool_t show_progress = FALSE;
int dirty_unprotects = FALSE;
int dirty_destroys = FALSE;
hbool_t display_stats = FALSE;
int32_t lag = 10;
+ int32_t max_index = (10 * 1024) - 1;
int mile_stone = 1;
H5F_t * file_ptr = NULL;
TESTING("smoke check #1 -- all clean, ins, dest, ren, 4/2 MB cache");
- if ( skip_long_tests ) {
- SKIPPED();
- HDfprintf(stdout, " Long tests disabled.\n");
- return 0; /* <========== note return */
+ switch ( express_test )
+ {
+ case 0:
+ max_index = (10 * 1024) - 1;
+ break;
+
+ case 1:
+ max_index = (1 * 1024) - 1;
+ break;
+
+ case 2:
+ max_index = (512) - 1;
+ break;
+
+ default:
+ SKIPPED();
+ HDfprintf(stdout, " Long tests disabled.\n");
+ return 0; /* <========== note return */
+ break;
}
pass = TRUE;
@@ -271,6 +284,7 @@ smoke_check_1(void)
FUNC, mile_stone++, (int)pass);
row_major_scan_forward(/* file_ptr */ file_ptr,
+ /* max_index */ max_index,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
@@ -289,6 +303,7 @@ smoke_check_1(void)
FUNC, mile_stone++, (int)pass);
row_major_scan_backward(/* file_ptr */ file_ptr,
+ /* max_index */ max_index,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
@@ -307,6 +322,7 @@ smoke_check_1(void)
FUNC, mile_stone++, (int)pass);
row_major_scan_forward(/* file_ptr */ file_ptr,
+ /* max_index */ max_index,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
@@ -336,6 +352,7 @@ smoke_check_1(void)
FUNC, mile_stone++, (int)pass);
col_major_scan_forward(/* file_ptr */ file_ptr,
+ /* max_index */ max_index,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
@@ -360,6 +377,7 @@ smoke_check_1(void)
FUNC, mile_stone++, (int)pass);
col_major_scan_backward(/* file_ptr */ file_ptr,
+ /* max_index */ max_index,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
@@ -407,32 +425,42 @@ smoke_check_1(void)
* Programmer: John Mainzer
* 6/24/04
*
- * Modifications:
- *
- * JRM -- 1/18/05
- * Added code to skip this test if the skip_long_tests global
- * is true.
- *
*-------------------------------------------------------------------------
*/
static unsigned
-smoke_check_2(void)
+smoke_check_2(int express_test)
{
hbool_t show_progress = FALSE;
int dirty_unprotects = TRUE;
int dirty_destroys = TRUE;
hbool_t display_stats = FALSE;
+ int32_t max_index = (10 * 1024) - 1;
int32_t lag = 10;
int mile_stone = 1;
H5F_t * file_ptr = NULL;
TESTING("smoke check #2 -- ~1/2 dirty, ins, dest, ren, 4/2 MB cache");
- if ( skip_long_tests ) {
- SKIPPED();
- HDfprintf(stdout, " Long tests disabled.\n");
- return 0; /* <========== note return */
+ switch ( express_test )
+ {
+ case 0:
+ max_index = (10 * 1024) - 1;
+ break;
+
+ case 1:
+ max_index = (1 * 1024) - 1;
+ break;
+
+ case 2:
+ max_index = (512) - 1;
+ break;
+
+ default:
+ SKIPPED();
+ HDfprintf(stdout, " Long tests disabled.\n");
+ return 0; /* <========== note return */
+ break;
}
pass = TRUE;
@@ -455,6 +483,7 @@ smoke_check_2(void)
FUNC, mile_stone++, (int)pass);
row_major_scan_forward(/* file_ptr */ file_ptr,
+ /* max_index */ max_index,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
@@ -473,6 +502,7 @@ smoke_check_2(void)
FUNC, mile_stone++, (int)pass);
row_major_scan_backward(/* file_ptr */ file_ptr,
+ /* max_index */ max_index,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
@@ -491,6 +521,7 @@ smoke_check_2(void)
FUNC, mile_stone++, (int)pass);
row_major_scan_forward(/* file_ptr */ file_ptr,
+ /* max_index */ max_index,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
@@ -520,6 +551,7 @@ smoke_check_2(void)
FUNC, mile_stone++, (int)pass);
col_major_scan_forward(/* file_ptr */ file_ptr,
+ /* max_index */ max_index,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
@@ -544,6 +576,7 @@ smoke_check_2(void)
FUNC, mile_stone++, (int)pass);
col_major_scan_backward(/* file_ptr */ file_ptr,
+ /* max_index */ max_index,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
@@ -590,32 +623,42 @@ smoke_check_2(void)
* Programmer: John Mainzer
* 6/16/04
*
- * Modifications:
- *
- * JRM -- 1/18/05
- * Added code to skip this test if the skip_long_tests global
- * is true.
- *
*-------------------------------------------------------------------------
*/
static unsigned
-smoke_check_3(void)
+smoke_check_3(int express_test)
{
hbool_t show_progress = FALSE;
int dirty_unprotects = FALSE;
int dirty_destroys = FALSE;
hbool_t display_stats = FALSE;
+ int32_t max_index = (10 * 1024) - 1;
int32_t lag = 10;
int mile_stone = 1;
H5F_t * file_ptr = NULL;
TESTING("smoke check #3 -- all clean, ins, dest, ren, 2/1 KB cache");
- if ( skip_long_tests ) {
- SKIPPED();
- HDfprintf(stdout, " Long tests disabled.\n");
- return 0; /* <========== note return */
+ switch ( express_test )
+ {
+ case 0:
+ max_index = (10 * 1024) - 1;
+ break;
+
+ case 1:
+ max_index = (1 * 1024) - 1;
+ break;
+
+ case 2:
+ max_index = (512) - 1;
+ break;
+
+ default:
+ SKIPPED();
+ HDfprintf(stdout, " Long tests disabled.\n");
+ return 0; /* <========== note return */
+ break;
}
pass = TRUE;
@@ -638,6 +681,7 @@ smoke_check_3(void)
FUNC, mile_stone++, (int)pass);
row_major_scan_forward(/* file_ptr */ file_ptr,
+ /* max_index */ max_index,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
@@ -656,6 +700,7 @@ smoke_check_3(void)
FUNC, mile_stone++, (int)pass);
row_major_scan_backward(/* file_ptr */ file_ptr,
+ /* max_index */ max_index,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
@@ -674,6 +719,7 @@ smoke_check_3(void)
FUNC, mile_stone++, (int)pass);
row_major_scan_forward(/* file_ptr */ file_ptr,
+ /* max_index */ max_index,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
@@ -703,6 +749,7 @@ smoke_check_3(void)
FUNC, mile_stone++, (int)pass);
col_major_scan_forward(/* file_ptr */ file_ptr,
+ /* max_index */ max_index,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
@@ -727,6 +774,7 @@ smoke_check_3(void)
FUNC, mile_stone++, (int)pass);
col_major_scan_backward(/* file_ptr */ file_ptr,
+ /* max_index */ max_index,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
@@ -774,32 +822,42 @@ smoke_check_3(void)
* Programmer: John Mainzer
* 6/24/04
*
- * Modifications:
- *
- * JRM -- 1/18/05
- * Added code to skip this test if the skip_long_tests global
- * is true.
- *
*-------------------------------------------------------------------------
*/
static unsigned
-smoke_check_4(void)
+smoke_check_4(int express_test)
{
hbool_t show_progress = FALSE;
int dirty_unprotects = TRUE;
int dirty_destroys = TRUE;
hbool_t display_stats = FALSE;
+ int32_t max_index = (10 * 1024) - 1;
int32_t lag = 10;
int mile_stone = 1;
H5F_t * file_ptr = NULL;
TESTING("smoke check #4 -- ~1/2 dirty, ins, dest, ren, 2/1 KB cache");
- if ( skip_long_tests ) {
- SKIPPED();
- HDfprintf(stdout, " Long tests disabled.\n");
- return 0; /* <========== note return */
+ switch ( express_test )
+ {
+ case 0:
+ max_index = (10 * 1024) - 1;
+ break;
+
+ case 1:
+ max_index = (1 * 1024) - 1;
+ break;
+
+ case 2:
+ max_index = (512) - 1;
+ break;
+
+ default:
+ SKIPPED();
+ HDfprintf(stdout, " Long tests disabled.\n");
+ return 0; /* <========== note return */
+ break;
}
pass = TRUE;
@@ -822,6 +880,7 @@ smoke_check_4(void)
FUNC, mile_stone++, (int)pass);
row_major_scan_forward(/* file_ptr */ file_ptr,
+ /* max_index */ max_index,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
@@ -840,6 +899,7 @@ smoke_check_4(void)
FUNC, mile_stone++, (int)pass);
row_major_scan_backward(/* file_ptr */ file_ptr,
+ /* max_index */ max_index,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
@@ -858,6 +918,7 @@ smoke_check_4(void)
FUNC, mile_stone++, (int)pass);
row_major_scan_forward(/* file_ptr */ file_ptr,
+ /* max_index */ max_index,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
@@ -887,6 +948,7 @@ smoke_check_4(void)
FUNC, mile_stone++, (int)pass);
col_major_scan_forward(/* file_ptr */ file_ptr,
+ /* max_index */ max_index,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
@@ -911,6 +973,7 @@ smoke_check_4(void)
FUNC, mile_stone++, (int)pass);
col_major_scan_backward(/* file_ptr */ file_ptr,
+ /* max_index */ max_index,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
@@ -958,17 +1021,11 @@ smoke_check_4(void)
* Programmer: John Mainzer
* 10/14/04
*
- * Modifications:
- *
- * JRM -- 1/18/05
- * Added code to skip this test if the skip_long_tests global
- * is true.
- *
*-------------------------------------------------------------------------
*/
static unsigned
-smoke_check_5(void)
+smoke_check_5(int express_test)
{
herr_t result;
hbool_t show_progress = FALSE;
@@ -1029,18 +1086,25 @@ smoke_check_5(void)
TESTING("smoke check #5 -- all clean, ins, prot, unprot, AR cache 1");
- if ( skip_long_tests ) {
-
- SKIPPED();
-
- HDfprintf(stdout, " Long tests disabled.\n");
+ switch ( express_test )
+ {
+ case 0:
+ max_index = (10 * 1024) - 1;
+ break;
- return 0; /* <========== note return */
- }
+ case 1:
+ max_index = (1 * 1024) - 1;
+ break;
- if ( run_full_test ) {
+ case 2:
+ max_index = (512) - 1;
+ break;
- max_index = (10 * 1024) - 1;
+ default:
+ SKIPPED();
+ HDfprintf(stdout, " Long tests disabled.\n");
+ return 0; /* <========== note return */
+ break;
}
pass = TRUE;
@@ -1193,17 +1257,11 @@ smoke_check_5(void)
* Programmer: John Mainzer
* 10/25/04
*
- * Modifications:
- *
- * JRM -- 1/18/05
- * Added code to skip this test if the skip_long_tests global
- * is true.
- *
*-------------------------------------------------------------------------
*/
static unsigned
-smoke_check_6(void)
+smoke_check_6(int express_test)
{
herr_t result;
hbool_t show_progress = FALSE;
@@ -1266,15 +1324,25 @@ smoke_check_6(void)
pass = TRUE;
- if ( skip_long_tests ) {
- SKIPPED();
- HDfprintf(stdout, " Long tests disabled.\n");
- return 0; /* <========== note return */
- }
+ switch ( express_test )
+ {
+ case 0:
+ max_index = (10 * 1024) - 1;
+ break;
+
+ case 1:
+ max_index = (1 * 1024) - 1;
+ break;
- if ( run_full_test ) {
+ case 2:
+ max_index = (512) - 1;
+ break;
- max_index = (10 * 1024) - 1;
+ default:
+ SKIPPED();
+ HDfprintf(stdout, " Long tests disabled.\n");
+ return 0; /* <========== note return */
+ break;
}
if ( show_progress ) /* 1 */
@@ -1425,17 +1493,11 @@ smoke_check_6(void)
* Programmer: John Mainzer
* 12/2/04
*
- * Modifications:
- *
- * JRM -- 1/18/05
- * Added code to skip this test if the skip_long_tests global
- * is true.
- *
*-------------------------------------------------------------------------
*/
static unsigned
-smoke_check_7(void)
+smoke_check_7(int express_test)
{
herr_t result;
hbool_t show_progress = FALSE;
@@ -1497,15 +1559,25 @@ smoke_check_7(void)
TESTING("smoke check #7 -- all clean, ins, prot, unprot, AR cache 2");
- if ( skip_long_tests ) {
- SKIPPED();
- HDfprintf(stdout, " Long tests disabled.\n");
- return 0; /* <========== note return */
- }
+ switch ( express_test )
+ {
+ case 0:
+ max_index = (10 * 1024) - 1;
+ break;
- if ( run_full_test ) {
+ case 1:
+ max_index = (1 * 1024) - 1;
+ break;
- max_index = (10 * 1024) - 1;
+ case 2:
+ max_index = (512) - 1;
+ break;
+
+ default:
+ SKIPPED();
+ HDfprintf(stdout, " Long tests disabled.\n");
+ return 0; /* <========== note return */
+ break;
}
pass = TRUE;
@@ -1658,17 +1730,11 @@ smoke_check_7(void)
* Programmer: John Mainzer
* 10/25/04
*
- * Modifications:
- *
- * JRM -- 1/18/05
- * Added code to skip this test if the skip_long_tests global
- * is true.
- *
*-------------------------------------------------------------------------
*/
static unsigned
-smoke_check_8(void)
+smoke_check_8(int express_test)
{
herr_t result;
hbool_t show_progress = FALSE;
@@ -1730,15 +1796,25 @@ smoke_check_8(void)
TESTING("smoke check #8 -- ~1/2 dirty, ins, prot, unprot, AR cache 2");
- if ( skip_long_tests ) {
- SKIPPED();
- HDfprintf(stdout, " Long tests disabled.\n");
- return 0; /* <========== note return */
- }
+ switch ( express_test )
+ {
+ case 0:
+ max_index = (10 * 1024) - 1;
+ break;
+
+ case 1:
+ max_index = (1 * 1024) - 1;
+ break;
- if ( run_full_test ) {
+ case 2:
+ max_index = (512) - 1;
+ break;
- max_index = (10 * 1024) - 1;
+ default:
+ SKIPPED();
+ HDfprintf(stdout, " Long tests disabled.\n");
+ return 0; /* <========== note return */
+ break;
}
pass = TRUE;
@@ -1901,7 +1977,7 @@ smoke_check_8(void)
*/
static unsigned
-smoke_check_9(void)
+smoke_check_9(int express_test)
{
herr_t result;
hbool_t show_progress = FALSE;
@@ -1909,6 +1985,7 @@ smoke_check_9(void)
int dirty_destroys = FALSE;
hbool_t display_stats = FALSE;
hbool_t display_detailed_stats = FALSE;
+ int32_t max_index = (10 * 1024) - 1;
int32_t lag = 10;
int mile_stone = 1;
H5F_t * file_ptr = NULL;
@@ -1916,10 +1993,25 @@ smoke_check_9(void)
TESTING("smoke check #9 -- all clean, ins, dest, ren, 4/2 MB, corked");
- if ( skip_long_tests ) {
- SKIPPED();
- HDfprintf(stdout, " Long tests disabled.\n");
- return 0; /* <========== note return */
+ switch ( express_test )
+ {
+ case 0:
+ max_index = (10 * 1024) - 1;
+ break;
+
+ case 1:
+ max_index = (1 * 1024) - 1;
+ break;
+
+ case 2:
+ max_index = (512) - 1;
+ break;
+
+ default:
+ SKIPPED();
+ HDfprintf(stdout, " Long tests disabled.\n");
+ return 0; /* <========== note return */
+ break;
}
pass = TRUE;
@@ -1960,6 +2052,7 @@ smoke_check_9(void)
FUNC, mile_stone++, (int)pass);
row_major_scan_forward(/* file_ptr */ file_ptr,
+ /* max_index */ max_index,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
@@ -1995,6 +2088,7 @@ smoke_check_9(void)
FUNC, mile_stone++, (int)pass);
row_major_scan_backward(/* file_ptr */ file_ptr,
+ /* max_index */ max_index,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
@@ -2028,6 +2122,7 @@ smoke_check_9(void)
FUNC, mile_stone++, (int)pass);
row_major_scan_forward(/* file_ptr */ file_ptr,
+ /* max_index */ max_index,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
@@ -2087,6 +2182,7 @@ smoke_check_9(void)
FUNC, mile_stone++, (int)pass);
col_major_scan_forward(/* file_ptr */ file_ptr,
+ /* max_index */ max_index,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
@@ -2126,6 +2222,7 @@ smoke_check_9(void)
FUNC, mile_stone++, (int)pass);
col_major_scan_backward(/* file_ptr */ file_ptr,
+ /* max_index */ max_index,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
@@ -2200,7 +2297,7 @@ smoke_check_9(void)
*/
static unsigned
-smoke_check_10(void)
+smoke_check_10(int express_test)
{
herr_t result;
hbool_t show_progress = FALSE;
@@ -2208,6 +2305,7 @@ smoke_check_10(void)
int dirty_destroys = TRUE;
hbool_t display_stats = FALSE;
hbool_t display_detailed_stats = FALSE;
+ int32_t max_index = (10 * 1024) - 1;
int32_t lag = 10;
int mile_stone = 1;
H5F_t * file_ptr = NULL;
@@ -2215,10 +2313,25 @@ smoke_check_10(void)
TESTING("smoke check #10 -- ~1/2 dirty, ins, dest, ren, 4/2 MB, corked");
- if ( skip_long_tests ) {
- SKIPPED();
- HDfprintf(stdout, " Long tests disabled.\n");
- return 0; /* <========== note return */
+ switch ( express_test )
+ {
+ case 0:
+ max_index = (10 * 1024) - 1;
+ break;
+
+ case 1:
+ max_index = (1 * 1024) - 1;
+ break;
+
+ case 2:
+ max_index = (512) - 1;
+ break;
+
+ default:
+ SKIPPED();
+ HDfprintf(stdout, " Long tests disabled.\n");
+ return 0; /* <========== note return */
+ break;
}
pass = TRUE;
@@ -2242,6 +2355,7 @@ smoke_check_10(void)
FUNC, mile_stone++, (int)pass);
row_major_scan_forward(/* file_ptr */ file_ptr,
+ /* max_index */ max_index,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
@@ -2275,6 +2389,7 @@ smoke_check_10(void)
FUNC, mile_stone++, (int)pass);
row_major_scan_backward(/* file_ptr */ file_ptr,
+ /* max_index */ max_index,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
@@ -2308,6 +2423,7 @@ smoke_check_10(void)
FUNC, mile_stone++, (int)pass);
row_major_scan_forward(/* file_ptr */ file_ptr,
+ /* max_index */ max_index,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
@@ -2367,6 +2483,7 @@ smoke_check_10(void)
FUNC, mile_stone++, (int)pass);
col_major_scan_forward(/* file_ptr */ file_ptr,
+ /* max_index */ max_index,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
@@ -2421,6 +2538,7 @@ smoke_check_10(void)
FUNC, mile_stone++, (int)pass);
col_major_scan_backward(/* file_ptr */ file_ptr,
+ /* max_index */ max_index,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
@@ -2489,13 +2607,18 @@ smoke_check_10(void)
*-------------------------------------------------------------------------
*/
static unsigned
-write_permitted_check(void)
+write_permitted_check(int
+#if !H5C_MAINTAIN_CLEAN_AND_DIRTY_LRU_LISTS
+H5_ATTR_UNUSED
+#endif /* H5C_MAINTAIN_CLEAN_AND_DIRTY_LRU_LISTS */
+express_test)
{
#if H5C_MAINTAIN_CLEAN_AND_DIRTY_LRU_LISTS
hbool_t show_progress = FALSE;
hbool_t display_stats = FALSE;
+ int32_t max_index = (10 * 1024) - 1;
int32_t lag = 10;
int mile_stone = 1;
H5F_t * file_ptr = NULL;
@@ -2506,6 +2629,27 @@ write_permitted_check(void)
#if H5C_MAINTAIN_CLEAN_AND_DIRTY_LRU_LISTS
+ switch ( express_test )
+ {
+ case 0:
+ max_index = (10 * 1024) - 1;
+ break;
+
+ case 1:
+ max_index = (1 * 1024) - 1;
+ break;
+
+ case 2:
+ max_index = (512) - 1;
+ break;
+
+ default:
+ SKIPPED();
+ HDfprintf(stdout, " Long tests disabled.\n");
+ return 0; /* <========== note return */
+ break;
+ }
+
pass = TRUE;
if ( show_progress ) /* 1 */
@@ -2526,6 +2670,7 @@ write_permitted_check(void)
FUNC, mile_stone++, (int)pass);
row_major_scan_forward(/* file_ptr */ file_ptr,
+ /* max_index */ max_index,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
@@ -2546,6 +2691,7 @@ write_permitted_check(void)
write_permitted = FALSE;
row_major_scan_backward(/* file_ptr */ file_ptr,
+ /* max_index */ max_index,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
@@ -2566,6 +2712,7 @@ write_permitted_check(void)
write_permitted = TRUE;
row_major_scan_forward(/* file_ptr */ file_ptr,
+ /* max_index */ max_index,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
@@ -2595,6 +2742,7 @@ write_permitted_check(void)
FUNC, mile_stone++, (int)pass);
col_major_scan_forward(/* file_ptr */ file_ptr,
+ /* max_index */ max_index,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
@@ -2610,6 +2758,7 @@ write_permitted_check(void)
write_permitted = FALSE;
col_major_scan_backward(/* file_ptr */ file_ptr,
+ /* max_index */ max_index,
/* lag */ lag,
/* verbose */ FALSE,
/* reset_stats */ TRUE,
@@ -3076,8 +3225,7 @@ check_flush_cache__empty_cache(H5F_t * file_ptr)
if ( pass ) {
- result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT,
- H5C__NO_FLAGS_SET);
+ result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5C__NO_FLAGS_SET);
if ( result < 0 ) {
@@ -3088,8 +3236,7 @@ check_flush_cache__empty_cache(H5F_t * file_ptr)
if ( pass ) {
- result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT,
- H5C__FLUSH_INVALIDATE_FLAG);
+ result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5C__FLUSH_INVALIDATE_FLAG);
if ( result < 0 ) {
@@ -3100,8 +3247,7 @@ check_flush_cache__empty_cache(H5F_t * file_ptr)
if ( pass ) {
- result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT,
- H5C__FLUSH_CLEAR_ONLY_FLAG);
+ result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5C__FLUSH_CLEAR_ONLY_FLAG);
if ( result < 0 ) {
@@ -3113,8 +3259,7 @@ check_flush_cache__empty_cache(H5F_t * file_ptr)
if ( pass ) {
- result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT,
- H5C__FLUSH_MARKED_ENTRIES_FLAG);
+ result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5C__FLUSH_MARKED_ENTRIES_FLAG);
if ( result < 0 ) {
@@ -3175,9 +3320,8 @@ check_flush_cache__multi_entry(H5F_t * file_ptr)
/* entry_index = */ 100,
/* insert_flag = */ FALSE,
/* flags = */ H5C__NO_FLAGS_SET,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ FALSE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ FALSE,
/* expected_destroyed = */ FALSE
},
{
@@ -3186,9 +3330,8 @@ check_flush_cache__multi_entry(H5F_t * file_ptr)
/* entry_index = */ 75,
/* insert_flag = */ FALSE,
/* flags = */ H5C__DIRTIED_FLAG,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
@@ -3197,9 +3340,8 @@ check_flush_cache__multi_entry(H5F_t * file_ptr)
/* entry_index = */ 25,
/* insert_flag = */ TRUE,
/* flags = */ H5C__NO_FLAGS_SET,
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
@@ -3207,10 +3349,9 @@ check_flush_cache__multi_entry(H5F_t * file_ptr)
/* entry_type = */ PICO_ENTRY_TYPE,
/* entry_index = */ 50,
/* insert_flag = */ TRUE,
- /* flags = */ H5C__DIRTIED_FLAG,
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* flags = */ H5C__NO_FLAGS_SET,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
@@ -3219,9 +3360,8 @@ check_flush_cache__multi_entry(H5F_t * file_ptr)
/* entry_index = */ 10,
/* insert_flag = */ FALSE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ FALSE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ FALSE,
/* expected_destroyed = */ FALSE
},
{
@@ -3230,9 +3370,8 @@ check_flush_cache__multi_entry(H5F_t * file_ptr)
/* entry_index = */ 20,
/* insert_flag = */ FALSE,
/* flags = */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
@@ -3241,20 +3380,18 @@ check_flush_cache__multi_entry(H5F_t * file_ptr)
/* entry_index = */ 30,
/* insert_flag = */ TRUE,
/* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
- /* entry_num = */ 7,
+ /* entry_num = */ 7,
/* entry_type = */ MONSTER_ENTRY_TYPE,
/* entry_index = */ 40,
/* insert_flag = */ TRUE,
- /* flags = */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ FALSE
}
};
@@ -3272,92 +3409,84 @@ check_flush_cache__multi_entry(H5F_t * file_ptr)
struct flush_cache_test_spec spec[8] =
{
{
- /* entry_num = */ 0,
- /* entry_type = */ PICO_ENTRY_TYPE,
- /* entry_index = */ 100,
- /* insert_flag = */ FALSE,
- /* flags = */ H5C__NO_FLAGS_SET,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 0,
+ /* entry_type = */ PICO_ENTRY_TYPE,
+ /* entry_index = */ 100,
+ /* insert_flag = */ FALSE,
+ /* flags = */ H5C__NO_FLAGS_SET,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ TRUE
},
{
- /* entry_num = */ 1,
- /* entry_type = */ PICO_ENTRY_TYPE,
- /* entry_index = */ 75,
- /* insert_flag = */ FALSE,
- /* flags = */ H5C__DIRTIED_FLAG,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 1,
+ /* entry_type = */ PICO_ENTRY_TYPE,
+ /* entry_index = */ 75,
+ /* insert_flag = */ FALSE,
+ /* flags = */ H5C__DIRTIED_FLAG,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
+ /* expected_destroyed = */ TRUE
},
{
- /* entry_num = */ 2,
- /* entry_type = */ PICO_ENTRY_TYPE,
- /* entry_index = */ 25,
- /* insert_flag = */ TRUE,
- /* flags = */ H5C__NO_FLAGS_SET,
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 2,
+ /* entry_type = */ PICO_ENTRY_TYPE,
+ /* entry_index = */ 25,
+ /* insert_flag = */ TRUE,
+ /* flags = */ H5C__NO_FLAGS_SET,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ TRUE,
+ /* expected_destroyed = */ TRUE
},
{
- /* entry_num = */ 3,
- /* entry_type = */ PICO_ENTRY_TYPE,
- /* entry_index = */ 50,
- /* insert_flag = */ TRUE,
- /* flags = */ H5C__DIRTIED_FLAG,
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 3,
+ /* entry_type = */ PICO_ENTRY_TYPE,
+ /* entry_index = */ 50,
+ /* insert_flag = */ TRUE,
+ /* flags = */ H5C__NO_FLAGS_SET,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ TRUE,
+ /* expected_destroyed = */ TRUE
},
{
- /* entry_num = */ 4,
- /* entry_type = */ MONSTER_ENTRY_TYPE,
- /* entry_index = */ 10,
- /* insert_flag = */ FALSE,
- /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 4,
+ /* entry_type = */ MONSTER_ENTRY_TYPE,
+ /* entry_index = */ 10,
+ /* insert_flag = */ FALSE,
+ /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ TRUE
},
{
- /* entry_num = */ 5,
- /* entry_type = */ MONSTER_ENTRY_TYPE,
- /* entry_index = */ 20,
- /* insert_flag = */ FALSE,
- /* flags = */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 5,
+ /* entry_type = */ MONSTER_ENTRY_TYPE,
+ /* entry_index = */ 20,
+ /* insert_flag = */ FALSE,
+ /* flags = */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
+ /* expected_destroyed = */ TRUE
},
{
- /* entry_num = */ 6,
- /* entry_type = */ MONSTER_ENTRY_TYPE,
- /* entry_index = */ 30,
- /* insert_flag = */ TRUE,
- /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 6,
+ /* entry_type = */ MONSTER_ENTRY_TYPE,
+ /* entry_index = */ 30,
+ /* insert_flag = */ TRUE,
+ /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ TRUE,
+ /* expected_destroyed = */ TRUE
},
{
- /* entry_num = */ 7,
- /* entry_type = */ MONSTER_ENTRY_TYPE,
- /* entry_index = */ 40,
- /* insert_flag = */ TRUE,
- /* flags = */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 7,
+ /* entry_type = */ MONSTER_ENTRY_TYPE,
+ /* entry_index = */ 40,
+ /* insert_flag = */ TRUE,
+ /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ TRUE,
+ /* expected_destroyed = */ TRUE
}
};
@@ -3374,92 +3503,84 @@ check_flush_cache__multi_entry(H5F_t * file_ptr)
struct flush_cache_test_spec spec[8] =
{
{
- /* entry_num = */ 0,
- /* entry_type = */ PICO_ENTRY_TYPE,
- /* entry_index = */ 100,
- /* insert_flag = */ FALSE,
- /* flags = */ H5C__NO_FLAGS_SET,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ FALSE,
- /* expected_destroyed = */ FALSE
+ /* entry_num = */ 0,
+ /* entry_type = */ PICO_ENTRY_TYPE,
+ /* entry_index = */ 100,
+ /* insert_flag = */ FALSE,
+ /* flags = */ H5C__NO_FLAGS_SET,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ FALSE
},
{
- /* entry_num = */ 1,
- /* entry_type = */ PICO_ENTRY_TYPE,
- /* entry_index = */ 75,
- /* insert_flag = */ FALSE,
- /* flags = */ H5C__DIRTIED_FLAG,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ TRUE,
- /* expected_flushed = */ FALSE,
- /* expected_destroyed = */ FALSE
+ /* entry_num = */ 1,
+ /* entry_type = */ PICO_ENTRY_TYPE,
+ /* entry_index = */ 75,
+ /* insert_flag = */ FALSE,
+ /* flags = */ H5C__DIRTIED_FLAG,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ FALSE
},
{
- /* entry_num = */ 2,
- /* entry_type = */ PICO_ENTRY_TYPE,
- /* entry_index = */ 25,
- /* insert_flag = */ TRUE,
- /* flags = */ H5C__NO_FLAGS_SET,
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ TRUE,
- /* expected_flushed = */ FALSE,
- /* expected_destroyed = */ FALSE
+ /* entry_num = */ 2,
+ /* entry_type = */ PICO_ENTRY_TYPE,
+ /* entry_index = */ 25,
+ /* insert_flag = */ TRUE,
+ /* flags = */ H5C__NO_FLAGS_SET,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ FALSE
},
{
- /* entry_num = */ 3,
- /* entry_type = */ PICO_ENTRY_TYPE,
- /* entry_index = */ 50,
- /* insert_flag = */ TRUE,
- /* flags = */ H5C__DIRTIED_FLAG,
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ TRUE,
- /* expected_flushed = */ FALSE,
- /* expected_destroyed = */ FALSE
+ /* entry_num = */ 3,
+ /* entry_type = */ PICO_ENTRY_TYPE,
+ /* entry_index = */ 50,
+ /* insert_flag = */ TRUE,
+ /* flags = */ H5C__NO_FLAGS_SET,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ FALSE
},
{
- /* entry_num = */ 4,
- /* entry_type = */ MONSTER_ENTRY_TYPE,
- /* entry_index = */ 10,
- /* insert_flag = */ FALSE,
- /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ FALSE,
- /* expected_destroyed = */ FALSE
+ /* entry_num = */ 4,
+ /* entry_type = */ MONSTER_ENTRY_TYPE,
+ /* entry_index = */ 10,
+ /* insert_flag = */ FALSE,
+ /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ FALSE
},
{
- /* entry_num = */ 5,
- /* entry_type = */ MONSTER_ENTRY_TYPE,
- /* entry_index = */ 20,
- /* insert_flag = */ FALSE,
- /* flags = */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ TRUE,
- /* expected_flushed = */ FALSE,
- /* expected_destroyed = */ FALSE
+ /* entry_num = */ 5,
+ /* entry_type = */ MONSTER_ENTRY_TYPE,
+ /* entry_index = */ 20,
+ /* insert_flag = */ FALSE,
+ /* flags = */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ FALSE
},
{
- /* entry_num = */ 6,
- /* entry_type = */ MONSTER_ENTRY_TYPE,
- /* entry_index = */ 30,
- /* insert_flag = */ TRUE,
- /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ TRUE,
- /* expected_flushed = */ FALSE,
- /* expected_destroyed = */ FALSE
+ /* entry_num = */ 6,
+ /* entry_type = */ MONSTER_ENTRY_TYPE,
+ /* entry_index = */ 30,
+ /* insert_flag = */ TRUE,
+ /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ FALSE
},
{
- /* entry_num = */ 7,
- /* entry_type = */ MONSTER_ENTRY_TYPE,
- /* entry_index = */ 40,
- /* insert_flag = */ TRUE,
- /* flags = */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ TRUE,
- /* expected_flushed = */ FALSE,
- /* expected_destroyed = */ FALSE
+ /* entry_num = */ 7,
+ /* entry_type = */ MONSTER_ENTRY_TYPE,
+ /* entry_index = */ 40,
+ /* insert_flag = */ TRUE,
+ /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ FALSE
}
};
@@ -3476,92 +3597,84 @@ check_flush_cache__multi_entry(H5F_t * file_ptr)
struct flush_cache_test_spec spec[8] =
{
{
- /* entry_num = */ 0,
- /* entry_type = */ PICO_ENTRY_TYPE,
- /* entry_index = */ 100,
- /* insert_flag = */ FALSE,
- /* flags = */ H5C__NO_FLAGS_SET,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ FALSE,
- /* expected_destroyed = */ FALSE
+ /* entry_num = */ 0,
+ /* entry_type = */ PICO_ENTRY_TYPE,
+ /* entry_index = */ 100,
+ /* insert_flag = */ FALSE,
+ /* flags = */ H5C__NO_FLAGS_SET,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ FALSE
},
{
- /* entry_num = */ 1,
- /* entry_type = */ PICO_ENTRY_TYPE,
- /* entry_index = */ 75,
- /* insert_flag = */ FALSE,
- /* flags = */ H5C__DIRTIED_FLAG,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ FALSE,
- /* expected_destroyed = */ FALSE
+ /* entry_num = */ 1,
+ /* entry_type = */ PICO_ENTRY_TYPE,
+ /* entry_index = */ 75,
+ /* insert_flag = */ FALSE,
+ /* flags = */ H5C__DIRTIED_FLAG,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ FALSE
},
{
- /* entry_num = */ 2,
- /* entry_type = */ PICO_ENTRY_TYPE,
- /* entry_index = */ 25,
- /* insert_flag = */ TRUE,
- /* flags = */ H5C__NO_FLAGS_SET,
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ FALSE,
- /* expected_destroyed = */ FALSE
+ /* entry_num = */ 2,
+ /* entry_type = */ PICO_ENTRY_TYPE,
+ /* entry_index = */ 25,
+ /* insert_flag = */ TRUE,
+ /* flags = */ H5C__NO_FLAGS_SET,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ FALSE
},
{
- /* entry_num = */ 3,
- /* entry_type = */ PICO_ENTRY_TYPE,
- /* entry_index = */ 50,
- /* insert_flag = */ TRUE,
- /* flags = */ H5C__DIRTIED_FLAG,
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ FALSE,
- /* expected_destroyed = */ FALSE
+ /* entry_num = */ 3,
+ /* entry_type = */ PICO_ENTRY_TYPE,
+ /* entry_index = */ 50,
+ /* insert_flag = */ TRUE,
+ /* flags = */ H5C__NO_FLAGS_SET,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ FALSE
},
{
- /* entry_num = */ 4,
- /* entry_type = */ MONSTER_ENTRY_TYPE,
- /* entry_index = */ 10,
- /* insert_flag = */ FALSE,
- /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ FALSE,
- /* expected_destroyed = */ FALSE
+ /* entry_num = */ 4,
+ /* entry_type = */ MONSTER_ENTRY_TYPE,
+ /* entry_index = */ 10,
+ /* insert_flag = */ FALSE,
+ /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ FALSE
},
{
- /* entry_num = */ 5,
- /* entry_type = */ MONSTER_ENTRY_TYPE,
- /* entry_index = */ 20,
- /* insert_flag = */ FALSE,
- /* flags = */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
- /* expected_destroyed = */ FALSE
+ /* entry_num = */ 5,
+ /* entry_type = */ MONSTER_ENTRY_TYPE,
+ /* entry_index = */ 20,
+ /* insert_flag = */ FALSE,
+ /* flags = */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
+ /* expected_destroyed = */ FALSE
},
{
- /* entry_num = */ 6,
- /* entry_type = */ MONSTER_ENTRY_TYPE,
- /* entry_index = */ 30,
- /* insert_flag = */ TRUE,
- /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
- /* expected_destroyed = */ FALSE
+ /* entry_num = */ 6,
+ /* entry_type = */ MONSTER_ENTRY_TYPE,
+ /* entry_index = */ 30,
+ /* insert_flag = */ TRUE,
+ /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ TRUE,
+ /* expected_destroyed = */ FALSE
},
{
- /* entry_num = */ 7,
- /* entry_type = */ MONSTER_ENTRY_TYPE,
- /* entry_index = */ 40,
- /* insert_flag = */ TRUE,
- /* flags = */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
- /* expected_destroyed = */ FALSE
+ /* entry_num = */ 7,
+ /* entry_type = */ MONSTER_ENTRY_TYPE,
+ /* entry_index = */ 40,
+ /* insert_flag = */ TRUE,
+ /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ TRUE,
+ /* expected_destroyed = */ FALSE
}
};
@@ -3579,92 +3692,84 @@ check_flush_cache__multi_entry(H5F_t * file_ptr)
struct flush_cache_test_spec spec[8] =
{
{
- /* entry_num = */ 0,
- /* entry_type = */ PICO_ENTRY_TYPE,
- /* entry_index = */ 100,
- /* insert_flag = */ FALSE,
- /* flags = */ H5C__NO_FLAGS_SET,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ TRUE,
- /* expected_flushed = */ FALSE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 0,
+ /* entry_type = */ PICO_ENTRY_TYPE,
+ /* entry_index = */ 100,
+ /* insert_flag = */ FALSE,
+ /* flags = */ H5C__NO_FLAGS_SET,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ TRUE
},
{
- /* entry_num = */ 1,
- /* entry_type = */ PICO_ENTRY_TYPE,
- /* entry_index = */ 75,
- /* insert_flag = */ FALSE,
- /* flags = */ H5C__DIRTIED_FLAG,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ TRUE,
- /* expected_flushed = */ FALSE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 1,
+ /* entry_type = */ PICO_ENTRY_TYPE,
+ /* entry_index = */ 75,
+ /* insert_flag = */ FALSE,
+ /* flags = */ H5C__DIRTIED_FLAG,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ TRUE
},
{
- /* entry_num = */ 2,
- /* entry_type = */ PICO_ENTRY_TYPE,
- /* entry_index = */ 25,
- /* insert_flag = */ TRUE,
- /* flags = */ H5C__NO_FLAGS_SET,
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ TRUE,
- /* expected_flushed = */ FALSE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 2,
+ /* entry_type = */ PICO_ENTRY_TYPE,
+ /* entry_index = */ 25,
+ /* insert_flag = */ TRUE,
+ /* flags = */ H5C__NO_FLAGS_SET,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ TRUE
},
{
- /* entry_num = */ 3,
- /* entry_type = */ PICO_ENTRY_TYPE,
- /* entry_index = */ 50,
- /* insert_flag = */ TRUE,
- /* flags = */ H5C__DIRTIED_FLAG,
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ TRUE,
- /* expected_flushed = */ FALSE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 3,
+ /* entry_type = */ PICO_ENTRY_TYPE,
+ /* entry_index = */ 50,
+ /* insert_flag = */ TRUE,
+ /* flags = */ H5C__NO_FLAGS_SET,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ TRUE
},
{
- /* entry_num = */ 4,
- /* entry_type = */ MONSTER_ENTRY_TYPE,
- /* entry_index = */ 10,
- /* insert_flag = */ FALSE,
- /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ TRUE,
- /* expected_flushed = */ FALSE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 4,
+ /* entry_type = */ MONSTER_ENTRY_TYPE,
+ /* entry_index = */ 10,
+ /* insert_flag = */ FALSE,
+ /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ TRUE
},
{
- /* entry_num = */ 5,
- /* entry_type = */ MONSTER_ENTRY_TYPE,
- /* entry_index = */ 20,
- /* insert_flag = */ FALSE,
- /* flags = */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ TRUE,
- /* expected_flushed = */ FALSE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 5,
+ /* entry_type = */ MONSTER_ENTRY_TYPE,
+ /* entry_index = */ 20,
+ /* insert_flag = */ FALSE,
+ /* flags = */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ TRUE
},
{
- /* entry_num = */ 6,
- /* entry_type = */ MONSTER_ENTRY_TYPE,
- /* entry_index = */ 30,
- /* insert_flag = */ TRUE,
- /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ TRUE,
- /* expected_flushed = */ FALSE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 6,
+ /* entry_type = */ MONSTER_ENTRY_TYPE,
+ /* entry_index = */ 30,
+ /* insert_flag = */ TRUE,
+ /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ TRUE
},
{
- /* entry_num = */ 7,
- /* entry_type = */ MONSTER_ENTRY_TYPE,
- /* entry_index = */ 40,
- /* insert_flag = */ TRUE,
- /* flags = */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ TRUE,
- /* expected_flushed = */ FALSE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 7,
+ /* entry_type = */ MONSTER_ENTRY_TYPE,
+ /* entry_index = */ 40,
+ /* insert_flag = */ TRUE,
+ /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ TRUE
}
};
@@ -3682,92 +3787,84 @@ check_flush_cache__multi_entry(H5F_t * file_ptr)
struct flush_cache_test_spec spec[8] =
{
{
- /* entry_num = */ 0,
- /* entry_type = */ PICO_ENTRY_TYPE,
- /* entry_index = */ 100,
- /* insert_flag = */ FALSE,
- /* flags = */ H5C__NO_FLAGS_SET,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 0,
+ /* entry_type = */ PICO_ENTRY_TYPE,
+ /* entry_index = */ 100,
+ /* insert_flag = */ FALSE,
+ /* flags = */ H5C__NO_FLAGS_SET,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ TRUE
},
{
- /* entry_num = */ 1,
- /* entry_type = */ PICO_ENTRY_TYPE,
- /* entry_index = */ 75,
- /* insert_flag = */ FALSE,
- /* flags = */ H5C__DIRTIED_FLAG,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 1,
+ /* entry_type = */ PICO_ENTRY_TYPE,
+ /* entry_index = */ 75,
+ /* insert_flag = */ FALSE,
+ /* flags = */ H5C__DIRTIED_FLAG,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
+ /* expected_destroyed = */ TRUE
},
{
- /* entry_num = */ 2,
- /* entry_type = */ PICO_ENTRY_TYPE,
- /* entry_index = */ 25,
- /* insert_flag = */ TRUE,
- /* flags = */ H5C__NO_FLAGS_SET,
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 2,
+ /* entry_type = */ PICO_ENTRY_TYPE,
+ /* entry_index = */ 25,
+ /* insert_flag = */ TRUE,
+ /* flags = */ H5C__NO_FLAGS_SET,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ TRUE,
+ /* expected_destroyed = */ TRUE
},
{
- /* entry_num = */ 3,
- /* entry_type = */ PICO_ENTRY_TYPE,
- /* entry_index = */ 50,
- /* insert_flag = */ TRUE,
- /* flags = */ H5C__DIRTIED_FLAG,
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 3,
+ /* entry_type = */ PICO_ENTRY_TYPE,
+ /* entry_index = */ 50,
+ /* insert_flag = */ TRUE,
+ /* flags = */ H5C__NO_FLAGS_SET,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ TRUE,
+ /* expected_destroyed = */ TRUE
},
{
- /* entry_num = */ 4,
- /* entry_type = */ MONSTER_ENTRY_TYPE,
- /* entry_index = */ 10,
- /* insert_flag = */ FALSE,
- /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 4,
+ /* entry_type = */ MONSTER_ENTRY_TYPE,
+ /* entry_index = */ 10,
+ /* insert_flag = */ FALSE,
+ /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ TRUE
},
{
- /* entry_num = */ 5,
- /* entry_type = */ MONSTER_ENTRY_TYPE,
- /* entry_index = */ 20,
- /* insert_flag = */ FALSE,
- /* flags = */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 5,
+ /* entry_type = */ MONSTER_ENTRY_TYPE,
+ /* entry_index = */ 20,
+ /* insert_flag = */ FALSE,
+ /* flags = */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
+ /* expected_destroyed = */ TRUE
},
{
- /* entry_num = */ 6,
- /* entry_type = */ MONSTER_ENTRY_TYPE,
- /* entry_index = */ 30,
- /* insert_flag = */ TRUE,
- /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 6,
+ /* entry_type = */ MONSTER_ENTRY_TYPE,
+ /* entry_index = */ 30,
+ /* insert_flag = */ TRUE,
+ /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ TRUE,
+ /* expected_destroyed = */ TRUE
},
{
- /* entry_num = */ 7,
- /* entry_type = */ MONSTER_ENTRY_TYPE,
- /* entry_index = */ 40,
- /* insert_flag = */ TRUE,
- /* flags = */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 7,
+ /* entry_type = */ MONSTER_ENTRY_TYPE,
+ /* entry_index = */ 40,
+ /* insert_flag = */ TRUE,
+ /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ TRUE,
+ /* expected_destroyed = */ TRUE
}
};
@@ -3785,92 +3882,84 @@ check_flush_cache__multi_entry(H5F_t * file_ptr)
struct flush_cache_test_spec spec[8] =
{
{
- /* entry_num = */ 0,
- /* entry_type = */ PICO_ENTRY_TYPE,
- /* entry_index = */ 100,
- /* insert_flag = */ FALSE,
- /* flags = */ H5C__NO_FLAGS_SET,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ FALSE,
- /* expected_destroyed = */ FALSE
+ /* entry_num = */ 0,
+ /* entry_type = */ PICO_ENTRY_TYPE,
+ /* entry_index = */ 100,
+ /* insert_flag = */ FALSE,
+ /* flags = */ H5C__NO_FLAGS_SET,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ FALSE
},
{
- /* entry_num = */ 1,
- /* entry_type = */ PICO_ENTRY_TYPE,
- /* entry_index = */ 75,
- /* insert_flag = */ FALSE,
- /* flags = */ H5C__DIRTIED_FLAG,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ FALSE,
- /* expected_destroyed = */ FALSE
+ /* entry_num = */ 1,
+ /* entry_type = */ PICO_ENTRY_TYPE,
+ /* entry_index = */ 75,
+ /* insert_flag = */ FALSE,
+ /* flags = */ H5C__DIRTIED_FLAG,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ FALSE
},
{
- /* entry_num = */ 2,
- /* entry_type = */ PICO_ENTRY_TYPE,
- /* entry_index = */ 25,
- /* insert_flag = */ TRUE,
- /* flags = */ H5C__NO_FLAGS_SET,
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ FALSE,
- /* expected_destroyed = */ FALSE
+ /* entry_num = */ 2,
+ /* entry_type = */ PICO_ENTRY_TYPE,
+ /* entry_index = */ 25,
+ /* insert_flag = */ TRUE,
+ /* flags = */ H5C__NO_FLAGS_SET,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ FALSE
},
{
- /* entry_num = */ 3,
- /* entry_type = */ PICO_ENTRY_TYPE,
- /* entry_index = */ 50,
- /* insert_flag = */ TRUE,
- /* flags = */ H5C__DIRTIED_FLAG,
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ FALSE,
- /* expected_destroyed = */ FALSE
+ /* entry_num = */ 3,
+ /* entry_type = */ PICO_ENTRY_TYPE,
+ /* entry_index = */ 50,
+ /* insert_flag = */ TRUE,
+ /* flags = */ H5C__NO_FLAGS_SET,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ FALSE
},
{
- /* entry_num = */ 4,
- /* entry_type = */ MONSTER_ENTRY_TYPE,
- /* entry_index = */ 10,
- /* insert_flag = */ FALSE,
- /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ FALSE,
- /* expected_destroyed = */ FALSE
+ /* entry_num = */ 4,
+ /* entry_type = */ MONSTER_ENTRY_TYPE,
+ /* entry_index = */ 10,
+ /* insert_flag = */ FALSE,
+ /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ FALSE
},
{
- /* entry_num = */ 5,
- /* entry_type = */ MONSTER_ENTRY_TYPE,
- /* entry_index = */ 20,
- /* insert_flag = */ FALSE,
- /* flags = */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ TRUE,
- /* expected_flushed = */ FALSE,
- /* expected_destroyed = */ FALSE
+ /* entry_num = */ 5,
+ /* entry_type = */ MONSTER_ENTRY_TYPE,
+ /* entry_index = */ 20,
+ /* insert_flag = */ FALSE,
+ /* flags = */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ FALSE
},
{
- /* entry_num = */ 6,
- /* entry_type = */ MONSTER_ENTRY_TYPE,
- /* entry_index = */ 30,
- /* insert_flag = */ TRUE,
- /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ TRUE,
- /* expected_flushed = */ FALSE,
- /* expected_destroyed = */ FALSE
+ /* entry_num = */ 6,
+ /* entry_type = */ MONSTER_ENTRY_TYPE,
+ /* entry_index = */ 30,
+ /* insert_flag = */ TRUE,
+ /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ FALSE
},
{
- /* entry_num = */ 7,
- /* entry_type = */ MONSTER_ENTRY_TYPE,
- /* entry_index = */ 40,
- /* insert_flag = */ TRUE,
- /* flags = */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ TRUE,
- /* expected_flushed = */ FALSE,
- /* expected_destroyed = */ FALSE
+ /* entry_num = */ 7,
+ /* entry_type = */ MONSTER_ENTRY_TYPE,
+ /* entry_index = */ 40,
+ /* insert_flag = */ TRUE,
+ /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ FALSE
}
};
@@ -3889,92 +3978,84 @@ check_flush_cache__multi_entry(H5F_t * file_ptr)
struct flush_cache_test_spec spec[8] =
{
{
- /* entry_num = */ 0,
- /* entry_type = */ PICO_ENTRY_TYPE,
- /* entry_index = */ 100,
- /* insert_flag = */ FALSE,
- /* flags = */ H5C__NO_FLAGS_SET,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ TRUE,
- /* expected_flushed = */ FALSE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 0,
+ /* entry_type = */ PICO_ENTRY_TYPE,
+ /* entry_index = */ 100,
+ /* insert_flag = */ FALSE,
+ /* flags = */ H5C__NO_FLAGS_SET,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ TRUE
},
{
- /* entry_num = */ 1,
- /* entry_type = */ PICO_ENTRY_TYPE,
- /* entry_index = */ 75,
- /* insert_flag = */ FALSE,
- /* flags = */ H5C__DIRTIED_FLAG,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ TRUE,
- /* expected_flushed = */ FALSE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 1,
+ /* entry_type = */ PICO_ENTRY_TYPE,
+ /* entry_index = */ 75,
+ /* insert_flag = */ FALSE,
+ /* flags = */ H5C__DIRTIED_FLAG,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ TRUE
},
{
- /* entry_num = */ 2,
- /* entry_type = */ PICO_ENTRY_TYPE,
- /* entry_index = */ 25,
- /* insert_flag = */ TRUE,
- /* flags = */ H5C__NO_FLAGS_SET,
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ TRUE,
- /* expected_flushed = */ FALSE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 2,
+ /* entry_type = */ PICO_ENTRY_TYPE,
+ /* entry_index = */ 25,
+ /* insert_flag = */ TRUE,
+ /* flags = */ H5C__NO_FLAGS_SET,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ TRUE
},
{
- /* entry_num = */ 3,
- /* entry_type = */ PICO_ENTRY_TYPE,
- /* entry_index = */ 50,
- /* insert_flag = */ TRUE,
- /* flags = */ H5C__DIRTIED_FLAG,
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ TRUE,
- /* expected_flushed = */ FALSE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 3,
+ /* entry_type = */ PICO_ENTRY_TYPE,
+ /* entry_index = */ 50,
+ /* insert_flag = */ TRUE,
+ /* flags = */ H5C__NO_FLAGS_SET,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ TRUE
},
{
- /* entry_num = */ 4,
- /* entry_type = */ MONSTER_ENTRY_TYPE,
- /* entry_index = */ 10,
- /* insert_flag = */ FALSE,
- /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ TRUE,
- /* expected_flushed = */ FALSE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 4,
+ /* entry_type = */ MONSTER_ENTRY_TYPE,
+ /* entry_index = */ 10,
+ /* insert_flag = */ FALSE,
+ /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ TRUE
},
{
- /* entry_num = */ 5,
- /* entry_type = */ MONSTER_ENTRY_TYPE,
- /* entry_index = */ 20,
- /* insert_flag = */ FALSE,
- /* flags = */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ TRUE,
- /* expected_flushed = */ FALSE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 5,
+ /* entry_type = */ MONSTER_ENTRY_TYPE,
+ /* entry_index = */ 20,
+ /* insert_flag = */ FALSE,
+ /* flags = */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ TRUE
},
{
- /* entry_num = */ 6,
- /* entry_type = */ MONSTER_ENTRY_TYPE,
- /* entry_index = */ 30,
- /* insert_flag = */ TRUE,
- /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ TRUE,
- /* expected_flushed = */ FALSE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 6,
+ /* entry_type = */ MONSTER_ENTRY_TYPE,
+ /* entry_index = */ 30,
+ /* insert_flag = */ TRUE,
+ /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ TRUE
},
{
- /* entry_num = */ 7,
- /* entry_type = */ MONSTER_ENTRY_TYPE,
- /* entry_index = */ 40,
- /* insert_flag = */ TRUE,
- /* flags = */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ TRUE,
- /* expected_flushed = */ FALSE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 7,
+ /* entry_type = */ MONSTER_ENTRY_TYPE,
+ /* entry_index = */ 40,
+ /* insert_flag = */ TRUE,
+ /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ TRUE
}
};
@@ -3995,92 +4076,84 @@ check_flush_cache__multi_entry(H5F_t * file_ptr)
struct flush_cache_test_spec spec[8] =
{
{
- /* entry_num = */ 0,
- /* entry_type = */ PICO_ENTRY_TYPE,
- /* entry_index = */ 100,
- /* insert_flag = */ FALSE,
- /* flags = */ H5C__NO_FLAGS_SET,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ FALSE,
- /* expected_destroyed = */ FALSE
+ /* entry_num = */ 0,
+ /* entry_type = */ PICO_ENTRY_TYPE,
+ /* entry_index = */ 100,
+ /* insert_flag = */ FALSE,
+ /* flags = */ H5C__NO_FLAGS_SET,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ FALSE
},
{
- /* entry_num = */ 1,
- /* entry_type = */ PICO_ENTRY_TYPE,
- /* entry_index = */ 75,
- /* insert_flag = */ FALSE,
- /* flags = */ H5C__DIRTIED_FLAG,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
- /* expected_destroyed = */ FALSE
+ /* entry_num = */ 1,
+ /* entry_type = */ PICO_ENTRY_TYPE,
+ /* entry_index = */ 75,
+ /* insert_flag = */ FALSE,
+ /* flags = */ H5C__DIRTIED_FLAG,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
+ /* expected_destroyed = */ FALSE
},
{
- /* entry_num = */ 2,
- /* entry_type = */ PICO_ENTRY_TYPE,
- /* entry_index = */ 25,
- /* insert_flag = */ TRUE,
- /* flags = */ H5C__NO_FLAGS_SET,
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
- /* expected_destroyed = */ FALSE
+ /* entry_num = */ 2,
+ /* entry_type = */ PICO_ENTRY_TYPE,
+ /* entry_index = */ 25,
+ /* insert_flag = */ TRUE,
+ /* flags = */ H5C__NO_FLAGS_SET,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ TRUE,
+ /* expected_destroyed = */ FALSE
},
{
- /* entry_num = */ 3,
- /* entry_type = */ PICO_ENTRY_TYPE,
- /* entry_index = */ 50,
- /* insert_flag = */ TRUE,
- /* flags = */ H5C__DIRTIED_FLAG,
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
- /* expected_destroyed = */ FALSE
+ /* entry_num = */ 3,
+ /* entry_type = */ PICO_ENTRY_TYPE,
+ /* entry_index = */ 50,
+ /* insert_flag = */ TRUE,
+ /* flags = */ H5C__NO_FLAGS_SET,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ TRUE,
+ /* expected_destroyed = */ FALSE
},
{
- /* entry_num = */ 4,
- /* entry_type = */ MONSTER_ENTRY_TYPE,
- /* entry_index = */ 10,
- /* insert_flag = */ FALSE,
- /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ FALSE,
- /* expected_destroyed = */ FALSE
+ /* entry_num = */ 4,
+ /* entry_type = */ MONSTER_ENTRY_TYPE,
+ /* entry_index = */ 10,
+ /* insert_flag = */ FALSE,
+ /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ FALSE
},
{
- /* entry_num = */ 5,
- /* entry_type = */ MONSTER_ENTRY_TYPE,
- /* entry_index = */ 20,
- /* insert_flag = */ FALSE,
- /* flags = */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
- /* expected_destroyed = */ FALSE
+ /* entry_num = */ 5,
+ /* entry_type = */ MONSTER_ENTRY_TYPE,
+ /* entry_index = */ 20,
+ /* insert_flag = */ FALSE,
+ /* flags = */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
+ /* expected_destroyed = */ FALSE
},
{
- /* entry_num = */ 6,
- /* entry_type = */ MONSTER_ENTRY_TYPE,
- /* entry_index = */ 30,
- /* insert_flag = */ TRUE,
- /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
- /* expected_destroyed = */ FALSE
+ /* entry_num = */ 6,
+ /* entry_type = */ MONSTER_ENTRY_TYPE,
+ /* entry_index = */ 30,
+ /* insert_flag = */ TRUE,
+ /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ TRUE,
+ /* expected_destroyed = */ FALSE
},
{
- /* entry_num = */ 7,
- /* entry_type = */ MONSTER_ENTRY_TYPE,
- /* entry_index = */ 40,
- /* insert_flag = */ TRUE,
- /* flags = */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
- /* expected_destroyed = */ FALSE
+ /* entry_num = */ 7,
+ /* entry_type = */ MONSTER_ENTRY_TYPE,
+ /* entry_index = */ 40,
+ /* insert_flag = */ TRUE,
+ /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ TRUE,
+ /* expected_destroyed = */ FALSE
}
};
@@ -4102,144 +4175,136 @@ check_flush_cache__multi_entry(H5F_t * file_ptr)
struct pe_flush_cache_test_spec spec[8] =
{
{
- /* entry_num = */ 0,
- /* entry_type = */ PICO_ENTRY_TYPE,
- /* entry_index = */ 100,
- /* insert_flag = */ FALSE,
- /* flags = */ H5C__NO_FLAGS_SET,
- /* num_pins = */ 0,
- /* pin_type[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
- /* pin_idx[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ FALSE,
- /* expected_destroyed = */ FALSE
+ /* entry_num = */ 0,
+ /* entry_type = */ PICO_ENTRY_TYPE,
+ /* entry_index = */ 100,
+ /* insert_flag = */ FALSE,
+ /* flags = */ H5C__NO_FLAGS_SET,
+ /* num_pins = */ 0,
+ /* pin_type[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
+ /* pin_idx[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ FALSE
},
{
- /* entry_num = */ 1,
- /* entry_type = */ PICO_ENTRY_TYPE,
- /* entry_index = */ 75,
- /* insert_flag = */ FALSE,
- /* flags = */ H5C__DIRTIED_FLAG,
- /* num_pins = */ 1,
- /* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
- -1, -1, -1, -1, -1, -1, -1},
- /* pin_idx[MAX_PINS] = */ {100, -1, -1, -1, -1, -1, -1, -1},
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
- /* expected_destroyed = */ FALSE
+ /* entry_num = */ 1,
+ /* entry_type = */ PICO_ENTRY_TYPE,
+ /* entry_index = */ 75,
+ /* insert_flag = */ FALSE,
+ /* flags = */ H5C__DIRTIED_FLAG,
+ /* num_pins = */ 1,
+ /* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
+ -1, -1, -1, -1, -1, -1, -1},
+ /* pin_idx[MAX_PINS] = */ {100, -1, -1, -1, -1, -1, -1, -1},
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
+ /* expected_destroyed = */ FALSE
},
{
- /* entry_num = */ 2,
- /* entry_type = */ PICO_ENTRY_TYPE,
- /* entry_index = */ 25,
- /* insert_flag = */ TRUE,
- /* flags = */ H5C__NO_FLAGS_SET,
- /* num_pins = */ 2,
- /* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
- PICO_ENTRY_TYPE,
- -1, -1, -1, -1, -1, -1},
- /* pin_idx[MAX_PINS] = */ {100, 75, -1, -1, -1, -1, -1, -1},
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
- /* expected_destroyed = */ FALSE
+ /* entry_num = */ 2,
+ /* entry_type = */ PICO_ENTRY_TYPE,
+ /* entry_index = */ 25,
+ /* insert_flag = */ TRUE,
+ /* flags = */ H5C__NO_FLAGS_SET,
+ /* num_pins = */ 2,
+ /* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
+ PICO_ENTRY_TYPE,
+ -1, -1, -1, -1, -1, -1},
+ /* pin_idx[MAX_PINS] = */ {100, 75, -1, -1, -1, -1, -1, -1},
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ TRUE,
+ /* expected_destroyed = */ FALSE
},
{
- /* entry_num = */ 3,
- /* entry_type = */ PICO_ENTRY_TYPE,
- /* entry_index = */ 50,
- /* insert_flag = */ TRUE,
- /* flags = */ H5C__DIRTIED_FLAG,
- /* num_pins = */ 3,
- /* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
- PICO_ENTRY_TYPE,
- PICO_ENTRY_TYPE,
- -1, -1, -1, -1, -1},
- /* pin_idx[MAX_PINS] = */ {100, 75, 25, -1, -1, -1, -1, -1},
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
- /* expected_destroyed = */ FALSE
+ /* entry_num = */ 3,
+ /* entry_type = */ PICO_ENTRY_TYPE,
+ /* entry_index = */ 50,
+ /* insert_flag = */ TRUE,
+ /* flags = */ H5C__NO_FLAGS_SET,
+ /* num_pins = */ 3,
+ /* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
+ PICO_ENTRY_TYPE,
+ PICO_ENTRY_TYPE,
+ -1, -1, -1, -1, -1},
+ /* pin_idx[MAX_PINS] = */ {100, 75, 25, -1, -1, -1, -1, -1},
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ TRUE,
+ /* expected_destroyed = */ FALSE
},
{
- /* entry_num = */ 4,
- /* entry_type = */ MONSTER_ENTRY_TYPE,
- /* entry_index = */ 10,
- /* insert_flag = */ FALSE,
- /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
- /* num_pins = */ 4,
- /* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
- PICO_ENTRY_TYPE,
- PICO_ENTRY_TYPE,
- PICO_ENTRY_TYPE,
- -1, -1, -1, -1},
- /* pin_idx[MAX_PINS] = */ {100, 75, 25, 50, -1, -1, -1, -1},
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ FALSE,
- /* expected_destroyed = */ FALSE
+ /* entry_num = */ 4,
+ /* entry_type = */ MONSTER_ENTRY_TYPE,
+ /* entry_index = */ 10,
+ /* insert_flag = */ FALSE,
+ /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* num_pins = */ 4,
+ /* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
+ PICO_ENTRY_TYPE,
+ PICO_ENTRY_TYPE,
+ PICO_ENTRY_TYPE,
+ -1, -1, -1, -1},
+ /* pin_idx[MAX_PINS] = */ {100, 75, 25, 50, -1, -1, -1, -1},
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ FALSE
},
{
- /* entry_num = */ 5,
- /* entry_type = */ MONSTER_ENTRY_TYPE,
- /* entry_index = */ 20,
- /* insert_flag = */ FALSE,
- /* flags = */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
- /* num_pins = */ 5,
- /* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
- PICO_ENTRY_TYPE,
- PICO_ENTRY_TYPE,
- PICO_ENTRY_TYPE,
- MONSTER_ENTRY_TYPE,
- -1, -1, -1},
- /* pin_idx[MAX_PINS] = */ {100, 75, 25, 50, 10, -1, -1, -1},
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
- /* expected_destroyed = */ FALSE
+ /* entry_num = */ 5,
+ /* entry_type = */ MONSTER_ENTRY_TYPE,
+ /* entry_index = */ 20,
+ /* insert_flag = */ FALSE,
+ /* flags = */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
+ /* num_pins = */ 5,
+ /* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
+ PICO_ENTRY_TYPE,
+ PICO_ENTRY_TYPE,
+ PICO_ENTRY_TYPE,
+ MONSTER_ENTRY_TYPE,
+ -1, -1, -1},
+ /* pin_idx[MAX_PINS] = */ {100, 75, 25, 50, 10, -1, -1, -1},
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
+ /* expected_destroyed = */ FALSE
},
{
- /* entry_num = */ 6,
- /* entry_type = */ MONSTER_ENTRY_TYPE,
- /* entry_index = */ 30,
- /* insert_flag = */ TRUE,
- /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
- /* num_pins = */ 6,
- /* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
- PICO_ENTRY_TYPE,
- PICO_ENTRY_TYPE,
- PICO_ENTRY_TYPE,
- MONSTER_ENTRY_TYPE,
- MONSTER_ENTRY_TYPE,
- -1, -1},
- /* pin_idx[MAX_PINS] = */ {100, 75, 25, 50, 10, 20, -1, -1},
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
- /* expected_destroyed = */ FALSE
+ /* entry_num = */ 6,
+ /* entry_type = */ MONSTER_ENTRY_TYPE,
+ /* entry_index = */ 30,
+ /* insert_flag = */ TRUE,
+ /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* num_pins = */ 6,
+ /* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
+ PICO_ENTRY_TYPE,
+ PICO_ENTRY_TYPE,
+ PICO_ENTRY_TYPE,
+ MONSTER_ENTRY_TYPE,
+ MONSTER_ENTRY_TYPE,
+ -1, -1},
+ /* pin_idx[MAX_PINS] = */ {100, 75, 25, 50, 10, 20, -1, -1},
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ TRUE,
+ /* expected_destroyed = */ FALSE
},
{
- /* entry_num = */ 7,
- /* entry_type = */ MONSTER_ENTRY_TYPE,
- /* entry_index = */ 40,
- /* insert_flag = */ TRUE,
- /* flags = */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
- /* num_pins = */ 7,
- /* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
- PICO_ENTRY_TYPE,
- PICO_ENTRY_TYPE,
- PICO_ENTRY_TYPE,
- MONSTER_ENTRY_TYPE,
- MONSTER_ENTRY_TYPE,
- MONSTER_ENTRY_TYPE,
- -1},
- /* pin_idx[MAX_PINS] = */ {100, 75, 25, 50, 10, 20, 30, -1},
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
- /* expected_destroyed = */ FALSE
+ /* entry_num = */ 7,
+ /* entry_type = */ MONSTER_ENTRY_TYPE,
+ /* entry_index = */ 40,
+ /* insert_flag = */ TRUE,
+ /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* num_pins = */ 7,
+ /* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
+ PICO_ENTRY_TYPE,
+ PICO_ENTRY_TYPE,
+ PICO_ENTRY_TYPE,
+ MONSTER_ENTRY_TYPE,
+ MONSTER_ENTRY_TYPE,
+ MONSTER_ENTRY_TYPE,
+ -1},
+ /* pin_idx[MAX_PINS] = */ {100, 75, 25, 50, 10, 20, 30, -1},
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ TRUE,
+ /* expected_destroyed = */ FALSE
}
};
@@ -4256,128 +4321,120 @@ check_flush_cache__multi_entry(H5F_t * file_ptr)
struct pe_flush_cache_test_spec spec[8] =
{
{
- /* entry_num = */ 0,
- /* entry_type = */ PICO_ENTRY_TYPE,
- /* entry_index = */ 100,
- /* insert_flag = */ FALSE,
- /* flags = */ H5C__NO_FLAGS_SET,
- /* num_pins = */ 0,
- /* pin_type[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
- /* pin_idx[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 0,
+ /* entry_type = */ PICO_ENTRY_TYPE,
+ /* entry_index = */ 100,
+ /* insert_flag = */ FALSE,
+ /* flags = */ H5C__NO_FLAGS_SET,
+ /* num_pins = */ 0,
+ /* pin_type[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
+ /* pin_idx[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ TRUE
},
{
- /* entry_num = */ 1,
- /* entry_type = */ PICO_ENTRY_TYPE,
- /* entry_index = */ 75,
- /* insert_flag = */ FALSE,
- /* flags = */ H5C__DIRTIED_FLAG,
- /* num_pins = */ 1,
- /* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
- -1, -1, -1, -1, -1, -1, -1},
- /* pin_idx[MAX_PINS] = */ {100, -1, -1, -1, -1, -1, -1, -1},
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 1,
+ /* entry_type = */ PICO_ENTRY_TYPE,
+ /* entry_index = */ 75,
+ /* insert_flag = */ FALSE,
+ /* flags = */ H5C__DIRTIED_FLAG,
+ /* num_pins = */ 1,
+ /* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
+ -1, -1, -1, -1, -1, -1, -1},
+ /* pin_idx[MAX_PINS] = */ {100, -1, -1, -1, -1, -1, -1, -1},
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
+ /* expected_destroyed = */ TRUE
},
{
- /* entry_num = */ 2,
- /* entry_type = */ PICO_ENTRY_TYPE,
- /* entry_index = */ 25,
- /* insert_flag = */ TRUE,
- /* flags = */ H5C__NO_FLAGS_SET,
- /* num_pins = */ 2,
- /* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
- PICO_ENTRY_TYPE,
- -1, -1, -1, -1, -1, -1},
+ /* entry_num = */ 2,
+ /* entry_type = */ PICO_ENTRY_TYPE,
+ /* entry_index = */ 25,
+ /* insert_flag = */ TRUE,
+ /* flags = */ H5C__NO_FLAGS_SET,
+ /* num_pins = */ 2,
+ /* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
+ PICO_ENTRY_TYPE,
+ -1, -1, -1, -1, -1, -1},
/* pin_idx[MAX_PINS] = */ {100, 75, -1, -1, -1, -1, -1, -1},
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
- /* expected_destroyed = */ TRUE
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ TRUE,
+ /* expected_destroyed = */ TRUE
},
{
- /* entry_num = */ 3,
- /* entry_type = */ PICO_ENTRY_TYPE,
- /* entry_index = */ 50,
- /* insert_flag = */ TRUE,
- /* flags = */ H5C__DIRTIED_FLAG,
- /* num_pins = */ 3,
- /* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
- PICO_ENTRY_TYPE,
- PICO_ENTRY_TYPE,
- -1, -1, -1, -1, -1},
- /* pin_idx[MAX_PINS] = */ {100, 75, 25, -1, -1, -1, -1, -1},
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 3,
+ /* entry_type = */ PICO_ENTRY_TYPE,
+ /* entry_index = */ 50,
+ /* insert_flag = */ TRUE,
+ /* flags = */ H5C__NO_FLAGS_SET,
+ /* num_pins = */ 3,
+ /* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
+ PICO_ENTRY_TYPE,
+ PICO_ENTRY_TYPE,
+ -1, -1, -1, -1, -1},
+ /* pin_idx[MAX_PINS] = */ {100, 75, 25, -1, -1, -1, -1, -1},
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ TRUE,
+ /* expected_destroyed = */ TRUE
},
{
- /* entry_num = */ 4,
- /* entry_type = */ MONSTER_ENTRY_TYPE,
- /* entry_index = */ 10,
- /* insert_flag = */ FALSE,
- /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
- /* num_pins = */ 0,
- /* pin_type[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
- /* pin_idx[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 4,
+ /* entry_type = */ MONSTER_ENTRY_TYPE,
+ /* entry_index = */ 10,
+ /* insert_flag = */ FALSE,
+ /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* num_pins = */ 0,
+ /* pin_type[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
+ /* pin_idx[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ TRUE
},
{
- /* entry_num = */ 5,
- /* entry_type = */ MONSTER_ENTRY_TYPE,
- /* entry_index = */ 20,
- /* insert_flag = */ FALSE,
- /* flags = */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
- /* num_pins = */ 1,
- /* pin_type[MAX_PINS] = */ {MONSTER_ENTRY_TYPE,
- -1, -1, -1, -1 -1, -1, -1},
- /* pin_idx[MAX_PINS] = */ {10, -1, -1, -1 -1, -1, -1, -1},
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 5,
+ /* entry_type = */ MONSTER_ENTRY_TYPE,
+ /* entry_index = */ 20,
+ /* insert_flag = */ FALSE,
+ /* flags = */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
+ /* num_pins = */ 1,
+ /* pin_type[MAX_PINS] = */ {MONSTER_ENTRY_TYPE,
+ -1, -1, -1, -1 -1, -1, -1},
+ /* pin_idx[MAX_PINS] = */ {10, -1, -1, -1 -1, -1, -1, -1},
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
+ /* expected_destroyed = */ TRUE
},
{
- /* entry_num = */ 6,
- /* entry_type = */ MONSTER_ENTRY_TYPE,
- /* entry_index = */ 30,
- /* insert_flag = */ TRUE,
- /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
- /* num_pins = */ 2,
- /* pin_type[MAX_PINS] = */ {MONSTER_ENTRY_TYPE,
- MONSTER_ENTRY_TYPE,
- -1, -1, -1, -1, -1, -1},
- /* pin_idx[MAX_PINS] = */ {10, 20, -1, -1, -1, -1, -1, -1},
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 6,
+ /* entry_type = */ MONSTER_ENTRY_TYPE,
+ /* entry_index = */ 30,
+ /* insert_flag = */ TRUE,
+ /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* num_pins = */ 2,
+ /* pin_type[MAX_PINS] = */ {MONSTER_ENTRY_TYPE,
+ MONSTER_ENTRY_TYPE,
+ -1, -1, -1, -1, -1, -1},
+ /* pin_idx[MAX_PINS] = */ {10, 20, -1, -1, -1, -1, -1, -1},
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ TRUE,
+ /* expected_destroyed = */ TRUE
},
{
- /* entry_num = */ 7,
- /* entry_type = */ MONSTER_ENTRY_TYPE,
- /* entry_index = */ 40,
- /* insert_flag = */ TRUE,
- /* flags = */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
- /* num_pins = */ 3,
- /* pin_type[MAX_PINS] = */ {MONSTER_ENTRY_TYPE,
- MONSTER_ENTRY_TYPE,
- MONSTER_ENTRY_TYPE,
- -1, -1, -1, -1, -1},
- /* pin_idx[MAX_PINS] = */ {10, 20, 30, -1, -1, -1, -1, -1},
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 7,
+ /* entry_type = */ MONSTER_ENTRY_TYPE,
+ /* entry_index = */ 40,
+ /* insert_flag = */ TRUE,
+ /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* num_pins = */ 3,
+ /* pin_type[MAX_PINS] = */ {MONSTER_ENTRY_TYPE,
+ MONSTER_ENTRY_TYPE,
+ MONSTER_ENTRY_TYPE,
+ -1, -1, -1, -1, -1},
+ /* pin_idx[MAX_PINS] = */ {10, 20, 30, -1, -1, -1, -1, -1},
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ TRUE,
+ /* expected_destroyed = */ TRUE
}
};
@@ -4394,119 +4451,111 @@ check_flush_cache__multi_entry(H5F_t * file_ptr)
struct pe_flush_cache_test_spec spec[8] =
{
{
- /* entry_num = */ 0,
- /* entry_type = */ PICO_ENTRY_TYPE,
- /* entry_index = */ 100,
- /* insert_flag = */ FALSE,
- /* flags = */ H5C__NO_FLAGS_SET,
- /* num_pins = */ 0,
- /* pin_type[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
- /* pin_idx[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ TRUE,
- /* expected_flushed = */ FALSE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 0,
+ /* entry_type = */ PICO_ENTRY_TYPE,
+ /* entry_index = */ 100,
+ /* insert_flag = */ FALSE,
+ /* flags = */ H5C__NO_FLAGS_SET,
+ /* num_pins = */ 0,
+ /* pin_type[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
+ /* pin_idx[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ TRUE
},
{
- /* entry_num = */ 1,
- /* entry_type = */ PICO_ENTRY_TYPE,
- /* entry_index = */ 75,
- /* insert_flag = */ FALSE,
- /* flags = */ H5C__DIRTIED_FLAG,
- /* num_pins = */ 1,
- /* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
- -1, -1, -1, -1, -1, -1, -1},
- /* pin_idx[MAX_PINS] = */ {100, -1, -1, -1, -1, -1, -1, -1},
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ TRUE,
- /* expected_flushed = */ FALSE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 1,
+ /* entry_type = */ PICO_ENTRY_TYPE,
+ /* entry_index = */ 75,
+ /* insert_flag = */ FALSE,
+ /* flags = */ H5C__DIRTIED_FLAG,
+ /* num_pins = */ 1,
+ /* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
+ -1, -1, -1, -1, -1, -1, -1},
+ /* pin_idx[MAX_PINS] = */ {100, -1, -1, -1, -1, -1, -1, -1},
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ TRUE
},
{
- /* entry_num = */ 2,
- /* entry_type = */ PICO_ENTRY_TYPE,
- /* entry_index = */ 25,
- /* insert_flag = */ TRUE,
- /* flags = */ H5C__NO_FLAGS_SET,
- /* num_pins = */ 1,
- /* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
- -1, -1, -1, -1, -1, -1, -1},
- /* pin_idx[MAX_PINS] = */ {100, -1, -1, -1, -1, -1, -1, -1},
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ TRUE,
- /* expected_flushed = */ FALSE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 2,
+ /* entry_type = */ PICO_ENTRY_TYPE,
+ /* entry_index = */ 25,
+ /* insert_flag = */ TRUE,
+ /* flags = */ H5C__NO_FLAGS_SET,
+ /* num_pins = */ 1,
+ /* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
+ -1, -1, -1, -1, -1, -1, -1},
+ /* pin_idx[MAX_PINS] = */ {100, -1, -1, -1, -1, -1, -1, -1},
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ TRUE
},
{
- /* entry_num = */ 3,
- /* entry_type = */ PICO_ENTRY_TYPE,
- /* entry_index = */ 50,
- /* insert_flag = */ TRUE,
- /* flags = */ H5C__DIRTIED_FLAG,
- /* num_pins = */ 1,
- /* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
- -1, -1, -1, -1, -1, -1, -1},
- /* pin_idx[MAX_PINS] = */ {100, -1, -1, -1, -1, -1, -1, -1},
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ TRUE,
- /* expected_flushed = */ FALSE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 3,
+ /* entry_type = */ PICO_ENTRY_TYPE,
+ /* entry_index = */ 50,
+ /* insert_flag = */ TRUE,
+ /* flags = */ H5C__NO_FLAGS_SET,
+ /* num_pins = */ 1,
+ /* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
+ -1, -1, -1, -1, -1, -1, -1},
+ /* pin_idx[MAX_PINS] = */ {100, -1, -1, -1, -1, -1, -1, -1},
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ TRUE
},
{
- /* entry_num = */ 4,
- /* entry_type = */ MONSTER_ENTRY_TYPE,
- /* entry_index = */ 10,
- /* insert_flag = */ FALSE,
- /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
- /* num_pins = */ 0,
- /* pin_type[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
- /* pin_idx[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ TRUE,
- /* expected_flushed = */ FALSE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 4,
+ /* entry_type = */ MONSTER_ENTRY_TYPE,
+ /* entry_index = */ 10,
+ /* insert_flag = */ FALSE,
+ /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* num_pins = */ 0,
+ /* pin_type[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
+ /* pin_idx[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ TRUE
},
{
- /* entry_num = */ 5,
- /* entry_type = */ MONSTER_ENTRY_TYPE,
- /* entry_index = */ 20,
- /* insert_flag = */ FALSE,
- /* flags = */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
- /* num_pins = */ 0,
- /* pin_type[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
- /* pin_idx[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ TRUE,
- /* expected_flushed = */ FALSE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 5,
+ /* entry_type = */ MONSTER_ENTRY_TYPE,
+ /* entry_index = */ 20,
+ /* insert_flag = */ FALSE,
+ /* flags = */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
+ /* num_pins = */ 0,
+ /* pin_type[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
+ /* pin_idx[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ TRUE
},
{
- /* entry_num = */ 6,
- /* entry_type = */ MONSTER_ENTRY_TYPE,
- /* entry_index = */ 30,
- /* insert_flag = */ TRUE,
- /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
- /* num_pins = */ 0,
- /* pin_type[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
- /* pin_idx[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ TRUE,
- /* expected_flushed = */ FALSE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 6,
+ /* entry_type = */ MONSTER_ENTRY_TYPE,
+ /* entry_index = */ 30,
+ /* insert_flag = */ TRUE,
+ /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* num_pins = */ 0,
+ /* pin_type[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
+ /* pin_idx[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ TRUE
},
{
- /* entry_num = */ 7,
- /* entry_type = */ MONSTER_ENTRY_TYPE,
- /* entry_index = */ 40,
- /* insert_flag = */ TRUE,
- /* flags = */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
- /* num_pins = */ 0,
- /* pin_type[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
- /* pin_idx[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ TRUE,
- /* expected_flushed = */ FALSE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 7,
+ /* entry_type = */ MONSTER_ENTRY_TYPE,
+ /* entry_index = */ 40,
+ /* insert_flag = */ TRUE,
+ /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* num_pins = */ 0,
+ /* pin_type[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
+ /* pin_idx[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ TRUE
}
};
@@ -4524,127 +4573,119 @@ check_flush_cache__multi_entry(H5F_t * file_ptr)
struct pe_flush_cache_test_spec spec[8] =
{
{
- /* entry_num = */ 0,
- /* entry_type = */ PICO_ENTRY_TYPE,
- /* entry_index = */ 100,
- /* insert_flag = */ FALSE,
- /* flags = */ H5C__NO_FLAGS_SET,
- /* num_pins = */ 0,
- /* pin_type[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
- /* pin_idx[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 0,
+ /* entry_type = */ PICO_ENTRY_TYPE,
+ /* entry_index = */ 100,
+ /* insert_flag = */ FALSE,
+ /* flags = */ H5C__NO_FLAGS_SET,
+ /* num_pins = */ 0,
+ /* pin_type[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
+ /* pin_idx[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ TRUE
},
{
- /* entry_num = */ 1,
- /* entry_type = */ PICO_ENTRY_TYPE,
- /* entry_index = */ 75,
- /* insert_flag = */ FALSE,
- /* flags = */ H5C__DIRTIED_FLAG,
- /* num_pins = */ 1,
- /* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
- -1, -1, -1, -1, -1, -1, -1},
- /* pin_idx[MAX_PINS] = */ {100, -1, -1, -1, -1, -1, -1, -1},
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 1,
+ /* entry_type = */ PICO_ENTRY_TYPE,
+ /* entry_index = */ 75,
+ /* insert_flag = */ FALSE,
+ /* flags = */ H5C__DIRTIED_FLAG,
+ /* num_pins = */ 1,
+ /* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
+ -1, -1, -1, -1, -1, -1, -1},
+ /* pin_idx[MAX_PINS] = */ {100, -1, -1, -1, -1, -1, -1, -1},
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
+ /* expected_destroyed = */ TRUE
},
{
- /* entry_num = */ 2,
- /* entry_type = */ PICO_ENTRY_TYPE,
- /* entry_index = */ 25,
- /* insert_flag = */ TRUE,
- /* flags = */ H5C__NO_FLAGS_SET,
- /* num_pins = */ 1,
- /* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
- -1, -1, -1, -1, -1, -1, -1},
- /* pin_idx[MAX_PINS] = */ {100, -1, -1, -1, -1, -1, -1, -1},
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 2,
+ /* entry_type = */ PICO_ENTRY_TYPE,
+ /* entry_index = */ 25,
+ /* insert_flag = */ TRUE,
+ /* flags = */ H5C__NO_FLAGS_SET,
+ /* num_pins = */ 1,
+ /* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
+ -1, -1, -1, -1, -1, -1, -1},
+ /* pin_idx[MAX_PINS] = */ {100, -1, -1, -1, -1, -1, -1, -1},
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ TRUE,
+ /* expected_destroyed = */ TRUE
},
{
- /* entry_num = */ 3,
- /* entry_type = */ PICO_ENTRY_TYPE,
- /* entry_index = */ 50,
- /* insert_flag = */ TRUE,
- /* flags = */ H5C__DIRTIED_FLAG,
- /* num_pins = */ 1,
- /* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
- -1, -1, -1, -1, -1, -1, -1},
- /* pin_idx[MAX_PINS] = */ {100, -1, -1, -1, -1, -1, -1, -1},
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 3,
+ /* entry_type = */ PICO_ENTRY_TYPE,
+ /* entry_index = */ 50,
+ /* insert_flag = */ TRUE,
+ /* flags = */ H5C__NO_FLAGS_SET,
+ /* num_pins = */ 1,
+ /* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
+ -1, -1, -1, -1, -1, -1, -1},
+ /* pin_idx[MAX_PINS] = */ {100, -1, -1, -1, -1, -1, -1, -1},
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ TRUE,
+ /* expected_destroyed = */ TRUE
},
{
- /* entry_num = */ 4,
- /* entry_type = */ MONSTER_ENTRY_TYPE,
- /* entry_index = */ 10,
- /* insert_flag = */ FALSE,
- /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
- /* num_pins = */ 0,
- /* pin_type[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
- /* pin_idx[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 4,
+ /* entry_type = */ MONSTER_ENTRY_TYPE,
+ /* entry_index = */ 10,
+ /* insert_flag = */ FALSE,
+ /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* num_pins = */ 0,
+ /* pin_type[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
+ /* pin_idx[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ TRUE
},
{
- /* entry_num = */ 5,
- /* entry_type = */ MONSTER_ENTRY_TYPE,
- /* entry_index = */ 20,
- /* insert_flag = */ FALSE,
- /* flags = */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
- /* num_pins = */ 4,
- /* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
- PICO_ENTRY_TYPE,
- PICO_ENTRY_TYPE,
- PICO_ENTRY_TYPE,
- -1, -1, -1, -1},
- /* pin_idx[MAX_PINS] = */ {100, 75, 25, 50, -1, -1, -1, -1},
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 5,
+ /* entry_type = */ MONSTER_ENTRY_TYPE,
+ /* entry_index = */ 20,
+ /* insert_flag = */ FALSE,
+ /* flags = */ H5C__DIRTIED_FLAG,
+ /* num_pins = */ 4,
+ /* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
+ PICO_ENTRY_TYPE,
+ PICO_ENTRY_TYPE,
+ PICO_ENTRY_TYPE,
+ -1, -1, -1, -1},
+ /* pin_idx[MAX_PINS] = */ {100, 75, 25, 50, -1, -1, -1, -1},
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
+ /* expected_destroyed = */ TRUE
},
{
- /* entry_num = */ 6,
- /* entry_type = */ MONSTER_ENTRY_TYPE,
- /* entry_index = */ 30,
- /* insert_flag = */ TRUE,
- /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
- /* num_pins = */ 4,
- /* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
- PICO_ENTRY_TYPE,
- PICO_ENTRY_TYPE,
- PICO_ENTRY_TYPE,
- -1, -1, -1, -1},
- /* pin_idx[MAX_PINS] = */ {100, 75, 25, 50, -1, -1, -1, -1},
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 6,
+ /* entry_type = */ MONSTER_ENTRY_TYPE,
+ /* entry_index = */ 30,
+ /* insert_flag = */ TRUE,
+ /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* num_pins = */ 4,
+ /* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
+ PICO_ENTRY_TYPE,
+ PICO_ENTRY_TYPE,
+ PICO_ENTRY_TYPE,
+ -1, -1, -1, -1},
+ /* pin_idx[MAX_PINS] = */ {100, 75, 25, 50, -1, -1, -1, -1},
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ TRUE,
+ /* expected_destroyed = */ TRUE
},
{
- /* entry_num = */ 7,
- /* entry_type = */ MONSTER_ENTRY_TYPE,
- /* entry_index = */ 40,
- /* insert_flag = */ TRUE,
- /* flags = */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
- /* num_pins = */ 0,
- /* pin_type[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
- /* pin_idx[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 7,
+ /* entry_type = */ MONSTER_ENTRY_TYPE,
+ /* entry_index = */ 40,
+ /* insert_flag = */ TRUE,
+ /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* num_pins = */ 0,
+ /* pin_type[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
+ /* pin_idx[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ TRUE,
+ /* expected_destroyed = */ TRUE
}
};
@@ -4663,123 +4704,115 @@ check_flush_cache__multi_entry(H5F_t * file_ptr)
struct pe_flush_cache_test_spec spec[8] =
{
{
- /* entry_num = */ 0,
- /* entry_type = */ PICO_ENTRY_TYPE,
- /* entry_index = */ 100,
- /* insert_flag = */ FALSE,
- /* flags = */ H5C__NO_FLAGS_SET,
- /* num_pins = */ 0,
- /* pin_type[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
- /* pin_idx[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ TRUE,
- /* expected_flushed = */ FALSE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 0,
+ /* entry_type = */ PICO_ENTRY_TYPE,
+ /* entry_index = */ 100,
+ /* insert_flag = */ FALSE,
+ /* flags = */ H5C__NO_FLAGS_SET,
+ /* num_pins = */ 0,
+ /* pin_type[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
+ /* pin_idx[MAX_PINS] = */ {-1, -1, -1, -1, -1, -1, -1, -1},
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ TRUE
},
{
- /* entry_num = */ 1,
- /* entry_type = */ PICO_ENTRY_TYPE,
- /* entry_index = */ 75,
- /* insert_flag = */ FALSE,
- /* flags = */ H5C__DIRTIED_FLAG,
- /* num_pins = */ 1,
- /* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
- -1, -1, -1, -1, -1, -1, -1},
- /* pin_idx[MAX_PINS] = */ {100, -1, -1, -1, -1, -1, -1, -1},
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ TRUE,
- /* expected_flushed = */ FALSE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 1,
+ /* entry_type = */ PICO_ENTRY_TYPE,
+ /* entry_index = */ 75,
+ /* insert_flag = */ FALSE,
+ /* flags = */ H5C__DIRTIED_FLAG,
+ /* num_pins = */ 1,
+ /* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
+ -1, -1, -1, -1, -1, -1, -1},
+ /* pin_idx[MAX_PINS] = */ {100, -1, -1, -1, -1, -1, -1, -1},
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ TRUE
},
{
- /* entry_num = */ 2,
- /* entry_type = */ PICO_ENTRY_TYPE,
- /* entry_index = */ 25,
- /* insert_flag = */ TRUE,
- /* flags = */ H5C__NO_FLAGS_SET,
- /* num_pins = */ 1,
- /* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
- -1, -1, -1, -1, -1, -1, -1},
- /* pin_idx[MAX_PINS] = */ {100, -1, -1, -1, -1, -1, -1, -1},
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ TRUE,
- /* expected_flushed = */ FALSE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 2,
+ /* entry_type = */ PICO_ENTRY_TYPE,
+ /* entry_index = */ 25,
+ /* insert_flag = */ TRUE,
+ /* flags = */ H5C__NO_FLAGS_SET,
+ /* num_pins = */ 1,
+ /* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
+ -1, -1, -1, -1, -1, -1, -1},
+ /* pin_idx[MAX_PINS] = */ {100, -1, -1, -1, -1, -1, -1, -1},
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ TRUE
},
{
- /* entry_num = */ 3,
- /* entry_type = */ PICO_ENTRY_TYPE,
- /* entry_index = */ 50,
- /* insert_flag = */ TRUE,
- /* flags = */ H5C__DIRTIED_FLAG,
- /* num_pins = */ 1,
- /* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
- -1, -1, -1, -1, -1, -1, -1},
- /* pin_idx[MAX_PINS] = */ {100, -1, -1, -1, -1, -1, -1, -1},
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ TRUE,
- /* expected_flushed = */ FALSE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 3,
+ /* entry_type = */ PICO_ENTRY_TYPE,
+ /* entry_index = */ 50,
+ /* insert_flag = */ TRUE,
+ /* flags = */ H5C__NO_FLAGS_SET,
+ /* num_pins = */ 1,
+ /* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
+ -1, -1, -1, -1, -1, -1, -1},
+ /* pin_idx[MAX_PINS] = */ {100, -1, -1, -1, -1, -1, -1, -1},
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ TRUE
},
{
- /* entry_num = */ 4,
- /* entry_type = */ MONSTER_ENTRY_TYPE,
- /* entry_index = */ 10,
- /* insert_flag = */ FALSE,
- /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
- /* num_pins = */ 1,
- /* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
- -1, -1, -1, -1, -1, -1, -1},
- /* pin_idx[MAX_PINS] = */ {100, -1, -1, -1, -1, -1, -1, -1},
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ TRUE,
- /* expected_flushed = */ FALSE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 4,
+ /* entry_type = */ MONSTER_ENTRY_TYPE,
+ /* entry_index = */ 10,
+ /* insert_flag = */ FALSE,
+ /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* num_pins = */ 1,
+ /* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
+ -1, -1, -1, -1, -1, -1, -1},
+ /* pin_idx[MAX_PINS] = */ {100, -1, -1, -1, -1, -1, -1, -1},
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ TRUE
},
{
- /* entry_num = */ 5,
- /* entry_type = */ MONSTER_ENTRY_TYPE,
- /* entry_index = */ 20,
- /* insert_flag = */ FALSE,
- /* flags = */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
- /* num_pins = */ 1,
- /* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
- -1, -1, -1, -1, -1, -1, -1},
- /* pin_idx[MAX_PINS] = */ {100, -1, -1, -1, -1, -1, -1, -1},
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ TRUE,
- /* expected_flushed = */ FALSE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 5,
+ /* entry_type = */ MONSTER_ENTRY_TYPE,
+ /* entry_index = */ 20,
+ /* insert_flag = */ FALSE,
+ /* flags = */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
+ /* num_pins = */ 1,
+ /* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
+ -1, -1, -1, -1, -1, -1, -1},
+ /* pin_idx[MAX_PINS] = */ {100, -1, -1, -1, -1, -1, -1, -1},
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ TRUE
},
{
- /* entry_num = */ 6,
- /* entry_type = */ MONSTER_ENTRY_TYPE,
- /* entry_index = */ 30,
- /* insert_flag = */ TRUE,
- /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
- /* num_pins = */ 1,
- /* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
- -1, -1, -1, -1, -1, -1, -1},
- /* pin_idx[MAX_PINS] = */ {100, -1, -1, -1, -1, -1, -1, -1},
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ TRUE,
- /* expected_flushed = */ FALSE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 6,
+ /* entry_type = */ MONSTER_ENTRY_TYPE,
+ /* entry_index = */ 30,
+ /* insert_flag = */ TRUE,
+ /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* num_pins = */ 1,
+ /* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
+ -1, -1, -1, -1, -1, -1, -1},
+ /* pin_idx[MAX_PINS] = */ {100, -1, -1, -1, -1, -1, -1, -1},
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ TRUE
},
{
- /* entry_num = */ 7,
- /* entry_type = */ MONSTER_ENTRY_TYPE,
- /* entry_index = */ 40,
- /* insert_flag = */ TRUE,
- /* flags = */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
- /* num_pins = */ 1,
- /* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
- -1, -1, -1, -1, -1, -1, -1},
- /* pin_idx[MAX_PINS] = */ {100, -1, -1, -1, -1, -1, -1, -1},
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ TRUE,
- /* expected_flushed = */ FALSE,
- /* expected_destroyed = */ TRUE
+ /* entry_num = */ 7,
+ /* entry_type = */ MONSTER_ENTRY_TYPE,
+ /* entry_index = */ 40,
+ /* insert_flag = */ TRUE,
+ /* flags = */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* num_pins = */ 1,
+ /* pin_type[MAX_PINS] = */ {PICO_ENTRY_TYPE,
+ -1, -1, -1, -1, -1, -1, -1},
+ /* pin_idx[MAX_PINS] = */ {100, -1, -1, -1, -1, -1, -1, -1},
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ FALSE,
+ /* expected_destroyed = */ TRUE
}
};
@@ -4897,7 +4930,7 @@ check_flush_cache__multi_entry_test(H5F_t * file_ptr,
if ( pass ) {
- result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT, flush_flags);
+ result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, flush_flags);
if ( result < 0 ) {
@@ -4915,21 +4948,18 @@ check_flush_cache__multi_entry_test(H5F_t * file_ptr,
base_addr = entries[spec[i].entry_type];
entry_ptr = &(base_addr[spec[i].entry_index]);
- if ( ( entry_ptr->loaded != spec[i].expected_loaded ) ||
- ( entry_ptr->cleared != spec[i].expected_cleared ) ||
- ( entry_ptr->flushed != spec[i].expected_flushed ) ||
+ if ( ( entry_ptr->deserialized != spec[i].expected_deserialized ) ||
+ ( entry_ptr->serialized != spec[i].expected_serialized ) ||
( entry_ptr->destroyed != spec[i].expected_destroyed ) ) {
#if 0 /* This is useful debugging code. Lets keep it around. */
HDfprintf(stdout,
- "loaded = %d(%d), clrd = %d(%d), flshd = %d(%d), dest = %d(%d)\n",
- (int)(entry_ptr->loaded),
- (int)(spec[i].expected_loaded),
- (int)(entry_ptr->cleared),
- (int)(spec[i].expected_cleared),
- (int)(entry_ptr->flushed),
- (int)(spec[i].expected_flushed),
+ "deslzd = %d(%d), slzd = %d(%d), dest = %d(%d)\n",
+ (int)(entry_ptr->deserialized),
+ (int)(spec[i].expected_deserialized),
+ (int)(entry_ptr->serialized),
+ (int)(spec[i].expected_serialized),
(int)(entry_ptr->destroyed),
(int)(spec[i].expected_destroyed));
@@ -4974,8 +5004,7 @@ check_flush_cache__multi_entry_test(H5F_t * file_ptr,
/* clean up the cache to prep for the next test */
if ( pass ) {
- result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT,
- H5C__FLUSH_INVALIDATE_FLAG);
+ result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5C__FLUSH_INVALIDATE_FLAG);
if ( result < 0 ) {
@@ -5003,10 +5032,9 @@ check_flush_cache__multi_entry_test(H5F_t * file_ptr,
base_addr = entries[spec[i].entry_type];
entry_ptr = &(base_addr[spec[i].entry_index]);
- entry_ptr->loaded = FALSE;
- entry_ptr->cleared = FALSE;
- entry_ptr->flushed = FALSE;
- entry_ptr->destroyed = FALSE;
+ entry_ptr->deserialized = FALSE;
+ entry_ptr->serialized = FALSE;
+ entry_ptr->destroyed = FALSE;
i++;
}
@@ -5133,8 +5161,7 @@ check_flush_cache__pe_multi_entry_test(H5F_t * file_ptr,
if ( pass ) {
- result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT,
- flush_flags);
+ result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, flush_flags);
if ( result < 0 ) {
@@ -5152,21 +5179,18 @@ check_flush_cache__pe_multi_entry_test(H5F_t * file_ptr,
base_addr = entries[spec[i].entry_type];
entry_ptr = &(base_addr[spec[i].entry_index]);
- if ( ( entry_ptr->loaded != spec[i].expected_loaded ) ||
- ( entry_ptr->cleared != spec[i].expected_cleared ) ||
- ( entry_ptr->flushed != spec[i].expected_flushed ) ||
+ if ( ( entry_ptr->deserialized != spec[i].expected_deserialized ) ||
+ ( entry_ptr->serialized != spec[i].expected_serialized ) ||
( entry_ptr->destroyed != spec[i].expected_destroyed ) ) {
#if 0 /* This is useful debugging code. Lets keep it around. */
HDfprintf(stdout,
- "loaded = %d(%d), clrd = %d(%d), flshd = %d(%d), dest = %d(%d)\n",
- (int)(entry_ptr->loaded),
- (int)(spec[i].expected_loaded),
- (int)(entry_ptr->cleared),
- (int)(spec[i].expected_cleared),
- (int)(entry_ptr->flushed),
- (int)(spec[i].expected_flushed),
+ "desrlzd = %d(%d), srlzd = %d(%d), dest = %d(%d)\n",
+ (int)(entry_ptr->deserialized),
+ (int)(spec[i].expected_deserialized),
+ (int)(entry_ptr->serialized),
+ (int)(spec[i].expected_serialized),
(int)(entry_ptr->destroyed),
(int)(spec[i].expected_destroyed));
@@ -5211,8 +5235,7 @@ check_flush_cache__pe_multi_entry_test(H5F_t * file_ptr,
/* clean up the cache to prep for the next test */
if ( pass ) {
- result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT,
- H5C__FLUSH_INVALIDATE_FLAG);
+ result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5C__FLUSH_INVALIDATE_FLAG);
if ( result < 0 ) {
@@ -5240,10 +5263,9 @@ check_flush_cache__pe_multi_entry_test(H5F_t * file_ptr,
base_addr = entries[spec[i].entry_type];
entry_ptr = &(base_addr[spec[i].entry_index]);
- entry_ptr->loaded = FALSE;
- entry_ptr->cleared = FALSE;
- entry_ptr->flushed = FALSE;
- entry_ptr->destroyed = FALSE;
+ entry_ptr->deserialized = FALSE;
+ entry_ptr->serialized = FALSE;
+ entry_ptr->destroyed = FALSE;
i++;
}
@@ -5330,9 +5352,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
@@ -5359,9 +5380,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ FALSE
}
};
@@ -5378,9 +5398,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ FALSE,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ FALSE,
/* expected_destroyed = */ FALSE
}
};
@@ -5440,9 +5459,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
@@ -5469,9 +5487,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ TRUE
}
};
@@ -5488,9 +5505,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ FALSE,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ FALSE,
/* expected_destroyed = */ FALSE
}
};
@@ -5528,7 +5544,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 0,
/* insert_flag = */ FALSE,
- /* flags = */ H5C__NO_FLAGS_SET,
+ /* flags = */ H5C__DIRTIED_FLAG,
/* resize_flag = */ TRUE,
/* new_size = */ VARIABLE_ENTRY_SIZE / 4,
/* num_pins = */ 0,
@@ -5547,9 +5563,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ FALSE
}
};
@@ -5566,9 +5581,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ FALSE,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ FALSE,
/* expected_destroyed = */ FALSE
}
};
@@ -5608,7 +5622,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 0,
/* insert_flag = */ FALSE,
- /* flags = */ H5C__NO_FLAGS_SET,
+ /* flags = */ H5C__DIRTIED_FLAG,
/* resize_flag = */ TRUE,
/* new_size = */ VARIABLE_ENTRY_SIZE / 4,
/* num_pins = */ 0,
@@ -5627,9 +5641,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ TRUE
}
};
@@ -5646,9 +5659,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ FALSE,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ FALSE,
/* expected_destroyed = */ FALSE
}
};
@@ -5669,11 +5681,17 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
if ( pass ) /* test #5 & #6 */
{
/* Single entry test verifying that the cache can handle the case in
- * which the call back function moves the entry for which it has
- * been called.
+ * which the call back function first resizes and then moves the
+ * entry for which it has been called.
*
* Run this entry twice, as the first run moves the entry to its
* alternate address, and the second moves it back.
+ *
+ * 10/8/07 -- JRM
+ * Added a resize operation to this test to satisfy the new
+ * requiremnt that any resize of an entry on flush will always
+ * be accompanied by a resize. Note that as a result, this
+ * test becomes redundant with later tests.
*/
int test_num = 5; /* and 6 */
unsigned int flush_flags = H5C__NO_FLAGS_SET;
@@ -5681,7 +5699,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
int init_expected_index_len = 1;
size_t init_expected_index_size = VARIABLE_ENTRY_SIZE;
int expected_index_len = 1;
- size_t expected_index_size = VARIABLE_ENTRY_SIZE;
+ size_t expected_index_size = VARIABLE_ENTRY_SIZE / 2;
struct fo_flush_cache_test_spec spec[1] =
{
{
@@ -5695,11 +5713,11 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
/* num_pins = */ 0,
/* pin_type = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {0, 0, 0, 0, 0, 0, 0, 0},
- /* num_flush_ops = */ 1,
+ /* num_flush_ops = */ 2,
/* flush_ops = */
/* op_code: type: idx: flag: size: order_ptr: */
- { { FLUSH_OP__MOVE, VARIABLE_ENTRY_TYPE, 0, FALSE, 0, NULL },
- { FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
+ { { FLUSH_OP__RESIZE, VARIABLE_ENTRY_TYPE, 0, FALSE, VARIABLE_ENTRY_SIZE / 2, NULL },
+ { FLUSH_OP__MOVE, VARIABLE_ENTRY_TYPE, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
@@ -5708,9 +5726,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ FALSE
}
};
@@ -5727,9 +5744,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ FALSE,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ FALSE,
/* expected_destroyed = */ FALSE
}
};
@@ -5759,7 +5775,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
*/
if ( pass ) {
- spec[0].flush_ops[0].flag = TRUE;
+ spec[0].flush_ops[1].flag = TRUE;
test_num = 6;
check_flush_cache__flush_op_test(file_ptr,
@@ -5787,6 +5803,12 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
*
* Run this entry twice, as the first run moves the entry to its
* alternate address, and the second moves it back.
+ *
+ * 10/8/07 -- JRM
+ * Added a resize operation to this test to satisfy the new
+ * requiremnt that any resize of an entry on flush will always
+ * be accompanied by a resize. Note that as a result, this
+ * test becomes redundant with later tests.
*/
int test_num = 7; /* and 8 */
unsigned int flush_flags = H5C__NO_FLAGS_SET;
@@ -5794,7 +5816,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
int init_expected_index_len = 1;
size_t init_expected_index_size = VARIABLE_ENTRY_SIZE;
int expected_index_len = 1;
- size_t expected_index_size = VARIABLE_ENTRY_SIZE;
+ size_t expected_index_size = VARIABLE_ENTRY_SIZE / 2;
struct fo_flush_cache_test_spec spec[1] =
{
{
@@ -5808,11 +5830,11 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
/* num_pins = */ 0,
/* pin_type = */ {0, 0, 0, 0, 0, 0, 0, 0},
/* pin_idx = */ {0, 0, 0, 0, 0, 0, 0, 0},
- /* num_flush_ops = */ 1,
+ /* num_flush_ops = */ 2,
/* flush_ops = */
/* op_code: type: idx: flag: size: order_ptr: */
- { { FLUSH_OP__MOVE, VARIABLE_ENTRY_TYPE, 0, FALSE, 0, NULL },
- { FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
+ { { FLUSH_OP__RESIZE, VARIABLE_ENTRY_TYPE, 0, FALSE, VARIABLE_ENTRY_SIZE / 2, NULL },
+ { FLUSH_OP__MOVE, VARIABLE_ENTRY_TYPE, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
@@ -5821,9 +5843,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ FALSE
}
};
@@ -5840,9 +5861,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ FALSE,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ FALSE,
/* expected_destroyed = */ FALSE
}
};
@@ -5877,7 +5897,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
flush_flags = H5C__FLUSH_INVALIDATE_FLAG;
expected_index_len = 0;
expected_index_size = 0;
- spec[0].flush_ops[0].flag = TRUE;
+ spec[0].flush_ops[1].flag = TRUE;
spec[0].expected_destroyed = TRUE;
check_flush_cache__flush_op_test(file_ptr,
@@ -5917,7 +5937,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 0,
/* insert_flag = */ FALSE,
- /* flags = */ H5C__NO_FLAGS_SET,
+ /* flags = */ H5C__DIRTIED_FLAG,
/* resize_flag = */ TRUE,
/* new_size = */ VARIABLE_ENTRY_SIZE / 2,
/* num_pins = */ 0,
@@ -5936,9 +5956,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ FALSE
}
};
@@ -5955,9 +5974,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ FALSE,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ FALSE,
/* expected_destroyed = */ FALSE
}
};
@@ -6030,7 +6048,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
/* entry_type = */ VARIABLE_ENTRY_TYPE,
/* entry_index = */ 0,
/* insert_flag = */ FALSE,
- /* flags = */ H5C__NO_FLAGS_SET,
+ /* flags = */ H5C__DIRTIED_FLAG,
/* resize_flag = */ TRUE,
/* new_size = */ VARIABLE_ENTRY_SIZE / 2,
/* num_pins = */ 0,
@@ -6049,9 +6067,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ FALSE
}
};
@@ -6068,9 +6085,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ FALSE,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ FALSE,
/* expected_destroyed = */ FALSE
}
};
@@ -6165,9 +6181,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ FALSE
}
};
@@ -6184,9 +6199,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
@@ -6199,9 +6213,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ FALSE
}
};
@@ -6264,9 +6277,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ TRUE
}
};
@@ -6283,9 +6295,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
@@ -6298,9 +6309,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ TRUE
}
};
@@ -6362,9 +6372,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ FALSE
}
};
@@ -6381,9 +6390,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
@@ -6396,9 +6404,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ FALSE
}
};
@@ -6460,9 +6467,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ TRUE
}
};
@@ -6479,9 +6485,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
@@ -6494,9 +6499,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ TRUE
}
};
@@ -6558,9 +6562,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ FALSE
}
};
@@ -6577,9 +6580,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
@@ -6592,9 +6594,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ FALSE
}
};
@@ -6688,9 +6689,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ FALSE
}
};
@@ -6707,9 +6707,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
@@ -6722,9 +6721,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ FALSE
}
};
@@ -6830,9 +6828,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
@@ -6859,9 +6856,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ FALSE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ FALSE,
/* expected_destroyed = */ FALSE
},
{
@@ -6888,9 +6884,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
@@ -6917,9 +6912,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ FALSE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ FALSE,
/* expected_destroyed = */ FALSE
}
};
@@ -6936,9 +6930,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
/* is_dirty = */ TRUE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ FALSE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ FALSE,
/* expected_destroyed = */ FALSE
},
{
@@ -6951,9 +6944,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
/* is_dirty = */ TRUE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ FALSE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ FALSE,
/* expected_destroyed = */ FALSE
},
{
@@ -6966,9 +6958,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ FALSE,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ FALSE,
/* expected_destroyed = */ FALSE
},
{
@@ -6981,9 +6972,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ FALSE,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ FALSE,
/* expected_destroyed = */ FALSE
}
};
@@ -7049,9 +7039,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
@@ -7078,9 +7067,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
@@ -7107,9 +7095,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
@@ -7136,9 +7123,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ FALSE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ FALSE,
/* expected_destroyed = */ FALSE
},
{
@@ -7165,9 +7151,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
@@ -7194,9 +7179,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ FALSE
}
};
@@ -7213,9 +7197,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
@@ -7228,9 +7211,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
@@ -7243,9 +7225,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
@@ -7258,9 +7239,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ FALSE
}
};
@@ -7325,9 +7305,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
@@ -7354,9 +7333,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
@@ -7383,9 +7361,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
@@ -7412,9 +7389,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ FALSE,
/* expected_destroyed = */ TRUE
},
{
@@ -7441,9 +7417,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
@@ -7470,9 +7445,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ TRUE
}
};
@@ -7489,9 +7463,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
@@ -7504,9 +7477,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
@@ -7519,9 +7491,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
@@ -7534,9 +7505,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ TRUE
}
};
@@ -7597,9 +7567,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
@@ -7626,9 +7595,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
@@ -7655,9 +7623,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ FALSE
}
};
@@ -7674,9 +7641,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ FALSE,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ FALSE,
/* expected_destroyed = */ FALSE
}
};
@@ -7734,9 +7700,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
@@ -7763,9 +7728,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
@@ -7792,9 +7756,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ TRUE
}
};
@@ -7811,9 +7774,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ FALSE,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ FALSE,
/* expected_destroyed = */ FALSE
}
};
@@ -7941,9 +7903,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
@@ -7970,9 +7931,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
@@ -7999,9 +7959,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
@@ -8028,9 +7987,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
@@ -8057,9 +8015,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
@@ -8086,9 +8043,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
@@ -8115,9 +8071,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
@@ -8144,9 +8099,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
@@ -8173,9 +8127,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
@@ -8202,9 +8155,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ FALSE
}
};
@@ -8221,9 +8173,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
@@ -8236,9 +8187,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
@@ -8251,9 +8201,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ FALSE
}
@@ -8388,9 +8337,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
@@ -8417,9 +8365,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
@@ -8446,9 +8393,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
@@ -8475,9 +8421,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
@@ -8504,9 +8449,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
@@ -8533,9 +8477,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
@@ -8562,9 +8505,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
@@ -8591,9 +8533,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
@@ -8620,9 +8561,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
@@ -8649,9 +8589,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ TRUE
}
};
@@ -8668,9 +8607,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
@@ -8683,9 +8621,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
@@ -8698,9 +8635,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ TRUE
}
@@ -8760,9 +8696,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
@@ -8789,9 +8724,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
@@ -8818,9 +8752,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
@@ -8847,9 +8780,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ FALSE
},
{
@@ -8876,9 +8808,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ FALSE
}
};
@@ -8895,9 +8826,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ FALSE,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ FALSE,
/* expected_destroyed = */ FALSE
}
};
@@ -8958,9 +8888,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
@@ -8987,9 +8916,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
@@ -9016,9 +8944,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
@@ -9045,9 +8972,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ TRUE
},
{
@@ -9074,9 +9000,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL },
{ FLUSH_OP__NO_OP, 0, 0, FALSE, 0, NULL } },
- /* expected_loaded = */ TRUE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ TRUE,
+ /* expected_deserialized = */ TRUE,
+ /* expected_serialized = */ TRUE,
/* expected_destroyed = */ TRUE
}
};
@@ -9093,9 +9018,8 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
/* is_dirty = */ FALSE,
/* is_protected = */ FALSE,
/* is_pinned = */ FALSE,
- /* expected_loaded = */ FALSE,
- /* expected_cleared = */ FALSE,
- /* expected_flushed = */ FALSE,
+ /* expected_deserialized = */ FALSE,
+ /* expected_serialized = */ FALSE,
/* expected_destroyed = */ FALSE
}
};
@@ -9233,12 +9157,10 @@ check_flush_cache__flush_op_test(H5F_t * file_ptr,
( check[i].is_protected != FALSE ) ) ||
( ( check[i].is_pinned != TRUE ) &&
( check[i].is_pinned != FALSE ) ) ||
- ( ( check[i].expected_loaded != TRUE ) &&
- ( check[i].expected_loaded != FALSE ) ) ||
- ( ( check[i].expected_cleared != TRUE ) &&
- ( check[i].expected_cleared != FALSE ) ) ||
- ( ( check[i].expected_flushed != TRUE ) &&
- ( check[i].expected_flushed != FALSE ) ) ||
+ ( ( check[i].expected_deserialized != TRUE ) &&
+ ( check[i].expected_deserialized != FALSE ) ) ||
+ ( ( check[i].expected_serialized != TRUE ) &&
+ ( check[i].expected_serialized != FALSE ) ) ||
( ( check[i].expected_destroyed != TRUE ) &&
( check[i].expected_destroyed != FALSE ) ) ) {
@@ -9310,8 +9232,7 @@ check_flush_cache__flush_op_test(H5F_t * file_ptr,
if ( pass ) {
- result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT,
- flush_flags);
+ result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, flush_flags);
if ( result < 0 ) {
@@ -9330,21 +9251,18 @@ check_flush_cache__flush_op_test(H5F_t * file_ptr,
base_addr = entries[spec[i].entry_type];
entry_ptr = &(base_addr[spec[i].entry_index]);
- if ( ( entry_ptr->loaded != spec[i].expected_loaded ) ||
- ( entry_ptr->cleared != spec[i].expected_cleared ) ||
- ( entry_ptr->flushed != spec[i].expected_flushed ) ||
+ if ( ( entry_ptr->deserialized != spec[i].expected_deserialized ) ||
+ ( entry_ptr->serialized != spec[i].expected_serialized ) ||
( entry_ptr->destroyed != spec[i].expected_destroyed ) ) {
#if 0 /* This is useful debugging code. Lets keep it around. */
HDfprintf(stdout,
- "loaded = %d(%d), clrd = %d(%d), flshd = %d(%d), dest = %d(%d)\n",
- (int)(entry_ptr->loaded),
- (int)(spec[i].expected_loaded),
- (int)(entry_ptr->cleared),
- (int)(spec[i].expected_cleared),
- (int)(entry_ptr->flushed),
- (int)(spec[i].expected_flushed),
+ "desrlzd = %d(%d), srlzd = %d(%d), dest = %d(%d)\n",
+ (int)(entry_ptr->deserialized),
+ (int)(spec[i].expected_deserialized),
+ (int)(entry_ptr->serialized),
+ (int)(spec[i].expected_serialized),
(int)(entry_ptr->destroyed),
(int)(spec[i].expected_destroyed));
@@ -9391,9 +9309,8 @@ check_flush_cache__flush_op_test(H5F_t * file_ptr,
( entry_ptr->header.is_protected != check[i].is_protected ) ||
( entry_ptr->is_pinned != check[i].is_pinned ) ||
( entry_ptr->header.is_pinned != check[i].is_pinned ) ||
- ( entry_ptr->loaded != check[i].expected_loaded ) ||
- ( entry_ptr->cleared != check[i].expected_cleared ) ||
- ( entry_ptr->flushed != check[i].expected_flushed ) ||
+ ( entry_ptr->deserialized != check[i].expected_deserialized ) ||
+ ( entry_ptr->serialized != check[i].expected_serialized ) ||
( entry_ptr->destroyed != check[i].expected_destroyed ) ) {
#if 0 /* This is useful debugging code. Lets keep it around for a while. */
@@ -9448,20 +9365,18 @@ check_flush_cache__flush_op_test(H5F_t * file_ptr,
(int)(entry_ptr->header.is_pinned),
(int)(check[i].is_pinned));
}
- if ( entry_ptr->loaded != check[i].expected_loaded ) {
- HDfprintf(stdout, "entry_ptr->loaded (expected) = %d (%d).\n",
- (int)(entry_ptr->loaded),
- (int)(check[i].expected_loaded));
- }
- if ( entry_ptr->cleared != check[i].expected_cleared ) {
- HDfprintf(stdout, "entry_ptr->cleared (expected) = %d (%d).\n",
- (int)(entry_ptr->cleared),
- (int)(check[i].expected_cleared));
+ if ( entry_ptr->deserialized !=
+ check[i].expected_deserialized ) {
+ HDfprintf(stdout,
+ "entry_ptr->deserialized (expected) = %d (%d).\n",
+ (int)(entry_ptr->deserialized),
+ (int)(check[i].expected_deserialized));
}
- if ( entry_ptr->flushed != check[i].expected_flushed ) {
- HDfprintf(stdout, "entry_ptr->flushed (expected) = %d (%d).\n",
- (int)(entry_ptr->flushed),
- (int)(check[i].expected_flushed));
+ if ( entry_ptr->serialized != check[i].expected_serialized ) {
+ HDfprintf(stdout,
+ "entry_ptr->serialized (expected) = %d (%d).\n",
+ (int)(entry_ptr->serialized),
+ (int)(check[i].expected_serialized));
}
if ( entry_ptr->destroyed != check[i].expected_destroyed ) {
HDfprintf(stdout, "entry_ptr->destroyed (expected) = %d (%d).\n",
@@ -9509,8 +9424,7 @@ check_flush_cache__flush_op_test(H5F_t * file_ptr,
/* clean up the cache to prep for the next test */
if ( pass ) {
- result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT,
- H5C__FLUSH_INVALIDATE_FLAG);
+ result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5C__FLUSH_INVALIDATE_FLAG);
if ( result < 0 ) {
@@ -9542,10 +9456,9 @@ check_flush_cache__flush_op_test(H5F_t * file_ptr,
entry_ptr->size = entry_sizes[spec[i].entry_type];
- entry_ptr->loaded = FALSE;
- entry_ptr->cleared = FALSE;
- entry_ptr->flushed = FALSE;
- entry_ptr->destroyed = FALSE;
+ entry_ptr->deserialized = FALSE;
+ entry_ptr->serialized = FALSE;
+ entry_ptr->destroyed = FALSE;
i++;
}
@@ -9558,10 +9471,9 @@ check_flush_cache__flush_op_test(H5F_t * file_ptr,
entry_ptr->size = entry_sizes[check[i].entry_type];
- entry_ptr->loaded = FALSE;
- entry_ptr->cleared = FALSE;
- entry_ptr->flushed = FALSE;
- entry_ptr->destroyed = FALSE;
+ entry_ptr->deserialized = FALSE;
+ entry_ptr->serialized = FALSE;
+ entry_ptr->destroyed = FALSE;
i++;
}
@@ -9586,6 +9498,11 @@ check_flush_cache__flush_op_test(H5F_t * file_ptr,
*
* Modifications:
*
+ * Updated test for minor changes in the behaviour
+ * of H5C__flush_single_entry().
+ *
+ * JRM -- 2/16/15
+ *
*-------------------------------------------------------------------------
*/
@@ -9594,74 +9511,76 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
{
H5C_t * cache_ptr = file_ptr->shared->cache;
int i;
- int num_variable_entries = 8;
+ int num_variable_entries = 10;
int num_monster_entries = 31;
int num_large_entries = 0;
herr_t result;
test_entry_t * entry_ptr;
test_entry_t * base_addr;
- struct expected_entry_status expected[8 + 31 + 14] =
+ struct expected_entry_status expected[10 + 31 + 14] =
{
/* the expected array is used to maintain a table of the expected status of every
* entry used in this test. Note that since the function that processes this
* array only processes as much of it as it is told to, we don't have to
* worry about maintaining the status of entries that we haven't used yet.
*/
- /* entry entry in at main flush dep flush dep child flush flush flush */
- /* type: index: size: cache: addr: dirty: prot: pinned: loaded: clrd: flshd: dest: par type: par idx: dep ref.count: dep height: order: */
- { VARIABLE_ENTRY_TYPE, 0, VARIABLE_ENTRY_SIZE/2, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { VARIABLE_ENTRY_TYPE, 1, VARIABLE_ENTRY_SIZE, TRUE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { VARIABLE_ENTRY_TYPE, 2, VARIABLE_ENTRY_SIZE, TRUE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { VARIABLE_ENTRY_TYPE, 3, VARIABLE_ENTRY_SIZE/2, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { VARIABLE_ENTRY_TYPE, 4, VARIABLE_ENTRY_SIZE/2, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { VARIABLE_ENTRY_TYPE, 5, VARIABLE_ENTRY_SIZE/2, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { VARIABLE_ENTRY_TYPE, 6, VARIABLE_ENTRY_SIZE, TRUE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { VARIABLE_ENTRY_TYPE, 7, VARIABLE_ENTRY_SIZE, TRUE, TRUE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { MONSTER_ENTRY_TYPE, 0, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { MONSTER_ENTRY_TYPE, 1, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { MONSTER_ENTRY_TYPE, 2, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { MONSTER_ENTRY_TYPE, 3, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { MONSTER_ENTRY_TYPE, 4, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { MONSTER_ENTRY_TYPE, 5, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { MONSTER_ENTRY_TYPE, 6, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { MONSTER_ENTRY_TYPE, 7, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { MONSTER_ENTRY_TYPE, 8, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { MONSTER_ENTRY_TYPE, 9, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { MONSTER_ENTRY_TYPE, 10, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { MONSTER_ENTRY_TYPE, 11, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { MONSTER_ENTRY_TYPE, 12, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { MONSTER_ENTRY_TYPE, 13, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { MONSTER_ENTRY_TYPE, 14, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { MONSTER_ENTRY_TYPE, 15, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { MONSTER_ENTRY_TYPE, 16, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { MONSTER_ENTRY_TYPE, 17, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { MONSTER_ENTRY_TYPE, 18, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { MONSTER_ENTRY_TYPE, 19, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { MONSTER_ENTRY_TYPE, 20, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { MONSTER_ENTRY_TYPE, 21, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { MONSTER_ENTRY_TYPE, 22, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { MONSTER_ENTRY_TYPE, 23, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { MONSTER_ENTRY_TYPE, 24, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { MONSTER_ENTRY_TYPE, 25, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { MONSTER_ENTRY_TYPE, 26, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { MONSTER_ENTRY_TYPE, 27, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { MONSTER_ENTRY_TYPE, 28, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { MONSTER_ENTRY_TYPE, 29, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { MONSTER_ENTRY_TYPE, 30, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { LARGE_ENTRY_TYPE, 0, LARGE_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { LARGE_ENTRY_TYPE, 1, LARGE_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { LARGE_ENTRY_TYPE, 2, LARGE_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { LARGE_ENTRY_TYPE, 3, LARGE_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { LARGE_ENTRY_TYPE, 4, LARGE_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { LARGE_ENTRY_TYPE, 5, LARGE_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { LARGE_ENTRY_TYPE, 6, LARGE_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { LARGE_ENTRY_TYPE, 7, LARGE_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { LARGE_ENTRY_TYPE, 8, LARGE_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { LARGE_ENTRY_TYPE, 9, LARGE_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { LARGE_ENTRY_TYPE, 10, LARGE_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { LARGE_ENTRY_TYPE, 11, LARGE_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { LARGE_ENTRY_TYPE, 12, LARGE_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { LARGE_ENTRY_TYPE, 13, LARGE_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 }
+ /* entry entry in at main flush dep flush dep child flush flush flush */
+ /* type: index: size: cache: addr: dirty: prot: pinned: dsrlzd: srlzd: dest: par idx: dep ref.count: dep height: order: */
+ { VARIABLE_ENTRY_TYPE, 0, VARIABLE_ENTRY_SIZE/4, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { VARIABLE_ENTRY_TYPE, 1, VARIABLE_ENTRY_SIZE/4, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { VARIABLE_ENTRY_TYPE, 2, VARIABLE_ENTRY_SIZE, TRUE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { VARIABLE_ENTRY_TYPE, 3, VARIABLE_ENTRY_SIZE/4, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { VARIABLE_ENTRY_TYPE, 4, VARIABLE_ENTRY_SIZE, TRUE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { VARIABLE_ENTRY_TYPE, 5, VARIABLE_ENTRY_SIZE/4, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { VARIABLE_ENTRY_TYPE, 6, VARIABLE_ENTRY_SIZE/2, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { VARIABLE_ENTRY_TYPE, 7, VARIABLE_ENTRY_SIZE/2, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { VARIABLE_ENTRY_TYPE, 8, VARIABLE_ENTRY_SIZE, TRUE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { VARIABLE_ENTRY_TYPE, 9, VARIABLE_ENTRY_SIZE, TRUE, TRUE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 0, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 1, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 2, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 3, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 4, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 5, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 6, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 7, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 8, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 9, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 10, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 11, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 12, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 13, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 14, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 15, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 16, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 17, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 18, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 19, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 20, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 21, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 22, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 23, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 24, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 25, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 26, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 27, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 28, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 29, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 30, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { LARGE_ENTRY_TYPE, 0, LARGE_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { LARGE_ENTRY_TYPE, 1, LARGE_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { LARGE_ENTRY_TYPE, 2, LARGE_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { LARGE_ENTRY_TYPE, 3, LARGE_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { LARGE_ENTRY_TYPE, 4, LARGE_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { LARGE_ENTRY_TYPE, 5, LARGE_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { LARGE_ENTRY_TYPE, 6, LARGE_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { LARGE_ENTRY_TYPE, 7, LARGE_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { LARGE_ENTRY_TYPE, 8, LARGE_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { LARGE_ENTRY_TYPE, 9, LARGE_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { LARGE_ENTRY_TYPE, 10, LARGE_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { LARGE_ENTRY_TYPE, 11, LARGE_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { LARGE_ENTRY_TYPE, 12, LARGE_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { LARGE_ENTRY_TYPE, 13, LARGE_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 }
};
if ( pass ) {
@@ -9718,38 +9637,49 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
protect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 0);
resize_entry(file_ptr, VARIABLE_ENTRY_TYPE, 0,
- (VARIABLE_ENTRY_SIZE / 2), TRUE);
+ (VARIABLE_ENTRY_SIZE / 4), TRUE);
unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 0, H5C__DIRTIED_FLAG);
protect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 1);
- unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 1, H5C__NO_FLAGS_SET);
+ resize_entry(file_ptr, VARIABLE_ENTRY_TYPE, 1,
+ (VARIABLE_ENTRY_SIZE / 4), TRUE);
+ unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 1, H5C__DIRTIED_FLAG);
protect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 2);
unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 2, H5C__NO_FLAGS_SET);
protect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 3);
resize_entry(file_ptr, VARIABLE_ENTRY_TYPE, 3,
- (VARIABLE_ENTRY_SIZE / 2), TRUE);
+ (VARIABLE_ENTRY_SIZE / 4), TRUE);
unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 3, H5C__DIRTIED_FLAG);
protect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 4);
- resize_entry(file_ptr, VARIABLE_ENTRY_TYPE, 4,
- (VARIABLE_ENTRY_SIZE / 2), TRUE);
- unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 4, H5C__DIRTIED_FLAG);
+ unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 4, H5C__NO_FLAGS_SET);
protect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 5);
resize_entry(file_ptr, VARIABLE_ENTRY_TYPE, 5,
- (VARIABLE_ENTRY_SIZE / 2), TRUE);
+ (VARIABLE_ENTRY_SIZE / 4), TRUE);
unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 5, H5C__DIRTIED_FLAG);
protect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 6);
- unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 6, H5C__NO_FLAGS_SET);
+ resize_entry(file_ptr, VARIABLE_ENTRY_TYPE, 6,
+ (VARIABLE_ENTRY_SIZE / 2), TRUE);
+ unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 6, H5C__DIRTIED_FLAG);
protect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 7);
- unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 7, H5C__NO_FLAGS_SET);
+ resize_entry(file_ptr, VARIABLE_ENTRY_TYPE, 7,
+ (VARIABLE_ENTRY_SIZE / 2), TRUE);
+ unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 7, H5C__DIRTIED_FLAG);
+
+ protect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 8);
+ unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 8, H5C__NO_FLAGS_SET);
- if ( ( cache_ptr->index_len != 8 ) ||
- ( cache_ptr->index_size != (4 * (VARIABLE_ENTRY_SIZE / 2)) +
+ protect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 9);
+ unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 9, H5C__NO_FLAGS_SET);
+
+ if ( ( cache_ptr->index_len != 10 ) ||
+ ( cache_ptr->index_size != (4 * (VARIABLE_ENTRY_SIZE / 4)) +
+ (2 * (VARIABLE_ENTRY_SIZE / 2)) +
(4 * VARIABLE_ENTRY_SIZE) ) ) {
pass = FALSE;
@@ -9761,33 +9691,35 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
/* Now set up the pinning relationships:
*
- * Briefly, (VET, 0) is pinned by (VET, 1), (VET, 2), and (VET, 3)
- * (VET, 7) is pinned by (VET, 3), and (VET, 5)
+ * Briefly, (VET, 0) is pinned by (VET, 1), (VET, 3), and (VET, 5)
+ * (VET, 9) is pinned by (VET, 5), and (VET, 7)
*/
create_pinned_entry_dependency(file_ptr, VARIABLE_ENTRY_TYPE, 1,
VARIABLE_ENTRY_TYPE, 0);
- create_pinned_entry_dependency(file_ptr, VARIABLE_ENTRY_TYPE, 2,
- VARIABLE_ENTRY_TYPE, 0);
create_pinned_entry_dependency(file_ptr, VARIABLE_ENTRY_TYPE, 3,
VARIABLE_ENTRY_TYPE, 0);
- create_pinned_entry_dependency(file_ptr, VARIABLE_ENTRY_TYPE, 3,
- VARIABLE_ENTRY_TYPE, 7);
create_pinned_entry_dependency(file_ptr, VARIABLE_ENTRY_TYPE, 5,
- VARIABLE_ENTRY_TYPE, 7);
+ VARIABLE_ENTRY_TYPE, 0);
+ create_pinned_entry_dependency(file_ptr, VARIABLE_ENTRY_TYPE, 5,
+ VARIABLE_ENTRY_TYPE, 9);
+ create_pinned_entry_dependency(file_ptr, VARIABLE_ENTRY_TYPE, 7,
+ VARIABLE_ENTRY_TYPE, 9);
/* Next, set up the flush operations:
*
* Briefly, (VET, 1) dirties (VET, 0)
* resizes (VET, 0) to 3/4 VARIABLE_ENTRY_SIZE
*
- * (VET, 2) dirties (VET, 0)
+ * (VET, 3) dirties (VET, 0)
* resizes (VET, 0) to VARIABLE_ENTRY_SIZE
* moves (VET, 0) to its alternate address
*
- * (VET, 3) dirties (VET, 0)
- * resizes itself to VARIABLE_ENTRY_SIZE
+ * (VET, 5) dirties (VET, 0)
+ * resizes itself to VARIABLE_ENTRY_SIZE / 2
+ *
+ * (VET, 7) dirties (VET, 9)
*
- * (VET, 7) dirties (VET, 6)
+ * (VET, 9) dirties (VET, 8)
*/
add_flush_op(VARIABLE_ENTRY_TYPE, 1, FLUSH_OP__DIRTY,
VARIABLE_ENTRY_TYPE, 0, FALSE, (size_t)0, NULL);
@@ -9795,20 +9727,23 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
VARIABLE_ENTRY_TYPE, 0, TRUE,
3 * VARIABLE_ENTRY_SIZE / 4, NULL);
- add_flush_op(VARIABLE_ENTRY_TYPE, 2, FLUSH_OP__DIRTY,
+ add_flush_op(VARIABLE_ENTRY_TYPE, 3, FLUSH_OP__DIRTY,
VARIABLE_ENTRY_TYPE, 0, FALSE, (size_t)0, NULL);
- add_flush_op(VARIABLE_ENTRY_TYPE, 2, FLUSH_OP__RESIZE,
+ add_flush_op(VARIABLE_ENTRY_TYPE, 3, FLUSH_OP__RESIZE,
VARIABLE_ENTRY_TYPE, 0, TRUE, VARIABLE_ENTRY_SIZE, NULL);
- add_flush_op(VARIABLE_ENTRY_TYPE, 2, FLUSH_OP__MOVE,
+ add_flush_op(VARIABLE_ENTRY_TYPE, 3, FLUSH_OP__MOVE,
VARIABLE_ENTRY_TYPE, 0, FALSE, (size_t)0, NULL);
- add_flush_op(VARIABLE_ENTRY_TYPE, 3, FLUSH_OP__DIRTY,
+ add_flush_op(VARIABLE_ENTRY_TYPE, 5, FLUSH_OP__DIRTY,
VARIABLE_ENTRY_TYPE, 0, FALSE, (size_t)0, NULL);
- add_flush_op(VARIABLE_ENTRY_TYPE, 3, FLUSH_OP__RESIZE,
- VARIABLE_ENTRY_TYPE, 3, TRUE, VARIABLE_ENTRY_SIZE, NULL);
+ add_flush_op(VARIABLE_ENTRY_TYPE, 5, FLUSH_OP__RESIZE,
+ VARIABLE_ENTRY_TYPE, 5, TRUE, VARIABLE_ENTRY_SIZE / 2, NULL);
add_flush_op(VARIABLE_ENTRY_TYPE, 7, FLUSH_OP__DIRTY,
- VARIABLE_ENTRY_TYPE, 6, FALSE, (size_t)0, NULL);
+ VARIABLE_ENTRY_TYPE, 9, FALSE, (size_t)0, NULL);
+
+ add_flush_op(VARIABLE_ENTRY_TYPE, 9, FLUSH_OP__DIRTY,
+ VARIABLE_ENTRY_TYPE, 8, FALSE, (size_t)0, NULL);
}
if ( pass ) {
@@ -9819,25 +9754,31 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
* in
* entry: cache? size: dirty? pinned? pins: flush operations:
*
- * (VET, 0) Y 5 KB Y Y - -
+ * (VET, 0) Y 2.5 KB Y Y - -
*
- * (VET, 1) Y 10 KB N N 0 dirty (VET, 0),
+ * (VET, 1) Y 2.5 KB Y N 0 dirty (VET, 0),
* resize (VET, 0) to 7.5 KB
*
- * (VET, 2) Y 10 KB N N 0 dirty (VET, 0)
+ * (VET, 2) Y 10 KB N N - -
+ *
+ *
+ * (VET, 3) Y 2.5 KB N N 0 dirty (VET, 0)
* resize (VET, 0) to 10 KB
* move (VET, 0) to its alternate address
*
- * (VET, 3) Y 5 KB Y N 0, 7 dirty (VET, 0)
- * resize (VET, 3) to 10 KB
+ * (VET, 4) Y 10 KB N N - -
+ *
+ *
+ * (VET, 5) Y 2.5 KB Y N 0, 9 dirty (VET, 0)
+ * resize (VET, 5) to 5 KB
*
- * (VET, 4) Y 5 KB Y N - -
+ * (VET, 6) Y 5 KB Y N - -
*
- * (VET, 5) Y 5 KB Y N 7 -
+ * (VET, 7) Y 5 KB Y N 9 dirty (VET, 9)
*
- * (VET, 6) Y 10 KB N N - -
+ * (VET, 8) Y 10 KB N N - -
*
- * (VET, 7) Y 10 KB N Y - dirty (VET, 6)
+ * (VET, 9) Y 10 KB N N - dirty (VET, 8)
*
* Recall that in this test bed, flush operations are excuted the
* first time the associated entry is flushed, and are then
@@ -9858,9 +9799,10 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
}
/* The cache should now be exactly full */
- if ( ( cache_ptr->index_len != 40 ) ||
+ if ( ( cache_ptr->index_len != 42 ) ||
( cache_ptr->index_size != 2 * 1024 * 1024 ) ||
- ( cache_ptr->index_size != ((4 * VARIABLE_ENTRY_SIZE / 2) +
+ ( cache_ptr->index_size != ((4 * VARIABLE_ENTRY_SIZE / 4) +
+ (2 * VARIABLE_ENTRY_SIZE / 2) +
(4 * VARIABLE_ENTRY_SIZE) +
(31 * MONSTER_ENTRY_SIZE) +
(1 * LARGE_ENTRY_SIZE)) ) ) {
@@ -9883,7 +9825,7 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
if ( pass ) {
/* Now load a large entry. This should result in the eviction
- * of (VET,1), and the increase in the size of (VET, 0) from .5
+ * of (VET,2), and the increase in the size of (VET, 0) from .25
* VARIABLE_ENTRY_SIZE to .75 VARIABLE_ENTRY_SIZE.
*
* The following table illustrates the intended state of affairs
@@ -9894,44 +9836,50 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
*
* (VET, 0) Y 7.5 KB Y Y - -
*
- * (VET, 1) N 10 KB N N - -
+ * (VET, 1) Y 2.5 KB N N - -
*
- * (VET, 2) Y 10 KB N N 0 dirty (VET, 0)
+ * (VET, 2) N 10 KB N N - -
+ *
+ * (VET, 3) Y 2.5 KB Y N 0 dirty (VET, 0)
* resize (VET, 0) to 10 KB
* move (VET, 0) to its alternate address
*
- * (VET, 3) Y 5 KB Y N 0, 7 dirty (VET, 0)
- * resize (VET, 3) to 10 KB
+ * (VET, 4) Y 10 KB N N - -
*
- * (VET, 4) Y 5 KB Y N - -
+ * (VET, 5) Y 2.5 KB Y N 0, 9 dirty (VET, 0)
+ * resize (VET, 5) to 5 KB
*
- * (VET, 5) Y 5 KB Y N 7 -
+ * (VET, 6) Y 5 KB Y N - -
*
- * (VET, 6) Y 10 KB N N - -
+ * (VET, 7) Y 5 KB Y N 9 dirty (VET, 9)
*
- * (VET, 7) Y 10 KB Y Y - dirty (VET, 6)
+ * (VET, 8) Y 10 KB N N - -
+ *
+ * (VET, 9) Y 10 KB N Y - dirty (VET, 8)
*
* Start by updating the expected table for the expected changes in entry status:
*/
- expected[0].size = 3 * VARIABLE_ENTRY_SIZE / 4;
- expected[1].in_cache = FALSE;
- expected[1].flushed = TRUE;
- expected[1].destroyed = TRUE;
+ expected[0].size = 3 * VARIABLE_ENTRY_SIZE / 4;
+ expected[1].is_dirty = FALSE;
+ expected[1].serialized = TRUE;
+ expected[2].in_cache = FALSE;
+ expected[2].destroyed = TRUE;
num_large_entries = 2;
protect_entry(file_ptr, LARGE_ENTRY_TYPE, 1);
unprotect_entry(file_ptr, LARGE_ENTRY_TYPE, 1, H5C__DIRTIED_FLAG);
- if ( ( cache_ptr->index_len != 40 ) ||
+ if ( ( cache_ptr->index_len != 42 ) ||
( cache_ptr->index_size != (2 * 1024 * 1024) -
(VARIABLE_ENTRY_SIZE) +
- (VARIABLE_ENTRY_SIZE / 4) +
+ (VARIABLE_ENTRY_SIZE / 2) +
(LARGE_ENTRY_SIZE) ) ||
- ( cache_ptr->index_size != ((1 * 3 * VARIABLE_ENTRY_SIZE / 4 ) +
- (3 * VARIABLE_ENTRY_SIZE / 2 ) +
- (3 * VARIABLE_ENTRY_SIZE) +
- (31 * MONSTER_ENTRY_SIZE) +
+ ( cache_ptr->index_size != ((1 * (3 * VARIABLE_ENTRY_SIZE / 4)) +
+ (3 * VARIABLE_ENTRY_SIZE / 4) +
+ (2 * VARIABLE_ENTRY_SIZE / 2) +
+ (3 * VARIABLE_ENTRY_SIZE) +
+ (31 * MONSTER_ENTRY_SIZE) +
(2 * LARGE_ENTRY_SIZE)) ) ) {
pass = FALSE;
failure_mssg = "unexpected size/len in flush op eviction test 3.";
@@ -9947,8 +9895,8 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
if ( pass ) {
/* Now load another large entry. This should result in the eviction
- * of (VET, 2), the increase in the size of (VET, 0) from .75
- * VARIABLE_ENTRY_SIZE to 1.0 VARIABLE_ENTRY_SIZE, and the moving
+ * of (VET, 4), the increase in the size of (VET, 0) from .75
+ * VARIABLE_ENTRY_SIZE to 1.0 VARIABLE_ENTRY_SIZE, and the renaming
* of (VET, 0) to its alternate address.
*
* The following table shows the expected states of the variable
@@ -9959,40 +9907,46 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
*
* (VET, 0) Y 10 KB Y Y - -
*
- * (VET, 1) N 10 KB N N - -
+ * (VET, 1) Y 2.5 KB N N - -
*
* (VET, 2) N 10 KB N N - -
*
- * (VET, 3) Y 5 KB Y N 0, 7 dirty (VET, 0)
- * resize (VET, 3) to 10 KB
+ * (VET, 3) Y 2.5 KB N N - -
+ *
+ * (VET, 4) N 10 KB N N - -
*
- * (VET, 4) Y 5 KB Y N - -
+ * (VET, 5) Y 2.5 KB Y N 0, 9 dirty (VET, 0)
+ * resize (VET, 5) to 5 KB
*
- * (VET, 5) Y 5 KB Y N 7 -
+ * (VET, 6) Y 5 KB Y N - -
*
- * (VET, 6) Y 10 KB N N - -
+ * (VET, 7) Y 5 KB Y N 9 dirty (VET, 9)
*
- * (VET, 7) Y 10 KB Y Y - dirty (VET, 6)
+ * (VET, 8) Y 10 KB N N - -
+ *
+ * (VET, 9) Y 10 KB N Y - dirty (VET, 8)
*
* Start by updating the expected table for the expected changes in entry status:
*/
expected[0].size = VARIABLE_ENTRY_SIZE;
expected[0].at_main_addr = FALSE;
- expected[2].in_cache = FALSE;
- expected[2].flushed = TRUE;
- expected[2].destroyed = TRUE;
+ expected[3].is_dirty = FALSE;
+ expected[3].serialized = TRUE;
+ expected[4].in_cache = FALSE;
+ expected[4].destroyed = TRUE;
num_large_entries = 3;
protect_entry(file_ptr, LARGE_ENTRY_TYPE, 2);
unprotect_entry(file_ptr, LARGE_ENTRY_TYPE, 2, H5C__DIRTIED_FLAG);
- if ( ( cache_ptr->index_len != 40 ) ||
+ if ( ( cache_ptr->index_len != 42 ) ||
( cache_ptr->index_size != (2 * 1024 * 1024) -
(2 * VARIABLE_ENTRY_SIZE) +
- (VARIABLE_ENTRY_SIZE / 2) +
+ (3 * VARIABLE_ENTRY_SIZE / 4) +
(2 * LARGE_ENTRY_SIZE) ) ||
- ( cache_ptr->index_size != ((3 * VARIABLE_ENTRY_SIZE / 2) +
+ ( cache_ptr->index_size != ((3 * VARIABLE_ENTRY_SIZE / 4) +
+ (2 * VARIABLE_ENTRY_SIZE / 2) +
(3 * VARIABLE_ENTRY_SIZE) +
(31 * MONSTER_ENTRY_SIZE) +
(3 * LARGE_ENTRY_SIZE)) ) ) {
@@ -10010,13 +9964,14 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
if ( pass ) {
- /* load two more large entries. This should result in (VET, 3) being
- * flushed, and increasing its size from 1/2 VARIABLE_ENTRY_SIZE to
+ /* load two more large entries. This should result in (VET, 5) being
+ * flushed, and increasing its size from 1/4 VARIABLE_ENTRY_SIZE to
* VARIABLE_ENTRY_SIZE.
*
* As a result of this size increase, the cache will have to look
- * for another entry to evict. After flushing (VET, 4) and (VET, 5),
- * it should evict (VET, 6), yielding the needed memory.
+ * for another entry to evict. After flushing (VET, 6) and (VET, 7),
+ * it should evict (VET, 8), yielding the needed memory and dirtying
+ * (VET, 9).
*
* The following table shows the expected states of the variable
* size entries after the test.
@@ -10026,33 +9981,37 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
*
* (VET, 0) Y 10 KB Y Y - -
*
- * (VET, 1) N 10 KB N N - -
+ * (VET, 1) Y 2.5 KB N N - -
*
* (VET, 2) N 10 KB N N - -
*
- * (VET, 3) Y 10 KB N N 0, 7 -
+ * (VET, 3) Y 2.5 KB N N - -
+ *
+ * (VET, 4) N 10 KB N N - -
+ *
+ * (VET, 5) Y 5 KB N N 0, 9 -
*
- * (VET, 4) Y 5 KB N N - -
+ * (VET, 6) Y 5 KB N N - -
*
- * (VET, 5) Y 5 KB N N 7 -
+ * (VET, 7) Y 5 KB N N 9 -
*
- * (VET, 6) N 10 KB N N - -
+ * (VET, 8) N 10 KB N N - -
*
- * (VET, 7) Y 10 KB Y Y - dirty (VET, 6)
+ * (VET, 9) Y 10 KB N Y - dirty (VET, 8)
*
* Start by updating the expected table for the expected changes in entry status:
*/
- expected[3].size = VARIABLE_ENTRY_SIZE;
- expected[3].is_dirty = FALSE;
- expected[3].flushed = TRUE;
- expected[4].is_dirty = FALSE;
- expected[4].flushed = TRUE;
+ expected[5].size = VARIABLE_ENTRY_SIZE / 2;
expected[5].is_dirty = FALSE;
- expected[5].flushed = TRUE;
- expected[6].in_cache = FALSE;
- expected[6].flushed = TRUE;
- expected[6].destroyed = TRUE;
+ expected[5].serialized = TRUE;
+ expected[6].is_dirty = FALSE;
+ expected[6].serialized = TRUE;
+ expected[7].is_dirty = FALSE;
+ expected[7].serialized = TRUE;
+ expected[8].in_cache = FALSE;
+ expected[8].destroyed = TRUE;
+ expected[9].is_dirty = TRUE;
num_large_entries = 5;
@@ -10063,13 +10022,15 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
unprotect_entry(file_ptr, LARGE_ENTRY_TYPE, 4, H5C__DIRTIED_FLAG);
/* verify cache size */
- if ( ( cache_ptr->index_len != 41 ) ||
+ if ( ( cache_ptr->index_len != 43 ) ||
( cache_ptr->index_size != (2 * 1024 * 1024) -
(3 * VARIABLE_ENTRY_SIZE) +
- (1 * VARIABLE_ENTRY_SIZE ) + /* size increases of (VET, 0) & (VET, 3) */
+ (1 * VARIABLE_ENTRY_SIZE / 4) +
+ (3 * VARIABLE_ENTRY_SIZE / 4) +
(4 * LARGE_ENTRY_SIZE) ) ||
- ( cache_ptr->index_size != ((2 * VARIABLE_ENTRY_SIZE / 2) +
- (3 * VARIABLE_ENTRY_SIZE) +
+ ( cache_ptr->index_size != ((2 * VARIABLE_ENTRY_SIZE / 4) +
+ (3 * VARIABLE_ENTRY_SIZE / 2) +
+ (2 * VARIABLE_ENTRY_SIZE) +
(31 * MONSTER_ENTRY_SIZE) +
(5 * LARGE_ENTRY_SIZE)) ) ) {
@@ -10090,7 +10051,7 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
* cache to bring all the VARIABLE_ENTRY_TYPE entries to the
* end of the LRU list.
*
- * Note that we don't have to worry about (VET, 0) and (VET, 7)
+ * Note that we don't have to worry about (VET, 0) and (VET, 9)
* as they are pinned and thus not in the LRU list to begin with.
*/
for ( i = 0; i < 31; i++ )
@@ -10106,10 +10067,17 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
}
/* verify cache size */
- if ( ( cache_ptr->index_len != 41 ) ||
+ if ( ( cache_ptr->index_len != 43 ) ||
( cache_ptr->index_size != (2 * 1024 * 1024) -
- (2 * VARIABLE_ENTRY_SIZE) +
- (4 * LARGE_ENTRY_SIZE) ) ) {
+ (3 * VARIABLE_ENTRY_SIZE) +
+ (1 * VARIABLE_ENTRY_SIZE / 4) +
+ (3 * VARIABLE_ENTRY_SIZE / 4) +
+ (4 * LARGE_ENTRY_SIZE) ) ||
+ ( cache_ptr->index_size != ((2 * VARIABLE_ENTRY_SIZE / 4) +
+ (3 * VARIABLE_ENTRY_SIZE / 2) +
+ (2 * VARIABLE_ENTRY_SIZE) +
+ (31 * MONSTER_ENTRY_SIZE) +
+ (5 * LARGE_ENTRY_SIZE)) ) ) {
pass = FALSE;
failure_mssg = "unexpected size/len in flush op eviction test 6.";
@@ -10125,7 +10093,8 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
if ( pass ) {
/* Now load three more large entries. This should result
- * in the eviction of (VET, 3), and the unpinning of (VET, 0)
+ * in the evictions of (VET, 1), (VET, 3), and (VET, 5), and the
+ * unpinning of (VET, 0)
*
* The following table shows the expected states of the variable
* size entries after the test.
@@ -10135,26 +10104,34 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
*
* (VET, 0) Y 10 KB Y N - -
*
- * (VET, 1) N 10 KB N N - -
+ * (VET, 1) N 2.5 KB N N - -
*
* (VET, 2) N 10 KB N N - -
*
- * (VET, 3) N 10 KB N N - -
+ * (VET, 3) N 2.5 KB N N - -
+ *
+ * (VET, 4) N 10 KB N N - -
+ *
+ * (VET, 5) N 5 KB N N - -
*
- * (VET, 4) Y 5 KB N N - -
+ * (VET, 6) Y 5 KB N N - -
*
- * (VET, 5) Y 5 KB N N 7 -
+ * (VET, 7) Y 5 KB N N 9 -
*
- * (VET, 6) N 10 KB N N - -
+ * (VET, 8) N 10 KB N N - -
*
- * (VET, 7) Y 10 KB Y Y - dirty (VET, 6)
+ * (VET, 9) Y 10 KB N Y - dirty (VET, 8)
*
* Start by updating the expected table for the expected changes in entry status:
*/
expected[0].is_pinned = FALSE;
+ expected[1].in_cache = FALSE;
+ expected[1].destroyed = TRUE;
expected[3].in_cache = FALSE;
expected[3].destroyed = TRUE;
+ expected[5].in_cache = FALSE;
+ expected[5].destroyed = TRUE;
num_large_entries = 8;
@@ -10167,7 +10144,9 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
/* verify cache size */
if ( ( cache_ptr->index_len != 43 ) ||
( cache_ptr->index_size != (2 * 1024 * 1024) -
- (3 * VARIABLE_ENTRY_SIZE) +
+ (4 * VARIABLE_ENTRY_SIZE) +
+ (1 * VARIABLE_ENTRY_SIZE / 4) +
+ (3 * VARIABLE_ENTRY_SIZE / 4) +
(7 * LARGE_ENTRY_SIZE) ) ||
( cache_ptr->index_size != ((2 * VARIABLE_ENTRY_SIZE / 2) +
(2 * VARIABLE_ENTRY_SIZE) +
@@ -10187,7 +10166,7 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
if ( pass ) {
- /* load another large entry. (VET, 4) should be evicted.
+ /* load another large entry. (VET, 6) should be evicted.
*
* The following table shows the expected states of the variable
* size entries after the test.
@@ -10197,25 +10176,29 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
*
* (VET, 0) Y 10 KB Y N - -
*
- * (VET, 1) N 10 KB N N - -
+ * (VET, 1) N 2.5 KB N N - -
*
* (VET, 2) N 10 KB N N - -
*
- * (VET, 3) N 10 KB N N - -
+ * (VET, 3) N 2.5 KB N N - -
*
- * (VET, 4) N 5 KB N N - -
+ * (VET, 4) N 10 KB N N - -
*
- * (VET, 5) Y 5 KB N N 7 -
+ * (VET, 5) N 5 KB N N - -
+ *
+ * (VET, 6) N 5 KB N N - -
+ *
+ * (VET, 7) Y 5 KB N N 9 -
*
- * (VET, 6) N 10 KB N N - -
+ * (VET, 8) N 10 KB N N - -
*
- * (VET, 7) Y 10 KB Y Y - dirty (VET, 6)
+ * (VET, 9) Y 10 KB N Y - dirty (VET, 8)
*
* Start by updating the expected table for the expected changes in entry status:
*/
- expected[4].in_cache = FALSE;
- expected[4].destroyed = TRUE;
+ expected[6].in_cache = FALSE;
+ expected[6].destroyed = TRUE;
num_large_entries = 9;
@@ -10251,7 +10234,7 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
/* Load another large entry.
*
- * (VET, 5) should be evicted, and (VET, 7) should be unpinned.
+ * (VET, 7) should be evicted, and (VET, 9) should be unpinned.
*
* The following table shows the expected states of the variable
* size entries after the test.
@@ -10261,26 +10244,30 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
*
* (VET, 0) Y 10 KB Y N - -
*
- * (VET, 1) N 10 KB N N - -
+ * (VET, 1) N 2.5 KB N N - -
*
* (VET, 2) N 10 KB N N - -
*
- * (VET, 3) N 10 KB N N - -
+ * (VET, 3) N 2.5 KB N N - -
*
- * (VET, 4) N 5 KB N N - -
+ * (VET, 4) N 10 KB N N - -
*
* (VET, 5) N 5 KB N N - -
*
- * (VET, 6) N 10 KB N N - -
+ * (VET, 6) N 5 KB N N - -
+ *
+ * (VET, 7) N 5 KB N N - -
*
- * (VET, 7) Y 10 KB Y N - dirty (VET, 6)
+ * (VET, 8) N 10 KB N N - -
+ *
+ * (VET, 9) Y 10 KB Y N - dirty (VET, 8)
*
* Start by updating the expected table for the expected changes in entry status:
*/
- expected[5].in_cache = FALSE;
- expected[5].destroyed = TRUE;
- expected[7].is_pinned = FALSE;
+ expected[7].in_cache = FALSE;
+ expected[7].destroyed = TRUE;
+ expected[9].is_pinned = FALSE;
num_large_entries = 10;
@@ -10353,20 +10340,66 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
if ( pass ) {
- /* load two more large entries.
- *
- * (VET, 0) should be flushed, but not evicted initially since it is dirty.
- *
- * (VET, 7) should be evicted, but (VET, 7) has an eviction operation that
- * dirties (VET, 6). Since (VET, 6) is not in the cache, it will be loaded.
- * Since this results in no net increase in free space, the cache will
- * continue to attempt to create free space.
+ /* load two more large entries. Things get a bit complicated here,
+ * so I'll go through the operation step by step.
+ *
+ * Initially, the cache has 4 KB of empty space, so the first entry
+ * (LET, 10) is loaded via calls to H5C_protect() H5C_unprotect()
+ * without causing any evictions.
+ *
+ * However, this is not the case for the call of H5C_protect() on
+ * (LET, 11).
+ *
+ * Before inserting (LET, 11), H5C_protect(LET, 11) must try to
+ * free up at least 4 KB of space. To do this, it starts scanning
+ * up the LRU list to find entries to evict.
+ *
+ * (VET, 0) is at the bottom of the LRU list, and thus is the first
+ * entry considered. However, it is dirty, so it flushed to disk,
+ * moved to the top of the LRU list, and marked clean.
+ *
+ * (VET, 9) is the next entry on the bottom of the LRU list. It is
+ * dirty too, calls its serialize callback function to construct an
+ * on disk image of the entry, and moves it to the top of the LRU
+ * list after the serialize callback returns.
+ *
+ * However, (VET 9)'s serialize function needs to modify (VET, 8),
+ * which is currently not in cache. Thus it calls H5C_protect(VET, 8)
+ * to gain access to it. H5C_protect(VET, 8) loads (VET, 8), and
+ * then attempts to evict entries to make space for it. While (VET, 9)
+ * is still at the bottom of the LRU, it is marked flush in progress
+ * and this is skipped. Thus the next entries on the LRU are (MET, 0)
+ * thru (MET, 30) and (LET, 0) thru (LET, 10) -- all of which are dirty,
+ * and are therefore flushed and moved to the head of the LRU list.
+ *
+ * The next entry on the bottom of the LRU list is (VET, 0), which
+ * is clean, and is therefore evicted to make space for (VET, 8).
+ * This space is sufficient, so H5C_protect(VET, 8) inserts
+ * (VET, 8) into the cache's index, marks it as protected, and
+ * returns to the serialize function for (VET, 9).
+ *
+ * When the serialize function for (VET, 9) is done with (VET, 8), it
+ * calls H5C_unprotect(VET, 8), which markes (VET, 8) as dirty and
+ * unprotected, and places it at the head of the LRU.
+ *
+ * The serialize function for (VET, 9) then returns, and (VET, 9) is
+ * is written to disk, marked clean, and moved to the head of the LRU.
+ *
+ * At this point, the cache is still full (since (VET, 8) took the
+ * space created by the eviction of (VET, 0)). Thus
+ * H5C_protect(LET, 11) continues to look for space. While
+ * (MET, 0) was the next item on the LRU list when it called the
+ * serialize function for (VET, 9), the function notices that the
+ * LRU has been modified, and restarts its search for candidates
+ * for eviction at the bottom of the LRU.
*
- * The cache will then flush all the monster and large entries, but since they
- * are all dirty, they will not be evicted.
+ * (MET, 0) is now at the bottom of the LRU, and is clean. Thus
+ * it is evicted. This makes sufficient space for (LET, 11), so
+ * H5C_protect(LET, 11) inserts it into the cache, marks it as
+ * protected, and returns.
*
- * Finally, it will reach (VET, 0) again, and evict it on the second pass.
- * This finally makes the necessary space.
+ * H5C_unprotect(LET, 11) marks (LET, 11) as unprotected, and then
+ * returns as well.
*
* The following table shows the expected states of the variable
* size entries after the test.
@@ -10376,44 +10409,54 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
*
* (VET, 0) N 10 KB N N - -
*
- * (VET, 1) N 10 KB N N - -
+ * (VET, 1) N 2.5 KB N N - -
*
* (VET, 2) N 10 KB N N - -
*
- * (VET, 3) N 10 KB N N - -
+ * (VET, 3) N 2.5 KB N N - -
*
- * (VET, 4) N 5 KB N N - -
+ * (VET, 4) N 10 KB N N - -
*
* (VET, 5) N 5 KB N N - -
*
- * (VET, 6) Y 10 KB Y N - -
+ * (VET, 6) N 5 KB N N - -
*
- * (VET, 7) N 10 KB N N - -
+ * (VET, 7) N 5 KB N N - -
*
- * Start by updating the expected table for the expected changes in entry status:
+ * (VET, 8) Y 10 KB Y N - -
+ *
+ * (VET, 9) Y 10 KB N N - -
+ *
+ * Start by updating the expected table for the expected changes in
+ * entry status:
*
- * Note that we reset the loaded, cleared, flushed, and destroyed fields of
- * (VET,6) so we can track what is happening.
+ * Note that we reset the loaded, flushed, and destroyed
+ * fields of (VET,8) so we can track what is happening.
*/
base_addr = entries[VARIABLE_ENTRY_TYPE];
- entry_ptr = &(base_addr[6]);
- entry_ptr->loaded = FALSE;
- entry_ptr->cleared = FALSE;
- entry_ptr->flushed = FALSE;
- entry_ptr->destroyed = FALSE;
+ entry_ptr = &(base_addr[8]);
+ entry_ptr->deserialized = FALSE;
+ entry_ptr->deserialized = FALSE;
+ entry_ptr->destroyed = FALSE;
expected[0].in_cache = FALSE;
expected[0].is_dirty = FALSE;
- expected[0].flushed = TRUE;
+ expected[0].serialized = TRUE;
expected[0].destroyed = TRUE;
- expected[6].in_cache = TRUE;
- expected[6].is_dirty = TRUE;
- expected[6].loaded = TRUE;
- expected[6].flushed = FALSE;
- expected[6].destroyed = FALSE;
- expected[7].in_cache = FALSE;
- expected[7].flushed = TRUE;
- expected[7].destroyed = TRUE;
+ expected[8].in_cache = TRUE;
+ expected[8].is_dirty = TRUE;
+ expected[8].deserialized = TRUE;
+ expected[8].serialized = FALSE;
+ expected[8].destroyed = FALSE;
+ expected[9].in_cache = TRUE;
+ expected[9].is_dirty = FALSE;
+ expected[9].serialized = TRUE;
+ expected[9].destroyed = FALSE;
+
+ expected[10].in_cache = FALSE;
+ expected[10].is_dirty = FALSE;
+ expected[10].serialized = TRUE;
+ expected[10].destroyed = TRUE;
num_large_entries = 12;
@@ -10424,8 +10467,8 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
i < num_variable_entries + num_monster_entries + num_large_entries - 1;
i++ )
{
- expected[i].is_dirty = FALSE;
- expected[i].flushed = TRUE;
+ expected[i].is_dirty = FALSE;
+ expected[i].serialized = TRUE;
}
for ( i = 10; i < 12; i++ )
@@ -10437,10 +10480,10 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
/* verify cache size */
if ( ( cache_ptr->index_len != 44 ) ||
( cache_ptr->index_size != (2 * 1024 * 1024) -
- (5 * VARIABLE_ENTRY_SIZE) +
- (11 * LARGE_ENTRY_SIZE) ) ||
- ( cache_ptr->index_size != ((1 * VARIABLE_ENTRY_SIZE) +
- (31 * MONSTER_ENTRY_SIZE) +
+ (2 * VARIABLE_ENTRY_SIZE) -
+ (10 * LARGE_ENTRY_SIZE) ) ||
+ ( cache_ptr->index_size != ((2 * VARIABLE_ENTRY_SIZE) +
+ (30 * MONSTER_ENTRY_SIZE) +
(12 * LARGE_ENTRY_SIZE)) ) ) {
pass = FALSE;
@@ -10456,10 +10499,33 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
if ( pass ) {
+ /* protect and unprotect VET 8 to move it to the top of the LRU */
+ protect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 8);
+ unprotect_entry(file_ptr, VARIABLE_ENTRY_TYPE, 8, H5C__NO_FLAGS_SET);
+
+
/* Again, touch all the non VARIABLE_ENTRY_TYPE entries in the
- * cache to bring the last remaining VARIABLE_ENTRY_TYPE entry to the
- * end of the LRU list.
+ * cache to evict VET 9 and move VET 8 to the bottom of the LRU.
+ *
+ * Must do this twice to get the desired result.
*/
+
+
+ /* skip MET 0 in first pass so that we evict VET 9 when we
+ * reload MET 0
+ */
+ for ( i = 1; i < num_monster_entries; i++ )
+ {
+ protect_entry(file_ptr, MONSTER_ENTRY_TYPE, i);
+ unprotect_entry(file_ptr, MONSTER_ENTRY_TYPE, i, H5C__DIRTIED_FLAG);
+ }
+
+ for ( i = 0; i < num_large_entries; i++ )
+ {
+ protect_entry(file_ptr, LARGE_ENTRY_TYPE, i);
+ unprotect_entry(file_ptr, LARGE_ENTRY_TYPE, i, H5C__DIRTIED_FLAG);
+ }
+
for ( i = 0; i < num_monster_entries; i++ )
{
protect_entry(file_ptr, MONSTER_ENTRY_TYPE, i);
@@ -10480,6 +10546,22 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
expected[i].is_dirty = TRUE;
}
+ /* update MET 0 to set its in cache flag, and reset the its destroyed flag */
+ expected[10].in_cache = TRUE;
+
+ /* pass through non variable entries will flush VET 8, and evict VET 9.
+ * Update accordingly.
+ */
+ expected[8].in_cache = TRUE;
+ expected[8].is_dirty = TRUE;
+ expected[8].serialized = FALSE;
+ expected[8].destroyed = FALSE;
+ expected[9].in_cache = FALSE;
+ expected[9].is_dirty = FALSE;
+ expected[9].serialized = TRUE;
+ expected[9].destroyed = TRUE;
+
+
/* verify cache size */
if ( ( cache_ptr->index_len != 44 ) ||
( cache_ptr->index_size != (2 * 1024 * 1024) -
@@ -10493,6 +10575,12 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
failure_mssg = "unexpected size/len in flush op eviction test 12.";
}
+ /* modifications to the H5C__flush_single_entry() function have
+ * changed the behavior of the cache slightly, causing
+ * this test to fail. Comment out for now -- come back and
+ * fix if all goes well.
+ */
+
/* verify entry status */
verify_entry_status(cache_ptr,
10,
@@ -10504,10 +10592,11 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
/* Load two more large entries.
*
- * Since (VET, 6) is dirty, at first this will just cause (VET, 6) to be flushed.
+ * Since (VET, 8) is dirty, at first this will just cause (VET, 8)
+ * to be flushed.
*
- * But all other entries in the cache are dirty, so the cache will flush them all,
- * and then evict (VET, 6) on the second pass.
+ * But all other entries in the cache are dirty, so the cache will
+ * flush them all, and then evict (VET, 8) on the second pass.
*
* The following table shows the expected states of the variable
* size entries after the test.
@@ -10517,27 +10606,32 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
*
* (VET, 0) N 10 KB N N - -
*
- * (VET, 1) N 10 KB N N - -
+ * (VET, 1) N 2.5 KB N N - -
*
* (VET, 2) N 10 KB N N - -
*
- * (VET, 3) N 10 KB N N - -
+ * (VET, 3) N 2.5 KB N N - -
*
- * (VET, 4) N 5 KB N N - -
+ * (VET, 4) N 10 KB N N - -
*
* (VET, 5) N 5 KB N N - -
*
- * (VET, 6) N 10 KB N N - -
+ * (VET, 6) N 5 KB N N - -
*
- * (VET, 7) N 10 KB N N - -
+ * (VET, 7) N 5 KB N N - -
*
- * Start by updating the expected table for the expected changes in entry status:
+ * (VET, 8) N 10 KB N N - -
+ *
+ * (VET, 9) N 10 KB N N - -
+ *
+ * Start by updating the expected table for the expected changes in
+ * entry status:
*/
- expected[6].in_cache = FALSE;
- expected[6].is_dirty = FALSE;
- expected[6].flushed = TRUE;
- expected[6].destroyed = TRUE;
+ expected[8].in_cache = FALSE;
+ expected[8].is_dirty = FALSE;
+ expected[8].serialized = TRUE;
+ expected[8].destroyed = TRUE;
num_large_entries = 14;
@@ -10548,8 +10642,8 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
i < num_variable_entries + num_monster_entries + num_large_entries - 1;
i++ )
{
- expected[i].is_dirty = FALSE;
- expected[i].flushed = TRUE;
+ expected[i].is_dirty = FALSE;
+ expected[i].serialized = TRUE;
}
for ( i = 12; i < 14; i++ )
@@ -10570,6 +10664,12 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
failure_mssg = "unexpected size/len in flush op eviction test 13.";
}
+ /* modifications to the H5C__flush_single_entry() function have
+ * changed the behavior of the cache slightly, causing
+ * this test to fail. Comment out for now -- come back and
+ * fix if all goes well.
+ */
+
/* verify entry status */
verify_entry_status(cache_ptr,
11,
@@ -10585,8 +10685,7 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
if ( pass ) {
- result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT,
- H5C__FLUSH_INVALIDATE_FLAG);
+ result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5C__FLUSH_INVALIDATE_FLAG);
if ( result < 0 ) {
@@ -10616,23 +10715,24 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
if ( ( cache_ptr->insertions[VARIABLE_ENTRY_TYPE] != 0 ) ||
( cache_ptr->pinned_insertions[VARIABLE_ENTRY_TYPE] != 0 ) ||
( cache_ptr->clears[VARIABLE_ENTRY_TYPE] != 0 ) ||
- ( cache_ptr->flushes[VARIABLE_ENTRY_TYPE] != 14 ) ||
- ( cache_ptr->evictions[VARIABLE_ENTRY_TYPE] != 9 ) ||
+ ( cache_ptr->flushes[VARIABLE_ENTRY_TYPE] != 8 ) ||
+ ( cache_ptr->evictions[VARIABLE_ENTRY_TYPE] != 11 ) ||
+ ( cache_ptr->take_ownerships[VARIABLE_ENTRY_TYPE] != 0 ) ||
( cache_ptr->moves[VARIABLE_ENTRY_TYPE] != 1 ) ||
( cache_ptr->entry_flush_moves[VARIABLE_ENTRY_TYPE] != 0 ) ||
( cache_ptr->cache_flush_moves[VARIABLE_ENTRY_TYPE] != 0 ) ||
( cache_ptr->pins[VARIABLE_ENTRY_TYPE] != 2 ) ||
( cache_ptr->unpins[VARIABLE_ENTRY_TYPE] != 2 ) ||
- ( cache_ptr->dirty_pins[VARIABLE_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->dirty_pins[VARIABLE_ENTRY_TYPE] != 2 ) ||
( cache_ptr->pinned_flushes[VARIABLE_ENTRY_TYPE] != 0 ) ||
( cache_ptr->pinned_clears[VARIABLE_ENTRY_TYPE] != 0 ) ||
( cache_ptr->size_increases[VARIABLE_ENTRY_TYPE] != 3 ) ||
- ( cache_ptr->size_decreases[VARIABLE_ENTRY_TYPE] != 4 ) ||
+ ( cache_ptr->size_decreases[VARIABLE_ENTRY_TYPE] != 6 ) ||
( cache_ptr->entry_flush_size_changes[VARIABLE_ENTRY_TYPE] != 1 ) ||
( cache_ptr->cache_flush_size_changes[VARIABLE_ENTRY_TYPE] != 0 ) ) {
pass = FALSE;
- failure_mssg = "Unexpected variable size entry stats.";
+ failure_mssg = "Unexpected variable size entry stats in check_flush_cache__flush_op_eviction_test().";
}
}
@@ -10641,8 +10741,9 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
if ( ( cache_ptr->insertions[LARGE_ENTRY_TYPE] != 0 ) ||
( cache_ptr->pinned_insertions[LARGE_ENTRY_TYPE] != 0 ) ||
( cache_ptr->clears[LARGE_ENTRY_TYPE] != 0 ) ||
- ( cache_ptr->flushes[LARGE_ENTRY_TYPE] != 38 ) ||
+ ( cache_ptr->flushes[LARGE_ENTRY_TYPE] != 25 ) ||
( cache_ptr->evictions[LARGE_ENTRY_TYPE] != 14 ) ||
+ ( cache_ptr->take_ownerships[LARGE_ENTRY_TYPE] != 0 ) ||
( cache_ptr->moves[LARGE_ENTRY_TYPE] != 0 ) ||
( cache_ptr->entry_flush_moves[LARGE_ENTRY_TYPE] != 0 ) ||
( cache_ptr->cache_flush_moves[LARGE_ENTRY_TYPE] != 0 ) ||
@@ -10657,7 +10758,7 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
( cache_ptr->cache_flush_size_changes[LARGE_ENTRY_TYPE] != 0 ) ) {
pass = FALSE;
- failure_mssg = "Unexpected monster entry stats.";
+ failure_mssg = "Unexpected large entry stats in check_flush_cache__flush_op_eviction_test().";
}
}
@@ -10666,8 +10767,9 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
if ( ( cache_ptr->insertions[MONSTER_ENTRY_TYPE] != 0 ) ||
( cache_ptr->pinned_insertions[MONSTER_ENTRY_TYPE] != 0 ) ||
( cache_ptr->clears[MONSTER_ENTRY_TYPE] != 0 ) ||
- ( cache_ptr->flushes[MONSTER_ENTRY_TYPE] != 93 ) ||
- ( cache_ptr->evictions[MONSTER_ENTRY_TYPE] != 31 ) ||
+ ( cache_ptr->flushes[MONSTER_ENTRY_TYPE] != 62 ) ||
+ ( cache_ptr->evictions[MONSTER_ENTRY_TYPE] != 32 ) ||
+ ( cache_ptr->take_ownerships[MONSTER_ENTRY_TYPE] != 0 ) ||
( cache_ptr->moves[MONSTER_ENTRY_TYPE] != 0 ) ||
( cache_ptr->entry_flush_moves[MONSTER_ENTRY_TYPE] != 0 ) ||
( cache_ptr->cache_flush_moves[MONSTER_ENTRY_TYPE] != 0 ) ||
@@ -10682,7 +10784,7 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
( cache_ptr->cache_flush_size_changes[MONSTER_ENTRY_TYPE] != 0 ) ) {
pass = FALSE;
- failure_mssg = "Unexpected monster entry stats.";
+ failure_mssg = "Unexpected monster entry stats in check_flush_cache__flush_op_eviction_test().";
}
}
#endif /* H5C_COLLECT_CACHE_STATS */
@@ -10741,17 +10843,16 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 1,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ FALSE,
- /* flags */ H5C__NO_FLAGS_SET,
- /* flush_flags */ H5C__NO_FLAGS_SET,
- /* expected_loaded */ TRUE,
- /* expected_cleared */ FALSE,
- /* expected_flushed */ FALSE,
- /* expected_destroyed */ FALSE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 1,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ FALSE,
+ /* flags */ H5C__NO_FLAGS_SET,
+ /* flush_flags */ H5C__NO_FLAGS_SET,
+ /* expected_deserialized */ TRUE,
+ /* expected_serialized */ FALSE,
+ /* expected_destroyed */ FALSE
);
}
@@ -10759,17 +10860,16 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 2,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ FALSE,
- /* flags */ H5C__DIRTIED_FLAG,
- /* flush_flags */ H5C__NO_FLAGS_SET,
- /* expected_loaded */ TRUE,
- /* expected_cleared */ FALSE,
- /* expected_flushed */ TRUE,
- /* expected_destroyed */ FALSE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 2,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ FALSE,
+ /* flags */ H5C__DIRTIED_FLAG,
+ /* flush_flags */ H5C__NO_FLAGS_SET,
+ /* expected_deserialized */ TRUE,
+ /* expected_serialized */ TRUE,
+ /* expected_destroyed */ FALSE
);
}
@@ -10777,17 +10877,16 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 3,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ FALSE,
- /* flags */ H5C__NO_FLAGS_SET,
- /* flush_flags */ H5C__FLUSH_CLEAR_ONLY_FLAG,
- /* expected_loaded */ TRUE,
- /* expected_cleared */ FALSE,
- /* expected_flushed */ FALSE,
- /* expected_destroyed */ FALSE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 3,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ FALSE,
+ /* flags */ H5C__NO_FLAGS_SET,
+ /* flush_flags */ H5C__FLUSH_CLEAR_ONLY_FLAG,
+ /* expected_deserialized */ TRUE,
+ /* expected_serialized */ FALSE,
+ /* expected_destroyed */ FALSE
);
}
@@ -10795,17 +10894,16 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 4,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ FALSE,
- /* flags */ H5C__DIRTIED_FLAG,
- /* flush_flags */ H5C__FLUSH_CLEAR_ONLY_FLAG,
- /* expected_loaded */ TRUE,
- /* expected_cleared */ TRUE,
- /* expected_flushed */ FALSE,
- /* expected_destroyed */ FALSE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 4,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ FALSE,
+ /* flags */ H5C__DIRTIED_FLAG,
+ /* flush_flags */ H5C__FLUSH_CLEAR_ONLY_FLAG,
+ /* expected_deserialized */ TRUE,
+ /* expected_serialized */ FALSE,
+ /* expected_destroyed */ FALSE
);
}
@@ -10813,17 +10911,16 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 5,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ FALSE,
- /* flags */ H5C__NO_FLAGS_SET,
- /* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG,
- /* expected_loaded */ TRUE,
- /* expected_cleared */ FALSE,
- /* expected_flushed */ TRUE,
- /* expected_destroyed */ TRUE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 5,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ FALSE,
+ /* flags */ H5C__NO_FLAGS_SET,
+ /* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG,
+ /* expected_deserialized */ TRUE,
+ /* expected_serialized */ FALSE,
+ /* expected_destroyed */ TRUE
);
}
@@ -10831,17 +10928,16 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 6,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ FALSE,
- /* flags */ H5C__DIRTIED_FLAG,
- /* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG,
- /* expected_loaded */ TRUE,
- /* expected_cleared */ FALSE,
- /* expected_flushed */ TRUE,
- /* expected_destroyed */ TRUE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 6,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ FALSE,
+ /* flags */ H5C__DIRTIED_FLAG,
+ /* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG,
+ /* expected_deserialized */ TRUE,
+ /* expected_serialized */ TRUE,
+ /* expected_destroyed */ TRUE
);
}
@@ -10849,17 +10945,16 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 7,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ FALSE,
- /* flags */ H5C__NO_FLAGS_SET,
- /* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG,
- /* expected_loaded */ TRUE,
- /* expected_cleared */ FALSE,
- /* expected_flushed */ FALSE,
- /* expected_destroyed */ FALSE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 7,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ FALSE,
+ /* flags */ H5C__NO_FLAGS_SET,
+ /* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG,
+ /* expected_deserialized */ TRUE,
+ /* expected_serialized */ FALSE,
+ /* expected_destroyed */ FALSE
);
}
@@ -10867,17 +10962,16 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 8,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ FALSE,
- /* flags */ H5C__DIRTIED_FLAG,
- /* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG,
- /* expected_loaded */ TRUE,
- /* expected_cleared */ FALSE,
- /* expected_flushed */ FALSE,
- /* expected_destroyed */ FALSE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 8,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ FALSE,
+ /* flags */ H5C__DIRTIED_FLAG,
+ /* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG,
+ /* expected_deserialized */ TRUE,
+ /* expected_serialized */ FALSE,
+ /* expected_destroyed */ FALSE
);
}
@@ -10885,18 +10979,17 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 9,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ FALSE,
- /* flags */ H5C__NO_FLAGS_SET,
- /* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG |
- H5C__FLUSH_CLEAR_ONLY_FLAG,
- /* expected_loaded */ TRUE,
- /* expected_cleared */ TRUE,
- /* expected_flushed */ FALSE,
- /* expected_destroyed */ TRUE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 9,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ FALSE,
+ /* flags */ H5C__NO_FLAGS_SET,
+ /* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG |
+ H5C__FLUSH_CLEAR_ONLY_FLAG,
+ /* expected_deserialized */ TRUE,
+ /* expected_serialized */ FALSE,
+ /* expected_destroyed */ TRUE
);
}
@@ -10904,18 +10997,17 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 10,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ FALSE,
- /* flags */ H5C__DIRTIED_FLAG,
- /* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG |
- H5C__FLUSH_CLEAR_ONLY_FLAG,
- /* expected_loaded */ TRUE,
- /* expected_cleared */ TRUE,
- /* expected_flushed */ FALSE,
- /* expected_destroyed */ TRUE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 10,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ FALSE,
+ /* flags */ H5C__DIRTIED_FLAG,
+ /* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG |
+ H5C__FLUSH_CLEAR_ONLY_FLAG,
+ /* expected_deserialized */ TRUE,
+ /* expected_serialized */ FALSE,
+ /* expected_destroyed */ TRUE
);
}
@@ -10923,18 +11015,17 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 11,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ FALSE,
- /* flags */ H5C__NO_FLAGS_SET,
- /* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG |
- H5C__FLUSH_CLEAR_ONLY_FLAG,
- /* expected_loaded */ TRUE,
- /* expected_cleared */ FALSE,
- /* expected_flushed */ FALSE,
- /* expected_destroyed */ FALSE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 11,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ FALSE,
+ /* flags */ H5C__NO_FLAGS_SET,
+ /* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG |
+ H5C__FLUSH_CLEAR_ONLY_FLAG,
+ /* expected_deserialized */ TRUE,
+ /* expected_serialized */ FALSE,
+ /* expected_destroyed */ FALSE
);
}
@@ -10942,18 +11033,17 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 12,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ FALSE,
- /* flags */ H5C__DIRTIED_FLAG,
- /* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG |
- H5C__FLUSH_CLEAR_ONLY_FLAG,
- /* expected_loaded */ TRUE,
- /* expected_cleared */ FALSE,
- /* expected_flushed */ FALSE,
- /* expected_destroyed */ FALSE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 12,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ FALSE,
+ /* flags */ H5C__DIRTIED_FLAG,
+ /* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG |
+ H5C__FLUSH_CLEAR_ONLY_FLAG,
+ /* expected_deserialized */ TRUE,
+ /* expected_serialized */ FALSE,
+ /* expected_destroyed */ FALSE
);
}
@@ -10961,18 +11051,17 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 13,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ FALSE,
- /* flags */ H5C__NO_FLAGS_SET,
- /* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG |
- H5C__FLUSH_INVALIDATE_FLAG,
- /* expected_loaded */ TRUE,
- /* expected_cleared */ FALSE,
- /* expected_flushed */ TRUE,
- /* expected_destroyed */ TRUE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 13,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ FALSE,
+ /* flags */ H5C__NO_FLAGS_SET,
+ /* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG |
+ H5C__FLUSH_INVALIDATE_FLAG,
+ /* expected_deserialized */ TRUE,
+ /* expected_serialized */ FALSE,
+ /* expected_destroyed */ TRUE
);
}
@@ -10980,18 +11069,17 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 14,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ FALSE,
- /* flags */ H5C__DIRTIED_FLAG,
- /* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG |
- H5C__FLUSH_INVALIDATE_FLAG,
- /* expected_loaded */ TRUE,
- /* expected_cleared */ FALSE,
- /* expected_flushed */ TRUE,
- /* expected_destroyed */ TRUE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 14,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ FALSE,
+ /* flags */ H5C__DIRTIED_FLAG,
+ /* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG |
+ H5C__FLUSH_INVALIDATE_FLAG,
+ /* expected_deserialized */ TRUE,
+ /* expected_serialized */ TRUE,
+ /* expected_destroyed */ TRUE
);
}
@@ -10999,19 +11087,18 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 15,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ FALSE,
- /* flags */ H5C__NO_FLAGS_SET,
- /* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG |
- H5C__FLUSH_CLEAR_ONLY_FLAG |
- H5C__FLUSH_MARKED_ENTRIES_FLAG,
- /* expected_loaded */ TRUE,
- /* expected_cleared */ TRUE,
- /* expected_flushed */ FALSE,
- /* expected_destroyed */ TRUE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 15,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ FALSE,
+ /* flags */ H5C__NO_FLAGS_SET,
+ /* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG |
+ H5C__FLUSH_CLEAR_ONLY_FLAG |
+ H5C__FLUSH_MARKED_ENTRIES_FLAG,
+ /* expected_deserialized */ TRUE,
+ /* expected_serialized */ FALSE,
+ /* expected_destroyed */ TRUE
);
}
@@ -11019,19 +11106,18 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 16,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ FALSE,
- /* flags */ H5C__DIRTIED_FLAG,
- /* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG |
- H5C__FLUSH_CLEAR_ONLY_FLAG |
- H5C__FLUSH_MARKED_ENTRIES_FLAG,
- /* expected_loaded */ TRUE,
- /* expected_cleared */ TRUE,
- /* expected_flushed */ FALSE,
- /* expected_destroyed */ TRUE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 16,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ FALSE,
+ /* flags */ H5C__DIRTIED_FLAG,
+ /* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG |
+ H5C__FLUSH_CLEAR_ONLY_FLAG |
+ H5C__FLUSH_MARKED_ENTRIES_FLAG,
+ /* expected_deserialized */ TRUE,
+ /* expected_serialized */ FALSE,
+ /* expected_destroyed */ TRUE
);
}
@@ -11039,17 +11125,16 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 17,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ FALSE,
- /* flags */ H5C__SET_FLUSH_MARKER_FLAG,
- /* flush_flags */ H5C__NO_FLAGS_SET,
- /* expected_loaded */ TRUE,
- /* expected_cleared */ FALSE,
- /* expected_flushed */ FALSE,
- /* expected_destroyed */ FALSE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 17,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ FALSE,
+ /* flags */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* flush_flags */ H5C__NO_FLAGS_SET,
+ /* expected_deserialized */ TRUE,
+ /* expected_serialized */ FALSE,
+ /* expected_destroyed */ FALSE
);
}
@@ -11057,17 +11142,16 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 18,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ FALSE,
- /* flags */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
- /* flush_flags */ H5C__NO_FLAGS_SET,
- /* expected_loaded */ TRUE,
- /* expected_cleared */ FALSE,
- /* expected_flushed */ TRUE,
- /* expected_destroyed */ FALSE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 18,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ FALSE,
+ /* flags */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
+ /* flush_flags */ H5C__NO_FLAGS_SET,
+ /* expected_deserialized */ TRUE,
+ /* expected_serialized */ TRUE,
+ /* expected_destroyed */ FALSE
);
}
@@ -11075,17 +11159,16 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 19,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ FALSE,
- /* flags */ H5C__SET_FLUSH_MARKER_FLAG,
- /* flush_flags */ H5C__FLUSH_CLEAR_ONLY_FLAG,
- /* expected_loaded */ TRUE,
- /* expected_cleared */ FALSE,
- /* expected_flushed */ FALSE,
- /* expected_destroyed */ FALSE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 19,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ FALSE,
+ /* flags */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* flush_flags */ H5C__FLUSH_CLEAR_ONLY_FLAG,
+ /* expected_deserialized */ TRUE,
+ /* expected_serialized */ FALSE,
+ /* expected_destroyed */ FALSE
);
}
@@ -11093,17 +11176,16 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 20,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ FALSE,
- /* flags */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
- /* flush_flags */ H5C__FLUSH_CLEAR_ONLY_FLAG,
- /* expected_loaded */ TRUE,
- /* expected_cleared */ TRUE,
- /* expected_flushed */ FALSE,
- /* expected_destroyed */ FALSE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 20,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ FALSE,
+ /* flags */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
+ /* flush_flags */ H5C__FLUSH_CLEAR_ONLY_FLAG,
+ /* expected_deserialized */ TRUE,
+ /* expected_serialized */ FALSE,
+ /* expected_destroyed */ FALSE
);
}
@@ -11111,17 +11193,16 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 21,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ FALSE,
- /* flags */ H5C__SET_FLUSH_MARKER_FLAG,
- /* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG,
- /* expected_loaded */ TRUE,
- /* expected_cleared */ FALSE,
- /* expected_flushed */ TRUE,
- /* expected_destroyed */ TRUE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 21,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ FALSE,
+ /* flags */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG,
+ /* expected_deserialized */ TRUE,
+ /* expected_serialized */ FALSE,
+ /* expected_destroyed */ TRUE
);
}
@@ -11129,17 +11210,16 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 22,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ FALSE,
- /* flags */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
- /* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG,
- /* expected_loaded */ TRUE,
- /* expected_cleared */ FALSE,
- /* expected_flushed */ TRUE,
- /* expected_destroyed */ TRUE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 22,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ FALSE,
+ /* flags */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
+ /* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG,
+ /* expected_deserialized */ TRUE,
+ /* expected_serialized */ TRUE,
+ /* expected_destroyed */ TRUE
);
}
@@ -11147,17 +11227,16 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 23,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ FALSE,
- /* flags */ H5C__SET_FLUSH_MARKER_FLAG,
- /* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG,
- /* expected_loaded */ TRUE,
- /* expected_cleared */ FALSE,
- /* expected_flushed */ FALSE,
- /* expected_destroyed */ FALSE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 23,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ FALSE,
+ /* flags */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG,
+ /* expected_deserialized */ TRUE,
+ /* expected_serialized */ FALSE,
+ /* expected_destroyed */ FALSE
);
}
@@ -11165,17 +11244,16 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 24,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ FALSE,
- /* flags */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
- /* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG,
- /* expected_loaded */ TRUE,
- /* expected_cleared */ FALSE,
- /* expected_flushed */ TRUE,
- /* expected_destroyed */ FALSE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 24,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ FALSE,
+ /* flags */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
+ /* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG,
+ /* expected_deserialized */ TRUE,
+ /* expected_serialized */ TRUE,
+ /* expected_destroyed */ FALSE
);
}
@@ -11183,18 +11261,17 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 25,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ FALSE,
- /* flags */ H5C__SET_FLUSH_MARKER_FLAG,
- /* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG |
- H5C__FLUSH_CLEAR_ONLY_FLAG,
- /* expected_loaded */ TRUE,
- /* expected_cleared */ TRUE,
- /* expected_flushed */ FALSE,
- /* expected_destroyed */ TRUE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 25,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ FALSE,
+ /* flags */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG |
+ H5C__FLUSH_CLEAR_ONLY_FLAG,
+ /* expected_deserialized */ TRUE,
+ /* expected_serialized */ FALSE,
+ /* expected_destroyed */ TRUE
);
}
@@ -11202,18 +11279,17 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 26,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ FALSE,
- /* flags */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
- /* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG |
- H5C__FLUSH_CLEAR_ONLY_FLAG,
- /* expected_loaded */ TRUE,
- /* expected_cleared */ TRUE,
- /* expected_flushed */ FALSE,
- /* expected_destroyed */ TRUE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 26,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ FALSE,
+ /* flags */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
+ /* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG |
+ H5C__FLUSH_CLEAR_ONLY_FLAG,
+ /* expected_deserialized */ TRUE,
+ /* expected_serialized */ FALSE,
+ /* expected_destroyed */ TRUE
);
}
@@ -11221,18 +11297,17 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 27,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ FALSE,
- /* flags */ H5C__SET_FLUSH_MARKER_FLAG,
- /* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG |
- H5C__FLUSH_CLEAR_ONLY_FLAG,
- /* expected_loaded */ TRUE,
- /* expected_cleared */ FALSE,
- /* expected_flushed */ FALSE,
- /* expected_destroyed */ FALSE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 27,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ FALSE,
+ /* flags */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG |
+ H5C__FLUSH_CLEAR_ONLY_FLAG,
+ /* expected_deserialized */ TRUE,
+ /* expected_serialized */ FALSE,
+ /* expected_destroyed */ FALSE
);
}
@@ -11240,18 +11315,17 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 28,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ FALSE,
- /* flags */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
- /* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG |
- H5C__FLUSH_CLEAR_ONLY_FLAG,
- /* expected_loaded */ TRUE,
- /* expected_cleared */ TRUE,
- /* expected_flushed */ FALSE,
- /* expected_destroyed */ FALSE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 28,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ FALSE,
+ /* flags */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
+ /* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG |
+ H5C__FLUSH_CLEAR_ONLY_FLAG,
+ /* expected_deserialized */ TRUE,
+ /* expected_serialized */ FALSE,
+ /* expected_destroyed */ FALSE
);
}
@@ -11259,18 +11333,17 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 29,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ FALSE,
- /* flags */ H5C__SET_FLUSH_MARKER_FLAG,
- /* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG |
- H5C__FLUSH_INVALIDATE_FLAG,
- /* expected_loaded */ TRUE,
- /* expected_cleared */ FALSE,
- /* expected_flushed */ TRUE,
- /* expected_destroyed */ TRUE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 29,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ FALSE,
+ /* flags */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG |
+ H5C__FLUSH_INVALIDATE_FLAG,
+ /* expected_deserialized */ TRUE,
+ /* expected_serialized */ FALSE,
+ /* expected_destroyed */ TRUE
);
}
@@ -11278,18 +11351,17 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 30,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ FALSE,
- /* flags */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
- /* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG |
- H5C__FLUSH_INVALIDATE_FLAG,
- /* expected_loaded */ TRUE,
- /* expected_cleared */ FALSE,
- /* expected_flushed */ TRUE,
- /* expected_destroyed */ TRUE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 30,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ FALSE,
+ /* flags */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
+ /* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG |
+ H5C__FLUSH_INVALIDATE_FLAG,
+ /* expected_deserialized */ TRUE,
+ /* expected_serialized */ TRUE,
+ /* expected_destroyed */ TRUE
);
}
@@ -11297,19 +11369,18 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 31,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ FALSE,
- /* flags */ H5C__SET_FLUSH_MARKER_FLAG,
- /* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG |
- H5C__FLUSH_CLEAR_ONLY_FLAG |
- H5C__FLUSH_MARKED_ENTRIES_FLAG,
- /* expected_loaded */ TRUE,
- /* expected_cleared */ TRUE,
- /* expected_flushed */ FALSE,
- /* expected_destroyed */ TRUE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 31,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ FALSE,
+ /* flags */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG |
+ H5C__FLUSH_CLEAR_ONLY_FLAG |
+ H5C__FLUSH_MARKED_ENTRIES_FLAG,
+ /* expected_deserialized */ TRUE,
+ /* expected_serialized */ FALSE,
+ /* expected_destroyed */ TRUE
);
}
@@ -11317,19 +11388,18 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 32,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ FALSE,
- /* flags */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
- /* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG |
+ /* file_ptr */ file_ptr,
+ /* test_num */ 32,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ FALSE,
+ /* flags */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
+ /* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG |
H5C__FLUSH_CLEAR_ONLY_FLAG |
H5C__FLUSH_MARKED_ENTRIES_FLAG,
- /* expected_loaded */ TRUE,
- /* expected_cleared */ TRUE,
- /* expected_flushed */ FALSE,
- /* expected_destroyed */ TRUE
+ /* expected_deserialized */ TRUE,
+ /* expected_serialized */ FALSE,
+ /* expected_destroyed */ TRUE
);
}
@@ -11337,17 +11407,16 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 33,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ TRUE,
- /* flags */ H5C__NO_FLAGS_SET,
- /* flush_flags */ H5C__NO_FLAGS_SET,
- /* expected_loaded */ FALSE,
- /* expected_cleared */ FALSE,
- /* expected_flushed */ TRUE,
- /* expected_destroyed */ FALSE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 33,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ TRUE,
+ /* flags */ H5C__NO_FLAGS_SET,
+ /* flush_flags */ H5C__NO_FLAGS_SET,
+ /* expected_deserialized */ FALSE,
+ /* expected_serialized */ TRUE,
+ /* expected_destroyed */ FALSE
);
}
@@ -11355,17 +11424,16 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 34,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ TRUE,
- /* flags */ H5C__DIRTIED_FLAG,
- /* flush_flags */ H5C__NO_FLAGS_SET,
- /* expected_loaded */ FALSE,
- /* expected_cleared */ FALSE,
- /* expected_flushed */ TRUE,
- /* expected_destroyed */ FALSE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 34,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ TRUE,
+ /* flags */ H5C__NO_FLAGS_SET,
+ /* flush_flags */ H5C__NO_FLAGS_SET,
+ /* expected_deserialized */ FALSE,
+ /* expected_serialized */ TRUE,
+ /* expected_destroyed */ FALSE
);
}
@@ -11373,17 +11441,16 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 35,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ TRUE,
- /* flags */ H5C__NO_FLAGS_SET,
- /* flush_flags */ H5C__FLUSH_CLEAR_ONLY_FLAG,
- /* expected_loaded */ FALSE,
- /* expected_cleared */ TRUE,
- /* expected_flushed */ FALSE,
- /* expected_destroyed */ FALSE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 35,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ TRUE,
+ /* flags */ H5C__NO_FLAGS_SET,
+ /* flush_flags */ H5C__FLUSH_CLEAR_ONLY_FLAG,
+ /* expected_deserialized */ FALSE,
+ /* expected_serialized */ FALSE,
+ /* expected_destroyed */ FALSE
);
}
@@ -11391,17 +11458,16 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 36,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ TRUE,
- /* flags */ H5C__DIRTIED_FLAG,
- /* flush_flags */ H5C__FLUSH_CLEAR_ONLY_FLAG,
- /* expected_loaded */ FALSE,
- /* expected_cleared */ TRUE,
- /* expected_flushed */ FALSE,
- /* expected_destroyed */ FALSE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 36,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ TRUE,
+ /* flags */ H5C__NO_FLAGS_SET,
+ /* flush_flags */ H5C__FLUSH_CLEAR_ONLY_FLAG,
+ /* expected_deserialized */ FALSE,
+ /* expected_serialized */ FALSE,
+ /* expected_destroyed */ FALSE
);
}
@@ -11409,17 +11475,16 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 37,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ TRUE,
- /* flags */ H5C__NO_FLAGS_SET,
- /* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG,
- /* expected_loaded */ FALSE,
- /* expected_cleared */ FALSE,
- /* expected_flushed */ TRUE,
- /* expected_destroyed */ TRUE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 37,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ TRUE,
+ /* flags */ H5C__NO_FLAGS_SET,
+ /* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG,
+ /* expected_deserialized */ FALSE,
+ /* expected_serialized */ TRUE,
+ /* expected_destroyed */ TRUE
);
}
@@ -11427,17 +11492,16 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 38,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ TRUE,
- /* flags */ H5C__DIRTIED_FLAG,
- /* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG,
- /* expected_loaded */ FALSE,
- /* expected_cleared */ FALSE,
- /* expected_flushed */ TRUE,
- /* expected_destroyed */ TRUE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 38,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ TRUE,
+ /* flags */ H5C__NO_FLAGS_SET,
+ /* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG,
+ /* expected_deserialized */ FALSE,
+ /* expected_serialized */ TRUE,
+ /* expected_destroyed */ TRUE
);
}
@@ -11445,17 +11509,16 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 39,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ TRUE,
- /* flags */ H5C__NO_FLAGS_SET,
- /* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG,
- /* expected_loaded */ FALSE,
- /* expected_cleared */ FALSE,
- /* expected_flushed */ FALSE,
- /* expected_destroyed */ FALSE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 39,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ TRUE,
+ /* flags */ H5C__NO_FLAGS_SET,
+ /* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG,
+ /* expected_deserialized */ FALSE,
+ /* expected_serialized */ FALSE,
+ /* expected_destroyed */ FALSE
);
}
@@ -11463,17 +11526,16 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 40,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ TRUE,
- /* flags */ H5C__DIRTIED_FLAG,
- /* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG,
- /* expected_loaded */ FALSE,
- /* expected_cleared */ FALSE,
- /* expected_flushed */ FALSE,
- /* expected_destroyed */ FALSE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 40,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ TRUE,
+ /* flags */ H5C__NO_FLAGS_SET,
+ /* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG,
+ /* expected_deserialized */ FALSE,
+ /* expected_serialized */ FALSE,
+ /* expected_destroyed */ FALSE
);
}
@@ -11481,18 +11543,17 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 41,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ TRUE,
- /* flags */ H5C__NO_FLAGS_SET,
- /* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG |
- H5C__FLUSH_CLEAR_ONLY_FLAG,
- /* expected_loaded */ FALSE,
- /* expected_cleared */ TRUE,
- /* expected_flushed */ FALSE,
- /* expected_destroyed */ TRUE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 41,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ TRUE,
+ /* flags */ H5C__NO_FLAGS_SET,
+ /* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG |
+ H5C__FLUSH_CLEAR_ONLY_FLAG,
+ /* expected_deserialized */ FALSE,
+ /* expected_serialized */ FALSE,
+ /* expected_destroyed */ TRUE
);
}
@@ -11500,18 +11561,17 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 42,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ TRUE,
- /* flags */ H5C__DIRTIED_FLAG,
- /* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG |
- H5C__FLUSH_CLEAR_ONLY_FLAG,
- /* expected_loaded */ FALSE,
- /* expected_cleared */ TRUE,
- /* expected_flushed */ FALSE,
- /* expected_destroyed */ TRUE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 42,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ TRUE,
+ /* flags */ H5C__NO_FLAGS_SET,
+ /* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG |
+ H5C__FLUSH_CLEAR_ONLY_FLAG,
+ /* expected_deserialized */ FALSE,
+ /* expected_serialized */ FALSE,
+ /* expected_destroyed */ TRUE
);
}
@@ -11519,18 +11579,17 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 43,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ TRUE,
- /* flags */ H5C__NO_FLAGS_SET,
- /* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG |
- H5C__FLUSH_CLEAR_ONLY_FLAG,
- /* expected_loaded */ FALSE,
- /* expected_cleared */ FALSE,
- /* expected_flushed */ FALSE,
- /* expected_destroyed */ FALSE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 43,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ TRUE,
+ /* flags */ H5C__NO_FLAGS_SET,
+ /* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG |
+ H5C__FLUSH_CLEAR_ONLY_FLAG,
+ /* expected_deserialized */ FALSE,
+ /* expected_serialized */ FALSE,
+ /* expected_destroyed */ FALSE
);
}
@@ -11538,18 +11597,17 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 44,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ TRUE,
- /* flags */ H5C__DIRTIED_FLAG,
- /* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG |
- H5C__FLUSH_CLEAR_ONLY_FLAG,
- /* expected_loaded */ FALSE,
- /* expected_cleared */ FALSE,
- /* expected_flushed */ FALSE,
- /* expected_destroyed */ FALSE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 44,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ TRUE,
+ /* flags */ H5C__NO_FLAGS_SET,
+ /* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG |
+ H5C__FLUSH_CLEAR_ONLY_FLAG,
+ /* expected_deserialized */ FALSE,
+ /* expected_serialized */ FALSE,
+ /* expected_destroyed */ FALSE
);
}
@@ -11557,18 +11615,17 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 45,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ TRUE,
- /* flags */ H5C__NO_FLAGS_SET,
- /* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG |
- H5C__FLUSH_INVALIDATE_FLAG,
- /* expected_loaded */ FALSE,
- /* expected_cleared */ FALSE,
- /* expected_flushed */ TRUE,
- /* expected_destroyed */ TRUE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 45,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ TRUE,
+ /* flags */ H5C__NO_FLAGS_SET,
+ /* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG |
+ H5C__FLUSH_INVALIDATE_FLAG,
+ /* expected_deserialized */ FALSE,
+ /* expected_serialized */ TRUE,
+ /* expected_destroyed */ TRUE
);
}
@@ -11576,18 +11633,17 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 46,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ TRUE,
- /* flags */ H5C__DIRTIED_FLAG,
- /* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG |
- H5C__FLUSH_INVALIDATE_FLAG,
- /* expected_loaded */ FALSE,
- /* expected_cleared */ FALSE,
- /* expected_flushed */ TRUE,
- /* expected_destroyed */ TRUE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 46,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ TRUE,
+ /* flags */ H5C__NO_FLAGS_SET,
+ /* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG |
+ H5C__FLUSH_INVALIDATE_FLAG,
+ /* expected_deserialized */ FALSE,
+ /* expected_serialized */ TRUE,
+ /* expected_destroyed */ TRUE
);
}
@@ -11595,19 +11651,18 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 47,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ TRUE,
- /* flags */ H5C__NO_FLAGS_SET,
- /* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG |
- H5C__FLUSH_CLEAR_ONLY_FLAG |
- H5C__FLUSH_MARKED_ENTRIES_FLAG,
- /* expected_loaded */ FALSE,
- /* expected_cleared */ TRUE,
- /* expected_flushed */ FALSE,
- /* expected_destroyed */ TRUE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 47,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ TRUE,
+ /* flags */ H5C__NO_FLAGS_SET,
+ /* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG |
+ H5C__FLUSH_CLEAR_ONLY_FLAG |
+ H5C__FLUSH_MARKED_ENTRIES_FLAG,
+ /* expected_deserialized */ FALSE,
+ /* expected_serialized */ FALSE,
+ /* expected_destroyed */ TRUE
);
}
@@ -11615,19 +11670,18 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 48,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ TRUE,
- /* flags */ H5C__DIRTIED_FLAG,
- /* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG |
- H5C__FLUSH_CLEAR_ONLY_FLAG |
- H5C__FLUSH_MARKED_ENTRIES_FLAG,
- /* expected_loaded */ FALSE,
- /* expected_cleared */ TRUE,
- /* expected_flushed */ FALSE,
- /* expected_destroyed */ TRUE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 48,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ TRUE,
+ /* flags */ H5C__NO_FLAGS_SET,
+ /* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG |
+ H5C__FLUSH_CLEAR_ONLY_FLAG |
+ H5C__FLUSH_MARKED_ENTRIES_FLAG,
+ /* expected_deserialized */ FALSE,
+ /* expected_serialized */ FALSE,
+ /* expected_destroyed */ TRUE
);
}
@@ -11635,17 +11689,16 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 49,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ TRUE,
- /* flags */ H5C__SET_FLUSH_MARKER_FLAG,
- /* flush_flags */ H5C__NO_FLAGS_SET,
- /* expected_loaded */ FALSE,
- /* expected_cleared */ FALSE,
- /* expected_flushed */ TRUE,
- /* expected_destroyed */ FALSE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 49,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ TRUE,
+ /* flags */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* flush_flags */ H5C__NO_FLAGS_SET,
+ /* expected_deserialized */ FALSE,
+ /* expected_serialized */ TRUE,
+ /* expected_destroyed */ FALSE
);
}
@@ -11653,17 +11706,16 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 50,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ TRUE,
- /* flags */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
- /* flush_flags */ H5C__NO_FLAGS_SET,
- /* expected_loaded */ FALSE,
- /* expected_cleared */ FALSE,
- /* expected_flushed */ TRUE,
- /* expected_destroyed */ FALSE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 50,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ TRUE,
+ /* flags */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* flush_flags */ H5C__NO_FLAGS_SET,
+ /* expected_deserialized */ FALSE,
+ /* expected_serialized */ TRUE,
+ /* expected_destroyed */ FALSE
);
}
@@ -11671,17 +11723,16 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 51,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ TRUE,
- /* flags */ H5C__SET_FLUSH_MARKER_FLAG,
- /* flush_flags */ H5C__FLUSH_CLEAR_ONLY_FLAG,
- /* expected_loaded */ FALSE,
- /* expected_cleared */ TRUE,
- /* expected_flushed */ FALSE,
- /* expected_destroyed */ FALSE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 51,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ TRUE,
+ /* flags */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* flush_flags */ H5C__FLUSH_CLEAR_ONLY_FLAG,
+ /* expected_deserialized */ FALSE,
+ /* expected_serialized */ FALSE,
+ /* expected_destroyed */ FALSE
);
}
@@ -11689,17 +11740,16 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 52,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ TRUE,
- /* flags */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
- /* flush_flags */ H5C__FLUSH_CLEAR_ONLY_FLAG,
- /* expected_loaded */ FALSE,
- /* expected_cleared */ TRUE,
- /* expected_flushed */ FALSE,
- /* expected_destroyed */ FALSE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 52,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ TRUE,
+ /* flags */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* flush_flags */ H5C__FLUSH_CLEAR_ONLY_FLAG,
+ /* expected_deserialized */ FALSE,
+ /* expected_serialized */ FALSE,
+ /* expected_destroyed */ FALSE
);
}
@@ -11707,17 +11757,16 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 53,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ TRUE,
- /* flags */ H5C__SET_FLUSH_MARKER_FLAG,
- /* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG,
- /* expected_loaded */ FALSE,
- /* expected_cleared */ FALSE,
- /* expected_flushed */ TRUE,
- /* expected_destroyed */ TRUE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 53,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ TRUE,
+ /* flags */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG,
+ /* expected_deserialized */ FALSE,
+ /* expected_serialized */ TRUE,
+ /* expected_destroyed */ TRUE
);
}
@@ -11725,17 +11774,16 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 54,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ TRUE,
- /* flags */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
- /* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG,
- /* expected_loaded */ FALSE,
- /* expected_cleared */ FALSE,
- /* expected_flushed */ TRUE,
- /* expected_destroyed */ TRUE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 54,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ TRUE,
+ /* flags */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG,
+ /* expected_deserialized */ FALSE,
+ /* expected_serialized */ TRUE,
+ /* expected_destroyed */ TRUE
);
}
@@ -11743,17 +11791,16 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 55,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ TRUE,
- /* flags */ H5C__SET_FLUSH_MARKER_FLAG,
- /* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG,
- /* expected_loaded */ FALSE,
- /* expected_cleared */ FALSE,
- /* expected_flushed */ TRUE,
- /* expected_destroyed */ FALSE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 55,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ TRUE,
+ /* flags */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG,
+ /* expected_deserialized */ FALSE,
+ /* expected_serialized */ TRUE,
+ /* expected_destroyed */ FALSE
);
}
@@ -11761,17 +11808,16 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 56,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ TRUE,
- /* flags */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
- /* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG,
- /* expected_loaded */ FALSE,
- /* expected_cleared */ FALSE,
- /* expected_flushed */ TRUE,
- /* expected_destroyed */ FALSE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 56,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ TRUE,
+ /* flags */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG,
+ /* expected_deserialized */ FALSE,
+ /* expected_serialized */ TRUE,
+ /* expected_destroyed */ FALSE
);
}
@@ -11779,18 +11825,17 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 57,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ TRUE,
- /* flags */ H5C__SET_FLUSH_MARKER_FLAG,
- /* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG |
- H5C__FLUSH_CLEAR_ONLY_FLAG,
- /* expected_loaded */ FALSE,
- /* expected_cleared */ TRUE,
- /* expected_flushed */ FALSE,
- /* expected_destroyed */ TRUE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 57,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ TRUE,
+ /* flags */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG |
+ H5C__FLUSH_CLEAR_ONLY_FLAG,
+ /* expected_deserialized */ FALSE,
+ /* expected_serialized */ FALSE,
+ /* expected_destroyed */ TRUE
);
}
@@ -11798,18 +11843,17 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 58,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ TRUE,
- /* flags */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
- /* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG |
- H5C__FLUSH_CLEAR_ONLY_FLAG,
- /* expected_loaded */ FALSE,
- /* expected_cleared */ TRUE,
- /* expected_flushed */ FALSE,
- /* expected_destroyed */ TRUE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 58,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ TRUE,
+ /* flags */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG |
+ H5C__FLUSH_CLEAR_ONLY_FLAG,
+ /* expected_deserialized */ FALSE,
+ /* expected_serialized */ FALSE,
+ /* expected_destroyed */ TRUE
);
}
@@ -11817,18 +11861,17 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 59,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ TRUE,
- /* flags */ H5C__SET_FLUSH_MARKER_FLAG,
- /* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG |
- H5C__FLUSH_CLEAR_ONLY_FLAG,
- /* expected_loaded */ FALSE,
- /* expected_cleared */ TRUE,
- /* expected_flushed */ FALSE,
- /* expected_destroyed */ FALSE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 59,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ TRUE,
+ /* flags */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG |
+ H5C__FLUSH_CLEAR_ONLY_FLAG,
+ /* expected_deserialized */ FALSE,
+ /* expected_serialized */ FALSE,
+ /* expected_destroyed */ FALSE
);
}
@@ -11836,18 +11879,17 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 60,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ TRUE,
- /* flags */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
- /* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG |
- H5C__FLUSH_CLEAR_ONLY_FLAG,
- /* expected_loaded */ FALSE,
- /* expected_cleared */ TRUE,
- /* expected_flushed */ FALSE,
- /* expected_destroyed */ FALSE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 60,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ TRUE,
+ /* flags */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG |
+ H5C__FLUSH_CLEAR_ONLY_FLAG,
+ /* expected_deserialized */ FALSE,
+ /* expected_serialized */ FALSE,
+ /* expected_destroyed */ FALSE
);
}
@@ -11855,18 +11897,17 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 61,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ TRUE,
- /* flags */ H5C__SET_FLUSH_MARKER_FLAG,
- /* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG |
- H5C__FLUSH_INVALIDATE_FLAG,
- /* expected_loaded */ FALSE,
- /* expected_cleared */ FALSE,
- /* expected_flushed */ TRUE,
- /* expected_destroyed */ TRUE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 61,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ TRUE,
+ /* flags */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG |
+ H5C__FLUSH_INVALIDATE_FLAG,
+ /* expected_deserialized */ FALSE,
+ /* expected_serialized */ TRUE,
+ /* expected_destroyed */ TRUE
);
}
@@ -11874,18 +11915,17 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 62,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ TRUE,
- /* flags */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
- /* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG |
- H5C__FLUSH_INVALIDATE_FLAG,
- /* expected_loaded */ FALSE,
- /* expected_cleared */ FALSE,
- /* expected_flushed */ TRUE,
- /* expected_destroyed */ TRUE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 62,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ TRUE,
+ /* flags */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* flush_flags */ H5C__FLUSH_MARKED_ENTRIES_FLAG |
+ H5C__FLUSH_INVALIDATE_FLAG,
+ /* expected_deserialized */ FALSE,
+ /* expected_serialized */ TRUE,
+ /* expected_destroyed */ TRUE
);
}
@@ -11893,19 +11933,18 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 63,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ TRUE,
- /* flags */ H5C__SET_FLUSH_MARKER_FLAG,
- /* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG |
- H5C__FLUSH_CLEAR_ONLY_FLAG |
- H5C__FLUSH_MARKED_ENTRIES_FLAG,
- /* expected_loaded */ FALSE,
- /* expected_cleared */ TRUE,
- /* expected_flushed */ FALSE,
- /* expected_destroyed */ TRUE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 63,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ TRUE,
+ /* flags */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG |
+ H5C__FLUSH_CLEAR_ONLY_FLAG |
+ H5C__FLUSH_MARKED_ENTRIES_FLAG,
+ /* expected_deserialized */ FALSE,
+ /* expected_serialized */ FALSE,
+ /* expected_destroyed */ TRUE
);
}
@@ -11913,19 +11952,18 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
check_flush_cache__single_entry_test
(
- /* file_ptr */ file_ptr,
- /* test_num */ 64,
- /* entry_type */ PICO_ENTRY_TYPE,
- /* entry_idx */ 0,
- /* insert_flag */ TRUE,
- /* flags */ H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG,
- /* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG |
- H5C__FLUSH_CLEAR_ONLY_FLAG |
- H5C__FLUSH_MARKED_ENTRIES_FLAG,
- /* expected_loaded */ FALSE,
- /* expected_cleared */ TRUE,
- /* expected_flushed */ FALSE,
- /* expected_destroyed */ TRUE
+ /* file_ptr */ file_ptr,
+ /* test_num */ 64,
+ /* entry_type */ PICO_ENTRY_TYPE,
+ /* entry_idx */ 0,
+ /* insert_flag */ TRUE,
+ /* flags */ H5C__SET_FLUSH_MARKER_FLAG,
+ /* flush_flags */ H5C__FLUSH_INVALIDATE_FLAG |
+ H5C__FLUSH_CLEAR_ONLY_FLAG |
+ H5C__FLUSH_MARKED_ENTRIES_FLAG,
+ /* expected_deserialized */ FALSE,
+ /* expected_serialized */ FALSE,
+ /* expected_destroyed */ TRUE
);
}
@@ -11953,14 +11991,13 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
* This yields a total of 256 tests.
*
* The tests and their expected results are given in the spec table
- * below. The values assigned to the expected_cleared, expected_flushed,
+ * below. The values assigned to the expected_serialized,
* and expected_destroyed fields are somewhat arcane, so the following
* overview may be useful.
*
* In addition to simply checking to see if the test case runs,
* we also check to see if the desired operations take place on the
- * cache entry. Thus expected_cleared is set to TRUE if we expect
- * the entry to be flushed, expected_flushed is set to TRUE if we
+ * cache entry. Thus expected_serialized is set to TRUE if we
* we expect the entry to be flushed, and expected_destroyed is set
* to TRUE if we expect the entry to be destroyed.
*
@@ -11998,277 +12035,277 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
int test_num;
int entry_type;
int entry_idx;
+ hbool_t dirty_flag;
hbool_t mark_dirty;
hbool_t pop_mark_dirty_prot;
hbool_t pop_mark_dirty_pinned;
hbool_t unprotect_unpin;
unsigned int flags;
unsigned int flush_flags;
- hbool_t expected_cleared;
- hbool_t expected_flushed;
+ hbool_t expected_serialized;
hbool_t expected_destroyed;
} spec[256] =
- /* pop pop
- * ent mark mark
- * test entry -ry mark dirty dirty unprot flush expect expect expect
- * num type idx dirty prot pinned unpin flags flags clear flush destroy
+ /* pop pop
+ * ent unprot mark mark
+ * test entry -ry dirty mark dirty dirty unprot flush expect expect
+ * num type idx flag dirty prot pinned unpin flags flags srlzd destroy
*/
- { { 1, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, FALSE, FALSE, FALSE },
- { 2, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, FALSE, FALSE, FALSE },
- { 3, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 4, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 5, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 6, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 7, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 8, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 9, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 10, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 11, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 12, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 13, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 14, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 15, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 16, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 17, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, FALSE, H5C__DIRTIED_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 18, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, TRUE, H5C__DIRTIED_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 19, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, FALSE, H5C__DIRTIED_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 20, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, TRUE, H5C__DIRTIED_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 21, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, FALSE, H5C__DIRTIED_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 22, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, TRUE, H5C__DIRTIED_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 23, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, FALSE, H5C__DIRTIED_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 24, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, TRUE, H5C__DIRTIED_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 25, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, FALSE, H5C__DIRTIED_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 26, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, TRUE, H5C__DIRTIED_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 27, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, FALSE, H5C__DIRTIED_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 28, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, TRUE, H5C__DIRTIED_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 29, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, FALSE, H5C__DIRTIED_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 30, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, TRUE, H5C__DIRTIED_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 31, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, FALSE, H5C__DIRTIED_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 32, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, TRUE, H5C__DIRTIED_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 33, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, FALSE, FALSE },
- { 34, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, FALSE, FALSE },
- { 35, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 36, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 37, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 38, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 39, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 40, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 41, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 42, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 43, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 44, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 45, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 46, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 47, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 48, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 49, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, FALSE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 50, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, TRUE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 51, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, FALSE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 52, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, TRUE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 53, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, FALSE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 54, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, TRUE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 55, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, FALSE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 56, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, TRUE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 57, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, FALSE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 58, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, TRUE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 59, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, FALSE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 60, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, TRUE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 61, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, FALSE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 62, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, TRUE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 63, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, FALSE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 64, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, TRUE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, TRUE, FALSE },
- { 65, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
- { 66, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
- { 67, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
- { 68, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
- { 69, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
- { 70, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
- { 71, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
- { 72, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
- { 73, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
- { 74, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
- { 75, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
- { 76, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
- { 77, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
- { 78, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
- { 79, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
- { 80, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
- { 81, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, FALSE, H5C__DIRTIED_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
- { 82, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, TRUE, H5C__DIRTIED_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
- { 83, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, FALSE, H5C__DIRTIED_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
- { 84, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, TRUE, H5C__DIRTIED_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
- { 85, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, FALSE, H5C__DIRTIED_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
- { 86, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, TRUE, H5C__DIRTIED_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
- { 87, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, FALSE, H5C__DIRTIED_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
- { 88, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, TRUE, H5C__DIRTIED_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
- { 89, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, FALSE, H5C__DIRTIED_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
- { 90, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, TRUE, H5C__DIRTIED_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
- { 91, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, FALSE, H5C__DIRTIED_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
- { 92, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, TRUE, H5C__DIRTIED_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
- { 93, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, FALSE, H5C__DIRTIED_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
- { 94, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, TRUE, H5C__DIRTIED_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
- { 95, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, FALSE, H5C__DIRTIED_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
- { 96, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, TRUE, H5C__DIRTIED_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
- { 97, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
- { 98, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
- { 99, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
- { 100, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
- { 101, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, TRUE, FALSE },
- { 102, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, TRUE, FALSE },
- { 103, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, TRUE, FALSE },
- { 104, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, TRUE, FALSE },
- { 105, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
- { 106, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
- { 107, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
- { 108, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE, FALSE },
- { 109, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, TRUE, FALSE },
- { 110, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, TRUE, FALSE },
- { 111, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, TRUE, FALSE },
- { 112, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, TRUE, FALSE },
- { 113, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, FALSE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, TRUE, FALSE },
- { 114, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, TRUE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, TRUE, FALSE },
- { 115, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, FALSE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, TRUE, FALSE },
- { 116, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, TRUE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, TRUE, FALSE },
- { 117, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, FALSE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, TRUE, FALSE },
- { 118, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, TRUE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, TRUE, FALSE },
- { 119, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, FALSE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, TRUE, FALSE },
- { 120, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, TRUE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, TRUE, FALSE },
- { 121, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, FALSE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, TRUE, FALSE },
- { 122, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, TRUE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, TRUE, FALSE },
- { 123, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, FALSE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, TRUE, FALSE },
- { 124, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, TRUE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, TRUE, FALSE },
- { 125, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, FALSE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, TRUE, FALSE },
- { 126, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, TRUE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, TRUE, FALSE },
- { 127, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, FALSE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, TRUE, FALSE },
- { 128, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, TRUE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, TRUE, FALSE },
- { 129, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
- { 130, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
- { 131, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 132, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 133, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 134, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 135, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 136, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 137, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 138, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 139, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 140, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 141, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 142, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 143, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 144, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 145, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, FALSE, H5C__DIRTIED_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 146, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, TRUE, H5C__DIRTIED_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 147, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, FALSE, H5C__DIRTIED_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 148, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, TRUE, H5C__DIRTIED_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 149, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, FALSE, H5C__DIRTIED_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 150, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, TRUE, H5C__DIRTIED_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 151, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, FALSE, H5C__DIRTIED_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 152, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, TRUE, H5C__DIRTIED_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 153, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, FALSE, H5C__DIRTIED_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 154, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, TRUE, H5C__DIRTIED_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 155, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, FALSE, H5C__DIRTIED_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 156, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, TRUE, H5C__DIRTIED_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 157, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, FALSE, H5C__DIRTIED_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 158, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, TRUE, H5C__DIRTIED_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 159, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, FALSE, H5C__DIRTIED_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 160, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, TRUE, H5C__DIRTIED_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 161, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
- { 162, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
- { 163, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 164, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 165, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 166, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 167, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 168, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 169, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 170, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 171, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 172, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 173, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 174, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 175, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 176, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 177, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, FALSE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 178, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, TRUE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 179, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, FALSE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 180, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, TRUE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 181, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, FALSE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 182, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, TRUE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 183, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, FALSE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 184, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, TRUE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 185, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, FALSE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 186, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, TRUE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 187, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, FALSE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 188, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, TRUE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 189, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, FALSE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 190, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, TRUE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 191, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, FALSE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 192, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, TRUE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 193, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
- { 194, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
- { 195, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
- { 196, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
- { 197, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
- { 198, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
- { 199, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
- { 200, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
- { 201, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
- { 202, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
- { 203, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
- { 204, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
- { 205, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
- { 206, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
- { 207, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
- { 208, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
- { 209, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, FALSE, H5C__DIRTIED_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
- { 210, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, TRUE, H5C__DIRTIED_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
- { 211, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, FALSE, H5C__DIRTIED_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
- { 212, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, TRUE, H5C__DIRTIED_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
- { 213, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, FALSE, H5C__DIRTIED_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
- { 214, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, TRUE, H5C__DIRTIED_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
- { 215, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, FALSE, H5C__DIRTIED_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
- { 216, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, TRUE, H5C__DIRTIED_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
- { 217, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, FALSE, H5C__DIRTIED_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
- { 218, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, TRUE, H5C__DIRTIED_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
- { 219, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, FALSE, H5C__DIRTIED_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
- { 220, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, TRUE, H5C__DIRTIED_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
- { 221, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, FALSE, H5C__DIRTIED_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
- { 222, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, TRUE, H5C__DIRTIED_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
- { 223, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, FALSE, H5C__DIRTIED_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
- { 224, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, TRUE, H5C__DIRTIED_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
- { 225, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
- { 226, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
- { 227, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
- { 228, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
- { 229, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 230, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 231, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 232, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 233, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
- { 234, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
- { 235, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
- { 236, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE, FALSE },
- { 237, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 238, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 239, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 240, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 241, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, FALSE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 242, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, TRUE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 243, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, FALSE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 244, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, TRUE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 245, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, FALSE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 246, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, TRUE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 247, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, FALSE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 248, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, TRUE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 249, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, FALSE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 250, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, TRUE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 251, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, FALSE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 252, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, TRUE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 253, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, FALSE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 254, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, TRUE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 255, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, FALSE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE },
- { 256, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, TRUE, H5C__DIRTIED_FLAG | H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, TRUE, FALSE, FALSE } };
+ { { 1, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, FALSE, FALSE },
+ { 2, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, FALSE, FALSE },
+ { 3, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 4, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 5, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 6, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 7, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 8, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 9, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 10, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 11, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 12, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 13, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 14, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 15, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 16, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 17, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 18, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 19, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 20, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 21, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 22, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 23, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 24, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 25, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 26, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 27, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 28, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 29, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 30, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 31, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 32, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 33, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, FALSE },
+ { 34, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, FALSE, FALSE },
+ { 35, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 36, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 37, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 38, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 39, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 40, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 41, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 42, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 43, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 44, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 45, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 46, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 47, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 48, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 49, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 50, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 51, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 52, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 53, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 54, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 55, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 56, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 57, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 58, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 59, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 60, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 61, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 62, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 63, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 64, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__NO_FLAGS_SET, TRUE, FALSE },
+ { 65, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE },
+ { 66, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE },
+ { 67, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE },
+ { 68, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE },
+ { 69, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE },
+ { 70, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE },
+ { 71, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE },
+ { 72, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE },
+ { 73, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE },
+ { 74, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE },
+ { 75, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE },
+ { 76, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE },
+ { 77, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE },
+ { 78, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE },
+ { 79, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE },
+ { 80, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE },
+ { 81, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE },
+ { 82, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE },
+ { 83, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE },
+ { 84, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE },
+ { 85, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE },
+ { 86, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE },
+ { 87, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE },
+ { 88, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE },
+ { 89, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE },
+ { 90, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE },
+ { 91, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE },
+ { 92, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE },
+ { 93, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE },
+ { 94, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE },
+ { 95, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE },
+ { 96, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE },
+ { 97, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE },
+ { 98, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE },
+ { 99, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE },
+ { 100, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE },
+ { 101, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, TRUE, FALSE },
+ { 102, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, TRUE, FALSE },
+ { 103, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, TRUE, FALSE },
+ { 104, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, TRUE, FALSE },
+ { 105, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE },
+ { 106, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE },
+ { 107, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE },
+ { 108, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, FALSE, FALSE },
+ { 109, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, TRUE, FALSE },
+ { 110, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, TRUE, FALSE },
+ { 111, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, TRUE, FALSE },
+ { 112, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, TRUE, FALSE },
+ { 113, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, TRUE, FALSE },
+ { 114, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, TRUE, FALSE },
+ { 115, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, TRUE, FALSE },
+ { 116, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, TRUE, FALSE },
+ { 117, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, TRUE, FALSE },
+ { 118, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, TRUE, FALSE },
+ { 119, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, TRUE, FALSE },
+ { 120, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, TRUE, FALSE },
+ { 121, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, TRUE, FALSE },
+ { 122, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, TRUE, FALSE },
+ { 123, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, TRUE, FALSE },
+ { 124, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, TRUE, FALSE },
+ { 125, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, TRUE, FALSE },
+ { 126, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, TRUE, FALSE },
+ { 127, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, TRUE, FALSE },
+ { 128, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG, TRUE, FALSE },
+ { 129, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 130, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 131, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 132, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 133, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 134, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 135, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 136, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 137, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 138, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 139, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 140, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 141, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 142, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 143, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 144, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 145, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 146, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 147, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 148, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 149, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 150, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 151, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 152, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 153, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 154, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 155, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 156, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 157, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 158, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 159, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 160, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 161, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 162, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 163, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 164, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 165, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 166, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 167, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 168, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 169, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 170, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 171, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 172, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 173, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 174, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 175, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 176, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 177, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 178, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 179, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 180, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 181, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 182, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 183, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 184, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 185, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 186, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 187, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 188, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 189, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 190, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 191, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 192, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 193, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 194, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 195, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 196, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 197, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 198, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 199, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 200, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 201, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 202, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 203, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 204, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 205, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 206, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 207, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 208, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 209, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 210, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 211, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 212, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 213, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 214, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 215, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 216, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 217, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 218, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 219, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 220, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 221, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, FALSE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 222, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, FALSE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 223, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, TRUE, FALSE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 224, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, TRUE, TRUE, H5C__NO_FLAGS_SET, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 225, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 226, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 227, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 228, PICO_ENTRY_TYPE, 0, FALSE, FALSE, FALSE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 229, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 230, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 231, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 232, PICO_ENTRY_TYPE, 0, FALSE, FALSE, TRUE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 233, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 234, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 235, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 236, PICO_ENTRY_TYPE, 0, FALSE, TRUE, FALSE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 237, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 238, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 239, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 240, PICO_ENTRY_TYPE, 0, FALSE, TRUE, TRUE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 241, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 242, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 243, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 244, PICO_ENTRY_TYPE, 0, TRUE, FALSE, FALSE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 245, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 246, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 247, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 248, PICO_ENTRY_TYPE, 0, TRUE, FALSE, TRUE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 249, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 250, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 251, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 252, PICO_ENTRY_TYPE, 0, TRUE, TRUE, FALSE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 253, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, FALSE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 254, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, FALSE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 255, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, TRUE, FALSE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE },
+ { 256, PICO_ENTRY_TYPE, 0, TRUE, TRUE, TRUE, TRUE, TRUE, H5C__SET_FLUSH_MARKER_FLAG, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_CLEAR_ONLY_FLAG, FALSE, FALSE } };
i = 0;
while ( ( pass ) && ( i < 256 ) )
@@ -12279,14 +12316,14 @@ check_flush_cache__single_entry(H5F_t * file_ptr)
/* test_num */ spec[i].test_num,
/* entry_type */ spec[i].entry_type,
/* entry_idx */ spec[i].entry_idx,
+ /* dirty_flag */ spec[i].dirty_flag,
/* mark_dirty */ spec[i].mark_dirty,
/* pop_mark_dirty_prot */ spec[i].pop_mark_dirty_prot,
/* pop_mark_dirty_pinned */ spec[i].pop_mark_dirty_pinned,
/* unprotect_unpin */ spec[i].unprotect_unpin,
/* flags */ spec[i].flags,
/* flush_flags */ spec[i].flush_flags,
- /* expected_cleared */ spec[i].expected_cleared,
- /* expected_flushed */ spec[i].expected_flushed,
+ /* expected_serialized */ spec[i].expected_serialized,
/* expected_destroyed */ spec[i].expected_destroyed
);
i++;
@@ -12321,9 +12358,8 @@ check_flush_cache__single_entry_test(H5F_t * file_ptr,
hbool_t insert_flag,
unsigned int flags,
unsigned int flush_flags,
- hbool_t expected_loaded,
- hbool_t expected_cleared,
- hbool_t expected_flushed,
+ hbool_t expected_deserialized,
+ hbool_t expected_serialized,
hbool_t expected_destroyed)
{
H5C_t * cache_ptr = file_ptr->shared->cache;
@@ -12378,7 +12414,7 @@ check_flush_cache__single_entry_test(H5F_t * file_ptr,
if ( pass ) {
- result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT, flush_flags);
+ result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, flush_flags);
if ( result < 0 ) {
@@ -12388,21 +12424,17 @@ check_flush_cache__single_entry_test(H5F_t * file_ptr,
flush_flags, test_num);
failure_mssg = msg;
}
- else if ( ( entry_ptr->loaded != expected_loaded ) ||
- ( entry_ptr->cleared != expected_cleared ) ||
- ( entry_ptr->flushed != expected_flushed ) ||
+ else if ( ( entry_ptr->deserialized != expected_deserialized ) ||
+ ( entry_ptr->serialized != expected_serialized ) ||
( entry_ptr->destroyed != expected_destroyed ) ) {
-
#if 0 /* This is useful debugging code -- lets keep it for a while */
HDfprintf(stdout,
- "loaded = %d(%d), clrd = %d(%d), flshd = %d(%d), dest = %d(%d)\n",
- (int)(entry_ptr->loaded),
- (int)expected_loaded,
- (int)(entry_ptr->cleared),
- (int)expected_cleared,
- (int)(entry_ptr->flushed),
- (int)expected_flushed,
+ "desrlzd = %d(%d), srlzd = %d(%d), dest = %d(%d)\n",
+ (int)(entry_ptr->deserialized),
+ (int)expected_deserialized,
+ (int)(entry_ptr->serialized),
+ (int)expected_serialized,
(int)(entry_ptr->destroyed),
(int)expected_destroyed);
#endif
@@ -12441,8 +12473,7 @@ check_flush_cache__single_entry_test(H5F_t * file_ptr,
/* clean up the cache to prep for the next test */
if ( pass ) {
- result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT,
- H5C__FLUSH_INVALIDATE_FLAG);
+ result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5C__FLUSH_INVALIDATE_FLAG);
if ( result < 0 ) {
@@ -12463,10 +12494,9 @@ check_flush_cache__single_entry_test(H5F_t * file_ptr,
} else {
- entry_ptr->loaded = FALSE;
- entry_ptr->cleared = FALSE;
- entry_ptr->flushed = FALSE;
- entry_ptr->destroyed = FALSE;
+ entry_ptr->deserialized = FALSE;
+ entry_ptr->serialized = FALSE;
+ entry_ptr->destroyed = FALSE;
}
}
@@ -12503,19 +12533,19 @@ check_flush_cache__pinned_single_entry_test(H5F_t * file_ptr,
int test_num,
int entry_type,
int entry_idx,
+ hbool_t unprot_dirty_flag,
hbool_t mark_dirty,
hbool_t pop_mark_dirty_prot,
hbool_t pop_mark_dirty_pinned,
hbool_t unprotect_unpin,
unsigned int flags,
unsigned int flush_flags,
- hbool_t expected_cleared,
- hbool_t expected_flushed,
+ hbool_t expected_serialized,
hbool_t expected_destroyed)
{
H5C_t * cache_ptr = file_ptr->shared->cache;
static char msg[128];
- hbool_t expected_loaded = TRUE;
+ hbool_t expected_deserialized = TRUE;
herr_t result;
test_entry_t * base_addr;
test_entry_t * entry_ptr = NULL;
@@ -12559,7 +12589,9 @@ check_flush_cache__pinned_single_entry_test(H5F_t * file_ptr,
mark_entry_dirty(entry_type, entry_idx);
}
- unprotect_entry(file_ptr, entry_type, entry_idx, (flags | H5C__PIN_ENTRY_FLAG));
+ unprotect_entry(file_ptr, entry_type, entry_idx,
+ (unprot_dirty_flag ? H5C__DIRTIED_FLAG : H5C__NO_FLAGS_SET) |
+ (flags | H5C__PIN_ENTRY_FLAG));
if ( mark_dirty ) {
@@ -12574,8 +12606,7 @@ check_flush_cache__pinned_single_entry_test(H5F_t * file_ptr,
if ( pass ) {
- result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT,
- flush_flags);
+ result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, flush_flags);
if ( result < 0 ) {
@@ -12585,19 +12616,16 @@ check_flush_cache__pinned_single_entry_test(H5F_t * file_ptr,
flush_flags, test_num);
failure_mssg = msg;
}
- else if ( ( entry_ptr->loaded != expected_loaded ) ||
- ( entry_ptr->cleared != expected_cleared ) ||
- ( entry_ptr->flushed != expected_flushed ) ||
+ else if ( ( entry_ptr->deserialized != expected_deserialized ) ||
+ ( entry_ptr->serialized != expected_serialized ) ||
( entry_ptr->destroyed != expected_destroyed ) ) {
#if 0 /* this is useful debugging code -- keep it around */
HDfprintf(stdout,
- "loaded = %d(%d), clrd = %d(%d), flshd = %d(%d), dest = %d(%d)\n",
- (int)(entry_ptr->loaded),
- (int)expected_loaded,
- (int)(entry_ptr->cleared),
- (int)expected_cleared,
- (int)(entry_ptr->flushed),
- (int)expected_flushed,
+ "desrlzd = %d(%d), srlzd = %d(%d), dest = %d(%d)\n",
+ (int)(entry_ptr->deserialized),
+ (int)expected_deserialized,
+ (int)(entry_ptr->serialized),
+ (int)expected_serialized,
(int)(entry_ptr->destroyed),
(int)expected_destroyed);
#endif
@@ -12641,7 +12669,8 @@ check_flush_cache__pinned_single_entry_test(H5F_t * file_ptr,
protect_entry(file_ptr, entry_type, entry_idx);
unprotect_entry(file_ptr, entry_type, entry_idx,
- (flags & H5C__DIRTIED_FLAG) | H5C__UNPIN_ENTRY_FLAG);
+ (unprot_dirty_flag ? H5C__DIRTIED_FLAG : H5C__NO_FLAGS_SET) |
+ H5C__UNPIN_ENTRY_FLAG);
} else {
@@ -12652,8 +12681,7 @@ check_flush_cache__pinned_single_entry_test(H5F_t * file_ptr,
if ( pass ) {
- result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT,
- H5C__FLUSH_INVALIDATE_FLAG);
+ result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5C__FLUSH_INVALIDATE_FLAG);
if ( result < 0 ) {
@@ -12674,10 +12702,9 @@ check_flush_cache__pinned_single_entry_test(H5F_t * file_ptr,
} else {
- entry_ptr->loaded = FALSE;
- entry_ptr->cleared = FALSE;
- entry_ptr->flushed = FALSE;
- entry_ptr->destroyed = FALSE;
+ entry_ptr->deserialized = FALSE;
+ entry_ptr->serialized = FALSE;
+ entry_ptr->destroyed = FALSE;
}
}
@@ -12982,9 +13009,8 @@ check_expunge_entry(void)
HDsnprintf(msg, (size_t)128, "Unexpected status 1.");
failure_mssg = msg;
- } else if ( ( entry_ptr->loaded ) ||
- ( entry_ptr->cleared ) ||
- ( entry_ptr->flushed ) ||
+ } else if ( ( entry_ptr->deserialized ) ||
+ ( entry_ptr->serialized ) ||
( entry_ptr->destroyed ) ) {
pass = FALSE;
@@ -13024,10 +13050,9 @@ check_expunge_entry(void)
HDsnprintf(msg, (size_t)128, "Unexpected status 2.");
failure_mssg = msg;
- } else if ( ( ! entry_ptr->loaded ) ||
- ( entry_ptr->cleared ) ||
- ( entry_ptr->flushed ) ||
- ( entry_ptr->destroyed ) ) {
+ } else if ( ( ! entry_ptr->deserialized ) ||
+ ( entry_ptr->serialized ) ||
+ ( entry_ptr->destroyed ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected entry history 2.");
@@ -13037,7 +13062,7 @@ check_expunge_entry(void)
}
/* Expunge the entry and then verify that it is no longer in the cache.
- * Also verify that the entry was loaded, cleared, and destroyed, but
+ * Also verify that the entry was loaded and destroyed, but
* not flushed.
*/
if ( pass ) {
@@ -13068,10 +13093,9 @@ check_expunge_entry(void)
HDsnprintf(msg, (size_t)128, "Unexpected status 3.");
failure_mssg = msg;
- } else if ( ( ! entry_ptr->loaded ) ||
- ( ! entry_ptr->cleared ) ||
- ( entry_ptr->flushed ) ||
- ( ! entry_ptr->destroyed ) ) {
+ } else if ( ( ! entry_ptr->deserialized ) ||
+ ( entry_ptr->serialized ) ||
+ ( ! entry_ptr->destroyed ) ) {
pass = FALSE;
HDsnprintf(msg, (size_t)128, "Unexpected entry history 3.");
@@ -13110,9 +13134,8 @@ check_expunge_entry(void)
HDsnprintf(msg, (size_t)128, "Unexpected status 4.");
failure_mssg = msg;
- } else if ( ( entry_ptr->loaded ) ||
- ( entry_ptr->cleared ) ||
- ( entry_ptr->flushed ) ||
+ } else if ( ( entry_ptr->deserialized ) ||
+ ( entry_ptr->serialized ) ||
( entry_ptr->destroyed ) ) {
pass = FALSE;
@@ -13153,9 +13176,8 @@ check_expunge_entry(void)
HDsnprintf(msg, (size_t)128, "Unexpected status 5.");
failure_mssg = msg;
- } else if ( ( ! entry_ptr->loaded ) ||
- ( entry_ptr->cleared ) ||
- ( entry_ptr->flushed ) ||
+ } else if ( ( ! entry_ptr->deserialized ) ||
+ ( entry_ptr->serialized ) ||
( entry_ptr->destroyed ) ) {
pass = FALSE;
@@ -13166,7 +13188,7 @@ check_expunge_entry(void)
}
/* Expunge the entry and then verify that it is no longer in the cache.
- * Also verify that the entry was loaded, cleared and destroyed, but not
+ * Also verify that the entry was loaded and destroyed, but not
* flushed.
*/
if ( pass ) {
@@ -13198,9 +13220,8 @@ check_expunge_entry(void)
HDsnprintf(msg, (size_t)128, "Unexpected status 6.");
failure_mssg = msg;
- } else if ( ( ! entry_ptr->loaded ) ||
- ( ! entry_ptr->cleared ) ||
- ( entry_ptr->flushed ) ||
+ } else if ( ( ! entry_ptr->deserialized ) ||
+ ( entry_ptr->serialized ) ||
( ! entry_ptr->destroyed ) ) {
pass = FALSE;
@@ -13795,8 +13816,23 @@ check_move_entry__run_test(H5F_t * file_ptr,
test_entry_t * entry_ptr = NULL;
H5C_cache_entry_t * test_ptr = NULL;
- assert( cache_ptr );
- assert( spec_ptr );
+ if ( cache_ptr == NULL ) {
+
+ pass = FALSE;
+ HDsnprintf(msg, (size_t)128,
+ "cache_ptr NULL on entry to move test #%d.",
+ test_num);
+ failure_mssg = msg;
+
+ } else if ( spec_ptr == NULL ) {
+
+ pass = FALSE;
+ HDsnprintf(msg, (size_t)128,
+ "spec_ptr NULL on entry to move test #%d.",
+ test_num);
+ failure_mssg = msg;
+
+ }
if ( pass ) {
@@ -14147,9 +14183,8 @@ check_resize_entry(void)
HDsnprintf(msg, (size_t)128, "Unexpected status 1.");
failure_mssg = msg;
- } else if ( ( ! entry_ptr->loaded ) ||
- ( entry_ptr->cleared ) ||
- ( entry_ptr->flushed ) ||
+ } else if ( ( ! entry_ptr->deserialized ) ||
+ ( entry_ptr->serialized ) ||
( entry_ptr->destroyed ) ) {
pass = FALSE;
@@ -14171,9 +14206,8 @@ check_resize_entry(void)
} else {
- result = H5C_unprotect(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT,
- &(types[LARGE_ENTRY_TYPE]), entry_ptr->addr, (void *)entry_ptr,
- H5C__DIRTIED_FLAG);
+ result = H5C_unprotect(file_ptr, H5P_DATASET_XFER_DEFAULT,
+ entry_ptr->addr, (void *)entry_ptr, H5C__DIRTIED_FLAG);
if ( result < 0 ) {
@@ -14228,9 +14262,8 @@ check_resize_entry(void)
HDsnprintf(msg, (size_t)128, "Unexpected status 2.");
failure_mssg = msg;
- } else if ( ( ! entry_ptr->loaded ) ||
- ( entry_ptr->cleared ) ||
- ( entry_ptr->flushed ) ||
+ } else if ( ( ! entry_ptr->deserialized ) ||
+ ( entry_ptr->serialized ) ||
( entry_ptr->destroyed ) ) {
pass = FALSE;
@@ -14258,9 +14291,8 @@ check_resize_entry(void)
} else {
- result = H5C_unprotect(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT,
- &(types[LARGE_ENTRY_TYPE]), entry_ptr->addr, (void *)entry_ptr,
- H5C__DIRTIED_FLAG);
+ result = H5C_unprotect(file_ptr, H5P_DATASET_XFER_DEFAULT,
+ entry_ptr->addr, (void *)entry_ptr, H5C__DIRTIED_FLAG);
if ( result < 0 ) {
@@ -14315,9 +14347,8 @@ check_resize_entry(void)
HDsnprintf(msg, (size_t)128, "Unexpected status 3.");
failure_mssg = msg;
- } else if ( ( ! entry_ptr->loaded ) ||
- ( entry_ptr->cleared ) ||
- ( entry_ptr->flushed ) ||
+ } else if ( ( ! entry_ptr->deserialized ) ||
+ ( entry_ptr->serialized ) ||
( entry_ptr->destroyed ) ) {
pass = FALSE;
@@ -14384,9 +14415,8 @@ check_resize_entry(void)
HDsnprintf(msg, (size_t)128, "Unexpected status 4.");
failure_mssg = msg;
- } else if ( ( ! entry_ptr->loaded ) ||
- ( entry_ptr->cleared ) ||
- ( entry_ptr->flushed ) ||
+ } else if ( ( ! entry_ptr->deserialized ) ||
+ ( entry_ptr->serialized ) ||
( entry_ptr->destroyed ) ) {
pass = FALSE;
@@ -14445,9 +14475,8 @@ check_resize_entry(void)
HDsnprintf(msg, (size_t)128, "Unexpected status 5.");
failure_mssg = msg;
- } else if ( ( ! entry_ptr->loaded ) ||
- ( entry_ptr->cleared ) ||
- ( entry_ptr->flushed ) ||
+ } else if ( ( ! entry_ptr->deserialized ) ||
+ ( entry_ptr->serialized ) ||
( entry_ptr->destroyed ) ) {
pass = FALSE;
@@ -14485,9 +14514,8 @@ check_resize_entry(void)
HDsnprintf(msg, (size_t)128, "Unexpected status 6.");
failure_mssg = msg;
- } else if ( ( ! entry_ptr->loaded ) ||
- ( ! entry_ptr->cleared ) ||
- ( entry_ptr->flushed ) ||
+ } else if ( ( ! entry_ptr->deserialized ) ||
+ ( entry_ptr->serialized ) ||
( ! entry_ptr->destroyed ) ) {
pass = FALSE;
@@ -14600,9 +14628,8 @@ check_resize_entry(void)
HDsnprintf(msg, (size_t)128, "Unexpected status 7.");
failure_mssg = msg;
- } else if ( ( ! entry_ptr->loaded ) ||
- ( entry_ptr->cleared ) ||
- ( entry_ptr->flushed ) ||
+ } else if ( ( ! entry_ptr->deserialized ) ||
+ ( entry_ptr->serialized ) ||
( entry_ptr->destroyed ) ) {
pass = FALSE;
@@ -14624,9 +14651,8 @@ check_resize_entry(void)
} else {
- result = H5C_unprotect(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT,
- &(types[LARGE_ENTRY_TYPE]), entry_ptr->addr, (void *)entry_ptr,
- H5C__DIRTIED_FLAG);
+ result = H5C_unprotect(file_ptr, H5P_DATASET_XFER_DEFAULT,
+ entry_ptr->addr, (void *)entry_ptr, H5C__DIRTIED_FLAG);
if ( result < 0 ) {
@@ -14683,9 +14709,8 @@ check_resize_entry(void)
HDsnprintf(msg, (size_t)128, "Unexpected status 8.");
failure_mssg = msg;
- } else if ( ( ! entry_ptr->loaded ) ||
- ( entry_ptr->cleared ) ||
- ( entry_ptr->flushed ) ||
+ } else if ( ( ! entry_ptr->deserialized ) ||
+ ( entry_ptr->serialized ) ||
( entry_ptr->destroyed ) ) {
pass = FALSE;
@@ -14713,9 +14738,8 @@ check_resize_entry(void)
} else {
- result = H5C_unprotect(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT,
- &(types[LARGE_ENTRY_TYPE]), entry_ptr->addr, (void *)entry_ptr,
- H5C__DIRTIED_FLAG);
+ result = H5C_unprotect(file_ptr, H5P_DATASET_XFER_DEFAULT,
+ entry_ptr->addr, (void *)entry_ptr, H5C__DIRTIED_FLAG);
if ( result < 0 ) {
@@ -14770,9 +14794,8 @@ check_resize_entry(void)
HDsnprintf(msg, (size_t)128, "Unexpected status 9.");
failure_mssg = msg;
- } else if ( ( ! entry_ptr->loaded ) ||
- ( entry_ptr->cleared ) ||
- ( entry_ptr->flushed ) ||
+ } else if ( ( ! entry_ptr->deserialized ) ||
+ ( entry_ptr->serialized ) ||
( entry_ptr->destroyed ) ) {
pass = FALSE;
@@ -14841,9 +14864,8 @@ check_resize_entry(void)
HDsnprintf(msg, (size_t)128, "Unexpected status 10.");
failure_mssg = msg;
- } else if ( ( ! entry_ptr->loaded ) ||
- ( entry_ptr->cleared ) ||
- ( entry_ptr->flushed ) ||
+ } else if ( ( ! entry_ptr->deserialized ) ||
+ ( entry_ptr->serialized ) ||
( entry_ptr->destroyed ) ) {
pass = FALSE;
@@ -14902,9 +14924,8 @@ check_resize_entry(void)
HDsnprintf(msg, (size_t)128, "Unexpected status 11.");
failure_mssg = msg;
- } else if ( ( ! entry_ptr->loaded ) ||
- ( entry_ptr->cleared ) ||
- ( entry_ptr->flushed ) ||
+ } else if ( ( ! entry_ptr->deserialized ) ||
+ ( entry_ptr->serialized ) ||
( entry_ptr->destroyed ) ) {
pass = FALSE;
@@ -14942,9 +14963,8 @@ check_resize_entry(void)
HDsnprintf(msg, (size_t)128, "Unexpected status 12.");
failure_mssg = msg;
- } else if ( ( ! entry_ptr->loaded ) ||
- ( ! entry_ptr->cleared ) ||
- ( entry_ptr->flushed ) ||
+ } else if ( ( ! entry_ptr->deserialized ) ||
+ ( entry_ptr->serialized ) ||
( ! entry_ptr->destroyed ) ) {
pass = FALSE;
@@ -15239,9 +15259,8 @@ check_evictions_enabled(void)
HDsnprintf(msg, (size_t)128, "Unexpected status 1.");
failure_mssg = msg;
- } else if ( ( ! entry_ptr->loaded ) ||
- ( entry_ptr->cleared ) ||
- ( ! entry_ptr->flushed ) ||
+ } else if ( ( ! entry_ptr->deserialized ) ||
+ ( entry_ptr->serialized ) ||
( ! entry_ptr->destroyed ) ) {
pass = FALSE;
@@ -15306,9 +15325,8 @@ check_evictions_enabled(void)
HDsnprintf(msg, (size_t)128, "Unexpected status 2.");
failure_mssg = msg;
- } else if ( ( ! entry_ptr->loaded ) ||
- ( entry_ptr->cleared ) ||
- ( ! entry_ptr->flushed ) ||
+ } else if ( ( ! entry_ptr->deserialized ) ||
+ ( entry_ptr->serialized ) ||
( ! entry_ptr->destroyed ) ) {
pass = FALSE;
@@ -15526,9 +15544,8 @@ check_evictions_enabled(void)
HDsnprintf(msg, (size_t)128, "Unexpected status 3.");
failure_mssg = msg;
- } else if ( ( ! entry_ptr->loaded ) ||
- ( entry_ptr->cleared ) ||
- ( ! entry_ptr->flushed ) ||
+ } else if ( ( ! entry_ptr->deserialized ) ||
+ ( entry_ptr->serialized ) ||
( ! entry_ptr->destroyed ) ) {
pass = FALSE;
@@ -15562,9 +15579,8 @@ check_evictions_enabled(void)
HDsnprintf(msg, (size_t)128, "Unexpected status 4.");
failure_mssg = msg;
- } else if ( ( ! entry_ptr->loaded ) ||
- ( entry_ptr->cleared ) ||
- ( ! entry_ptr->flushed ) ||
+ } else if ( ( ! entry_ptr->deserialized ) ||
+ ( entry_ptr->serialized ) ||
( ! entry_ptr->destroyed ) ) {
pass = FALSE;
@@ -15697,9 +15713,8 @@ check_evictions_enabled(void)
HDsnprintf(msg, (size_t)128, "Unexpected status 5.");
failure_mssg = msg;
- } else if ( ( ! entry_ptr->loaded ) ||
- ( entry_ptr->cleared ) ||
- ( ! entry_ptr->flushed ) ||
+ } else if ( ( ! entry_ptr->deserialized ) ||
+ ( entry_ptr->serialized ) ||
( ! entry_ptr->destroyed ) ) {
pass = FALSE;
@@ -15791,8 +15806,7 @@ check_flush_protected_err(void)
protect_entry(file_ptr, 0, 0);
- if ( H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT,
- H5C__NO_FLAGS_SET) >= 0 ) {
+ if ( H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5C__NO_FLAGS_SET) >= 0 ) {
pass = FALSE;
failure_mssg = "flush succeeded on cache with protected entry.\n";
@@ -15801,8 +15815,7 @@ check_flush_protected_err(void)
unprotect_entry(file_ptr, 0, 0, H5C__DIRTIED_FLAG);
- if ( H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT,
- H5C__NO_FLAGS_SET) < 0 ) {
+ if ( H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5C__NO_FLAGS_SET) < 0 ) {
pass = FALSE;
failure_mssg = "flush failed after unprotect.\n";
@@ -15871,7 +15884,7 @@ check_destroy_pinned_err(void)
protect_entry(file_ptr, 0, 0);
unprotect_entry(file_ptr, 0, 0, H5C__PIN_ENTRY_FLAG);
- if ( H5C_dest(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT) >= 0 ) {
+ if ( H5C_dest(file_ptr, H5P_DATASET_XFER_DEFAULT) >= 0 ) {
pass = FALSE;
failure_mssg = "destroy succeeded on cache with pinned entry.\n";
@@ -15880,7 +15893,7 @@ check_destroy_pinned_err(void)
unpin_entry(0, 0);
- if ( H5C_dest(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT) < 0 ) {
+ if ( H5C_dest(file_ptr, H5P_DATASET_XFER_DEFAULT) < 0 ) {
pass = FALSE;
failure_mssg = "destroy failed after unpin.\n";
@@ -15957,7 +15970,7 @@ check_destroy_protected_err(void)
protect_entry(file_ptr, 0, 0);
- if ( H5C_dest(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT) >= 0 ) {
+ if ( H5C_dest(file_ptr, H5P_DATASET_XFER_DEFAULT) >= 0 ) {
pass = FALSE;
failure_mssg = "destroy succeeded on cache with protected entry.\n";
@@ -15966,7 +15979,7 @@ check_destroy_protected_err(void)
unprotect_entry(file_ptr, 0, 0, H5C__DIRTIED_FLAG);
- if ( H5C_dest(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT) < 0 ) {
+ if ( H5C_dest(file_ptr, H5P_DATASET_XFER_DEFAULT) < 0 ) {
pass = FALSE;
failure_mssg = "destroy failed after unprotect.\n";
@@ -16050,8 +16063,9 @@ check_duplicate_insert_err(void)
base_addr = entries[0];
entry_ptr = &(base_addr[0]);
- result = H5C_insert_entry(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT,
- &(types[0]), entry_ptr->addr, (void *)entry_ptr, H5C__NO_FLAGS_SET);
+ result = H5C_insert_entry(file_ptr, H5P_DATASET_XFER_DEFAULT,
+ &(types[0]), entry_ptr->addr,
+ (void *)entry_ptr, H5C__NO_FLAGS_SET);
if ( result >= 0 ) {
@@ -16227,9 +16241,8 @@ check_double_pin_err(void)
if ( pass ) {
- result = H5C_unprotect(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT,
- &(types[0]), entry_ptr->addr, (void *)entry_ptr,
- H5C__PIN_ENTRY_FLAG);
+ result = H5C_unprotect(file_ptr, H5P_DATASET_XFER_DEFAULT,
+ entry_ptr->addr, (void *)entry_ptr, H5C__PIN_ENTRY_FLAG);
if ( result > 0 ) {
@@ -16312,9 +16325,8 @@ check_double_unpin_err(void)
if ( pass ) {
- result = H5C_unprotect(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT,
- &(types[0]), entry_ptr->addr, (void *)entry_ptr,
- H5C__UNPIN_ENTRY_FLAG);
+ result = H5C_unprotect(file_ptr, H5P_DATASET_XFER_DEFAULT,
+ entry_ptr->addr, (void *)entry_ptr, H5C__UNPIN_ENTRY_FLAG);
if ( result > 0 ) {
@@ -16513,8 +16525,9 @@ check_double_protect_err(void)
if ( pass ) {
- cache_entry_ptr = (H5C_cache_entry_t *)H5C_protect(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT,
- &(types[0]), entry_ptr->addr, NULL, H5C__NO_FLAGS_SET);
+ cache_entry_ptr = (H5C_cache_entry_t *)H5C_protect(file_ptr, H5P_DATASET_XFER_DEFAULT,
+ &(types[0]), entry_ptr->addr,
+ &entry_ptr->addr, H5C__NO_FLAGS_SET);
if ( cache_entry_ptr != NULL ) {
@@ -16592,9 +16605,8 @@ check_double_unprotect_err(void)
if ( pass ) {
- result = H5C_unprotect(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT,
- &(types[0]), entry_ptr->addr, (void *)entry_ptr,
- H5C__NO_FLAGS_SET);
+ result = H5C_unprotect(file_ptr, H5P_DATASET_XFER_DEFAULT,
+ entry_ptr->addr, (void *)entry_ptr, H5C__NO_FLAGS_SET);
if ( result > 0 ) {
@@ -16757,7 +16769,7 @@ check_expunge_entry_errs(void)
if ( pass ) {
- result = H5C_expunge_entry(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT,
+ result = H5C_expunge_entry(file_ptr, H5P_DATASET_XFER_DEFAULT,
&(types[0]), entry_ptr->addr, H5C__NO_FLAGS_SET);
if ( result > 0 ) {
@@ -16775,7 +16787,7 @@ check_expunge_entry_errs(void)
if ( pass ) {
- result = H5C_expunge_entry(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT,
+ result = H5C_expunge_entry(file_ptr, H5P_DATASET_XFER_DEFAULT,
&(types[0]), entry_ptr->addr, H5C__NO_FLAGS_SET);
if ( result > 0 ) {
@@ -16793,7 +16805,7 @@ check_expunge_entry_errs(void)
if ( pass ) {
- result = H5C_expunge_entry(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT,
+ result = H5C_expunge_entry(file_ptr, H5P_DATASET_XFER_DEFAULT,
&(types[0]), entry_ptr->addr, H5C__NO_FLAGS_SET);
if ( result < 0 ) {
@@ -16969,9 +16981,8 @@ check_unprotect_ro_dirty_err(void)
if ( pass ) {
- result = H5C_unprotect(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT,
- &(types[0]), entry_ptr->addr, (void *)entry_ptr,
- H5C__DIRTIED_FLAG);
+ result = H5C_unprotect(file_ptr, H5P_DATASET_XFER_DEFAULT,
+ entry_ptr->addr, (void *)entry_ptr, H5C__DIRTIED_FLAG);
if ( result >= 0 ) {
@@ -17013,9 +17024,8 @@ check_unprotect_ro_dirty_err(void)
if ( pass ) {
- result = H5C_unprotect(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT,
- &(types[0]), entry_ptr->addr, (void *)entry_ptr,
- H5C__DIRTIED_FLAG);
+ result = H5C_unprotect(file_ptr, H5P_DATASET_XFER_DEFAULT,
+ entry_ptr->addr, (void *)entry_ptr, H5C__DIRTIED_FLAG);
if ( result > 0 ) {
@@ -17099,8 +17109,9 @@ check_protect_ro_rw_err(void)
if ( pass ) {
- thing_ptr = (H5C_cache_entry_t *)H5C_protect(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT,
- &(types[0]), entry_ptr->addr, NULL, H5C__NO_FLAGS_SET);
+ thing_ptr = (H5C_cache_entry_t *)H5C_protect(file_ptr, H5P_DATASET_XFER_DEFAULT,
+ &(types[0]), entry_ptr->addr,
+ &entry_ptr->addr, H5C__NO_FLAGS_SET);
if ( thing_ptr != NULL ) {
@@ -20402,10 +20413,6 @@ check_auto_cache_resize(void)
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
- if ( pass ) {
-
- takedown_cache(file_ptr, FALSE, FALSE);
- }
/* now test the flash cache size increment code. At least at present,
* there should be no interaction between the regular auto-resize
@@ -20420,18 +20427,18 @@ check_auto_cache_resize(void)
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
- /* allocate a cache, enable the flash cache size increase code, and
- * then force the flash size increase code through all its operational
- * modes. Verify that all performs as expected.
+ /* Place the cache in a known state via a flush-destroy on the cache
+ * to clear out all entries, and then a reset on all the entries.
+ * Then configure the cache for the flash cache size increase tests,
+ * and force the flash size increase code through all its operational
+ * modes. Verify that all perform as expected.
*/
if ( pass ) {
- reset_entries();
+ flush_cache(file_ptr, TRUE, FALSE, FALSE);
- file_ptr = setup_cache((size_t)(2 * 1024),
- (size_t)(1 * 1024));
- cache_ptr = file_ptr->shared->cache;
+ reset_entries();
}
if ( show_progress ) HDfprintf(stderr, "check point %d\n", checkpoint++);
@@ -27913,10 +27920,10 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
int32_t entry_idx = 0;
int32_t i;
- /* Expected loaded status of entries depends on how they get into
- * the cache. Insertions = not loaded, protect/unprotect = loaded.
+ /* Expected deserialized status of entries depends on how they get into
+ * the cache. Insertions = not deserialized, protect/unprotect = deserialized.
*/
- hbool_t loaded = (hbool_t)!(fill_via_insertion);
+ hbool_t deserialized = (hbool_t)!(fill_via_insertion);
/* Set up the expected array. This is used to maintain a table of the
* expected status of every entry used in this test.
@@ -27924,157 +27931,157 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
struct expected_entry_status expected[150] =
{
/* entry entry in at main flush dep flush dep child flush flush flush */
- /* type: index: size: cache: addr: dirty: prot: pinned: loaded: clrd: flshd: dest: par type: par idx: dep ref.count: dep height: order: */
- { HUGE_ENTRY_TYPE, 0, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 1, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 2, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 3, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 4, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 5, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 6, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 7, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 8, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 9, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 10, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 11, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 12, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 13, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 14, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 15, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 16, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 17, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 18, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 19, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 20, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 21, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 22, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 23, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 24, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 25, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 26, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 27, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 28, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 29, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 30, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 31, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 32, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 33, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 34, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 35, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 36, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 37, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 38, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 39, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 40, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 41, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 42, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 43, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 44, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 45, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 46, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 47, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 48, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 49, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 50, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 51, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 52, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 53, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 54, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 55, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 56, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 57, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 58, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 59, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 60, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 61, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 62, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 63, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 64, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 65, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 66, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 67, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 68, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 69, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 70, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 71, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 72, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 73, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 74, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 75, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 76, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 77, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 78, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 79, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 80, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 81, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 82, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 83, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 84, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 85, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 86, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 87, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 88, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 89, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 90, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 91, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 92, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 93, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 94, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 95, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 96, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 97, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 98, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 99, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 100, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 101, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 102, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 103, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 104, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 105, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 106, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 107, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 108, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 109, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 110, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 111, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 112, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 113, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 114, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 115, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 116, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 117, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 118, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 119, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 120, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 121, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 122, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 123, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 124, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 125, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 126, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 127, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 128, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 129, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 130, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 131, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 132, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 133, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 134, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 135, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 136, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 137, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 138, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 139, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 140, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 141, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 142, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 143, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 144, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 145, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 146, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 147, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 148, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { HUGE_ENTRY_TYPE, 149, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 }
+ /* type: index: size: cache: addr: dirty: prot: pinned: dsrlzd: srlzd: dest: par type: par idx: dep ref.count: dep height: order: */
+ { HUGE_ENTRY_TYPE, 0, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 1, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 2, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 3, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 4, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 5, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 6, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 7, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 8, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 9, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 10, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 11, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 12, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 13, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 14, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 15, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 16, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 17, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 18, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 19, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 20, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 21, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 22, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 23, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 24, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 25, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 26, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 27, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 28, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 29, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 30, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 31, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 32, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 33, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 34, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 35, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 36, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 37, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 38, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 39, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 40, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 41, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 42, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 43, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 44, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 45, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 46, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 47, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 48, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 49, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 50, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 51, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 52, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 53, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 54, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 55, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 56, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 57, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 58, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 59, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 60, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 61, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 62, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 63, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 64, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 65, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 66, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 67, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 68, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 69, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 70, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 71, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 72, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 73, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 74, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 75, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 76, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 77, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 78, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 79, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 80, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 81, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 82, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 83, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 84, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 85, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 86, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 87, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 88, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 89, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 90, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 91, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 92, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 93, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 94, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 95, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 96, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 97, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 98, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 99, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 100, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 101, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 102, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 103, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 104, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 105, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 106, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 107, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 108, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 109, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 110, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 111, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 112, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 113, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 114, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 115, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 116, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 117, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 118, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 119, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 120, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 121, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 122, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 123, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 124, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 125, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 126, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 127, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 128, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 129, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 130, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 131, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 132, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 133, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 134, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 135, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 136, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 137, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 138, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 139, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 140, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 141, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 142, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 143, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 144, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 145, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 146, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 147, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 148, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 149, HUGE_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 }
};
pass = TRUE;
@@ -28167,7 +28174,7 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
*/
expected[entry_idx].in_cache = TRUE;
expected[entry_idx].is_dirty = TRUE;
- expected[entry_idx].loaded = (unsigned char)loaded;
+ expected[entry_idx].deserialized = (unsigned char)deserialized;
verify_entry_status(cache_ptr, /* H5C_t * cache_ptr */
entry_idx, /* int tag */
@@ -28231,13 +28238,13 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
*/
/* entry w/ index 0 has now been flushed and is now clean. */
- expected[0].flushed = TRUE;
expected[0].is_dirty = FALSE;
+ expected[0].serialized = TRUE;
/* entry w/ index 26 is now in the cache and dirty. */
expected[26].in_cache = TRUE;
expected[26].is_dirty = TRUE;
- expected[26].loaded = (unsigned char)loaded;
+ expected[26].deserialized = (unsigned char)deserialized;
/* verify the status */
verify_entry_status(cache_ptr, /* H5C_t * cache_ptr */
@@ -28285,13 +28292,13 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
*/
/* entry w/ index 1 has now been flushed and is now clean. */
- expected[1].flushed = TRUE;
expected[1].is_dirty = FALSE;
+ expected[1].serialized = TRUE;
/* entry w/ index 27 is now in the cache and dirty. */
expected[27].in_cache = TRUE;
expected[27].is_dirty = TRUE;
- expected[27].loaded = (unsigned char)loaded;
+ expected[27].deserialized = (unsigned char)deserialized;
/* verify the status */
verify_entry_status(cache_ptr, /* H5C_t * cache_ptr */
@@ -28331,12 +28338,12 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
* entry currently getting inserted is now in the cache and
* dirty.
*/
- expected[entry_idx - 26].flushed = TRUE;
expected[entry_idx - 26].is_dirty = FALSE;
+ expected[entry_idx - 26].serialized = TRUE;
expected[entry_idx].in_cache = TRUE;
expected[entry_idx].is_dirty = TRUE;
- expected[entry_idx].loaded = (unsigned char)loaded;
+ expected[entry_idx].deserialized = (unsigned char)deserialized;
/* verify the status */
verify_entry_status(cache_ptr, /* H5C_t * cache_ptr */
@@ -28411,15 +28418,15 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
expected[0].destroyed = TRUE;
/* entries w/ indices 24,25 have now been flushed and are clean. */
- expected[24].flushed = TRUE;
expected[24].is_dirty = FALSE;
- expected[25].flushed = TRUE;
+ expected[24].serialized = TRUE;
expected[25].is_dirty = FALSE;
+ expected[25].serialized = TRUE;
/* entry w/ index 50 is now in the cache and dirty */
expected[50].in_cache = TRUE;
expected[50].is_dirty = TRUE;
- expected[50].loaded = (unsigned char)loaded;
+ expected[50].deserialized = (unsigned char)deserialized;
/* verify the status */
verify_entry_status(cache_ptr, /* H5C_t * cache_ptr */
@@ -28464,7 +28471,7 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
/* This past inserted entry is now in the cache and dirty */
expected[entry_idx].in_cache = TRUE;
expected[entry_idx].is_dirty = TRUE;
- expected[entry_idx].loaded = (unsigned char)loaded;
+ expected[entry_idx].deserialized = (unsigned char)deserialized;
/* The entry inserted 50 insertions ago has been evicted */
expected[entry_idx - 50].in_cache = FALSE;
@@ -28476,8 +28483,8 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
* 25 insertions ago. */
if (entry_idx < 75) {
- expected[entry_idx - 25].flushed = TRUE;
expected[entry_idx - 25].is_dirty = FALSE;
+ expected[entry_idx - 25].serialized = TRUE;
}
/* If the newly inserted entry is among the last
* 25 insertions in this loop, then the insertion will
@@ -28488,8 +28495,8 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
* flush-then-evict, it switches to evict-then-flush. */
else {
- expected[entry_idx - 26].flushed = TRUE;
expected[entry_idx - 26].is_dirty = FALSE;
+ expected[entry_idx - 26].serialized = TRUE;
}
/* Verify this expected status */
@@ -28551,8 +28558,8 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
/* entries w/ indices 74-99 have been flushed. */
for (i = 74; i < 100; i++) {
- expected[i].flushed = TRUE;
expected[i].is_dirty = FALSE;
+ expected[i].serialized = TRUE;
}
verify_entry_status(cache_ptr, /* H5C_t * cache_ptr */
0, /* int tag */
@@ -28595,7 +28602,7 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
/* This past inserted entry is now in the cache and dirty */
expected[entry_idx].in_cache = TRUE;
expected[entry_idx].is_dirty = TRUE;
- expected[entry_idx].loaded = (unsigned char)loaded;
+ expected[entry_idx].deserialized = (unsigned char)deserialized;
/* The entry with ID minus 50 will have been evicted */
expected[entry_idx - 50].in_cache = FALSE;
@@ -28645,13 +28652,13 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
expected[76].destroyed = TRUE;
/* entry w/ index 100 has now been flushed and is now clean. */
- expected[100].flushed = TRUE;
expected[100].is_dirty = FALSE;
+ expected[100].serialized = TRUE;
/* entry w/ index 26 is now in the cache and dirty. */
expected[126].in_cache = TRUE;
expected[126].is_dirty = TRUE;
- expected[126].loaded = (unsigned char)loaded;
+ expected[126].deserialized = (unsigned char)deserialized;
/* verify the status */
verify_entry_status(cache_ptr, /* H5C_t * cache_ptr */
@@ -28689,15 +28696,15 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
/* This past inserted entry is now in the cache and dirty */
expected[entry_idx].in_cache = TRUE;
expected[entry_idx].is_dirty = TRUE;
- expected[entry_idx].loaded = (unsigned char)loaded;
+ expected[entry_idx].deserialized = (unsigned char)deserialized;
/* The entry with ID minus 50 will have been evicted */
expected[entry_idx - 50].in_cache = FALSE;
expected[entry_idx - 50].destroyed = TRUE;
/* The entry with ID minus 26 will now be clean */
- expected[entry_idx - 26].flushed = TRUE;
expected[entry_idx - 26].is_dirty = FALSE;
+ expected[entry_idx - 26].serialized = TRUE;
/* verify the status */
verify_entry_status(cache_ptr, /* H5C_t * cache_ptr */
@@ -28712,7 +28719,7 @@ check_metadata_blizzard_absence(hbool_t fill_via_insertion)
HDfprintf(stdout, "%s: check point %d -- pass %d\n",
FUNC, checkpoint++, pass);
- if ( pass ) {
+ if ( cache_ptr ) {
/* We're done with testing. We can take down the cache. */
takedown_cache(file_ptr, FALSE, FALSE);
@@ -28754,12 +28761,12 @@ check_flush_deps(void)
struct expected_entry_status expected[5] =
{
/* entry entry in at main flush dep flush dep child flush flush flush */
- /* type: index: size: cache: addr: dirty: prot: pinned: loaded: clrd: flshd: dest: par type: par idx: dep ref.count: dep height: order: */
- { PICO_ENTRY_TYPE, 0, PICO_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { PICO_ENTRY_TYPE, 1, PICO_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { PICO_ENTRY_TYPE, 2, PICO_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { PICO_ENTRY_TYPE, 3, PICO_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { PICO_ENTRY_TYPE, 4, PICO_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 }
+ /* type: index: size: cache: addr: dirty: prot: pinned: dsrlzd: srlzd: dest: par type: par idx: dep ref.count: dep height: order: */
+ { PICO_ENTRY_TYPE, 0, PICO_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { PICO_ENTRY_TYPE, 1, PICO_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { PICO_ENTRY_TYPE, 2, PICO_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { PICO_ENTRY_TYPE, 3, PICO_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { PICO_ENTRY_TYPE, 4, PICO_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 }
};
TESTING("flush dependencies");
@@ -30793,12 +30800,12 @@ check_flush_deps_order(void)
struct expected_entry_status expected[5] =
{
/* entry entry in at main flush dep flush dep child flush flush flush */
- /* type: index: size: cache: addr: dirty: prot: pinned: loaded: clrd: flshd: dest: par type: par idx: dep ref.count: dep height: order: */
- { PICO_ENTRY_TYPE, 0, PICO_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { PICO_ENTRY_TYPE, 1, PICO_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { PICO_ENTRY_TYPE, 2, PICO_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { PICO_ENTRY_TYPE, 3, PICO_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { PICO_ENTRY_TYPE, 4, PICO_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 }
+ /* type: index: size: cache: addr: dirty: prot: pinned: dsrlzd: srlzd: dest: par type: par idx: dep ref.count: dep height: order: */
+ { PICO_ENTRY_TYPE, 0, PICO_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { PICO_ENTRY_TYPE, 1, PICO_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { PICO_ENTRY_TYPE, 2, PICO_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { PICO_ENTRY_TYPE, 3, PICO_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { PICO_ENTRY_TYPE, 4, PICO_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 }
};
unsigned flush_order; /* Index for tracking flush order */
@@ -30881,25 +30888,25 @@ check_flush_deps_order(void)
/* Reset index for tracking flush order */
flush_order = 0;
- result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT, H5C__NO_FLAGS_SET);
+ result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5C__NO_FLAGS_SET);
if( result < 0 ) CACHE_ERROR("flushing entries with flush dependendices")
/* Change expected values, and verify the status of the entries
* after destroy flush dependency
*/
expected[0].is_dirty = FALSE;
- expected[0].flushed = TRUE;
+ expected[0].serialized = TRUE;
expected[0].flush_order = 0;
expected[1].is_dirty = FALSE;
- expected[1].flushed = TRUE;
+ expected[1].serialized = TRUE;
expected[1].flush_order = 1;
expected[1].is_protected = FALSE;
expected[2].is_dirty = FALSE;
- expected[2].flushed = TRUE;
+ expected[2].serialized = TRUE;
expected[3].is_dirty = FALSE;
- expected[3].flushed = TRUE;
+ expected[3].serialized = TRUE;
expected[4].is_dirty = FALSE;
- expected[4].flushed = TRUE;
+ expected[4].serialized = TRUE;
/* Verify the status */
verify_entry_status(cache_ptr, /* H5C_t * cache_ptr */
@@ -30979,27 +30986,27 @@ check_flush_deps_order(void)
dirty_entry(file_ptr, entry_type, 1, FALSE);
if ( !pass ) CACHE_ERROR("dirty_entry failed")
- /* Reset 'flushed' flag & 'flush_order' value in expected array */
- expected[0].flushed = FALSE;
+ /* Reset 'serialized' flag & 'flush_order' value in expected array */
+ expected[0].serialized = FALSE;
expected[0].flush_order = -1;
- expected[1].flushed = FALSE;
+ expected[1].serialized = FALSE;
expected[1].flush_order = -1;
/* Reset index for tracking flush order */
flush_order = 0;
- result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT, H5C__NO_FLAGS_SET);
+ result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5C__NO_FLAGS_SET);
if( result < 0 ) CACHE_ERROR("flushing entries with flush dependendices")
/* Change expected values, and verify the status of the entries
* after destroy flush dependency
*/
expected[0].is_dirty = FALSE;
- expected[0].flushed = TRUE;
+ expected[0].serialized = TRUE;
expected[0].flush_order = 1;
expected[0].is_protected = FALSE;
expected[1].is_dirty = FALSE;
- expected[1].flushed = TRUE;
+ expected[1].serialized = TRUE;
expected[1].flush_order = 0;
/* Verify the status */
@@ -31090,31 +31097,31 @@ check_flush_deps_order(void)
dirty_entry(file_ptr, entry_type, 2, TRUE);
if ( !pass ) CACHE_ERROR("dirty_entry failed")
- /* Reset 'flushed' flag & 'flush_order' value in expected array */
- expected[0].flushed = FALSE;
+ /* Reset 'serialized' flag & 'flush_order' value in expected array */
+ expected[0].serialized = FALSE;
expected[0].flush_order = -1;
- expected[1].flushed = FALSE;
+ expected[1].serialized = FALSE;
expected[1].flush_order = -1;
- expected[2].flushed = FALSE;
+ expected[2].serialized = FALSE;
expected[2].flush_order = -1;
/* Reset index for tracking flush order */
flush_order = 0;
- result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT, H5C__NO_FLAGS_SET);
+ result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5C__NO_FLAGS_SET);
if( result < 0 ) CACHE_ERROR("flushing entries with flush dependendices")
/* Change expected values, and verify the status of the entries
* after destroy flush dependency
*/
expected[0].is_dirty = FALSE;
- expected[0].flushed = TRUE;
+ expected[0].serialized = TRUE;
expected[0].flush_order = 0;
expected[1].is_dirty = FALSE;
- expected[1].flushed = TRUE;
+ expected[1].serialized = TRUE;
expected[1].flush_order = 1;
expected[2].is_dirty = FALSE;
- expected[2].flushed = TRUE;
+ expected[2].serialized = TRUE;
expected[2].flush_order = 2;
expected[2].is_protected = FALSE;
@@ -31211,32 +31218,32 @@ check_flush_deps_order(void)
dirty_entry(file_ptr, entry_type, 2, FALSE);
if ( !pass ) CACHE_ERROR("dirty_entry failed")
- /* Reset 'flushed' flag & 'flush_order' value in expected array */
- expected[0].flushed = FALSE;
+ /* Reset 'serialized' flag & 'flush_order' value in expected array */
+ expected[0].serialized = FALSE;
expected[0].flush_order = -1;
- expected[1].flushed = FALSE;
+ expected[1].serialized = FALSE;
expected[1].flush_order = -1;
- expected[2].flushed = FALSE;
+ expected[2].serialized = FALSE;
expected[2].flush_order = -1;
/* Reset index for tracking flush order */
flush_order = 0;
- result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT, H5C__NO_FLAGS_SET);
+ result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5C__NO_FLAGS_SET);
if( result < 0 ) CACHE_ERROR("flushing entries with flush dependendices")
/* Change expected values, and verify the status of the entries
* after destroy flush dependency
*/
expected[0].is_dirty = FALSE;
- expected[0].flushed = TRUE;
+ expected[0].serialized = TRUE;
expected[0].flush_order = 2;
expected[0].is_protected = FALSE;
expected[1].is_dirty = FALSE;
- expected[1].flushed = TRUE;
+ expected[1].serialized = TRUE;
expected[1].flush_order = 0;
expected[2].is_dirty = FALSE;
- expected[2].flushed = TRUE;
+ expected[2].serialized = TRUE;
expected[2].flush_order = 1;
/* Verify the status */
@@ -31388,37 +31395,37 @@ check_flush_deps_order(void)
dirty_entry(file_ptr, entry_type, 3, TRUE);
if ( !pass ) CACHE_ERROR("dirty_entry failed")
- /* Reset 'flushed' flag & 'flush_order' value in expected array */
- expected[0].flushed = FALSE;
+ /* Reset 'serialized' flag & 'flush_order' value in expected array */
+ expected[0].serialized = FALSE;
expected[0].flush_order = -1;
- expected[1].flushed = FALSE;
+ expected[1].serialized = FALSE;
expected[1].flush_order = -1;
- expected[2].flushed = FALSE;
+ expected[2].serialized = FALSE;
expected[2].flush_order = -1;
- expected[3].flushed = FALSE;
+ expected[3].serialized = FALSE;
expected[3].flush_order = -1;
/* Reset index for tracking flush order */
flush_order = 0;
- result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT, H5C__NO_FLAGS_SET);
+ result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5C__NO_FLAGS_SET);
if( result < 0 ) CACHE_ERROR("flushing entries with flush dependendices")
/* Change expected values, and verify the status of the entries
* after destroy flush dependency
*/
expected[0].is_dirty = FALSE;
- expected[0].flushed = TRUE;
+ expected[0].serialized = TRUE;
expected[0].flush_order = 0;
expected[1].is_dirty = FALSE;
- expected[1].flushed = TRUE;
+ expected[1].serialized = TRUE;
expected[1].flush_order = 1;
expected[1].is_protected = FALSE;
expected[2].is_dirty = FALSE;
- expected[2].flushed = TRUE;
+ expected[2].serialized = TRUE;
expected[2].flush_order = 2;
expected[2].is_protected = FALSE;
- expected[3].flushed = TRUE;
+ expected[3].serialized = TRUE;
expected[3].flush_order = 3;
expected[3].is_protected = FALSE;
@@ -31613,39 +31620,39 @@ check_flush_deps_order(void)
dirty_entry(file_ptr, entry_type, 3, FALSE);
if ( !pass ) CACHE_ERROR("dirty_entry failed")
- /* Reset 'flushed' flag & 'flush_order' value in expected array */
- expected[0].flushed = FALSE;
+ /* Reset 'serialized' flag & 'flush_order' value in expected array */
+ expected[0].serialized = FALSE;
expected[0].flush_order = -1;
- expected[1].flushed = FALSE;
+ expected[1].serialized = FALSE;
expected[1].flush_order = -1;
- expected[2].flushed = FALSE;
+ expected[2].serialized = FALSE;
expected[2].flush_order = -1;
- expected[3].flushed = FALSE;
+ expected[3].serialized = FALSE;
expected[3].flush_order = -1;
/* Reset index for tracking flush order */
flush_order = 0;
- result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT, H5C__NO_FLAGS_SET);
+ result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5C__NO_FLAGS_SET);
if( result < 0 ) CACHE_ERROR("flushing entries with flush dependendices")
/* Change expected values, and verify the status of the entries
* after destroy flush dependency
*/
expected[0].is_dirty = FALSE;
- expected[0].flushed = TRUE;
+ expected[0].serialized = TRUE;
expected[0].flush_order = 3;
expected[0].is_protected = FALSE;
expected[1].is_dirty = FALSE;
- expected[1].flushed = TRUE;
+ expected[1].serialized = TRUE;
expected[1].flush_order = 2;
expected[1].is_protected = FALSE;
expected[2].is_dirty = FALSE;
- expected[2].flushed = TRUE;
+ expected[2].serialized = TRUE;
expected[2].flush_order = 1;
expected[2].is_protected = FALSE;
expected[3].is_dirty = FALSE;
- expected[3].flushed = TRUE;
+ expected[3].serialized = TRUE;
expected[3].flush_order = 0;
/* Verify the status */
@@ -31784,41 +31791,41 @@ check_flush_deps_order(void)
dirty_entry(file_ptr, entry_type, 4, TRUE);
if ( !pass ) CACHE_ERROR("dirty_entry failed")
- /* Reset 'flushed' flag & 'flush_order' value in expected array */
- expected[0].flushed = FALSE;
+ /* Reset 'serialized' flag & 'flush_order' value in expected array */
+ expected[0].serialized = FALSE;
expected[0].flush_order = -1;
- expected[1].flushed = FALSE;
+ expected[1].serialized = FALSE;
expected[1].flush_order = -1;
- expected[2].flushed = FALSE;
+ expected[2].serialized = FALSE;
expected[2].flush_order = -1;
- expected[3].flushed = FALSE;
+ expected[3].serialized = FALSE;
expected[3].flush_order = -1;
- expected[4].flushed = FALSE;
+ expected[4].serialized = FALSE;
expected[4].flush_order = -1;
/* Reset index for tracking flush order */
flush_order = 0;
- result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT, H5C__NO_FLAGS_SET);
+ result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5C__NO_FLAGS_SET);
if( result < 0 ) CACHE_ERROR("flushing entries with flush dependendices")
/* Change expected values, and verify the status of the entries
* after destroy flush dependency
*/
expected[0].is_dirty = FALSE;
- expected[0].flushed = TRUE;
+ expected[0].serialized = TRUE;
expected[0].flush_order = 0;
expected[1].is_dirty = FALSE;
- expected[1].flushed = TRUE;
+ expected[1].serialized = TRUE;
expected[1].flush_order = 1;
expected[2].is_dirty = FALSE;
- expected[2].flushed = TRUE;
+ expected[2].serialized = TRUE;
expected[2].flush_order = 2;
expected[3].is_dirty = FALSE;
- expected[3].flushed = TRUE;
+ expected[3].serialized = TRUE;
expected[3].flush_order = 3;
expected[4].is_dirty = FALSE;
- expected[4].flushed = TRUE;
+ expected[4].serialized = TRUE;
expected[4].flush_order = 4;
expected[4].is_protected = FALSE;
@@ -31920,42 +31927,42 @@ check_flush_deps_order(void)
dirty_entry(file_ptr, entry_type, 4, FALSE);
if ( !pass ) CACHE_ERROR("dirty_entry failed")
- /* Reset 'flushed' flag & 'flush_order' value in expected array */
- expected[0].flushed = FALSE;
+ /* Reset 'serialized' flag & 'flush_order' value in expected array */
+ expected[0].serialized = FALSE;
expected[0].flush_order = -1;
- expected[1].flushed = FALSE;
+ expected[1].serialized = FALSE;
expected[1].flush_order = -1;
- expected[2].flushed = FALSE;
+ expected[2].serialized = FALSE;
expected[2].flush_order = -1;
- expected[3].flushed = FALSE;
+ expected[3].serialized = FALSE;
expected[3].flush_order = -1;
- expected[4].flushed = FALSE;
+ expected[4].serialized = FALSE;
expected[4].flush_order = -1;
/* Reset index for tracking flush order */
flush_order = 0;
- result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT, H5C__NO_FLAGS_SET);
+ result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5C__NO_FLAGS_SET);
if( result < 0 ) CACHE_ERROR("flushing entries with flush dependendices")
/* Change expected values, and verify the status of the entries
* after destroy flush dependency
*/
expected[0].is_dirty = FALSE;
- expected[0].flushed = TRUE;
+ expected[0].serialized = TRUE;
expected[0].flush_order = 4;
expected[0].is_protected = FALSE;
expected[1].is_dirty = FALSE;
- expected[1].flushed = TRUE;
+ expected[1].serialized = TRUE;
expected[1].flush_order = 0;
expected[2].is_dirty = FALSE;
- expected[2].flushed = TRUE;
+ expected[2].serialized = TRUE;
expected[2].flush_order = 1;
expected[3].is_dirty = FALSE;
- expected[3].flushed = TRUE;
+ expected[3].serialized = TRUE;
expected[3].flush_order = 2;
expected[4].is_dirty = FALSE;
- expected[4].flushed = TRUE;
+ expected[4].serialized = TRUE;
expected[4].flush_order = 3;
/* Verify the status */
@@ -32118,42 +32125,42 @@ check_flush_deps_order(void)
dirty_entry(file_ptr, entry_type, 4, TRUE);
if ( !pass ) CACHE_ERROR("dirty_entry failed")
- /* Reset 'flushed' flag & 'flush_order' value in expected array */
- expected[0].flushed = FALSE;
+ /* Reset 'serialized' flag & 'flush_order' value in expected array */
+ expected[0].serialized = FALSE;
expected[0].flush_order = -1;
- expected[1].flushed = FALSE;
+ expected[1].serialized = FALSE;
expected[1].flush_order = -1;
- expected[2].flushed = FALSE;
+ expected[2].serialized = FALSE;
expected[2].flush_order = -1;
- expected[3].flushed = FALSE;
+ expected[3].serialized = FALSE;
expected[3].flush_order = -1;
- expected[4].flushed = FALSE;
+ expected[4].serialized = FALSE;
expected[4].flush_order = -1;
/* Reset index for tracking flush order */
flush_order = 0;
- result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT, H5C__NO_FLAGS_SET);
+ result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5C__NO_FLAGS_SET);
if( result < 0 ) CACHE_ERROR("flushing entries with flush dependendices")
/* Change expected values, and verify the status of the entries
* after destroy flush dependency
*/
expected[0].is_dirty = FALSE;
- expected[0].flushed = TRUE;
+ expected[0].serialized = TRUE;
expected[0].flush_order = 2;
expected[0].is_protected = FALSE;
expected[1].is_dirty = FALSE;
- expected[1].flushed = TRUE;
+ expected[1].serialized = TRUE;
expected[1].flush_order = 3;
expected[1].is_protected = FALSE;
expected[2].is_dirty = FALSE;
- expected[2].flushed = TRUE;
+ expected[2].serialized = TRUE;
expected[3].is_dirty = FALSE;
- expected[3].flushed = TRUE;
+ expected[3].serialized = TRUE;
expected[3].flush_order = 0;
expected[4].is_dirty = FALSE;
- expected[4].flushed = TRUE;
+ expected[4].serialized = TRUE;
expected[4].flush_order = 1;
expected[4].is_protected = FALSE;
@@ -32369,44 +32376,44 @@ check_flush_deps_order(void)
dirty_entry(file_ptr, entry_type, 4, TRUE);
if ( !pass ) CACHE_ERROR("dirty_entry failed")
- /* Reset 'flushed' flag & 'flush_order' value in expected array */
- expected[0].flushed = FALSE;
+ /* Reset 'serialized' flag & 'flush_order' value in expected array */
+ expected[0].serialized = FALSE;
expected[0].flush_order = -1;
- expected[1].flushed = FALSE;
+ expected[1].serialized = FALSE;
expected[1].flush_order = -1;
- expected[2].flushed = FALSE;
+ expected[2].serialized = FALSE;
expected[2].flush_order = -1;
- expected[3].flushed = FALSE;
+ expected[3].serialized = FALSE;
expected[3].flush_order = -1;
- expected[4].flushed = FALSE;
+ expected[4].serialized = FALSE;
expected[4].flush_order = -1;
/* Reset index for tracking flush order */
flush_order = 0;
- result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT, H5C__NO_FLAGS_SET);
+ result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5C__NO_FLAGS_SET);
if( result < 0 ) CACHE_ERROR("flushing entries with flush dependendices")
/* Change expected values, and verify the status of the entries
* after destroy flush dependency
*/
expected[0].is_dirty = FALSE;
- expected[0].flushed = TRUE;
+ expected[0].serialized = TRUE;
expected[0].flush_order = 0;
expected[0].is_protected = FALSE;
expected[1].is_dirty = FALSE;
- expected[1].flushed = TRUE;
+ expected[1].serialized = TRUE;
expected[1].flush_order = 3;
expected[1].is_protected = FALSE;
expected[2].is_dirty = FALSE;
- expected[2].flushed = TRUE;
+ expected[2].serialized = TRUE;
expected[2].flush_order = 4;
expected[2].is_protected = FALSE;
expected[3].is_dirty = FALSE;
- expected[3].flushed = TRUE;
+ expected[3].serialized = TRUE;
expected[3].flush_order = 1;
expected[4].is_dirty = FALSE;
- expected[4].flushed = TRUE;
+ expected[4].serialized = TRUE;
expected[4].flush_order = 2;
expected[4].is_protected = FALSE;
@@ -32636,44 +32643,44 @@ check_flush_deps_order(void)
dirty_entry(file_ptr, entry_type, 4, TRUE);
if ( !pass ) CACHE_ERROR("dirty_entry failed")
- /* Reset 'flushed' flag & 'flush_order' value in expected array */
- expected[0].flushed = FALSE;
+ /* Reset 'serialized' flag & 'flush_order' value in expected array */
+ expected[0].serialized = FALSE;
expected[0].flush_order = -1;
- expected[1].flushed = FALSE;
+ expected[1].serialized = FALSE;
expected[1].flush_order = -1;
- expected[2].flushed = FALSE;
+ expected[2].serialized = FALSE;
expected[2].flush_order = -1;
- expected[3].flushed = FALSE;
+ expected[3].serialized = FALSE;
expected[3].flush_order = -1;
- expected[4].flushed = FALSE;
+ expected[4].serialized = FALSE;
expected[4].flush_order = -1;
/* Reset index for tracking flush order */
flush_order = 0;
- result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT, H5C__NO_FLAGS_SET);
+ result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5C__NO_FLAGS_SET);
if( result < 0 ) CACHE_ERROR("flushing entries with flush dependendices")
/* Change expected values, and verify the status of the entries
* after destroy flush dependency
*/
expected[0].is_dirty = FALSE;
- expected[0].flushed = TRUE;
+ expected[0].serialized = TRUE;
expected[0].flush_order = 0;
expected[0].is_protected = FALSE;
expected[1].is_dirty = FALSE;
- expected[1].flushed = TRUE;
+ expected[1].serialized = TRUE;
expected[1].flush_order = 2;
expected[1].is_protected = FALSE;
expected[2].is_dirty = FALSE;
- expected[2].flushed = TRUE;
+ expected[2].serialized = TRUE;
expected[2].flush_order = 4;
expected[2].is_protected = FALSE;
expected[3].is_dirty = FALSE;
- expected[3].flushed = TRUE;
+ expected[3].serialized = TRUE;
expected[3].flush_order = 1;
expected[4].is_dirty = FALSE;
- expected[4].flushed = TRUE;
+ expected[4].serialized = TRUE;
expected[4].flush_order = 3;
expected[4].is_protected = FALSE;
@@ -32802,13 +32809,13 @@ check_notify_cb(void)
unsigned u; /* Local index variable */
struct expected_entry_status expected[5] =
{
- /* entry entry in at main flush dep flush dep child flush flush flush */
- /* type: index: size: cache: addr: dirty: prot: pinned: loaded: clrd: flshd: dest: par type: par idx: dep ref.count: dep height: order: */
- { NOTIFY_ENTRY_TYPE, 0, NOTIFY_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { NOTIFY_ENTRY_TYPE, 1, NOTIFY_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { NOTIFY_ENTRY_TYPE, 2, NOTIFY_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { NOTIFY_ENTRY_TYPE, 3, NOTIFY_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
- { NOTIFY_ENTRY_TYPE, 4, NOTIFY_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 }
+ /* entry entry in at main flush dep flush dep child flush flush flush */
+ /* type: index: size: cache: addr: dirty: prot: pinned: dsrlzd: srlzd: dest: par type: par idx: dep ref.count: dep height: order: */
+ { NOTIFY_ENTRY_TYPE, 0, NOTIFY_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { NOTIFY_ENTRY_TYPE, 1, NOTIFY_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { NOTIFY_ENTRY_TYPE, 2, NOTIFY_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { NOTIFY_ENTRY_TYPE, 3, NOTIFY_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { NOTIFY_ENTRY_TYPE, 4, NOTIFY_ENTRY_SIZE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 }
};
TESTING("'notify' callback");
@@ -32859,11 +32866,11 @@ check_notify_cb(void)
if ( !pass ) CACHE_ERROR("expunge_entry failed")
/* Change expected values, and verify the status of the entries
- * after each insertion
+ * after each expunge
*/
expected[u].in_cache = FALSE;
- expected[u].is_dirty = FALSE;
- expected[u].cleared = TRUE;
+ expected[u].is_dirty = TRUE;
+ expected[u].serialized = FALSE;
expected[u].destroyed = TRUE;
/* Verify the status */
@@ -32892,7 +32899,7 @@ check_notify_cb(void)
expected[u].in_cache = TRUE;
expected[u].is_dirty = FALSE;
expected[u].is_protected = TRUE;
- expected[u].loaded = TRUE;
+ expected[u].deserialized = TRUE;
/* Verify the status */
verify_entry_status(cache_ptr, /* H5C_t * cache_ptr */
@@ -32942,11 +32949,11 @@ check_notify_cb(void)
if ( !pass ) CACHE_ERROR("expunge_entry failed")
/* Change expected values, and verify the status of the entries
- * after each insertion
+ * after each expunge
*/
expected[u].in_cache = FALSE;
- expected[u].is_dirty = FALSE;
- expected[u].cleared = TRUE;
+ expected[u].is_dirty = TRUE;
+ expected[u].serialized = FALSE;
expected[u].destroyed = TRUE;
/* Verify the status */
@@ -32979,6 +32986,2066 @@ done:
/*-------------------------------------------------------------------------
+ * Function: check_entry_deletions_during_scans()
+ *
+ * Purpose: With the addition of the H5C__TAKE_OWNERSHIP_FLAG, it is
+ * possible for an entry to be removed from the cache as a
+ * side effect of flushing an entry.
+ *
+ * For the most part, this doesn't cause problems. However,
+ * during the scans of lists, it is possible that the entry
+ * removed will be the next entry in the scan -- which if not
+ * detected, will typeically cause the cache to attempt to flush
+ * an entry that is no longer in the cache, and which may have
+ * been deleted.
+ *
+ * This function contans tests for correct handling on this
+ * situation.
+ *
+ * Do nothing if pass is FALSE on entry.
+ *
+ * Return: void
+ *
+ * Programmer: John Mainzer
+ * 4/3/15
+ *
+ * Modifications:
+ *
+ * None.
+ *
+ *-------------------------------------------------------------------------
+ */
+
+static unsigned
+check_entry_deletions_during_scans(void)
+{
+ H5F_t * file_ptr = NULL;
+
+ TESTING("entry deletion during list scan detection and adaption");
+
+ pass = TRUE;
+
+ /* allocate a cache, and flush it under various circumstances.
+ * To the extent possible, verify that the desired actions took
+ * place.
+ */
+
+ if ( pass ) {
+
+ reset_entries();
+
+ file_ptr = setup_cache((size_t)(2 * 1024 * 1024),
+ (size_t)(1 * 1024 * 1024));
+ }
+
+ /* run the tests. This set of tests is somewhat eclectic, as
+ * we are trying to test all locations where the deletion of
+ * an entry from the cache as a side effect of the fluch of
+ * a different entry could cause problems.
+ */
+
+ if ( pass ) {
+
+ cedds__expunge_dirty_entry_in_flush_test(file_ptr);
+ }
+
+ if ( pass ) {
+
+ cedds__H5C_make_space_in_cache(file_ptr);
+ }
+
+ if ( pass ) {
+
+ cedds__H5C__autoadjust__ageout__evict_aged_out_entries(file_ptr);
+ }
+
+ if ( pass ) {
+
+ cedds__H5C_flush_invalidate_cache__bucket_scan(file_ptr);
+ }
+
+
+ if ( pass ) {
+
+ takedown_cache(file_ptr, FALSE, FALSE);
+ }
+
+ if ( pass ) { PASSED(); } else { H5_FAILED(); }
+
+ if ( ! pass ) {
+
+ HDfprintf(stdout, "%s(): failure_mssg = \"%s\".\n",
+ FUNC, failure_mssg);
+ }
+
+ return (unsigned)!pass;
+
+} /* check_entry_deletions_during_scans() */
+
+
+/*-------------------------------------------------------------------------
+ * Function: cedds__expunge_dirty_entry_in_flush_test()
+ *
+ * Purpose: Verify that H5C_flush_cache() can handle the removal of
+ * a dirty entry from the cache during its scan of the
+ * skip list.
+ *
+ * Do this by setting up a full cache, with the last entry
+ * on the LRU being both dirty and having a flush operation
+ * that deletes the second to last entry on the LRU. Then
+ * flush the cache, triggering the flush of the last
+ * item, and thereby the deletion of the second to last item.
+ *
+ * H5C_flush_cache() should handle this deletion gracefully.
+ *
+ * Do nothing if pass is FALSE on entry.
+ *
+ * Return: void
+ *
+ * Programmer: John Mainzer
+ * 4/4/15
+ *
+ * Modifications:
+ *
+ * None.
+ *
+ *-------------------------------------------------------------------------
+ */
+
+static void
+cedds__expunge_dirty_entry_in_flush_test(H5F_t * file_ptr)
+{
+ H5C_t * cache_ptr = file_ptr->shared->cache;
+ int i;
+ herr_t result;
+ struct expected_entry_status expected[36] =
+ {
+ /* the expected array is used to maintain a table of the expected status of every
+ * entry used in this test. Note that since the function that processes this
+ * array only processes as much of it as it is told to, we don't have to
+ * worry about maintaining the status of entries that we haven't used yet.
+ */
+ /* entry entry in at main flush dep flush dep child flush flush flush */
+ /* type: index: size: cache: addr: dirty: prot: pinned: dsrlzd: srlzd: dest: par idx: dep ref.count: dep height: order: */
+ { HUGE_ENTRY_TYPE, 0, HUGE_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 1, HUGE_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 2, HUGE_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 3, HUGE_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 }
+ };
+
+ if ( pass ) {
+
+ if ( cache_ptr == NULL ) {
+
+ pass = FALSE;
+ failure_mssg = "cache_ptr NULL on entry to cedds expunge dirty entry in flush test.";
+ }
+ else if ( ( cache_ptr->index_len != 0 ) ||
+ ( cache_ptr->index_size != 0 ) ) {
+
+ pass = FALSE;
+ failure_mssg = "cache not empty on entry to cedds expunge dirty entry in flush test.";
+ }
+ else if ( ( cache_ptr->max_cache_size != (2 * 1024 * 1024 ) ) ||
+ ( cache_ptr->min_clean_size != (1 * 1024 * 1024 ) ) ) {
+
+ pass = FALSE;
+ failure_mssg =
+ "unexpected cache config at start of cedds expunge dirty entry in flush test.";
+
+ } else {
+
+ /* set min clean size to zero for this test as it simplifies
+ * computing the expected cache size after each operation.
+ */
+
+ cache_ptr->min_clean_size = 0;
+ }
+ }
+
+ if ( pass ) {
+
+ /* The basic idea of this test is to setup the cache such
+ * that:
+ *
+ * 1) the cache contains several dirty entries.
+ *
+ * 2) the first entry on the slist is dirty, and has a flush
+ * operation that will remove the second entry on the
+ * slist.
+ *
+ * Then load flush the cache. Cache should handle the
+ * removal of the next entry in the slist scan gracefully.
+ */
+
+ /* reset the stats before we start. If stats are enabled, we will
+ * check to see if they are as expected at the end.
+ */
+ H5C_stats__reset(cache_ptr);
+
+
+ /* Load four huge entries into the cache. Recall that huge entries
+ * are one fourth the size of monster entries (16 KB vs. 64 KB).
+ */
+ for ( i = 0; i < 4; i++ ) {
+
+ protect_entry(file_ptr, HUGE_ENTRY_TYPE, i);
+ unprotect_entry(file_ptr, HUGE_ENTRY_TYPE, i, H5C__DIRTIED_FLAG);
+ }
+
+ if ( ( cache_ptr->index_len != 4 ) ||
+ ( cache_ptr->index_size != (4 * HUGE_ENTRY_SIZE) ) ) {
+
+ pass = FALSE;
+
+ failure_mssg = "unexpected size/len in cedds expunge dirty entry in flush test (1)";
+ }
+ }
+
+ if ( pass ) {
+
+ /* Next, set up the flush operation:
+ *
+ * (HET, 0) expunges (HET, 1)
+ *
+ */
+ add_flush_op(HUGE_ENTRY_TYPE, 0, FLUSH_OP__EXPUNGE,
+ HUGE_ENTRY_TYPE, 1, FALSE, (size_t)0, NULL);
+
+ }
+
+ if ( pass ) {
+
+ /* to summarize, at present the following entries
+ * are in cache with the following characteristics:
+ *
+ * in
+ * entry: cache? size: dirty? pinned? pins: flush operations:
+ *
+ * (HET, 0) Y 16 KB Y N - expunge (HET 1)
+ *
+ * (HET, 1) Y 16 KB Y N - -
+ *
+ * (HET, 2) Y 16 KB Y N - -
+ *
+ * (HET, 3) Y 16 KB Y N - -
+ *
+ * Recall that in this test bed, flush operations are excuted the
+ * first time the associated entry is flushed, and are then
+ * deleted.
+ */
+
+ /* verify the expected status of all entries we have loaded to date: */
+ verify_entry_status(cache_ptr, 0, 4, expected);
+ }
+
+ /* flush the cache to run the test. In the process, clean up after test. */
+
+ if ( pass ) {
+
+ result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5C__FLUSH_INVALIDATE_FLAG);
+
+ if ( result < 0 ) {
+
+ pass = FALSE;
+ failure_mssg = "Cache flush invalidate failed in cedds expunge dirty entry in flush test";
+ }
+ else if ( ( cache_ptr->index_len != 0 ) ||
+ ( cache_ptr->index_size != 0 ) ) {
+
+ pass = FALSE;
+ failure_mssg = "Unexpected cache len/size after cedds expunge dirty entry in flush test";
+
+ }
+ }
+
+#if H5C_COLLECT_CACHE_STATS
+ /* If we are collecting stats, check to see if we get the expected
+ * values.
+ */
+ if ( pass ) {
+
+ if ( ( cache_ptr->insertions[HUGE_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->pinned_insertions[HUGE_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->clears[HUGE_ENTRY_TYPE] != 1 ) ||
+ ( cache_ptr->flushes[HUGE_ENTRY_TYPE] != 3 ) ||
+ ( cache_ptr->evictions[HUGE_ENTRY_TYPE] != 4 ) ||
+ ( cache_ptr->take_ownerships[HUGE_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->moves[HUGE_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->entry_flush_moves[HUGE_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->cache_flush_moves[HUGE_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->pins[HUGE_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->unpins[HUGE_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->dirty_pins[HUGE_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->pinned_flushes[HUGE_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->pinned_clears[HUGE_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->size_increases[HUGE_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->size_decreases[HUGE_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->entry_flush_size_changes[HUGE_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->cache_flush_size_changes[HUGE_ENTRY_TYPE] != 0 ) ) {
+
+ pass = FALSE;
+ failure_mssg = "Unexpected huge size entry stats in cedds__expunge_dirty_entry_in_flush_test().";
+ }
+ }
+
+ if ( pass ) {
+
+ if ( ( cache_ptr->slist_scan_restarts != 1 ) ||
+ ( cache_ptr->LRU_scan_restarts != 0 ) ||
+ ( cache_ptr->hash_bucket_scan_restarts != 0 ) ) {
+
+ pass = FALSE;
+ failure_mssg = "unexpected scan restart stats in cedds__expunge_dirty_entry_in_flush_test().";
+ }
+ }
+#endif /* H5C_COLLECT_CACHE_STATS */
+
+ if ( pass ) {
+
+ reset_entries();
+ }
+
+ if ( pass ) {
+
+ /* reset cache min clean size to its expected value */
+ cache_ptr->min_clean_size = (1 * 1024 * 1024);
+ }
+
+ return;
+
+} /* cedds__expunge_dirty_entry_in_flush_test() */
+
+
+/*-------------------------------------------------------------------------
+ * Function: cedds__H5C_make_space_in_cache()
+ *
+ * Purpose: Verify that H5C_make_space_in_cache() can handle the
+ * removal from the cache of the next item in its reverse scan
+ * of the LRU list.
+ *
+ * Do this by setting up a full cache, with the last entry
+ * on the LRU being both dirty and having a flush operation
+ * that deleted the second to last entry on the LRU. Then
+ * load an additional entry, triggering the flush of the last
+ * item, and thereby the deletion of the second to last item.
+ *
+ * H5C_make_space_in_cache() should detect this deletion, and
+ * restart its scan of the LRU from the tail, instead of
+ * examining the now deleted next item up on the LRU.
+ *
+ * Do nothing if pass is FALSE on entry.
+ *
+ * Return: void
+ *
+ * Programmer: John Mainzer
+ * 4/4/15
+ *
+ * Modifications:
+ *
+ * None.
+ *
+ *-------------------------------------------------------------------------
+ */
+
+static void
+cedds__H5C_make_space_in_cache(H5F_t * file_ptr)
+{
+ H5C_t * cache_ptr = file_ptr->shared->cache;
+ int i;
+ const int num_huge_entries = 4;
+ const int num_monster_entries = 32;
+ herr_t result;
+ struct expected_entry_status expected[36] =
+ {
+ /* the expected array is used to maintain a table of the expected status of every
+ * entry used in this test. Note that since the function that processes this
+ * array only processes as much of it as it is told to, we don't have to
+ * worry about maintaining the status of entries that we haven't used yet.
+ */
+ /* entry entry in at main flush dep flush dep child flush flush flush */
+ /* type: index: size: cache: addr: dirty: prot: pinned: dsrlzd: srlzd: dest: par idx: dep ref.count: dep height: order: */
+ { HUGE_ENTRY_TYPE, 0, HUGE_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 1, HUGE_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 2, HUGE_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { HUGE_ENTRY_TYPE, 3, HUGE_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 0, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 1, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 2, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 3, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 4, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 5, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 6, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 7, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 8, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 9, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 10, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 11, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 12, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 13, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 14, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 15, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 16, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 17, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 18, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 19, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 20, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 21, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 22, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 23, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 24, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 25, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 26, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 27, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 28, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 29, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 30, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 31, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 }
+ };
+
+ if ( pass ) {
+
+ if ( cache_ptr == NULL ) {
+
+ pass = FALSE;
+ failure_mssg = "cache_ptr NULL on entry to cedds for H5C_make_space_in_cache() test.";
+ }
+ else if ( ( cache_ptr->index_len != 0 ) ||
+ ( cache_ptr->index_size != 0 ) ) {
+
+ pass = FALSE;
+ failure_mssg = "cache not empty at start of flush ops eviction test.";
+ }
+ else if ( ( cache_ptr->max_cache_size != (2 * 1024 * 1024 ) ) ||
+ ( cache_ptr->min_clean_size != (1 * 1024 * 1024 ) ) ) {
+
+ pass = FALSE;
+ failure_mssg =
+ "unexpected cache config at start of cedds H5C__make_space_in_cache() test.";
+
+ } else {
+
+ /* set min clean size to zero for this test as it simplifies
+ * computing the expected cache size after each operation.
+ */
+
+ cache_ptr->min_clean_size = 0;
+ }
+ }
+
+ if ( pass ) {
+
+ /* The basic idea of this test is to setup the cache such
+ * that:
+ *
+ * 1) the cache is full
+ *
+ * 2) the last entry on the LRU is dirty, and has a flush
+ * operation that will remove the second to last entry
+ * on the LRU from the cache.
+ *
+ * Then load another entry into the cache. See if
+ * H5C__make_space_in_cache() detects the removal of
+ * the next item in the scan, and restarts the scan
+ * from the bottom of the LRU. Note that the newly
+ * loaded entry must be large enough to require that
+ * the scan continue after the entry is expunged.
+ */
+
+ /* reset the stats before we start. If stats are enabled, we will
+ * check to see if they are as expected at the end.
+ */
+ H5C_stats__reset(cache_ptr);
+
+
+ /* Load four huge entries into the cache. Recall that huge entries
+ * are one fourth the size of monster entries (16 KB vs. 64 KB).
+ */
+ for ( i = 0; i < 4; i++ ) {
+
+ protect_entry(file_ptr, HUGE_ENTRY_TYPE, i);
+ unprotect_entry(file_ptr, HUGE_ENTRY_TYPE, i, H5C__DIRTIED_FLAG);
+ }
+
+ if ( ( cache_ptr->index_len != 4 ) ||
+ ( cache_ptr->index_size != (4 * HUGE_ENTRY_SIZE) ) ) {
+
+ pass = FALSE;
+
+ failure_mssg = "unexpected size/len in H5C__make_space_in_cache() test (1)";
+ }
+ }
+
+ if ( pass ) {
+
+ /* Next, set up the flush operation:
+ *
+ * (HET, 0) expunges (HET, 1)
+ *
+ */
+ add_flush_op(HUGE_ENTRY_TYPE, 0, FLUSH_OP__EXPUNGE,
+ HUGE_ENTRY_TYPE, 1, FALSE, (size_t)0, NULL);
+
+ }
+
+ if ( pass ) {
+
+ /* to summarize, at present the following entries
+ * are in cache with the following characteristics:
+ *
+ * in
+ * entry: cache? size: dirty? pinned? pins: flush operations:
+ *
+ * (HET, 0) Y 16 KB Y N - expunge (HET 1)
+ *
+ * (HET, 1) Y 16 KB N N - -
+ *
+ * (HET, 2) Y 16 KB N N - -
+ *
+ * (HET, 3) Y 16 KB N N - -
+ *
+ * Recall that in this test bed, flush operations are excuted the
+ * first time the associated entry is flushed, and are then
+ * deleted.
+ */
+
+ /* Now fill up the cache with other, unrelated entries. Recall
+ * that the cache size is 2 MB and 31 * 64 KB + 4 * 16 KP == 2 MB.
+ */
+ for ( i = 0; i < 31; i++ )
+ {
+ protect_entry(file_ptr, MONSTER_ENTRY_TYPE, i);
+ unprotect_entry(file_ptr, MONSTER_ENTRY_TYPE, i, H5C__DIRTIED_FLAG);
+ }
+
+ /* The cache should now be exactly full */
+ if ( ( cache_ptr->index_len != 35 ) ||
+ ( cache_ptr->index_size != 2 * 1024 * 1024 ) ||
+ ( cache_ptr->index_size != ((4 * HUGE_ENTRY_SIZE) +
+ (31 * MONSTER_ENTRY_SIZE)) ) ) {
+
+ pass = FALSE;
+ failure_mssg = "unexpected size/len in H5C__make_space_in_cache() test (2)";
+
+ } else {
+
+ /* verify the expected status of all entries we have loaded to date: */
+ verify_entry_status(cache_ptr, 0, 35, expected);
+ }
+ }
+
+ if ( pass ) {
+
+ /* now load another monster entry. This should cause
+ * H5C__make_space_in_cache() to be called. (HET 0) is dirty, and is at
+ * the bottom of the LRU. * Thus it will be flushed, and moved to the
+ * head of the LRU. However, during the flush, (HET 1) should be expunged
+ * from the cache. Since (MET 1) is the next item in
+ * H5C__make_space_in_cache(), must detect its removal from the cache,
+ * and refrain from trying to flush it.
+ *
+ * Since all entries in the cache are dirty, all entries will be flushed,
+ * and HET 0, 2, and 3 will be evicted to make room for the new
+ * monster entry (MET, 31).
+ *
+ * Verify this. If H5C_make_space_in_cache() chokes, failure will
+ * be detected in protect_entry(). Thus end the "if ( pass )" clause
+ * there so the error message will not be overwritten.
+ */
+
+ protect_entry(file_ptr, MONSTER_ENTRY_TYPE, 31);
+ }
+
+ if ( pass ) {
+
+ /* if the protect succeeded, unprotect and verify that all is at
+ * it should be.
+ */
+
+ unprotect_entry(file_ptr, MONSTER_ENTRY_TYPE, 31, H5C__DIRTIED_FLAG);
+
+ /* The cache should now be exactly full */
+ if ( ( cache_ptr->index_len != 32 ) ||
+ ( cache_ptr->index_size != 2 * 1024 * 1024 ) ||
+ ( cache_ptr->index_size != (32 * MONSTER_ENTRY_SIZE) ) ) {
+
+ pass = FALSE;
+ failure_mssg = "unexpected size/len in H5C__make_space_in_cache() test (3)";
+
+ } else {
+
+ /* modify the expected table to match the new situation, and
+ * then call verify_entry_status().
+ */
+ for ( i = 0; i < num_huge_entries; i++ )
+ {
+ expected[i].in_cache = FALSE;
+ expected[i].is_dirty = FALSE;
+ expected[i].serialized = TRUE;
+ expected[i].destroyed = TRUE;
+ }
+
+ /* (HET, 1) was expunged, so touch its entry up accordingly */
+ expected[1].is_dirty = TRUE;
+ expected[1].serialized = FALSE;
+
+ for ( i = num_huge_entries; i < num_huge_entries + num_monster_entries - 1; i++ )
+ {
+ expected[i].is_dirty = FALSE;
+ expected[i].serialized = TRUE;
+ }
+
+ /* verify the expected status of all entries: */
+ verify_entry_status(cache_ptr, 0, 36, expected);
+ }
+ }
+
+ /* flush the cache and end the test. */
+
+ if ( pass ) {
+
+ result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5C__FLUSH_INVALIDATE_FLAG);
+
+ if ( result < 0 ) {
+
+ pass = FALSE;
+ failure_mssg = "Cache flush invalidate failed after flush op eviction test";
+ }
+ else if ( ( cache_ptr->index_len != 0 ) ||
+ ( cache_ptr->index_size != 0 ) ) {
+
+ pass = FALSE;
+ failure_mssg = "Unexpected cache len/size after cleanup of flush op eviction test";
+
+ }
+ }
+
+#if H5C_COLLECT_CACHE_STATS
+ /* If we are collecting stats, check to see if we get the expected
+ * values.
+ */
+
+ if ( pass ) {
+
+ if ( ( cache_ptr->insertions[HUGE_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->pinned_insertions[HUGE_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->clears[HUGE_ENTRY_TYPE] != 1 ) ||
+ ( cache_ptr->flushes[HUGE_ENTRY_TYPE] != 3 ) ||
+ ( cache_ptr->evictions[HUGE_ENTRY_TYPE] != 4 ) ||
+ ( cache_ptr->take_ownerships[HUGE_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->moves[HUGE_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->entry_flush_moves[HUGE_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->cache_flush_moves[HUGE_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->pins[HUGE_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->unpins[HUGE_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->dirty_pins[HUGE_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->pinned_flushes[HUGE_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->pinned_clears[HUGE_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->size_increases[HUGE_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->size_decreases[HUGE_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->entry_flush_size_changes[HUGE_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->cache_flush_size_changes[HUGE_ENTRY_TYPE] != 0 ) ) {
+
+ pass = FALSE;
+ failure_mssg = "Unexpected large entry stats in cedds__H5C_make_space_in_cache().";
+ }
+ }
+
+ if ( pass ) {
+
+ if ( ( cache_ptr->insertions[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->pinned_insertions[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->clears[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->flushes[MONSTER_ENTRY_TYPE] != 32 ) ||
+ ( cache_ptr->evictions[MONSTER_ENTRY_TYPE] != 32 ) ||
+ ( cache_ptr->take_ownerships[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->moves[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->entry_flush_moves[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->cache_flush_moves[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->pins[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->unpins[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->dirty_pins[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->pinned_flushes[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->pinned_clears[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->size_increases[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->size_decreases[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->entry_flush_size_changes[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->cache_flush_size_changes[MONSTER_ENTRY_TYPE] != 0 ) ) {
+
+ pass = FALSE;
+ failure_mssg = "Unexpected monster entry stats in cedds__H5C_make_space_in_cache().";
+ }
+ }
+
+ if ( pass ) {
+
+ if ( ( cache_ptr->slist_scan_restarts != 0 ) ||
+ ( cache_ptr->LRU_scan_restarts != 1 ) ||
+ ( cache_ptr->hash_bucket_scan_restarts != 0 ) ) {
+
+ pass = FALSE;
+ failure_mssg = "unexpected scan restart stats in cedds__H5C_make_space_in_cache().";
+ }
+ }
+#endif /* H5C_COLLECT_CACHE_STATS */
+
+ if ( pass ) {
+
+ reset_entries();
+ }
+
+ if ( pass ) {
+
+ /* reset cache min clean size to its expected value */
+ cache_ptr->min_clean_size = (1 * 1024 * 1024);
+ }
+
+ return;
+
+} /* cedds__H5C_make_space_in_cache() */
+
+
+/*-------------------------------------------------------------------------
+ * Function: cedds__H5C__autoadjust__ageout__evict_aged_out_entries()
+ *
+ * Purpose: Verify that H5C__autoadjust__ageout__evict_aged_out_entries()
+ * can handle the removal from the cache of the next item in
+ * its reverse scan of the LRU list.
+ *
+ * Do this by setting up a full cache, with the last entry
+ * on the LRU being both dirty and having a flush operation
+ * that deletes the second to last entry on the LRU. Then
+ * access the first item in the LRU repeatedly until the
+ * item, and thereby the deletion of the second to last item.
+ *
+ * H5C_make_space_in_cache() should detect this deletion, and
+ * restart its scan of the LRU from the tail, instead of
+ * examining the now deleted next item up on the LRU.
+ *
+ * Do nothing if pass is FALSE on entry.
+ *
+ * Return: void
+ *
+ * Programmer: John Mainzer
+ * 4/4/15
+ *
+ * Modifications:
+ *
+ * None.
+ *
+ *-------------------------------------------------------------------------
+ */
+
+static void
+cedds__H5C__autoadjust__ageout__evict_aged_out_entries(H5F_t * file_ptr)
+{
+ H5C_t * cache_ptr = file_ptr->shared->cache;
+ int i;
+ herr_t result;
+ struct expected_entry_status expected[36] =
+ {
+ /* the expected array is used to maintain a table of the expected status of every
+ * entry used in this test. Note that since the function that processes this
+ * array only processes as much of it as it is told to, we don't have to
+ * worry about maintaining the status of entries that we haven't used yet.
+ */
+ /* entry entry in at main flush dep flush dep child flush flush flush */
+ /* type: index: size: cache: addr: dirty: prot: pinned: dsrlzd: srlzd: dest: par idx: dep ref.count: dep height: order: */
+ { MONSTER_ENTRY_TYPE, 0, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 1, MONSTER_ENTRY_SIZE, TRUE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 2, MONSTER_ENTRY_SIZE, TRUE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 3, MONSTER_ENTRY_SIZE, TRUE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 4, MONSTER_ENTRY_SIZE, TRUE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 5, MONSTER_ENTRY_SIZE, TRUE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 6, MONSTER_ENTRY_SIZE, TRUE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 7, MONSTER_ENTRY_SIZE, TRUE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 8, MONSTER_ENTRY_SIZE, TRUE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 9, MONSTER_ENTRY_SIZE, TRUE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 10, MONSTER_ENTRY_SIZE, TRUE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 11, MONSTER_ENTRY_SIZE, TRUE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 12, MONSTER_ENTRY_SIZE, TRUE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 13, MONSTER_ENTRY_SIZE, TRUE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 14, MONSTER_ENTRY_SIZE, TRUE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 15, MONSTER_ENTRY_SIZE, TRUE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 16, MONSTER_ENTRY_SIZE, TRUE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 17, MONSTER_ENTRY_SIZE, TRUE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 18, MONSTER_ENTRY_SIZE, TRUE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 19, MONSTER_ENTRY_SIZE, TRUE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 20, MONSTER_ENTRY_SIZE, TRUE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 21, MONSTER_ENTRY_SIZE, TRUE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 22, MONSTER_ENTRY_SIZE, TRUE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 23, MONSTER_ENTRY_SIZE, TRUE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 24, MONSTER_ENTRY_SIZE, TRUE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 25, MONSTER_ENTRY_SIZE, TRUE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 26, MONSTER_ENTRY_SIZE, TRUE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 27, MONSTER_ENTRY_SIZE, TRUE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 28, MONSTER_ENTRY_SIZE, TRUE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 29, MONSTER_ENTRY_SIZE, TRUE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 30, MONSTER_ENTRY_SIZE, TRUE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 31, MONSTER_ENTRY_SIZE, TRUE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 }
+ };
+ H5C_auto_size_ctl_t saved_auto_size_ctl;
+ H5C_auto_size_ctl_t test_auto_size_ctl =
+ {
+ /* int32_t version = */ H5C__CURR_AUTO_SIZE_CTL_VER,
+ /* H5C_auto_resize_report_fcn rpt_fcn = */ test_rpt_fcn,
+
+ /* hbool_t set_initial_size = */ TRUE,
+ /* size_t initial_size = */ (2 * 1024 * 1024),
+
+ /* double min_clean_fraction = */ 0.5f,
+
+ /* size_t max_size = */ (8 * 1024 * 1024),
+ /* size_t min_size = */ (1 * 1024 * 1024),
+
+ /* int64_t epoch_length = */ 1000,
+
+
+ /* enum H5C_cache_incr_mode incr_mode = */ H5C_incr__threshold,
+
+ /* double lower_hr_threshold = */ 0.75f,
+
+ /* double increment = */ 2.0f,
+
+ /* hbool_t apply_max_increment = */ TRUE,
+ /* size_t max_increment = */ (4 * 1024 * 1024),
+
+ /* enum H5C_cache_flash_incr_mode */
+ /* flash_incr_mode = */ H5C_flash_incr__off,
+ /* double flash_multiple = */ 2.0f,
+ /* double flash_threshold = */ 0.5f,
+
+
+ /* enum H5C_cache_decr_mode decr_mode = */ H5C_decr__age_out,
+
+ /* double upper_hr_threshold = */ 0.995f,
+
+ /* double decrement = */ 0.5f,
+
+ /* hbool_t apply_max_decrement = */ FALSE,
+ /* size_t max_decrement = */ (1 * 1024 * 1024),
+
+ /* int32_t epochs_before_eviction = */ 1,
+
+ /* hbool_t apply_empty_reserve = */ TRUE,
+ /* double empty_reserve = */ 0.05f
+ };
+
+ if ( pass ) {
+
+ if ( cache_ptr == NULL ) {
+
+ pass = FALSE;
+ failure_mssg = "cache_ptr NULL on entry to cedds for H5C__autoadjust__ageout__evict_aged_out_entries() test.";
+ }
+ else if ( ( cache_ptr->index_len != 0 ) ||
+ ( cache_ptr->index_size != 0 ) ) {
+
+ pass = FALSE;
+ failure_mssg = "cache not empty at start cedds for H5C__autoadjust__ageout__evict_aged_out_entries() test.";
+ }
+ else if ( ( cache_ptr->max_cache_size != (2 * 1024 * 1024 ) ) ||
+ ( cache_ptr->min_clean_size != (1 * 1024 * 1024 ) ) ) {
+
+ pass = FALSE;
+ failure_mssg =
+ "unexpected cache config at start of cedds H5C__autoadjust__ageout__evict_aged_out_entries() test.";
+
+ } else {
+
+ /* set min clean size to zero for this test as it simplifies
+ * computing the expected cache size after each operation.
+ */
+
+ cache_ptr->min_clean_size = 0;
+ }
+ }
+
+ /* save the initial resize configuration so we can restore it later */
+ if ( pass ) {
+
+ saved_auto_size_ctl.version = H5C__CURR_AUTO_SIZE_CTL_VER;
+
+ result = H5C_get_cache_auto_resize_config(cache_ptr,
+ &saved_auto_size_ctl);
+
+ if ( result != SUCCEED ) {
+
+ pass = FALSE;
+ failure_mssg = "H5C_get_cache_auto_resize_config failed.";
+
+ }
+ }
+
+ /* set the resize configuration we will be using in the test */
+ if ( pass ) {
+
+ result = H5C_set_cache_auto_resize_config(cache_ptr, &test_auto_size_ctl);
+
+ if ( result != SUCCEED ) {
+
+ pass = FALSE;
+ failure_mssg = "H5C_set_cache_auto_resize_config failed 1.\n";
+ }
+ }
+
+ if ( pass ) {
+
+ /* The basic idea of this test is to setup the cache such
+ * that:
+ *
+ * 1) the cache is full
+ *
+ * 2) the last entry on the LRU is dirty, and has a flush
+ * operation that will remove the second to last entry
+ * on the LRU from the cache.
+ *
+ * Then access the first item in the LRU until the epoch
+ * and H5C__autoadjust__ageout__evict_aged_out_entries()
+ * is invoked. Verify that the function deals with the
+ * deletion of the next item in its scan cleanly.
+ */
+
+ /* reset the stats before we start. If stats are enabled, we will
+ * check to see if they are as expected at the end.
+ */
+ H5C_stats__reset(cache_ptr);
+
+
+ /* load the first entry -- mark it dirty */
+ protect_entry(file_ptr, MONSTER_ENTRY_TYPE, 0);
+ unprotect_entry(file_ptr, MONSTER_ENTRY_TYPE, 0, H5C__DIRTIED_FLAG);
+
+ /* Then load the rest of the entries to fill the cache:
+ *
+ * Recall that the cache size is 2 MB and 32 * 64 KB == 2 MB.
+ */
+ for ( i = 1; i < 32; i++ )
+ {
+ protect_entry(file_ptr, MONSTER_ENTRY_TYPE, i);
+ unprotect_entry(file_ptr, MONSTER_ENTRY_TYPE, i, H5C__NO_FLAGS_SET);
+ }
+ }
+
+ if ( pass ) {
+
+ /* Next, set up the flush operation:
+ *
+ * (MET, 0) expunges (MET, 1)
+ *
+ */
+ add_flush_op(MONSTER_ENTRY_TYPE, 0, FLUSH_OP__EXPUNGE,
+ MONSTER_ENTRY_TYPE, 1, FALSE, (size_t)0, NULL);
+
+ }
+
+ if ( pass ) {
+
+ /* to summarize, at present the following entries
+ * are in cache with the following characteristics:
+ *
+ * in
+ * entry: cache? size: dirty? pinned? pins: flush operations:
+ *
+ * (MET, 0) Y 64 KB Y N - expunge (MET 1)
+ *
+ * (MET, 1-31) Y 64 KB N N - -
+ *
+ * Recall that in this test bed, flush operations are excuted the
+ * first time the associated entry is flushed, and are then
+ * deleted.
+ */
+
+ /* The cache should now be exactly full */
+ if ( ( cache_ptr->index_len != 32 ) ||
+ ( cache_ptr->index_size != 2 * 1024 * 1024 ) ||
+ ( cache_ptr->index_size != (32 * MONSTER_ENTRY_SIZE) ) ) {
+
+ pass = FALSE;
+ failure_mssg = "unexpected size/len in H5C__autoadjust__ageout__evict_aged_out_entries() test (1)";
+
+ } else {
+
+ /* verify the expected status of all entries we have loaded to date: */
+ verify_entry_status(cache_ptr, 0, 32, expected);
+ }
+ }
+
+ /* protect and unprotect (MET, 31) repeatedly until the end of the first epoch */
+ while ( ( pass ) && ( cache_ptr->cache_accesses > 0 ) ) {
+
+ protect_entry(file_ptr, MONSTER_ENTRY_TYPE, 31);
+ unprotect_entry(file_ptr, MONSTER_ENTRY_TYPE, 31, H5C__NO_FLAGS_SET);
+ }
+
+ /* at this point, an epoch marker entry should have been inserted into the LRU */
+
+ if ( pass ) {
+
+ /* protect and unprotect (MET, 31) again to get cache_accesses > 0 */
+ protect_entry(file_ptr, MONSTER_ENTRY_TYPE, 31);
+ unprotect_entry(file_ptr, MONSTER_ENTRY_TYPE, 31, H5C__NO_FLAGS_SET);
+ }
+
+ /* protect and unprotect (MET, 31) repeatedly until the end of the second epoch */
+ while ( ( pass ) && ( cache_ptr->cache_accesses > 0 ) ) {
+
+ protect_entry(file_ptr, MONSTER_ENTRY_TYPE, 31);
+ unprotect_entry(file_ptr, MONSTER_ENTRY_TYPE, 31, H5C__NO_FLAGS_SET);
+ }
+
+ /* at this point, only (MET, 0) and (MET, 31) should remain in the cache,
+ * all other entries having been evicted by the ageout adaptive cache
+ * resizing algorithm. (Since (MET, 0) was dirty, it was flushed and
+ * moved to the head of the LRU by the ageout algorithm.)
+ */
+
+ if ( pass ) {
+
+ if ( ( cache_ptr->index_len != 2 ) ||
+ ( cache_ptr->index_size != 2 * MONSTER_ENTRY_SIZE ) ) {
+
+ pass = FALSE;
+ failure_mssg = "unexpected size/len in H5C__autoadjust__ageout__evict_aged_out_entries() test (2)";
+
+ } else {
+
+ /* update the expected table to reflect the expected values at
+ * this point, and then verify.
+ */
+
+ expected[0].is_dirty = FALSE;
+ expected[0].serialized = TRUE;
+
+ for ( i = 1; i < 31; i++ )
+ {
+ expected[i].in_cache = FALSE;
+ expected[i].is_dirty = FALSE;
+ expected[i].destroyed = TRUE;
+ }
+
+ verify_entry_status(cache_ptr, 0, 32, expected);
+ }
+ }
+
+ /* restore the initial resize configuration */
+ if ( pass ) {
+
+ saved_auto_size_ctl.set_initial_size = TRUE;
+ saved_auto_size_ctl.initial_size = 2 * 1024 * 1024;
+
+ result = H5C_set_cache_auto_resize_config(cache_ptr, &saved_auto_size_ctl);
+
+ if ( result != SUCCEED ) {
+
+ pass = FALSE;
+ failure_mssg = "H5C_set_cache_auto_resize_config failed 2.\n";
+ }
+ }
+
+ /* flush the cache and end the test. */
+
+ if ( pass ) {
+
+ result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5C__FLUSH_INVALIDATE_FLAG);
+
+ if ( result < 0 ) {
+
+ pass = FALSE;
+ failure_mssg = "Cache flush invalidate failed after flush op eviction test";
+ }
+ else if ( ( cache_ptr->index_len != 0 ) ||
+ ( cache_ptr->index_size != 0 ) ) {
+
+ pass = FALSE;
+ failure_mssg = "Unexpected cache len/size after cleanup of flush op eviction test";
+
+ }
+ }
+
+#if H5C_COLLECT_CACHE_STATS
+ /* If we are collecting stats, check to see if we get the expected
+ * values.
+ */
+
+ if ( pass ) {
+
+ if ( ( cache_ptr->insertions[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->pinned_insertions[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->clears[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->flushes[MONSTER_ENTRY_TYPE] != 1 ) ||
+ ( cache_ptr->evictions[MONSTER_ENTRY_TYPE] != 32 ) ||
+ ( cache_ptr->take_ownerships[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->moves[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->entry_flush_moves[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->cache_flush_moves[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->pins[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->unpins[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->dirty_pins[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->pinned_flushes[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->pinned_clears[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->size_increases[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->size_decreases[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->entry_flush_size_changes[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->cache_flush_size_changes[MONSTER_ENTRY_TYPE] != 0 ) ) {
+
+ pass = FALSE;
+ failure_mssg = "Unexpected monster entry stats in cedds__H5C__autoadjust__ageout__evict_aged_out_entries().";
+ }
+ }
+
+ if ( pass ) {
+
+ if ( ( cache_ptr->slist_scan_restarts != 0 ) ||
+ ( cache_ptr->LRU_scan_restarts != 1 ) ||
+ ( cache_ptr->hash_bucket_scan_restarts != 0 ) ) {
+
+ pass = FALSE;
+ failure_mssg = "unexpected scan restart stats in cedds__H5C__autoadjust__ageout__evict_aged_out_entries().";
+ }
+ }
+#endif /* H5C_COLLECT_CACHE_STATS */
+
+ if ( pass ) {
+
+ reset_entries();
+ }
+
+ if ( pass ) {
+
+ /* reset cache min clean size to its expected value */
+ cache_ptr->min_clean_size = (1 * 1024 * 1024);
+ }
+
+ return;
+
+} /* cedds__H5C__autoadjust__ageout__evict_aged_out_entries() */
+
+
+/*-------------------------------------------------------------------------
+ * Function: cedds__H5C_flush_invalidate_cache__bucket_scan()
+ *
+ * Purpose: Verify that H5C_flush_invalidate_cache() can handle
+ * the removal from the cache of the next item in
+ * its scans of hash buckets.
+ *
+ * !!!!!!!!!! WARNING !!!!!!!!!!
+ *
+ * This test may fail to function correctly if the hash
+ * table size or hash function is altered.
+ *
+ * To setup the test, this function depends on the fact that
+ * H5C_flush_invalidate_cache() does alternating scans of the
+ * slist and the index. If this changes, the test will likely
+ * also cease to function correctly.
+ *
+ * The test relies on a known hash function and hash table
+ * size to select a set of test entries that will all hash
+ * to the same hash bucket -- call it the test hash bucket.
+ * It also relies on known behavior of the cache to place
+ * the entries in the test bucket in a known order.
+ *
+ * To avoid pre-mature flushes of the entries in the
+ * test hash bucket, all entries are initially clean,
+ * with the exception of the first entry which is dirty.
+ * It avoids premature flushing by being the parent in
+ * a flush dependency. The first entry in the test bucket
+ * also has a flush op which expunges the second entry --
+ * setting up the failure.
+ *
+ * An additional dirty entry is added (which must hash
+ * to a different bucket, and must have a higher address
+ * than at least the first entry in the test hash bucket.
+ * This entry is the child in a flush dependency with the
+ * first entry in the above hash bucket, and contains
+ * a flush op to destroy this flush dependency.
+ *
+ * Since the first entry in the test hash bucket has a lower
+ * address that the other dirty entry, the scan of the
+ * slist encounters it first, and passes over it because
+ * it has a flush dependency height of 1.
+ *
+ * The scan then encounters the second dirty entry and flushes
+ * it -- causing it to destroy the flush dependency and thus
+ * reducing the flush dependency height of the first entry in
+ * the test hash bucket to zero.
+ *
+ * After completing a scan of the slist,
+ * H5C_flush_invalidate_cache() then scans the index,
+ * flushing all entries of flush dependency height zero.
+ *
+ * This sets up the potential error when the first entry
+ * in the test hash bucket is flushed -- expunging the
+ * second entry as a side effect. If
+ * H5C_flush_invalidate_cache() fails to detect this,
+ * it will attempt to continue its scan of the bucket with
+ * an entry that has been deleted from the cache.
+ *
+ * Do nothing if pass is FALSE on entry.
+ *
+ * Return: void
+ *
+ * Programmer: John Mainzer
+ * 4/9/15
+ *
+ * Modifications:
+ *
+ * None.
+ *
+ *-------------------------------------------------------------------------
+ */
+
+static void
+cedds__H5C_flush_invalidate_cache__bucket_scan(H5F_t * file_ptr)
+{
+ H5C_t * cache_ptr = file_ptr->shared->cache;
+ int i;
+ int expected_hash_bucket = 0;
+ herr_t result;
+ haddr_t entry_addr;
+ test_entry_t * entry_ptr;
+ test_entry_t * base_addr = NULL;
+ struct H5C_cache_entry_t * scan_ptr;
+ struct expected_entry_status expected[5] =
+ {
+ /* the expected array is used to maintain a table of the expected status of every
+ * entry used in this test. Note that since the function that processes this
+ * array only processes as much of it as it is told to, we don't have to
+ * worry about maintaining the status of entries that we haven't used yet.
+ */
+ /* entry entry in at main flush dep flush dep child flush flush flush */
+ /* type: index: size: cache: addr: dirty: prot: pinned: dsrlzd: srlzd: dest: par type: par idx: dep ref.count: dep height: order: */
+ { MONSTER_ENTRY_TYPE, 0, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, TRUE, TRUE, FALSE, FALSE, -1, -1, {1,0,0,0,0,0}, 1, -1 },
+ { MONSTER_ENTRY_TYPE, 8, MONSTER_ENTRY_SIZE, TRUE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 16, MONSTER_ENTRY_SIZE, TRUE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 24, MONSTER_ENTRY_SIZE, TRUE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, -1, -1, {0,0,0,0,0,0}, 0, -1 },
+ { MONSTER_ENTRY_TYPE, 31, MONSTER_ENTRY_SIZE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, MONSTER_ENTRY_TYPE, 0, {0,0,0,0,0,0}, 0, -1 }
+ };
+
+ if ( pass ) {
+
+ if ( cache_ptr == NULL ) {
+
+ pass = FALSE;
+ failure_mssg = "cache_ptr NULL on entry to cedds for H5C__autoadjust__ageout__evict_aged_out_entries() test.";
+ }
+ else if ( ( cache_ptr->index_len != 0 ) ||
+ ( cache_ptr->index_size != 0 ) ) {
+
+ pass = FALSE;
+ failure_mssg = "cache not empty at start cedds for H5C__autoadjust__ageout__evict_aged_out_entries() test.";
+ }
+ else if ( ( cache_ptr->max_cache_size != (2 * 1024 * 1024 ) ) ||
+ ( cache_ptr->min_clean_size != (1 * 1024 * 1024 ) ) ) {
+
+ pass = FALSE;
+ failure_mssg =
+ "unexpected cache config at start of cedds H5C__autoadjust__ageout__evict_aged_out_entries() test.";
+
+ } else {
+
+ /* set min clean size to zero for this test as it simplifies
+ * computing the expected cache size after each operation.
+ */
+
+ cache_ptr->min_clean_size = 0;
+ }
+ }
+
+
+ if ( pass ) {
+
+ /* reset the stats before we start. If stats are enabled, we will
+ * check to see if they are as expected at the end.
+ */
+
+ H5C_stats__reset(cache_ptr);
+
+
+ /* load one dirty and three clean entries that should hash to the
+ * same hash bucket.
+ */
+
+ protect_entry(file_ptr, MONSTER_ENTRY_TYPE, 0);
+ unprotect_entry(file_ptr, MONSTER_ENTRY_TYPE, 0, H5C__DIRTIED_FLAG);
+
+ for ( i = 8; i <= 24; i += 8 )
+ {
+ protect_entry(file_ptr, MONSTER_ENTRY_TYPE, i);
+ unprotect_entry(file_ptr, MONSTER_ENTRY_TYPE, i, H5C__NO_FLAGS_SET);
+ }
+ }
+
+ if ( pass ) {
+
+ /* verify that the above entries hash to the same bucket */
+ base_addr = entries[MONSTER_ENTRY_TYPE];
+ entry_ptr = &(base_addr[0]);
+ entry_addr = entry_ptr->header.addr;
+
+ HDassert(entry_addr == entry_ptr->addr);
+
+ expected_hash_bucket = H5C__HASH_FCN(entry_addr);
+
+ for ( i = 8; i <= 24; i += 8 ) {
+
+ entry_ptr = &(base_addr[i]);
+ entry_addr = entry_ptr->header.addr;
+
+ if ( expected_hash_bucket != H5C__HASH_FCN(entry_addr) ) {
+
+ pass = FALSE;
+ failure_mssg = "Test entries don't map to same bucket -- hash table size or hash fcn change?";
+ }
+ }
+ }
+
+ if ( pass ) {
+
+ /* setup the expunge flush operation:
+ *
+ * (MET, 0) expunges (MET, 8)
+ *
+ */
+ add_flush_op(MONSTER_ENTRY_TYPE, 0, FLUSH_OP__EXPUNGE,
+ MONSTER_ENTRY_TYPE, 8, FALSE, (size_t)0, NULL);
+ }
+
+ if ( pass ) {
+
+ /* load the entry that will have a flush dependencey with (MET, 0),
+ * thus preventing it from being flushed on the first pass through
+ * the skip list.
+ */
+
+ protect_entry(file_ptr, MONSTER_ENTRY_TYPE, 31);
+ unprotect_entry(file_ptr, MONSTER_ENTRY_TYPE, 31, H5C__DIRTIED_FLAG);
+ }
+
+ if ( pass ) {
+
+ /* verify that the dirty entry doesn't map to the same
+ * hash bucket as the clean entries.
+ */
+
+ entry_ptr = &(base_addr[31]);
+ entry_addr = entry_ptr->header.addr;
+
+ if ( expected_hash_bucket == H5C__HASH_FCN(entry_addr) ) {
+
+ pass = FALSE;
+ failure_mssg = "Dirty entry maps to same hash bucket as clean entries?!?!";
+ }
+ }
+
+ if ( pass ) {
+
+ /* Next, create the flush dependency requiring (MET, 31) to
+ * be flushed prior to (MET, 0).
+ */
+
+ protect_entry(file_ptr, MONSTER_ENTRY_TYPE, 0);
+ create_flush_dependency(MONSTER_ENTRY_TYPE, 0, MONSTER_ENTRY_TYPE, 31);
+ unprotect_entry(file_ptr, MONSTER_ENTRY_TYPE, 0, H5C__DIRTIED_FLAG);
+
+ }
+
+ if ( pass ) {
+
+ /* Then, setup the flush operation to take down the flush
+ * dependency when (MET, 31) is flushed.
+ *
+ * (MET, 31) destroys flush dependency with (MET, 8)
+ *
+ */
+ add_flush_op(MONSTER_ENTRY_TYPE, 31, FLUSH_OP__DEST_FLUSH_DEP,
+ MONSTER_ENTRY_TYPE, 0, FALSE, (size_t)0, NULL);
+
+ }
+
+ if ( pass ) {
+
+ /* verify the expected status of all entries we have loaded to date: */
+ verify_entry_status(cache_ptr, 0, 5, expected);
+ }
+
+ if ( pass ) {
+
+ /* now do some protect / unprotect cycles to force the
+ * entries into the desired order in the hash bucket.
+ * Recall that entries are moved to the head of the
+ * hash bucket list on lookup.
+ */
+
+ for ( i = 24; i >= 0; i -= 8 )
+ {
+ protect_entry(file_ptr, MONSTER_ENTRY_TYPE, i);
+ unprotect_entry(file_ptr, MONSTER_ENTRY_TYPE, i, H5C__NO_FLAGS_SET);
+ }
+ }
+
+ if ( pass ) {
+
+ /* scan the hash bucket to verify that the expected entries appear
+ * in the expected order.
+ */
+ scan_ptr = cache_ptr->index[expected_hash_bucket];
+
+ i = 0;
+
+ while ( ( pass ) && ( i <= 24 ) )
+ {
+ entry_ptr = &(base_addr[i]);
+
+ if ( scan_ptr == NULL ) {
+
+ pass = FALSE;
+ failure_mssg = "premature end of hash bucket list?!?!";
+
+ } else if ( ( scan_ptr == NULL ) ||
+ ( scan_ptr != &(entry_ptr->header) ) ) {
+
+ pass = FALSE;
+ failure_mssg = "bad test hash bucket setup?!?!";
+ }
+
+ if ( pass ) {
+
+ scan_ptr = scan_ptr->ht_next;
+ i += 8;
+ }
+ }
+ }
+
+
+ /* test setup complete -- flush the cache to run and end the test. */
+
+ if ( pass ) {
+
+ result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5C__FLUSH_INVALIDATE_FLAG);
+
+ if ( result < 0 ) {
+
+ pass = FALSE;
+ failure_mssg = "Cache flush invalidate failed after flush op eviction test";
+ }
+ else if ( ( cache_ptr->index_len != 0 ) ||
+ ( cache_ptr->index_size != 0 ) ) {
+
+ pass = FALSE;
+ failure_mssg = "Unexpected cache len/size after cleanup of flush op eviction test";
+
+ }
+ }
+
+#if H5C_COLLECT_CACHE_STATS
+ /* If we are collecting stats, check to see if we get the expected
+ * values.
+ */
+
+ if ( pass ) {
+
+ if ( ( cache_ptr->insertions[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->pinned_insertions[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->clears[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->flushes[MONSTER_ENTRY_TYPE] != 2 ) ||
+ ( cache_ptr->evictions[MONSTER_ENTRY_TYPE] != 5 ) ||
+ ( cache_ptr->take_ownerships[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->moves[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->entry_flush_moves[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->cache_flush_moves[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->pins[MONSTER_ENTRY_TYPE] != 1 ) ||
+ ( cache_ptr->unpins[MONSTER_ENTRY_TYPE] != 1 ) ||
+ ( cache_ptr->dirty_pins[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->pinned_flushes[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->pinned_clears[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->size_increases[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->size_decreases[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->entry_flush_size_changes[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->cache_flush_size_changes[MONSTER_ENTRY_TYPE] != 0 ) ) {
+
+ pass = FALSE;
+ failure_mssg = "Unexpected monster entry stats in cedds__H5C_flush_invalidate_cache__bucket_scan().";
+ }
+ }
+
+ if ( pass ) {
+
+ if ( ( cache_ptr->slist_scan_restarts != 0 ) ||
+ ( cache_ptr->LRU_scan_restarts != 0 ) ||
+ ( cache_ptr->hash_bucket_scan_restarts != 1 ) ) {
+
+ pass = FALSE;
+ failure_mssg = "unexpected scan restart stats in cedds__H5C_flush_invalidate_cache__bucket_scan().";
+ }
+ }
+#endif /* H5C_COLLECT_CACHE_STATS */
+
+ if ( pass ) {
+
+ reset_entries();
+ }
+
+ if ( pass ) {
+
+ /* reset cache min clean size to its expected value */
+ cache_ptr->min_clean_size = (1 * 1024 * 1024);
+ }
+
+ return;
+
+} /* cedds__H5C_flush_invalidate_cache__bucket_scan() */
+
+
+/*-------------------------------------------------------------------------
+ * Function: check_stats()
+ *
+ * Purpose: If stats are enabled, conduct tests to verify correct
+ * functioning of the cache statistics collection code.
+ *
+ * Skip the test if stats are not enabled.
+ *
+ * At present this test is a shell -- fill it out at time
+ * permits.
+ *
+ * Return: void
+ *
+ * Programmer: John Mainzer
+ * 4/12/15
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+
+static unsigned
+check_stats(void)
+{
+
+#if H5C_COLLECT_CACHE_STATS
+
+ H5F_t * file_ptr = NULL;
+
+#endif /* H5C_COLLECT_CACHE_STATS */
+
+ TESTING("metadata cache statistics collection");
+
+#if H5C_COLLECT_CACHE_STATS
+
+ pass = TRUE;
+
+ reset_entries();
+
+ file_ptr = setup_cache((size_t)(2 * 1024 * 1024),
+ (size_t)(1 * 1024 * 1024));
+
+ if ( pass ) {
+
+ check_stats__smoke_check_1(file_ptr);
+ }
+
+
+
+ if ( pass ) {
+
+ takedown_cache(file_ptr, FALSE, FALSE);
+ }
+
+ if ( pass ) { PASSED(); } else { H5_FAILED(); }
+
+ if ( ! pass ) {
+
+ HDfprintf(stdout, "%s(): failure_mssg = \"%s\".\n",
+ FUNC, failure_mssg);
+ }
+
+#else /* H5C_COLLECT_CACHE_STATS */
+
+ SKIPPED();
+
+ HDfprintf(stdout, " Statistics collection disabled.\n");
+
+#endif /* H5C_COLLECT_CACHE_STATS */
+
+ return (unsigned)!pass;
+
+} /* check_stats() */
+
+
+/*-------------------------------------------------------------------------
+ * Function: check_stats__smoke_check_1()
+ *
+ * Purpose: Test to see if the statistics collection code is working
+ * more or less as expected. Do this by performing a number
+ * of operations in the cache, and checking to verify that
+ * they result in the expected statistics.
+ *
+ * Note that this function is not intended to be a full test
+ * of the statistics collection facility -- only a cursory
+ * check that will serve as a place holder until more complete
+ * tests are implemented.
+ *
+ * Do nothing if pass is FALSE on entry.
+ *
+ * Return: void
+ *
+ * Programmer: John Mainzer
+ * 4/22/15
+ *
+ * Modifications:
+ *
+ * None.
+ *
+ *-------------------------------------------------------------------------
+ */
+#if H5C_COLLECT_CACHE_STATS
+static void
+check_stats__smoke_check_1(H5F_t * file_ptr)
+{
+ H5C_t * cache_ptr = file_ptr->shared->cache;
+ int i;
+ herr_t result;
+
+ if ( pass ) {
+
+ if ( cache_ptr == NULL ) {
+
+ pass = FALSE;
+ failure_mssg = "cache_ptr NULL on entry to check_stats__smoke_check_1().";
+ }
+ else if ( ( cache_ptr->index_len != 0 ) ||
+ ( cache_ptr->index_size != 0 ) ) {
+
+ pass = FALSE;
+ failure_mssg = "cache not empty on entry to check_stats__smoke_check_1().";
+ }
+ else if ( ( cache_ptr->max_cache_size != (2 * 1024 * 1024 ) ) ||
+ ( cache_ptr->min_clean_size != (1 * 1024 * 1024 ) ) ) {
+
+ pass = FALSE;
+ failure_mssg =
+ "unexpected cache config at start of check_stats__smoke_check_1().";
+
+ } else {
+
+ /* set min clean size to zero for this test as it simplifies
+ * computing the expected cache size after each operation.
+ */
+
+ cache_ptr->min_clean_size = 0;
+ }
+ }
+
+ if ( pass ) {
+
+ /* first fill the cache with monster entryies via insertion */
+
+ for ( i = 0; i < 32; i++ )
+
+ insert_entry(file_ptr, MONSTER_ENTRY_TYPE, i, H5C__NO_FLAGS_SET);
+ }
+
+ if ( pass ) {
+
+ if ( ( cache_ptr->hits[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->misses[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->write_protects[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->read_protects[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->max_read_protects[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->insertions[MONSTER_ENTRY_TYPE] != 32 ) ||
+ ( cache_ptr->pinned_insertions[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->clears[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->flushes[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->evictions[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->take_ownerships[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->moves[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->entry_flush_moves[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->cache_flush_moves[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->pins[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->unpins[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->dirty_pins[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->pinned_flushes[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->pinned_clears[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->size_increases[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->size_decreases[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->entry_flush_size_changes[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->cache_flush_size_changes[MONSTER_ENTRY_TYPE] != 0 ) ) {
+
+ pass = FALSE;
+ failure_mssg = "Unexpected monster size entry stats in check_stats__smoke_check_1(1).";
+ }
+ }
+
+ if ( pass ) {
+
+ if ( ( cache_ptr->total_ht_insertions != 32 ) ||
+ ( cache_ptr->total_ht_deletions != 0 ) ||
+ ( cache_ptr->successful_ht_searches != 0 ) ||
+ ( cache_ptr->total_successful_ht_search_depth != 0 ) ||
+ ( cache_ptr->failed_ht_searches != 32 ) ||
+ ( cache_ptr->total_failed_ht_search_depth != 48 ) ||
+ ( cache_ptr->max_index_len != 32 ) ||
+ ( cache_ptr->max_index_size != 2 * 1024 * 1024 ) ||
+ ( cache_ptr->max_clean_index_size != 0 ) ||
+ ( cache_ptr->max_dirty_index_size != 2 * 1024 * 1024 ) ||
+ ( cache_ptr->max_slist_len != 32 ) ||
+ ( cache_ptr->max_slist_size != 2 * 1024 * 1024 ) ||
+ ( cache_ptr->max_pl_len != 0 ) ||
+ ( cache_ptr->max_pl_size != 0 ) ||
+ ( cache_ptr->max_pel_len != 0 ) ||
+ ( cache_ptr->max_pel_size != 0 ) ||
+ ( cache_ptr->calls_to_msic != 0 ) ||
+ ( cache_ptr->total_entries_skipped_in_msic != 0 ) ||
+ ( cache_ptr->total_entries_scanned_in_msic != 0 ) ||
+ ( cache_ptr->max_entries_skipped_in_msic != 0 ) ||
+ ( cache_ptr->max_entries_scanned_in_msic != 0 ) ||
+ ( cache_ptr->entries_scanned_to_make_space != 0 ) ||
+ ( cache_ptr->slist_scan_restarts != 0 ) ||
+ ( cache_ptr->LRU_scan_restarts != 0 ) ||
+ ( cache_ptr->hash_bucket_scan_restarts != 0 ) ) {
+
+ pass = FALSE;
+ failure_mssg = "Unexpected cache stats in check_stats__smoke_check_1(1).";
+ }
+ }
+
+#if H5C_COLLECT_CACHE_ENTRY_STATS
+ if ( pass ) {
+
+ /* Note that most entry level stats are only updated on entry eviction */
+
+ if ( ( cache_ptr->max_accesses[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->min_accesses[MONSTER_ENTRY_TYPE] != 1000000 ) || /* initial value */
+ ( cache_ptr->max_clears[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->max_flushes[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->max_size[MONSTER_ENTRY_TYPE] != 64 * 1024 ) ||
+ ( cache_ptr->max_pins[MONSTER_ENTRY_TYPE] != 0 ) ) {
+
+ pass = FALSE;
+ failure_mssg = "Unexpected monster entry level stats in check_stats__smoke_check_1(1).";
+ }
+ }
+#endif /* H5C_COLLECT_CACHE_ENTRY_STATS */
+
+ if ( pass ) {
+
+ /* protect and unprotect each entry once. Note
+ * that all entries are already dirty, as they
+ * entered the cache via insertion
+ */
+
+ for ( i = 0; i < 32; i++ )
+ {
+ protect_entry(file_ptr, MONSTER_ENTRY_TYPE, i);
+ unprotect_entry(file_ptr, MONSTER_ENTRY_TYPE, i, H5C__NO_FLAGS_SET);
+ }
+ }
+
+ if ( pass ) {
+
+ if ( ( cache_ptr->hits[MONSTER_ENTRY_TYPE] != 32 ) ||
+ ( cache_ptr->misses[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->write_protects[MONSTER_ENTRY_TYPE] != 32 ) ||
+ ( cache_ptr->read_protects[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->max_read_protects[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->insertions[MONSTER_ENTRY_TYPE] != 32 ) ||
+ ( cache_ptr->pinned_insertions[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->clears[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->flushes[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->evictions[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->take_ownerships[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->moves[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->entry_flush_moves[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->cache_flush_moves[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->pins[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->unpins[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->dirty_pins[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->pinned_flushes[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->pinned_clears[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->size_increases[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->size_decreases[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->entry_flush_size_changes[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->cache_flush_size_changes[MONSTER_ENTRY_TYPE] != 0 ) ) {
+
+ pass = FALSE;
+ failure_mssg = "Unexpected monster size entry stats in check_stats__smoke_check_1(2).";
+ }
+ }
+
+ if ( pass ) {
+
+ if ( ( cache_ptr->total_ht_insertions != 32 ) ||
+ ( cache_ptr->total_ht_deletions != 0 ) ||
+ ( cache_ptr->successful_ht_searches != 32 ) ||
+ ( cache_ptr->total_successful_ht_search_depth != 96 ) ||
+ ( cache_ptr->failed_ht_searches != 32 ) ||
+ ( cache_ptr->total_failed_ht_search_depth != 48 ) ||
+ ( cache_ptr->max_index_len != 32 ) ||
+ ( cache_ptr->max_index_size != 2 * 1024 * 1024 ) ||
+ ( cache_ptr->max_clean_index_size != 0 ) ||
+ ( cache_ptr->max_dirty_index_size != 2 * 1024 * 1024 ) ||
+ ( cache_ptr->max_slist_len != 32 ) ||
+ ( cache_ptr->max_slist_size != 2 * 1024 * 1024 ) ||
+ ( cache_ptr->max_pl_len != 1 ) ||
+ ( cache_ptr->max_pl_size != 64 * 1024 ) ||
+ ( cache_ptr->max_pel_len != 0 ) ||
+ ( cache_ptr->max_pel_size != 0 ) ||
+ ( cache_ptr->calls_to_msic != 0 ) ||
+ ( cache_ptr->total_entries_skipped_in_msic != 0 ) ||
+ ( cache_ptr->total_entries_scanned_in_msic != 0 ) ||
+ ( cache_ptr->max_entries_skipped_in_msic != 0 ) ||
+ ( cache_ptr->max_entries_scanned_in_msic != 0 ) ||
+ ( cache_ptr->entries_scanned_to_make_space != 0 ) ||
+ ( cache_ptr->slist_scan_restarts != 0 ) ||
+ ( cache_ptr->LRU_scan_restarts != 0 ) ||
+ ( cache_ptr->hash_bucket_scan_restarts != 0 ) ) {
+
+ pass = FALSE;
+ failure_mssg = "Unexpected cache stats in check_stats__smoke_check_1(2).";
+ }
+ }
+
+#if H5C_COLLECT_CACHE_ENTRY_STATS
+ if ( pass ) {
+
+ /* Note that most entry level stats are only updated on entry eviction */
+
+ if ( ( cache_ptr->max_accesses[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->min_accesses[MONSTER_ENTRY_TYPE] != 1000000 ) || /* initial value */
+ ( cache_ptr->max_clears[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->max_flushes[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->max_size[MONSTER_ENTRY_TYPE] != 64 * 1024 ) ||
+ ( cache_ptr->max_pins[MONSTER_ENTRY_TYPE] != 0 ) ) {
+
+ pass = FALSE;
+ failure_mssg = "Unexpected monster entry level stats in check_stats__smoke_check_1(2).";
+ }
+ }
+#endif /* H5C_COLLECT_CACHE_ENTRY_STATS */
+
+ if ( pass ) {
+
+ /* protect and unprotect an entry that is not currently
+ * in the cache. Since the cache is full and all entries
+ * are dirty, this will force a flush of each entry, and
+ * the eviction of (MET, 0).
+ */
+ protect_entry(file_ptr, MONSTER_ENTRY_TYPE, 32);
+ unprotect_entry(file_ptr, MONSTER_ENTRY_TYPE, 32, H5C__DIRTIED_FLAG);
+ }
+
+ if ( pass ) {
+
+ if ( ( cache_ptr->hits[MONSTER_ENTRY_TYPE] != 32 ) ||
+ ( cache_ptr->misses[MONSTER_ENTRY_TYPE] != 1 ) ||
+ ( cache_ptr->write_protects[MONSTER_ENTRY_TYPE] != 33 ) ||
+ ( cache_ptr->read_protects[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->max_read_protects[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->insertions[MONSTER_ENTRY_TYPE] != 32 ) ||
+ ( cache_ptr->pinned_insertions[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->clears[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->flushes[MONSTER_ENTRY_TYPE] != 32 ) ||
+ ( cache_ptr->evictions[MONSTER_ENTRY_TYPE] != 1 ) ||
+ ( cache_ptr->take_ownerships[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->moves[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->entry_flush_moves[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->cache_flush_moves[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->pins[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->unpins[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->dirty_pins[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->pinned_flushes[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->pinned_clears[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->size_increases[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->size_decreases[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->entry_flush_size_changes[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->cache_flush_size_changes[MONSTER_ENTRY_TYPE] != 0 ) ) {
+
+ pass = FALSE;
+ failure_mssg = "Unexpected monster size entry stats in check_stats__smoke_check_1(3).";
+ }
+ }
+
+ if ( pass ) {
+
+ if ( ( cache_ptr->total_ht_insertions != 33 ) ||
+ ( cache_ptr->total_ht_deletions != 1 ) ||
+ ( cache_ptr->successful_ht_searches != 32 ) ||
+ ( cache_ptr->total_successful_ht_search_depth != 96 ) ||
+ ( cache_ptr->failed_ht_searches != 33 ) ||
+ ( cache_ptr->total_failed_ht_search_depth != 52 ) ||
+ ( cache_ptr->max_index_len != 32 ) ||
+ ( cache_ptr->max_index_size != 2 * 1024 * 1024 ) ||
+ ( cache_ptr->max_clean_index_size != 2 * 1024 * 1024 ) ||
+ ( cache_ptr->max_dirty_index_size != 2 * 1024 * 1024 ) ||
+ ( cache_ptr->max_slist_len != 32 ) ||
+ ( cache_ptr->max_slist_size != 2 * 1024 * 1024 ) ||
+ ( cache_ptr->max_pl_len != 1 ) ||
+ ( cache_ptr->max_pl_size != 64 * 1024 ) ||
+ ( cache_ptr->max_pel_len != 0 ) ||
+ ( cache_ptr->max_pel_size != 0 ) ||
+ ( cache_ptr->calls_to_msic != 1 ) ||
+ ( cache_ptr->total_entries_skipped_in_msic != 0 ) ||
+ ( cache_ptr->total_entries_scanned_in_msic != 33 ) ||
+ ( cache_ptr->max_entries_skipped_in_msic != 0 ) ||
+ ( cache_ptr->max_entries_scanned_in_msic != 33 ) ||
+ ( cache_ptr->entries_scanned_to_make_space != 33 ) ||
+ ( cache_ptr->slist_scan_restarts != 0 ) ||
+ ( cache_ptr->LRU_scan_restarts != 0 ) ||
+ ( cache_ptr->hash_bucket_scan_restarts != 0 ) ) {
+
+ pass = FALSE;
+ failure_mssg = "Unexpected cache stats in check_stats__smoke_check_1(3).";
+ }
+ }
+
+#if H5C_COLLECT_CACHE_ENTRY_STATS
+ if ( pass ) {
+
+ /* Note that most entry level stats are only updated on entry eviction */
+
+ if ( ( cache_ptr->max_accesses[MONSTER_ENTRY_TYPE] != 1 ) ||
+ ( cache_ptr->min_accesses[MONSTER_ENTRY_TYPE] != 1 ) ||
+ ( cache_ptr->max_clears[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->max_flushes[MONSTER_ENTRY_TYPE] != 1 ) ||
+ ( cache_ptr->max_size[MONSTER_ENTRY_TYPE] != 64 * 1024 ) ||
+ ( cache_ptr->max_pins[MONSTER_ENTRY_TYPE] != 0 ) ) {
+
+ pass = FALSE;
+ failure_mssg = "Unexpected monster entry level stats in check_stats__smoke_check_1(3).";
+ }
+ }
+#endif /* H5C_COLLECT_CACHE_ENTRY_STATS */
+
+ if ( pass ) {
+
+ /* protect and unprotect dirty (MET, 1), and then flush destroy
+ * the cache.
+ */
+ protect_entry(file_ptr, MONSTER_ENTRY_TYPE, 1);
+ unprotect_entry(file_ptr, MONSTER_ENTRY_TYPE, 1, H5C__DIRTIED_FLAG);
+ }
+
+ /* flush the cache to end the test and collect all entry stats */
+
+ if ( pass ) {
+
+ result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT, H5C__FLUSH_INVALIDATE_FLAG);
+
+ if ( result < 0 ) {
+
+ pass = FALSE;
+ failure_mssg = "Cache flush invalidate failed in check_stats__smoke_check_1()";
+ }
+ else if ( ( cache_ptr->index_len != 0 ) ||
+ ( cache_ptr->index_size != 0 ) ) {
+
+ pass = FALSE;
+ failure_mssg = "Unexpected cache len/size after check_stats__smoke_check_1()";
+
+ }
+ }
+
+ if ( pass ) {
+
+ if ( ( cache_ptr->hits[MONSTER_ENTRY_TYPE] != 33 ) ||
+ ( cache_ptr->misses[MONSTER_ENTRY_TYPE] != 1 ) ||
+ ( cache_ptr->write_protects[MONSTER_ENTRY_TYPE] != 34 ) ||
+ ( cache_ptr->read_protects[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->max_read_protects[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->insertions[MONSTER_ENTRY_TYPE] != 32 ) ||
+ ( cache_ptr->pinned_insertions[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->clears[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->flushes[MONSTER_ENTRY_TYPE] != 34 ) ||
+ ( cache_ptr->evictions[MONSTER_ENTRY_TYPE] != 33 ) ||
+ ( cache_ptr->take_ownerships[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->moves[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->entry_flush_moves[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->cache_flush_moves[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->pins[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->unpins[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->dirty_pins[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->pinned_flushes[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->pinned_clears[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->size_increases[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->size_decreases[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->entry_flush_size_changes[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->cache_flush_size_changes[MONSTER_ENTRY_TYPE] != 0 ) ) {
+
+ pass = FALSE;
+ failure_mssg = "Unexpected monster size entry stats in check_stats__smoke_check_1(4).";
+ }
+ }
+
+ if ( pass ) {
+
+ if ( ( cache_ptr->total_ht_insertions != 33 ) ||
+ ( cache_ptr->total_ht_deletions != 33 ) ||
+ ( cache_ptr->successful_ht_searches != 33 ) ||
+ ( cache_ptr->total_successful_ht_search_depth != 99 ) ||
+ ( cache_ptr->failed_ht_searches != 33 ) ||
+ ( cache_ptr->total_failed_ht_search_depth != 52 ) ||
+ ( cache_ptr->max_index_len != 32 ) ||
+ ( cache_ptr->max_index_size != 2 * 1024 * 1024 ) ||
+ ( cache_ptr->max_clean_index_size != 2 * 1024 * 1024 ) ||
+ ( cache_ptr->max_dirty_index_size != 2 * 1024 * 1024 ) ||
+ ( cache_ptr->max_slist_len != 32 ) ||
+ ( cache_ptr->max_slist_size != 2 * 1024 * 1024 ) ||
+ ( cache_ptr->max_pl_len != 1 ) ||
+ ( cache_ptr->max_pl_size != 64 * 1024 ) ||
+ ( cache_ptr->max_pel_len != 0 ) ||
+ ( cache_ptr->max_pel_size != 0 ) ||
+ ( cache_ptr->calls_to_msic != 1 ) ||
+ ( cache_ptr->total_entries_skipped_in_msic != 0 ) ||
+ ( cache_ptr->total_entries_scanned_in_msic != 33 ) ||
+ ( cache_ptr->max_entries_skipped_in_msic != 0 ) ||
+ ( cache_ptr->max_entries_scanned_in_msic != 33 ) ||
+ ( cache_ptr->entries_scanned_to_make_space != 33 ) ||
+ ( cache_ptr->slist_scan_restarts != 0 ) ||
+ ( cache_ptr->LRU_scan_restarts != 0 ) ||
+ ( cache_ptr->hash_bucket_scan_restarts != 0 ) ) {
+
+ pass = FALSE;
+ failure_mssg = "Unexpected cache stats in check_stats__smoke_check_1(4).";
+ }
+ }
+
+#if H5C_COLLECT_CACHE_ENTRY_STATS
+ if ( pass ) {
+
+ /* Note that most entry level stats are only updated on entry eviction */
+
+ if ( ( cache_ptr->max_accesses[MONSTER_ENTRY_TYPE] != 2 ) ||
+ ( cache_ptr->min_accesses[MONSTER_ENTRY_TYPE] != 1 ) ||
+ ( cache_ptr->max_clears[MONSTER_ENTRY_TYPE] != 0 ) ||
+ ( cache_ptr->max_flushes[MONSTER_ENTRY_TYPE] != 2 ) ||
+ ( cache_ptr->max_size[MONSTER_ENTRY_TYPE] != 64 * 1024 ) ||
+ ( cache_ptr->max_pins[MONSTER_ENTRY_TYPE] != 0 ) ) {
+
+ pass = FALSE;
+ failure_mssg = "Unexpected monster entry level stats in check_stats__smoke_check_1(4).";
+ }
+ }
+#endif /* H5C_COLLECT_CACHE_ENTRY_STATS */
+
+ if ( pass ) {
+
+ reset_entries();
+ }
+
+ if ( pass ) {
+
+ /* reset cache min clean size to its expected value */
+ cache_ptr->min_clean_size = (1 * 1024 * 1024);
+ }
+
+ return;
+
+} /* check_stats__smoke_check_1() */
+
+#endif /* H5C_COLLECT_CACHE_STATS */
+
+
+/*-------------------------------------------------------------------------
* Function: main
*
* Purpose: Run tests on the cache code contained in H5C.c
@@ -32999,29 +35066,30 @@ int
main(void)
{
unsigned nerrs = 0;
+ int express_test;
H5open();
- skip_long_tests = FALSE;
-
-#ifdef NDEBUG
- run_full_test = TRUE;
-#else /* NDEBUG */
- run_full_test = FALSE;
-#endif /* NDEBUG */
-
- nerrs += smoke_check_1();
- nerrs += smoke_check_2();
- nerrs += smoke_check_3();
- nerrs += smoke_check_4();
- nerrs += smoke_check_5();
- nerrs += smoke_check_6();
- nerrs += smoke_check_7();
- nerrs += smoke_check_8();
- nerrs += smoke_check_9();
- nerrs += smoke_check_10();
-
- nerrs += write_permitted_check();
+ express_test = GetTestExpress();
+
+ printf("=========================================\n");
+ printf("Internal cache tests\n");
+ printf(" express_test = %d\n", express_test);
+ printf("=========================================\n");
+
+ nerrs += smoke_check_1(express_test);
+ nerrs += smoke_check_2(express_test);
+ nerrs += smoke_check_3(express_test);
+ nerrs += smoke_check_4(express_test);
+ nerrs += smoke_check_5(express_test);
+ nerrs += smoke_check_6(express_test);
+ nerrs += smoke_check_7(express_test);
+ nerrs += smoke_check_8(express_test);
+ nerrs += smoke_check_9(express_test);
+ nerrs += smoke_check_10(express_test);
+
+ nerrs += write_permitted_check(express_test);
+
nerrs += check_insert_entry();
nerrs += check_flush_cache();
nerrs += check_get_entry_status();
@@ -33058,6 +35126,8 @@ main(void)
nerrs += check_flush_deps_err();
nerrs += check_flush_deps_order();
nerrs += check_notify_cb();
+ nerrs += check_entry_deletions_during_scans();
+ nerrs += check_stats();
return(nerrs > 0);
} /* main() */
diff --git a/test/cache_api.c b/test/cache_api.c
index 6953d17..1697884 100644
--- a/test/cache_api.c
+++ b/test/cache_api.c
@@ -25,6 +25,9 @@
#include "H5ACprivate.h"
#include "cache_common.h"
+/* extern declarations */
+
+extern const char *FILENAME[];
/* global variable declarations: */
diff --git a/test/cache_common.c b/test/cache_common.c
index 60ab827..f3da908 100644
--- a/test/cache_common.c
+++ b/test/cache_common.c
@@ -23,6 +23,7 @@
#include "H5Cprivate.h"
#include "H5Iprivate.h"
#include "H5MFprivate.h"
+#include "H5MMprivate.h"
#include "cache_common.h"
@@ -57,8 +58,6 @@ haddr_t saved_actual_base_addr = HADDR_UNDEF; /* Store the address of the
hbool_t write_permitted = TRUE;
hbool_t pass = TRUE; /* set to false on error */
-hbool_t skip_long_tests = TRUE;
-hbool_t run_full_test = TRUE;
hbool_t try_core_file_driver = FALSE;
hbool_t core_file_driver_failed = FALSE;
const char *failure_mssg = NULL;
@@ -77,79 +76,156 @@ static test_entry_t notify_entries[NUM_NOTIFY_ENTRIES], orig_notify_entries[NUM_
hbool_t orig_entry_arrays_init = FALSE;
-static herr_t pico_clear(H5F_t * f, void * thing, hbool_t dest);
-static herr_t nano_clear(H5F_t * f, void * thing, hbool_t dest);
-static herr_t micro_clear(H5F_t * f, void * thing, hbool_t dest);
-static herr_t tiny_clear(H5F_t * f, void * thing, hbool_t dest);
-static herr_t small_clear(H5F_t * f, void * thing, hbool_t dest);
-static herr_t medium_clear(H5F_t * f, void * thing, hbool_t dest);
-static herr_t large_clear(H5F_t * f, void * thing, hbool_t dest);
-static herr_t huge_clear(H5F_t * f, void * thing, hbool_t dest);
-static herr_t monster_clear(H5F_t * f, void * thing, hbool_t dest);
-static herr_t variable_clear(H5F_t * f, void * thing, hbool_t dest);
-static herr_t notify_clear(H5F_t * f, void * thing, hbool_t dest);
-
-static herr_t pico_dest(H5F_t * f, void * thing);
-static herr_t nano_dest(H5F_t * f, void * thing);
-static herr_t micro_dest(H5F_t * f, void * thing);
-static herr_t tiny_dest(H5F_t * f, void * thing);
-static herr_t small_dest(H5F_t * f, void * thing);
-static herr_t medium_dest(H5F_t * f, void * thing);
-static herr_t large_dest(H5F_t * f, void * thing);
-static herr_t huge_dest(H5F_t * f, void * thing);
-static herr_t monster_dest(H5F_t * f, void * thing);
-static herr_t variable_dest(H5F_t * f, void * thing);
-static herr_t notify_dest(H5F_t * f, void * thing);
-
-static herr_t pico_flush(H5F_t *f, hid_t dxpl_id, hbool_t dest,
- haddr_t addr, void *thing, unsigned * flags_ptr);
-static herr_t nano_flush(H5F_t *f, hid_t dxpl_id, hbool_t dest,
- haddr_t addr, void *thing, unsigned * flags_ptr);
-static herr_t micro_flush(H5F_t *f, hid_t dxpl_id, hbool_t dest,
- haddr_t addr, void *thing, unsigned * flags_ptr);
-static herr_t tiny_flush(H5F_t *f, hid_t dxpl_id, hbool_t dest,
- haddr_t addr, void *thing, unsigned * flags_ptr);
-static herr_t small_flush(H5F_t *f, hid_t dxpl_id, hbool_t dest,
- haddr_t addr, void *thing, unsigned * flags_ptr);
-static herr_t medium_flush(H5F_t *f, hid_t dxpl_id, hbool_t dest,
- haddr_t addr, void *thing, unsigned * flags_ptr);
-static herr_t large_flush(H5F_t *f, hid_t dxpl_id, hbool_t dest,
- haddr_t addr, void *thing, unsigned * flags_ptr);
-static herr_t huge_flush(H5F_t *f, hid_t dxpl_id, hbool_t dest,
- haddr_t addr, void *thing, unsigned * flags_ptr);
-static herr_t monster_flush(H5F_t *f, hid_t dxpl_id, hbool_t dest,
- haddr_t addr, void *thing, unsigned * flags_ptr);
-static herr_t variable_flush(H5F_t *f, hid_t dxpl_id, hbool_t dest,
- haddr_t addr, void *thing, unsigned * flags_ptr);
-static herr_t notify_flush(H5F_t *f, hid_t dxpl_id, hbool_t dest,
- haddr_t addr, void *thing, unsigned * flags_ptr);
-
-static void * pico_load(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *udata);
-static void * nano_load(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *udata);
-static void * micro_load(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *udata);
-static void * tiny_load(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *udata);
-static void * small_load(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *udata);
-static void * medium_load(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *udata);
-static void * large_load(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *udata);
-static void * huge_load(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *udata);
-static void * monster_load(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *udata);
-static void * variable_load(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *udata);
-static void * notify_load(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *udata);
-
-static herr_t pico_size(H5F_t * f, void * thing, size_t * size_ptr);
-static herr_t nano_size(H5F_t * f, void * thing, size_t * size_ptr);
-static herr_t micro_size(H5F_t * f, void * thing, size_t * size_ptr);
-static herr_t tiny_size(H5F_t * f, void * thing, size_t * size_ptr);
-static herr_t small_size(H5F_t * f, void * thing, size_t * size_ptr);
-static herr_t medium_size(H5F_t * f, void * thing, size_t * size_ptr);
-static herr_t large_size(H5F_t * f, void * thing, size_t * size_ptr);
-static herr_t huge_size(H5F_t * f, void * thing, size_t * size_ptr);
-static herr_t monster_size(H5F_t * f, void * thing, size_t * size_ptr);
-static herr_t variable_size(H5F_t * f, void * thing, size_t * size_ptr);
-static herr_t notify_size(H5F_t * f, void * thing, size_t * size_ptr);
+static herr_t pico_get_load_size(const void *udata_ptr, size_t *image_len_ptr);
+static herr_t nano_get_load_size(const void *udata_ptr, size_t *image_len_ptr);
+static herr_t micro_get_load_size(const void *udata_ptr, size_t *image_len_ptr);
+static herr_t tiny_get_load_size(const void *udata_ptr, size_t *image_len_ptr);
+static herr_t small_get_load_size(const void *udata_ptr, size_t *image_len_ptr);
+static herr_t medium_get_load_size(const void *udata_ptr, size_t *image_len_ptr);
+static herr_t large_get_load_size(const void *udata_ptr, size_t *image_len_ptr);
+static herr_t huge_get_load_size(const void *udata_ptr, size_t *image_len_ptr);
+static herr_t monster_get_load_size(const void *udata_ptr, size_t *image_len_ptr);
+static herr_t variable_get_load_size(const void *udata_ptr, size_t *image_len_ptr);
+static herr_t notify_get_load_size(const void *udata_ptr, size_t *image_len_ptr);
+
+static void *pico_deserialize(const void *image_ptr, size_t len, void *udata_ptr,
+ hbool_t *dirty_ptr);
+static void *nano_deserialize(const void *image_ptr, size_t len, void *udata_ptr,
+ hbool_t *dirty_ptr);
+static void *micro_deserialize(const void *image_ptr, size_t len, void *udata_ptr,
+ hbool_t *dirty_ptr);
+static void *tiny_deserialize(const void *image_ptr, size_t len, void *udata_ptr,
+ hbool_t *dirty_ptr);
+static void *small_deserialize(const void *image_ptr, size_t len, void *udata_ptr,
+ hbool_t *dirty_ptr);
+static void *medium_deserialize(const void *image_ptr, size_t len, void *udata_ptr,
+ hbool_t *dirty_ptr);
+static void *large_deserialize(const void *image_ptr, size_t len, void *udata_ptr,
+ hbool_t *dirty_ptr);
+static void *huge_deserialize(const void *image_ptr, size_t len, void *udata_ptr,
+ hbool_t *dirty_ptr);
+static void *monster_deserialize(const void *image_ptr, size_t len, void *udata_ptr,
+ hbool_t *dirty_ptr);
+static void *variable_deserialize(const void *image_ptr, size_t len, void *udata_ptr,
+ hbool_t *dirty_ptr);
+static void *notify_deserialize(const void *image_ptr, size_t len, void *udata_ptr,
+ hbool_t *dirty_ptr);
+
+static herr_t pico_image_len(void *thing, size_t *image_len_ptr,
+ hbool_t *compressed_ptr, size_t * compressed_len_ptr);
+static herr_t nano_image_len(void *thing, size_t *image_len_ptr,
+ hbool_t *compressed_ptr, size_t * compressed_len_ptr);
+static herr_t micro_image_len(void *thing, size_t *image_len_ptr,
+ hbool_t *compressed_ptr, size_t * compressed_len_ptr);
+static herr_t tiny_image_len(void *thing, size_t *image_len_ptr,
+ hbool_t *compressed_ptr, size_t * compressed_len_ptr);
+static herr_t small_image_len(void *thing, size_t *image_len_ptr,
+ hbool_t *compressed_ptr, size_t * compressed_len_ptr);
+static herr_t medium_image_len(void *thing, size_t *image_len_ptr,
+ hbool_t *compressed_ptr, size_t * compressed_len_ptr);
+static herr_t large_image_len(void *thing, size_t *image_len_ptr,
+ hbool_t *compressed_ptr, size_t * compressed_len_ptr);
+static herr_t huge_image_len(void *thing, size_t *image_len_ptr,
+ hbool_t *compressed_ptr, size_t * compressed_len_ptr);
+static herr_t monster_image_len(void *thing, size_t *image_len_ptr,
+ hbool_t *compressed_ptr, size_t * compressed_len_ptr);
+static herr_t variable_image_len(void *thing, size_t *image_len_ptr,
+ hbool_t *compressed_ptr, size_t * compressed_len_ptr);
+static herr_t notify_image_len(void *thing, size_t *image_len_ptr,
+ hbool_t *compressed_ptr, size_t * compressed_len_ptr);
+
+static herr_t pico_pre_serialize(const H5F_t *f, hid_t dxpl_id, void *thing,
+ haddr_t addr, size_t len, size_t compressed_len, haddr_t *new_addr_ptr,
+ size_t *new_len_ptr, size_t *new_compressed_len_ptr, unsigned *flags_ptr);
+static herr_t nano_pre_serialize(const H5F_t *f, hid_t dxpl_id, void *thing,
+ haddr_t addr, size_t len, size_t compressed_len, haddr_t *new_addr_ptr,
+ size_t *new_len_ptr, size_t *new_compressed_len_ptr, unsigned *flags_ptr);
+static herr_t micro_pre_serialize(const H5F_t *f, hid_t dxpl_id, void *thing,
+ haddr_t addr, size_t len, size_t compressed_len, haddr_t *new_addr_ptr,
+ size_t *new_len_ptr, size_t *new_compressed_len_ptr, unsigned *flags_ptr);
+static herr_t tiny_pre_serialize(const H5F_t *f, hid_t dxpl_id, void *thing,
+ haddr_t addr, size_t len, size_t compressed_len, haddr_t *new_addr_ptr,
+ size_t *new_len_ptr, size_t *new_compressed_len_ptr, unsigned *flags_ptr);
+static herr_t small_pre_serialize(const H5F_t *f, hid_t dxpl_id, void *thing,
+ haddr_t addr, size_t len, size_t compressed_len, haddr_t *new_addr_ptr,
+ size_t *new_len_ptr, size_t *new_compressed_len_ptr, unsigned *flags_ptr);
+static herr_t medium_pre_serialize(const H5F_t *f, hid_t dxpl_id, void *thing,
+ haddr_t addr, size_t len, size_t compressed_len, haddr_t *new_addr_ptr,
+ size_t *new_len_ptr, size_t *new_compressed_len_ptr, unsigned *flags_ptr);
+static herr_t large_pre_serialize(const H5F_t *f, hid_t dxpl_id, void *thing,
+ haddr_t addr, size_t len, size_t compressed_len, haddr_t *new_addr_ptr,
+ size_t *new_len_ptr, size_t *new_compressed_len_ptr, unsigned *flags_ptr);
+static herr_t huge_pre_serialize(const H5F_t *f, hid_t dxpl_id, void *thing,
+ haddr_t addr, size_t len, size_t compressed_len, haddr_t *new_addr_ptr,
+ size_t *new_len_ptr, size_t *new_compressed_len_ptr, unsigned *flags_ptr);
+static herr_t monster_pre_serialize(const H5F_t *f, hid_t dxpl_id, void *thing,
+ haddr_t addr, size_t len, size_t compressed_len, haddr_t *new_addr_ptr,
+ size_t *new_len_ptr, size_t *new_compressed_len_ptr, unsigned *flags_ptr);
+static herr_t variable_pre_serialize(const H5F_t *f, hid_t dxpl_id, void *thing,
+ haddr_t addr, size_t len, size_t compressed_len, haddr_t *new_addr_ptr,
+ size_t *new_len_ptr, size_t *new_compressed_len_ptr, unsigned *flags_ptr);
+static herr_t notify_pre_serialize(const H5F_t *f, hid_t dxpl_id, void *thing,
+ haddr_t addr, size_t len, size_t compressed_len, haddr_t *new_addr_ptr,
+ size_t *new_len_ptr, size_t *new_compressed_len_ptr, unsigned *flags_ptr);
+
+static herr_t pico_serialize(const H5F_t *f, void *image_ptr,
+ size_t len, void *thing);
+static herr_t nano_serialize(const H5F_t *f, void *image_ptr,
+ size_t len, void *thing);
+static herr_t micro_serialize(const H5F_t *f, void *image_ptr,
+ size_t len, void *thing);
+static herr_t tiny_serialize(const H5F_t *f, void *image_ptr,
+ size_t len, void *thing);
+static herr_t small_serialize(const H5F_t *f, void *image_ptr,
+ size_t len, void *thing);
+static herr_t medium_serialize(const H5F_t *f, void *image_ptr,
+ size_t len, void *thing);
+static herr_t large_serialize(const H5F_t *f, void *image_ptr,
+ size_t len, void *thing);
+static herr_t huge_serialize(const H5F_t *f, void *image_ptr,
+ size_t len, void *thing);
+static herr_t monster_serialize(const H5F_t *f, void *image_ptr,
+ size_t len, void *thing);
+static herr_t variable_serialize(const H5F_t *f, void *image_ptr,
+ size_t len, void *thing);
+static herr_t notify_serialize(const H5F_t *f, void *image_ptr,
+ size_t len, void *thing);
+
+static herr_t pico_free_icr(void *thing);
+static herr_t nano_free_icr(void *thing);
+static herr_t micro_free_icr(void *thing);
+static herr_t tiny_free_icr(void *thing);
+static herr_t small_free_icr(void *thing);
+static herr_t medium_free_icr(void *thing);
+static herr_t large_free_icr(void *thing);
+static herr_t huge_free_icr(void *thing);
+static herr_t monster_free_icr(void *thing);
+static herr_t variable_free_icr(void *thing);
+static herr_t notify_free_icr(void *thing);
+
static herr_t notify_notify(H5C_notify_action_t action, void *thing);
+/* Generic callback routines */
+static herr_t get_load_size(const void *udata_ptr, size_t *image_len_ptr,
+ int32_t entry_type);
+static void *deserialize(const void *image_ptr, size_t len, void *udata_ptr,
+ hbool_t *dirty_ptr, int32_t entry_type);
+static herr_t image_len(void *thing, size_t *image_len_ptr, int32_t entry_type);
+static herr_t pre_serialize(const H5F_t *f, hid_t dxpl_id, void *thing,
+ haddr_t addr, size_t len, haddr_t *new_addr_ptr, size_t *new_len_ptr,
+ unsigned *flags_ptr);
+static herr_t serialize(const H5F_t *f, void *image_ptr, size_t len,
+ void *thing);
+static herr_t notify(H5C_notify_action_t action, void *thing, int32_t
+ entry_type);
+static herr_t free_icr(test_entry_t *entry, int32_t entry_type);
+
+/* Local routines */
+static void execute_flush_op(H5F_t *file_ptr, struct test_entry_t *entry_ptr,
+ struct flush_op *op_ptr, unsigned *flags_ptr);
+
+
test_entry_t *entries[NUMBER_OF_ENTRY_TYPES] =
{
pico_entries,
@@ -262,118 +338,171 @@ const H5C_class_t types[NUMBER_OF_ENTRY_TYPES] =
{
{
PICO_ENTRY_TYPE,
- (H5C_load_func_t)pico_load,
- (H5C_flush_func_t)pico_flush,
- (H5C_dest_func_t)pico_dest,
- (H5C_clear_func_t)pico_clear,
+ "pico_entry",
+ H5FD_MEM_DEFAULT,
+ H5C__CLASS_NO_FLAGS_SET,
+ (H5C_get_load_size_func_t)pico_get_load_size,
+ (H5C_deserialize_func_t)pico_deserialize,
+ (H5C_image_len_func_t)pico_image_len,
+ (H5AC_pre_serialize_func_t)pico_pre_serialize,
+ (H5C_serialize_func_t)pico_serialize,
(H5C_notify_func_t)NULL,
- (H5C_size_func_t)pico_size
+ (H5C_free_icr_func_t)pico_free_icr,
+ (H5C_clear_func_t)NULL,
+ (H5C_get_fsf_size_t)NULL,
},
{
NANO_ENTRY_TYPE,
- (H5C_load_func_t)nano_load,
- (H5C_flush_func_t)nano_flush,
- (H5C_dest_func_t)nano_dest,
- (H5C_clear_func_t)nano_clear,
+ "nano_entry",
+ H5FD_MEM_DEFAULT,
+ H5C__CLASS_NO_FLAGS_SET,
+ (H5C_get_load_size_func_t)nano_get_load_size,
+ (H5C_deserialize_func_t)nano_deserialize,
+ (H5C_image_len_func_t)nano_image_len,
+ (H5AC_pre_serialize_func_t)nano_pre_serialize,
+ (H5C_serialize_func_t)nano_serialize,
(H5C_notify_func_t)NULL,
- (H5C_size_func_t)nano_size
+ (H5C_free_icr_func_t)nano_free_icr,
+ (H5C_clear_func_t)NULL,
+ (H5C_get_fsf_size_t)NULL,
},
{
MICRO_ENTRY_TYPE,
- (H5C_load_func_t)micro_load,
- (H5C_flush_func_t)micro_flush,
- (H5C_dest_func_t)micro_dest,
- (H5C_clear_func_t)micro_clear,
+ "micro_entry",
+ H5FD_MEM_DEFAULT,
+ H5C__CLASS_NO_FLAGS_SET,
+ (H5C_get_load_size_func_t)micro_get_load_size,
+ (H5C_deserialize_func_t)micro_deserialize,
+ (H5C_image_len_func_t)micro_image_len,
+ (H5AC_pre_serialize_func_t)micro_pre_serialize,
+ (H5C_serialize_func_t)micro_serialize,
(H5C_notify_func_t)NULL,
- (H5C_size_func_t)micro_size
+ (H5C_free_icr_func_t)micro_free_icr,
+ (H5C_clear_func_t)NULL,
+ (H5C_get_fsf_size_t)NULL,
},
{
TINY_ENTRY_TYPE,
- (H5C_load_func_t)tiny_load,
- (H5C_flush_func_t)tiny_flush,
- (H5C_dest_func_t)tiny_dest,
- (H5C_clear_func_t)tiny_clear,
+ "tiny_entry",
+ H5FD_MEM_DEFAULT,
+ H5C__CLASS_NO_FLAGS_SET,
+ (H5C_get_load_size_func_t)tiny_get_load_size,
+ (H5C_deserialize_func_t)tiny_deserialize,
+ (H5C_image_len_func_t)tiny_image_len,
+ (H5AC_pre_serialize_func_t)tiny_pre_serialize,
+ (H5C_serialize_func_t)tiny_serialize,
(H5C_notify_func_t)NULL,
- (H5C_size_func_t)tiny_size
+ (H5C_free_icr_func_t)tiny_free_icr,
+ (H5C_clear_func_t)NULL,
+ (H5C_get_fsf_size_t)NULL,
},
{
SMALL_ENTRY_TYPE,
- (H5C_load_func_t)small_load,
- (H5C_flush_func_t)small_flush,
- (H5C_dest_func_t)small_dest,
- (H5C_clear_func_t)small_clear,
+ "small_entry",
+ H5FD_MEM_DEFAULT,
+ H5C__CLASS_NO_FLAGS_SET,
+ (H5C_get_load_size_func_t)small_get_load_size,
+ (H5C_deserialize_func_t)small_deserialize,
+ (H5C_image_len_func_t)small_image_len,
+ (H5AC_pre_serialize_func_t)small_pre_serialize,
+ (H5C_serialize_func_t)small_serialize,
(H5C_notify_func_t)NULL,
- (H5C_size_func_t)small_size
+ (H5C_free_icr_func_t)small_free_icr,
+ (H5C_clear_func_t)NULL,
+ (H5C_get_fsf_size_t)NULL,
},
{
MEDIUM_ENTRY_TYPE,
- (H5C_load_func_t)medium_load,
- (H5C_flush_func_t)medium_flush,
- (H5C_dest_func_t)medium_dest,
- (H5C_clear_func_t)medium_clear,
+ "medium_entry",
+ H5FD_MEM_DEFAULT,
+ H5C__CLASS_NO_FLAGS_SET,
+ (H5C_get_load_size_func_t)medium_get_load_size,
+ (H5C_deserialize_func_t)medium_deserialize,
+ (H5C_image_len_func_t)medium_image_len,
+ (H5AC_pre_serialize_func_t)medium_pre_serialize,
+ (H5C_serialize_func_t)medium_serialize,
(H5C_notify_func_t)NULL,
- (H5C_size_func_t)medium_size
+ (H5C_free_icr_func_t)medium_free_icr,
+ (H5C_clear_func_t)NULL,
+ (H5C_get_fsf_size_t)NULL,
},
{
LARGE_ENTRY_TYPE,
- (H5C_load_func_t)large_load,
- (H5C_flush_func_t)large_flush,
- (H5C_dest_func_t)large_dest,
- (H5C_clear_func_t)large_clear,
+ "large_entry",
+ H5FD_MEM_DEFAULT,
+ H5C__CLASS_NO_FLAGS_SET,
+ (H5C_get_load_size_func_t)large_get_load_size,
+ (H5C_deserialize_func_t)large_deserialize,
+ (H5C_image_len_func_t)large_image_len,
+ (H5AC_pre_serialize_func_t)large_pre_serialize,
+ (H5C_serialize_func_t)large_serialize,
(H5C_notify_func_t)NULL,
- (H5C_size_func_t)large_size
+ (H5C_free_icr_func_t)large_free_icr,
+ (H5C_clear_func_t)NULL,
+ (H5C_get_fsf_size_t)NULL,
},
{
HUGE_ENTRY_TYPE,
- (H5C_load_func_t)huge_load,
- (H5C_flush_func_t)huge_flush,
- (H5C_dest_func_t)huge_dest,
- (H5C_clear_func_t)huge_clear,
+ "huge_entry",
+ H5FD_MEM_DEFAULT,
+ H5C__CLASS_NO_FLAGS_SET,
+ (H5C_get_load_size_func_t)huge_get_load_size,
+ (H5C_deserialize_func_t)huge_deserialize,
+ (H5C_image_len_func_t)huge_image_len,
+ (H5AC_pre_serialize_func_t)huge_pre_serialize,
+ (H5C_serialize_func_t)huge_serialize,
(H5C_notify_func_t)NULL,
- (H5C_size_func_t)huge_size
+ (H5C_free_icr_func_t)huge_free_icr,
+ (H5C_clear_func_t)NULL,
+ (H5C_get_fsf_size_t)NULL,
},
{
MONSTER_ENTRY_TYPE,
- (H5C_load_func_t)monster_load,
- (H5C_flush_func_t)monster_flush,
- (H5C_dest_func_t)monster_dest,
- (H5C_clear_func_t)monster_clear,
+ "monster_entry",
+ H5FD_MEM_DEFAULT,
+ H5C__CLASS_NO_FLAGS_SET,
+ (H5C_get_load_size_func_t)monster_get_load_size,
+ (H5C_deserialize_func_t)monster_deserialize,
+ (H5C_image_len_func_t)monster_image_len,
+ (H5AC_pre_serialize_func_t)monster_pre_serialize,
+ (H5C_serialize_func_t)monster_serialize,
(H5C_notify_func_t)NULL,
- (H5C_size_func_t)monster_size
+ (H5C_free_icr_func_t)monster_free_icr,
+ (H5C_clear_func_t)NULL,
+ (H5C_get_fsf_size_t)NULL,
},
{
VARIABLE_ENTRY_TYPE,
- (H5C_load_func_t)variable_load,
- (H5C_flush_func_t)variable_flush,
- (H5C_dest_func_t)variable_dest,
- (H5C_clear_func_t)variable_clear,
+ "variable_entry",
+ H5FD_MEM_DEFAULT,
+ H5C__CLASS_SPECULATIVE_LOAD_FLAG,
+ (H5C_get_load_size_func_t)variable_get_load_size,
+ (H5C_deserialize_func_t)variable_deserialize,
+ (H5C_image_len_func_t)variable_image_len,
+ (H5AC_pre_serialize_func_t)variable_pre_serialize,
+ (H5C_serialize_func_t)variable_serialize,
(H5C_notify_func_t)NULL,
- (H5C_size_func_t)variable_size
+ (H5C_free_icr_func_t)variable_free_icr,
+ (H5C_clear_func_t)NULL,
+ (H5C_get_fsf_size_t)NULL,
},
{
NOTIFY_ENTRY_TYPE,
- (H5C_load_func_t)notify_load,
- (H5C_flush_func_t)notify_flush,
- (H5C_dest_func_t)notify_dest,
- (H5C_clear_func_t)notify_clear,
+ "notify_entry",
+ H5FD_MEM_DEFAULT,
+ H5C__CLASS_NO_FLAGS_SET,
+ (H5C_get_load_size_func_t)notify_get_load_size,
+ (H5C_deserialize_func_t)notify_deserialize,
+ (H5C_image_len_func_t)notify_image_len,
+ (H5AC_pre_serialize_func_t)notify_pre_serialize,
+ (H5C_serialize_func_t)notify_serialize,
(H5C_notify_func_t)notify_notify,
- (H5C_size_func_t)notify_size
+ (H5C_free_icr_func_t)notify_free_icr,
+ (H5C_clear_func_t)NULL,
+ (H5C_get_fsf_size_t)NULL,
}
};
-static herr_t clear(H5F_t * f, void * thing, hbool_t dest);
-static herr_t destroy(H5F_t * f, void * thing);
-static herr_t flush(H5F_t *f, hid_t dxpl_id, hbool_t dest,
- haddr_t addr, void *thing, unsigned H5_ATTR_UNUSED * flags_ptr);
-static void * load(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *udata);
-static herr_t size(H5F_t * f, void * thing, size_t * size_ptr);
-static herr_t notify(H5C_notify_action_t action, void *thing);
-static void execute_flush_op(H5F_t *file_ptr, struct test_entry_t *entry_ptr,
- struct flush_op *op_ptr, unsigned *flags_ptr);
-
-
-
-
/* address translation functions: */
@@ -478,7 +607,7 @@ addr_to_type_and_index(haddr_t addr,
static herr_t
check_write_permitted(const H5F_t H5_ATTR_UNUSED *f, hbool_t *write_permitted_ptr)
{
- HDassert(write_permitted_ptr);
+ HDassert( write_permitted_ptr );
*write_permitted_ptr = write_permitted;
@@ -487,721 +616,834 @@ check_write_permitted(const H5F_t H5_ATTR_UNUSED *f, hbool_t *write_permitted_pt
/*-------------------------------------------------------------------------
- * Function: clear & friends
+ * Function: get_load_size & friends
*
- * Purpose: clear the entry. The helper functions verify that the
- * correct version of clear is being called, and then call
- * clear proper.
+ * Purpose: Query the image size for loading an entry. The helper
+ * functions funnel into get_load_size proper.
*
* Return: SUCCEED
*
- * Programmer: John Mainzer
- * 6/10/04
+ * Programmer: Quincey Koziol
+ * 5/18/10
*
*-------------------------------------------------------------------------
*/
-
-herr_t
-clear(H5F_t * f,
- void * thing,
- hbool_t dest)
+static herr_t
+get_load_size(const void *udata, size_t *image_length, int32_t entry_type)
{
- test_entry_t * entry_ptr;
- test_entry_t * base_addr;
-
- HDassert( thing );
-
- entry_ptr = (test_entry_t *)thing;
- base_addr = entries[entry_ptr->type];
-
- HDassert( entry_ptr->index >= 0 );
- HDassert( entry_ptr->index <= max_indices[entry_ptr->type] );
- HDassert( entry_ptr == &(base_addr[entry_ptr->index]) );
- HDassert( entry_ptr == entry_ptr->self );
- HDassert( entry_ptr->header.addr == entry_ptr->addr );
- HDassert( entry_ptr->header.size == entry_ptr->size );
- HDassert( ( entry_ptr->type == VARIABLE_ENTRY_TYPE ) ||
- ( entry_ptr->size == entry_sizes[entry_ptr->type] ) );
-
- entry_ptr->header.is_dirty = FALSE;
- entry_ptr->is_dirty = FALSE;
+ test_entry_t *entry;
+ test_entry_t *base_addr;
+ haddr_t addr = *(const haddr_t *)udata;
+ int32_t type;
+ int32_t idx;
- entry_ptr->cleared = TRUE;
+ addr_to_type_and_index(addr, &type, &idx);
- if ( dest ) {
+ base_addr = entries[type];
+ entry = &(base_addr[idx]);
- destroy(f, thing);
+ HDassert(entry->type >= 0);
+ HDassert(entry->type == type);
+ HDassert(entry->type == entry_type);
+ HDassert(entry->type < NUMBER_OF_ENTRY_TYPES);
+ HDassert(entry->index == idx);
+ HDassert(entry->index >= 0);
+ HDassert(entry->index <= max_indices[type]);
+ HDassert(entry == entry->self);
+ HDassert(entry->addr == addr);
- }
+ *image_length = entry->size;
return(SUCCEED);
+} /* get_load_size() */
-} /* clear() */
-
-herr_t
-pico_clear(H5F_t * f, void * thing, hbool_t dest)
+static herr_t
+pico_get_load_size(const void *udata, size_t *image_length)
{
- HDassert ( ((test_entry_t *)thing)->type == PICO_ENTRY_TYPE );
- return(clear(f, thing, dest));
+ return get_load_size(udata, image_length, PICO_ENTRY_TYPE);
}
-herr_t
-nano_clear(H5F_t * f, void * thing, hbool_t dest)
+static herr_t
+nano_get_load_size(const void *udata, size_t *image_length)
{
- HDassert ( ((test_entry_t *)thing)->type == NANO_ENTRY_TYPE );
- return(clear(f, thing, dest));
+ return get_load_size(udata, image_length, NANO_ENTRY_TYPE);
}
-herr_t
-micro_clear(H5F_t * f, void * thing, hbool_t dest)
+static herr_t
+micro_get_load_size(const void *udata, size_t *image_length)
{
- HDassert ( ((test_entry_t *)thing)->type == MICRO_ENTRY_TYPE );
- return(clear(f, thing, dest));
+ return get_load_size(udata, image_length, MICRO_ENTRY_TYPE);
}
-herr_t
-tiny_clear(H5F_t * f, void * thing, hbool_t dest)
+static herr_t
+tiny_get_load_size(const void *udata, size_t *image_length)
{
- HDassert ( ((test_entry_t *)thing)->type == TINY_ENTRY_TYPE );
- return(clear(f, thing, dest));
+ return get_load_size(udata, image_length, TINY_ENTRY_TYPE);
}
-herr_t
-small_clear(H5F_t * f, void * thing, hbool_t dest)
+static herr_t
+small_get_load_size(const void *udata, size_t *image_length)
{
- HDassert ( ((test_entry_t *)thing)->type == SMALL_ENTRY_TYPE );
- return(clear(f, thing, dest));
+ return get_load_size(udata, image_length, SMALL_ENTRY_TYPE);
}
-herr_t
-medium_clear(H5F_t * f, void * thing, hbool_t dest)
+static herr_t
+medium_get_load_size(const void *udata, size_t *image_length)
{
- HDassert ( ((test_entry_t *)thing)->type == MEDIUM_ENTRY_TYPE );
- return(clear(f, thing, dest));
+ return get_load_size(udata, image_length, MEDIUM_ENTRY_TYPE);
}
-herr_t
-large_clear(H5F_t * f, void * thing, hbool_t dest)
+static herr_t
+large_get_load_size(const void *udata, size_t *image_length)
{
- HDassert ( ((test_entry_t *)thing)->type == LARGE_ENTRY_TYPE );
- return(clear(f, thing, dest));
+ return get_load_size(udata, image_length, LARGE_ENTRY_TYPE);
}
-herr_t
-huge_clear(H5F_t * f, void * thing, hbool_t dest)
+static herr_t
+huge_get_load_size(const void *udata, size_t *image_length)
{
- HDassert ( ((test_entry_t *)thing)->type == HUGE_ENTRY_TYPE );
- return(clear(f, thing, dest));
+ return get_load_size(udata, image_length, HUGE_ENTRY_TYPE);
}
-herr_t
-monster_clear(H5F_t * f, void * thing, hbool_t dest)
+static herr_t
+monster_get_load_size(const void *udata, size_t *image_length)
{
- HDassert ( ((test_entry_t *)thing)->type == MONSTER_ENTRY_TYPE );
- return(clear(f, thing, dest));
+ return get_load_size(udata, image_length, MONSTER_ENTRY_TYPE);
}
-herr_t
-variable_clear(H5F_t * f, void * thing, hbool_t dest)
+static herr_t
+variable_get_load_size(const void *udata, size_t *image_length)
{
- HDassert ( ((test_entry_t *)thing)->type == VARIABLE_ENTRY_TYPE );
- return(clear(f, thing, dest));
+ return get_load_size(udata, image_length, VARIABLE_ENTRY_TYPE);
}
-herr_t
-notify_clear(H5F_t * f, void * thing, hbool_t dest)
+static herr_t
+notify_get_load_size(const void *udata, size_t *image_length)
{
- HDassert ( ((test_entry_t *)thing)->type == NOTIFY_ENTRY_TYPE );
- return(clear(f, thing, dest));
+ return get_load_size(udata, image_length, NOTIFY_ENTRY_TYPE);
}
-
/*-------------------------------------------------------------------------
- * Function: dest & friends
+ * Function: deserialize & friends
*
- * Purpose: Destroy the entry. The helper functions verify that the
- * correct version of dest is being called, and then call
- * dest proper.
+ * Purpose: deserialize the entry. The helper functions verify that the
+ * correct version of deserialize is being called, and then call
+ * deserialize proper.
*
- * Return: SUCCEED
+ * Return: void * (pointer to the in core representation of the entry)
*
* Programmer: John Mainzer
- * 6/10/04
+ * 9/20/07
*
*-------------------------------------------------------------------------
*/
-
-herr_t
-destroy(H5F_t H5_ATTR_UNUSED * f,
- void * thing)
+static void *
+deserialize(const void *image, size_t len, void *udata, hbool_t *dirty,
+ int32_t entry_type)
{
- int i;
- test_entry_t * entry_ptr;
- test_entry_t * base_addr;
- test_entry_t * pinned_entry_ptr;
- test_entry_t * pinned_base_addr;
-
- HDassert( thing );
-
- entry_ptr = (test_entry_t *)thing;
- base_addr = entries[entry_ptr->type];
-
- HDassert( entry_ptr->index >= 0 );
- HDassert( entry_ptr->index <= max_indices[entry_ptr->type] );
- HDassert( entry_ptr == &(base_addr[entry_ptr->index]) );
- HDassert( entry_ptr == entry_ptr->self );
- HDassert( entry_ptr->cache_ptr != NULL );
- HDassert( entry_ptr->cache_ptr->magic == H5C__H5C_T_MAGIC );
- HDassert( ( entry_ptr->header.destroy_in_progress ) ||
- ( entry_ptr->header.addr == entry_ptr->addr ) );
- HDassert( entry_ptr->header.size == entry_ptr->size );
- HDassert( ( entry_ptr->type == VARIABLE_ENTRY_TYPE ) ||
- ( entry_ptr->size == entry_sizes[entry_ptr->type] ) );
-
- HDassert( !(entry_ptr->is_dirty) );
- HDassert( !(entry_ptr->header.is_dirty) );
-
- if ( entry_ptr->num_pins > 0 ) {
-
- for ( i = 0; i < entry_ptr->num_pins; i++ )
- {
- pinned_base_addr = entries[entry_ptr->pin_type[i]];
- pinned_entry_ptr = &(pinned_base_addr[entry_ptr->pin_idx[i]]);
-
- HDassert( 0 <= pinned_entry_ptr->type );
- HDassert( pinned_entry_ptr->type < NUMBER_OF_ENTRY_TYPES );
- HDassert( pinned_entry_ptr->type == entry_ptr->pin_type[i] );
- HDassert( pinned_entry_ptr->index >= 0 );
- HDassert( pinned_entry_ptr->index <=
- max_indices[pinned_entry_ptr->type] );
- HDassert( pinned_entry_ptr->index == entry_ptr->pin_idx[i] );
- HDassert( pinned_entry_ptr == pinned_entry_ptr->self );
- HDassert( pinned_entry_ptr->header.is_pinned );
- HDassert( pinned_entry_ptr->is_pinned );
- HDassert( pinned_entry_ptr->pinning_ref_count > 0 );
-
- pinned_entry_ptr->pinning_ref_count--;
-
- if ( pinned_entry_ptr->pinning_ref_count <= 0 ) {
-
- unpin_entry(pinned_entry_ptr->type,
- pinned_entry_ptr->index);
- }
+ test_entry_t *entry;
+ test_entry_t *base_addr;
+ haddr_t addr = *(haddr_t *)udata;
+ int32_t type;
+ int32_t idx;
- entry_ptr->pin_type[i] = -1;
- entry_ptr->pin_idx[i] = -1;
- }
- entry_ptr->num_pins = 0;
- }
+ addr_to_type_and_index(addr, &type, &idx);
- entry_ptr->destroyed = TRUE;
- entry_ptr->cache_ptr = NULL;
+ base_addr = entries[type];
+ entry = &(base_addr[idx]);
+
+ HDassert(entry->type >= 0);
+ HDassert(entry->type == type);
+ HDassert(entry->type == entry_type);
+ HDassert(entry->type < NUMBER_OF_ENTRY_TYPES);
+ HDassert(entry->index == idx);
+ HDassert(entry->index >= 0);
+ HDassert(entry->index <= max_indices[type]);
+ HDassert(entry == entry->self);
+ HDassert(entry->addr == addr);
+ HDassert(entry->size == len);
+ HDassert((entry->type == VARIABLE_ENTRY_TYPE) || (entry->size == entry_sizes[type]));
+ HDassert(dirty != NULL);
+
+ /* for now *dirty will always be FALSE */
+ *dirty = FALSE;
+
+ /* verify that the image contains the expected data. */
+ HDassert(image != NULL);
+ if((entry->at_main_addr && entry->written_to_main_addr) ||
+ (!entry->at_main_addr && entry->written_to_alt_addr)) {
+ if((type == PICO_ENTRY_TYPE) || (type == VARIABLE_ENTRY_TYPE) ||
+ (type == NOTIFY_ENTRY_TYPE)) {
+ if((*((const char *)image)) != (char)(idx & 0xFF)) {
+ HDfprintf(stdout, "type = %d, idx = %d, addr = 0x%lx.\n",
+ type, idx, (long)addr);
+ HDfprintf(stdout, "*image = 0x%x\n",
+ (int)(*((const char *)image)));
+ HDfprintf(stdout, "expected *image = 0x%x\n",
+ (int)(idx & 0xFF));
+ } /* end if */
+ HDassert((*((const char *)image)) == (char)(idx & 0xFF));
+ } /* end if */
+ else {
+ if((*(((const char *)image) + 2)) != (char)(idx & 0xFF)) {
+ HDfprintf(stdout, "type = %d, idx = %d, addr = 0x%lx.\n",
+ type, idx, (long)addr);
+ HDfprintf(stdout, "*image = 0x%x 0x%x 0x%x\n",
+ (int)(*((const char *)image)),
+ (int)(*(((const char *)image) + 1)),
+ (int)(*(((const char *)image) + 2)));
+ HDfprintf(stdout, "expected *image = 0x%x\n",
+ (int)(idx & 0xFF),
+ (int)((idx & 0xFF00) >> 8));
+ } /* end if */
+ HDassert((*((const char *)image)) == (char)(type & 0xFF));
+ HDassert((*(((const char *)image) + 1)) == (char)((idx & 0xFF00) >> 8));
+ HDassert((*(((const char *)image) + 2)) == (char)(idx & 0xFF));
+ } /* end else */
+ } /* end if */
- return(SUCCEED);
+ entry->deserialized = TRUE;
+ entry->header.is_dirty = FALSE;
+ entry->is_dirty = FALSE;
+ (entry->deserializes)++;
-} /* dest() */
+ return((void *)entry);
+} /* deserialize() */
-herr_t
-pico_dest(H5F_t * f, void * thing)
+void *
+pico_deserialize(const void *image, size_t len, void *udata, hbool_t *dirty)
{
- HDassert ( ((test_entry_t *)thing)->type == PICO_ENTRY_TYPE );
- return(destroy(f, thing));
+ return deserialize(image, len, udata, dirty, PICO_ENTRY_TYPE);
}
-herr_t
-nano_dest(H5F_t * f, void * thing)
+void *
+nano_deserialize(const void *image, size_t len, void *udata, hbool_t *dirty)
{
- HDassert ( ((test_entry_t *)thing)->type == NANO_ENTRY_TYPE );
- return(destroy(f, thing));
+ return deserialize(image, len, udata, dirty, NANO_ENTRY_TYPE);
}
-herr_t
-micro_dest(H5F_t * f, void * thing)
+void *
+micro_deserialize(const void *image, size_t len, void *udata, hbool_t *dirty)
{
- HDassert ( ((test_entry_t *)thing)->type == MICRO_ENTRY_TYPE );
- return(destroy(f, thing));
+ return deserialize(image, len, udata, dirty, MICRO_ENTRY_TYPE);
}
-herr_t
-tiny_dest(H5F_t * f, void * thing)
+void *
+tiny_deserialize(const void *image, size_t len, void *udata, hbool_t *dirty)
{
- HDassert ( ((test_entry_t *)thing)->type == TINY_ENTRY_TYPE );
- return(destroy(f, thing));
+ return deserialize(image, len, udata, dirty, TINY_ENTRY_TYPE);
}
-herr_t
-small_dest(H5F_t * f, void * thing)
+void *
+small_deserialize(const void *image, size_t len, void *udata, hbool_t *dirty)
{
- HDassert ( ((test_entry_t *)thing)->type == SMALL_ENTRY_TYPE );
- return(destroy(f, thing));
+ return deserialize(image, len, udata, dirty, SMALL_ENTRY_TYPE);
}
-herr_t
-medium_dest(H5F_t * f, void * thing)
+void *
+medium_deserialize(const void *image, size_t len, void *udata, hbool_t *dirty)
{
- HDassert ( ((test_entry_t *)thing)->type == MEDIUM_ENTRY_TYPE );
- return(destroy(f, thing));
+ return deserialize(image, len, udata, dirty, MEDIUM_ENTRY_TYPE);
}
-herr_t
-large_dest(H5F_t * f, void * thing)
+void *
+large_deserialize(const void *image, size_t len, void *udata, hbool_t *dirty)
{
- HDassert ( ((test_entry_t *)thing)->type == LARGE_ENTRY_TYPE );
- return(destroy(f, thing));
+ return deserialize(image, len, udata, dirty, LARGE_ENTRY_TYPE);
}
-herr_t
-huge_dest(H5F_t * f, void * thing)
+void *
+huge_deserialize(const void *image, size_t len, void *udata, hbool_t *dirty)
{
- HDassert ( ((test_entry_t *)thing)->type == HUGE_ENTRY_TYPE );
- return(destroy(f, thing));
+ return deserialize(image, len, udata, dirty, HUGE_ENTRY_TYPE);
}
-herr_t
-monster_dest(H5F_t * f, void * thing)
+void *
+monster_deserialize(const void *image, size_t len, void *udata, hbool_t *dirty)
{
- HDassert ( ((test_entry_t *)thing)->type == MONSTER_ENTRY_TYPE );
- return(destroy(f, thing));
+ return deserialize(image, len, udata, dirty, MONSTER_ENTRY_TYPE);
}
-herr_t
-variable_dest(H5F_t * f, void * thing)
+void *
+variable_deserialize(const void *image, size_t len, void *udata, hbool_t *dirty)
{
- HDassert ( ((test_entry_t *)thing)->type == VARIABLE_ENTRY_TYPE );
- return(destroy(f, thing));
+ return deserialize(image, len, udata, dirty, VARIABLE_ENTRY_TYPE);
}
-herr_t
-notify_dest(H5F_t * f, void * thing)
+void *
+notify_deserialize(const void *image, size_t len, void *udata, hbool_t *dirty)
{
- HDassert ( ((test_entry_t *)thing)->type == NOTIFY_ENTRY_TYPE );
- return(destroy(f, thing));
+ return deserialize(image, len, udata, dirty, NOTIFY_ENTRY_TYPE);
}
/*-------------------------------------------------------------------------
- * Function: flush & friends
+ * Function: image_len & friends
*
- * Purpose: flush the entry and mark it as clean. The helper functions
- * verify that the correct version of flush is being called,
- * and then call flush proper.
+ * Purpose: Return the real (and possibly reduced) length of the image.
+ * The helper functions verify that the correct version of
+ * deserialize is being called, and then call deserialize
+ * proper.
*
* Return: SUCCEED
*
* Programmer: John Mainzer
- * 6/10/04
+ * 9/19/07
*
*-------------------------------------------------------------------------
*/
herr_t
-flush(H5F_t *f,
- hid_t H5_ATTR_UNUSED dxpl_id,
- hbool_t dest,
- haddr_t
-#ifdef NDEBUG
- H5_ATTR_UNUSED
-#endif /* NDEBUG */
- addr,
- void *thing,
- unsigned * flags_ptr)
+image_len(void *thing, size_t *image_length, int32_t entry_type)
{
- int i;
- test_entry_t * entry_ptr;
- test_entry_t * base_addr;
-
- HDassert( thing );
-
- entry_ptr = (test_entry_t *)thing;
- base_addr = entries[entry_ptr->type];
-
- HDassert( entry_ptr->index >= 0 );
- HDassert( entry_ptr->index <= max_indices[entry_ptr->type] );
- HDassert( entry_ptr == &(base_addr[entry_ptr->index]) );
- HDassert( entry_ptr == entry_ptr->self );
- HDassert( entry_ptr->header.addr == entry_ptr->addr );
- HDassert( entry_ptr->addr == addr );
- HDassert( entry_ptr->header.size == entry_ptr->size );
- HDassert( ( entry_ptr->type == VARIABLE_ENTRY_TYPE ) ||
- ( entry_ptr->size == entry_sizes[entry_ptr->type] ) );
- HDassert( entry_ptr->header.is_dirty == entry_ptr->is_dirty );
- HDassert( entry_ptr->cache_ptr != NULL );
- HDassert( entry_ptr->cache_ptr->magic == H5C__H5C_T_MAGIC );
- HDassert( entry_ptr->num_flush_ops >= 0 );
- HDassert( entry_ptr->num_flush_ops < MAX_FLUSH_OPS );
-
- if ( entry_ptr->num_flush_ops > 0 ) {
-
- for ( i = 0; i < entry_ptr->num_flush_ops; i++ )
- {
- execute_flush_op(f,
- entry_ptr,
- &((entry_ptr->flush_ops)[i]),
- flags_ptr);
- }
- entry_ptr->num_flush_ops = 0;
- entry_ptr->flush_op_self_resize_in_progress = FALSE;
- }
+ test_entry_t *entry;
+ test_entry_t *base_addr;
+ int32_t type;
+ int32_t idx;
- entry_ptr->flushed = TRUE;
+ HDassert(thing);
+ HDassert(image_length);
- if ( ( ! write_permitted ) && ( entry_ptr->is_dirty ) ) {
+ entry = (test_entry_t *)thing;
- pass = FALSE;
- failure_mssg = "called flush when write_permitted is FALSE.";
- }
+ HDassert(entry->self == entry);
- if ( entry_ptr->is_dirty ) {
+ type = entry->type;
+ idx = entry->index;
- (entry_ptr->writes)++;
- entry_ptr->is_dirty = FALSE;
- entry_ptr->header.is_dirty = FALSE;
- }
+ HDassert((type >= 0) && (type < NUMBER_OF_ENTRY_TYPES));
+ HDassert(type == entry_type);
+ HDassert((idx >= 0) && (idx <= max_indices[type]));
- if ( dest ) {
+ base_addr = entries[type];
+ HDassert(entry == &(base_addr[idx]));
- destroy(f, thing);
+ if(type != VARIABLE_ENTRY_TYPE)
+ HDassert(entry->size == entry_sizes[type]);
+ else {
+ HDassert(entry->size <= entry_sizes[type]);
+ HDassert(entry->size > 0);
+ } /* end else */
- }
+ *image_length = entry->size;
return(SUCCEED);
-} /* flush() */
+} /* image_len() */
herr_t
-pico_flush(H5F_t *f, hid_t dxpl_id, hbool_t dest, haddr_t addr,
- void *thing, unsigned * flags_ptr)
+pico_image_len(void *thing, size_t *image_length,
+ hbool_t H5_ATTR_UNUSED *compressed_ptr, size_t H5_ATTR_UNUSED *compressed_len_ptr)
{
- HDassert ( ((test_entry_t *)thing)->type == PICO_ENTRY_TYPE );
- return(flush(f, dxpl_id, dest, addr, thing, flags_ptr));
+ return image_len(thing, image_length, PICO_ENTRY_TYPE);
}
herr_t
-nano_flush(H5F_t *f, hid_t dxpl_id, hbool_t dest, haddr_t addr,
- void *thing, unsigned * flags_ptr)
+nano_image_len(void *thing, size_t *image_length,
+ hbool_t H5_ATTR_UNUSED *compressed_ptr, size_t H5_ATTR_UNUSED *compressed_len_ptr)
{
- HDassert ( ((test_entry_t *)thing)->type == NANO_ENTRY_TYPE );
- return(flush(f, dxpl_id, dest, addr, thing, flags_ptr));
+ return image_len(thing, image_length, NANO_ENTRY_TYPE);
}
herr_t
-micro_flush(H5F_t *f, hid_t dxpl_id, hbool_t dest, haddr_t addr,
- void *thing, unsigned * flags_ptr)
+micro_image_len(void *thing, size_t *image_length,
+ hbool_t H5_ATTR_UNUSED *compressed_ptr, size_t H5_ATTR_UNUSED *compressed_len_ptr)
{
- HDassert ( ((test_entry_t *)thing)->type == MICRO_ENTRY_TYPE );
- return(flush(f, dxpl_id, dest, addr, thing, flags_ptr));
+ return image_len(thing, image_length, MICRO_ENTRY_TYPE);
}
herr_t
-tiny_flush(H5F_t *f, hid_t dxpl_id, hbool_t dest, haddr_t addr,
- void *thing, unsigned * flags_ptr)
+tiny_image_len(void *thing, size_t *image_length,
+ hbool_t H5_ATTR_UNUSED *compressed_ptr, size_t H5_ATTR_UNUSED *compressed_len_ptr)
{
- HDassert ( ((test_entry_t *)thing)->type == TINY_ENTRY_TYPE );
- return(flush(f, dxpl_id, dest, addr, thing, flags_ptr));
+ return image_len(thing, image_length, TINY_ENTRY_TYPE);
}
herr_t
-small_flush(H5F_t *f, hid_t dxpl_id, hbool_t dest, haddr_t addr,
- void *thing, unsigned * flags_ptr)
+small_image_len(void *thing, size_t *image_length,
+ hbool_t H5_ATTR_UNUSED *compressed_ptr, size_t H5_ATTR_UNUSED *compressed_len_ptr)
{
- HDassert ( ((test_entry_t *)thing)->type == SMALL_ENTRY_TYPE );
- return(flush(f, dxpl_id, dest, addr, thing, flags_ptr));
+ return image_len(thing, image_length, SMALL_ENTRY_TYPE);
}
herr_t
-medium_flush(H5F_t *f, hid_t dxpl_id, hbool_t dest, haddr_t addr,
- void *thing, unsigned * flags_ptr)
+medium_image_len(void *thing, size_t *image_length,
+ hbool_t H5_ATTR_UNUSED *compressed_ptr, size_t H5_ATTR_UNUSED *compressed_len_ptr)
{
- HDassert ( ((test_entry_t *)thing)->type == MEDIUM_ENTRY_TYPE );
- return(flush(f, dxpl_id, dest, addr, thing, flags_ptr));
+ return image_len(thing, image_length, MEDIUM_ENTRY_TYPE);
}
herr_t
-large_flush(H5F_t *f, hid_t dxpl_id, hbool_t dest, haddr_t addr,
- void *thing, unsigned * flags_ptr)
+large_image_len(void *thing, size_t *image_length,
+ hbool_t H5_ATTR_UNUSED *compressed_ptr, size_t H5_ATTR_UNUSED *compressed_len_ptr)
{
- HDassert ( ((test_entry_t *)thing)->type == LARGE_ENTRY_TYPE );
- return(flush(f, dxpl_id, dest, addr, thing, flags_ptr));
+ return image_len(thing, image_length, LARGE_ENTRY_TYPE);
}
herr_t
-huge_flush(H5F_t *f, hid_t dxpl_id, hbool_t dest, haddr_t addr,
- void *thing, unsigned * flags_ptr)
+huge_image_len(void *thing, size_t *image_length,
+ hbool_t H5_ATTR_UNUSED *compressed_ptr, size_t H5_ATTR_UNUSED *compressed_len_ptr)
{
- HDassert ( ((test_entry_t *)thing)->type == HUGE_ENTRY_TYPE );
- return(flush(f, dxpl_id, dest, addr, thing, flags_ptr));
+ return image_len(thing, image_length, HUGE_ENTRY_TYPE);
}
herr_t
-monster_flush(H5F_t *f, hid_t dxpl_id, hbool_t dest, haddr_t addr,
- void *thing, unsigned * flags_ptr)
+monster_image_len(void *thing, size_t *image_length,
+ hbool_t H5_ATTR_UNUSED *compressed_ptr, size_t H5_ATTR_UNUSED *compressed_len_ptr)
{
- HDassert ( ((test_entry_t *)thing)->type == MONSTER_ENTRY_TYPE );
- return(flush(f, dxpl_id, dest, addr, thing, flags_ptr));
+ return image_len(thing, image_length, MONSTER_ENTRY_TYPE);
}
herr_t
-variable_flush(H5F_t *f, hid_t dxpl_id, hbool_t dest, haddr_t addr,
- void *thing, unsigned * flags_ptr)
+variable_image_len(void *thing, size_t *image_length,
+ hbool_t H5_ATTR_UNUSED *compressed_ptr, size_t H5_ATTR_UNUSED *compressed_len_ptr)
{
- HDassert ( ((test_entry_t *)thing)->type == VARIABLE_ENTRY_TYPE );
- return(flush(f, dxpl_id, dest, addr, thing, flags_ptr));
+ return image_len(thing, image_length, VARIABLE_ENTRY_TYPE);
}
herr_t
-notify_flush(H5F_t *f, hid_t dxpl_id, hbool_t dest, haddr_t addr,
- void *thing, unsigned * flags_ptr)
+notify_image_len(void *thing, size_t *image_length,
+ hbool_t H5_ATTR_UNUSED *compressed_ptr, size_t H5_ATTR_UNUSED *compressed_len_ptr)
{
- HDassert ( ((test_entry_t *)thing)->type == NOTIFY_ENTRY_TYPE );
- return(flush(f, dxpl_id, dest, addr, thing, flags_ptr));
+ return image_len(thing, image_length, NOTIFY_ENTRY_TYPE);
}
/*-------------------------------------------------------------------------
- * Function: load & friends
+ * Function: pre_serialize & friends
*
- * Purpose: "load" the requested entry and mark it as clean. The
- * helper functions verify that the correct version of load
- * is being called, and then call load proper.
+ * Purpose: Pre_serialize the supplied entry. For now this consistes of
+ * executing any flush operations and loading the appropriate
+ * values into *new_addr_ptr, *new_len_ptr, and *flags_ptr.
*
- * Return: SUCCEED
+ * The helper functions verify that the correct version of
+ * serialize is being called, and then call serialize
+ * proper.
+ *
+ * Return: SUCCEED if successful, FAIL otherwise.
*
* Programmer: John Mainzer
- * 6/10/04
+ * 8/07/14
*
*-------------------------------------------------------------------------
*/
-
-void *
-load(H5F_t H5_ATTR_UNUSED *f,
- hid_t H5_ATTR_UNUSED dxpl_id,
- haddr_t addr,
- void H5_ATTR_UNUSED *udata)
+herr_t
+pre_serialize(const H5F_t *f,
+ hid_t H5_ATTR_UNUSED dxpl_id,
+ void *thing,
+ haddr_t addr,
+ size_t len,
+ haddr_t *new_addr_ptr,
+ size_t *new_len_ptr,
+ unsigned *flags_ptr)
{
+ test_entry_t *entry;
+ test_entry_t *base_addr;
int32_t type;
int32_t idx;
- test_entry_t * entry_ptr;
- test_entry_t * base_addr;
+ int32_t i;
- addr_to_type_and_index(addr, &type, &idx);
+ HDassert(f);
+ HDassert(thing);
+ HDassert(flags_ptr);
+
+ *flags_ptr = H5C__SERIALIZE_NO_FLAGS_SET;
+
+ HDassert(new_addr_ptr);
+ HDassert(new_len_ptr);
+
+ entry = (test_entry_t *)thing;
+
+ HDassert(entry->self == entry);
+ HDassert(entry->addr == addr);
+ HDassert(entry->size == len);
+
+ /* shouldn't serialize the entry unless it is dirty */
+ HDassert(entry->is_dirty);
+
+ type = entry->type;
+ idx = entry->index;
+
+ HDassert((type >= 0) && (type < NUMBER_OF_ENTRY_TYPES));
+ HDassert((idx >= 0) && (idx <= max_indices[type]));
base_addr = entries[type];
- entry_ptr = &(base_addr[idx]);
- HDassert( entry_ptr->type == type );
- HDassert( entry_ptr->type >= 0 );
- HDassert( entry_ptr->type < NUMBER_OF_ENTRY_TYPES );
- HDassert( entry_ptr->index == idx );
- HDassert( entry_ptr->index >= 0 );
- HDassert( entry_ptr->index <= max_indices[type] );
- HDassert( entry_ptr == entry_ptr->self );
- HDassert( entry_ptr->addr == addr );
-#if 1 /* JRM */
- if ( ! ( ( entry_ptr->type == VARIABLE_ENTRY_TYPE ) ||
- ( entry_ptr->size == entry_sizes[type] ) ) ) {
-
- HDfprintf(stdout, "entry type/index/size = %d/%d/%ld\n",
- (int)(entry_ptr->type),
- (int)(entry_ptr->index),
- (long)(entry_ptr->size));
- }
-#endif /* JRM */
- HDassert( ( entry_ptr->type == VARIABLE_ENTRY_TYPE ) ||
- ( entry_ptr->size == entry_sizes[type] ) );
+ HDassert(entry == &(base_addr[idx]));
+ HDassert(entry->num_flush_ops >= 0);
+ HDassert(entry->num_flush_ops < MAX_FLUSH_OPS);
- entry_ptr->loaded = TRUE;
+ if(entry->num_flush_ops > 0) {
+ for(i = 0; i < entry->num_flush_ops; i++ ) {
+ HDassert(entry->file_ptr);
- entry_ptr->header.is_dirty = FALSE;
- entry_ptr->is_dirty = FALSE;
+ execute_flush_op(entry->file_ptr, entry,
+ &((entry->flush_ops)[i]), flags_ptr);
+ } /* end for */
+ entry->num_flush_ops = 0;
+ entry->flush_op_self_resize_in_progress = FALSE;
- (entry_ptr->reads)++;
+ /* This looks wrong, but it isn't -- *flags_ptr will be modified
+ * by execute_flush_op() only if the target is this entry --
+ * and the flags set will accumulate over the set of calls in
+ * the for loop.
+ */
+ if(pass && (((*flags_ptr) & H5C__SERIALIZE_RESIZED_FLAG) != 0)) {
- return(entry_ptr);
+ /* set *new_len_ptr to the new length. */
-} /* load() */
+ HDassert(entry->type == VARIABLE_ENTRY_TYPE);
+ HDassert(entry->size > 0);
+ HDassert(entry->size <= VARIABLE_ENTRY_SIZE);
-void *
-pico_load(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *udata)
+ *new_len_ptr = entry->size;
+ } /* end if */
+
+ if(((*flags_ptr) & H5C__SERIALIZE_MOVED_FLAG) != 0) {
+
+ HDassert(((*flags_ptr) | H5C__SERIALIZE_RESIZED_FLAG) != 0);
+
+ /* place the new address in *new_addr */
+ *new_addr_ptr = entry->addr;
+ } /* end if */
+ } /* end if */
+
+ return(SUCCEED);
+
+} /* pre_serialize() */
+
+herr_t
+pico_pre_serialize(const H5F_t *f,
+ hid_t dxpl_id,
+ void *thing,
+ haddr_t addr,
+ size_t len,
+ size_t H5_ATTR_UNUSED compressed_len,
+ haddr_t *new_addr_ptr,
+ size_t *new_len_ptr,
+ size_t H5_ATTR_UNUSED *new_compressed_len_ptr,
+ unsigned *flags_ptr)
{
- return(load(f, dxpl_id, addr, udata));
+ return pre_serialize(f, dxpl_id, thing, addr, len,
+ new_addr_ptr, new_len_ptr, flags_ptr);
}
-void *
-nano_load(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *udata)
+herr_t
+nano_pre_serialize(const H5F_t *f,
+ hid_t dxpl_id,
+ void *thing,
+ haddr_t addr,
+ size_t len,
+ size_t H5_ATTR_UNUSED compressed_len,
+ haddr_t *new_addr_ptr,
+ size_t *new_len_ptr,
+ size_t H5_ATTR_UNUSED *new_compressed_len_ptr,
+ unsigned *flags_ptr)
{
- return(load(f, dxpl_id, addr, udata));
+ return pre_serialize(f, dxpl_id, thing, addr, len,
+ new_addr_ptr, new_len_ptr, flags_ptr);
}
-void *
-micro_load(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *udata)
+herr_t
+micro_pre_serialize(const H5F_t *f,
+ hid_t dxpl_id,
+ void *thing,
+ haddr_t addr,
+ size_t len,
+ size_t H5_ATTR_UNUSED compressed_len,
+ haddr_t *new_addr_ptr,
+ size_t *new_len_ptr,
+ size_t H5_ATTR_UNUSED *new_compressed_len_ptr,
+ unsigned *flags_ptr)
{
- return(load(f, dxpl_id, addr, udata));
+ return pre_serialize(f, dxpl_id, thing, addr, len,
+ new_addr_ptr, new_len_ptr, flags_ptr);
}
-void *
-tiny_load(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *udata)
+herr_t
+tiny_pre_serialize(const H5F_t *f,
+ hid_t dxpl_id,
+ void *thing,
+ haddr_t addr,
+ size_t len,
+ size_t H5_ATTR_UNUSED compressed_len,
+ haddr_t *new_addr_ptr,
+ size_t *new_len_ptr,
+ size_t H5_ATTR_UNUSED *new_compressed_len_ptr,
+ unsigned *flags_ptr)
{
- return(load(f, dxpl_id, addr, udata));
+ return pre_serialize(f, dxpl_id, thing, addr, len,
+ new_addr_ptr, new_len_ptr, flags_ptr);
}
-void *
-small_load(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *udata)
+herr_t
+small_pre_serialize(const H5F_t *f,
+ hid_t dxpl_id,
+ void *thing,
+ haddr_t addr,
+ size_t len,
+ size_t H5_ATTR_UNUSED compressed_len,
+ haddr_t *new_addr_ptr,
+ size_t *new_len_ptr,
+ size_t H5_ATTR_UNUSED *new_compressed_len_ptr,
+ unsigned *flags_ptr)
{
- return(load(f, dxpl_id, addr, udata));
+ return pre_serialize(f, dxpl_id, thing, addr, len,
+ new_addr_ptr, new_len_ptr, flags_ptr);
}
-void *
-medium_load(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *udata)
+herr_t
+medium_pre_serialize(const H5F_t *f,
+ hid_t dxpl_id,
+ void *thing,
+ haddr_t addr,
+ size_t len,
+ size_t H5_ATTR_UNUSED compressed_len,
+ haddr_t *new_addr_ptr,
+ size_t *new_len_ptr,
+ size_t H5_ATTR_UNUSED *new_compressed_len_ptr,
+ unsigned *flags_ptr)
{
- return(load(f, dxpl_id, addr, udata));
+ return pre_serialize(f, dxpl_id, thing, addr, len,
+ new_addr_ptr, new_len_ptr, flags_ptr);
}
-void *
-large_load(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *udata)
+herr_t
+large_pre_serialize(const H5F_t *f,
+ hid_t dxpl_id,
+ void *thing,
+ haddr_t addr,
+ size_t len,
+ size_t H5_ATTR_UNUSED compressed_len,
+ haddr_t *new_addr_ptr,
+ size_t *new_len_ptr,
+ size_t H5_ATTR_UNUSED *new_compressed_len_ptr,
+ unsigned *flags_ptr)
{
- return(load(f, dxpl_id, addr, udata));
+ return pre_serialize(f, dxpl_id, thing, addr, len,
+ new_addr_ptr, new_len_ptr, flags_ptr);
}
-void *
-huge_load(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *udata)
+herr_t
+huge_pre_serialize(const H5F_t *f,
+ hid_t dxpl_id,
+ void *thing,
+ haddr_t addr,
+ size_t len,
+ size_t H5_ATTR_UNUSED compressed_len,
+ haddr_t *new_addr_ptr,
+ size_t *new_len_ptr,
+ size_t H5_ATTR_UNUSED *new_compressed_len_ptr,
+ unsigned *flags_ptr)
{
- return(load(f, dxpl_id, addr, udata));
+ return pre_serialize(f, dxpl_id, thing, addr, len,
+ new_addr_ptr, new_len_ptr, flags_ptr);
}
-void *
-monster_load(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *udata)
+herr_t
+monster_pre_serialize(const H5F_t *f,
+ hid_t dxpl_id,
+ void *thing,
+ haddr_t addr,
+ size_t len,
+ size_t H5_ATTR_UNUSED compressed_len,
+ haddr_t *new_addr_ptr,
+ size_t *new_len_ptr,
+ size_t H5_ATTR_UNUSED *new_compressed_len_ptr,
+ unsigned *flags_ptr)
{
- return(load(f, dxpl_id, addr, udata));
+ return pre_serialize(f, dxpl_id, thing, addr, len,
+ new_addr_ptr, new_len_ptr, flags_ptr);
}
-void *
-variable_load(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *udata)
+herr_t
+variable_pre_serialize(const H5F_t *f,
+ hid_t dxpl_id,
+ void *thing,
+ haddr_t addr,
+ size_t len,
+ size_t H5_ATTR_UNUSED compressed_len,
+ haddr_t *new_addr_ptr,
+ size_t *new_len_ptr,
+ size_t H5_ATTR_UNUSED *new_compressed_len_ptr,
+ unsigned *flags_ptr)
{
- return(load(f, dxpl_id, addr, udata));
+ return pre_serialize(f, dxpl_id, thing, addr, len,
+ new_addr_ptr, new_len_ptr, flags_ptr);
}
-void *
-notify_load(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *udata)
+herr_t
+notify_pre_serialize(const H5F_t *f,
+ hid_t dxpl_id,
+ void *thing,
+ haddr_t addr,
+ size_t len,
+ size_t H5_ATTR_UNUSED compressed_len,
+ haddr_t *new_addr_ptr,
+ size_t *new_len_ptr,
+ size_t H5_ATTR_UNUSED *new_compressed_len_ptr,
+ unsigned *flags_ptr)
{
- return(load(f, dxpl_id, addr, udata));
+ return pre_serialize(f, dxpl_id, thing, addr, len,
+ new_addr_ptr, new_len_ptr, flags_ptr);
}
+
/*-------------------------------------------------------------------------
- * Function: size & friends
+ * Function: serialize & friends
*
- * Purpose: Get the size of the specified entry. The helper functions
- * verify that the correct version of size is being called,
- * and then call size proper.
+ * Purpose: Serialize the supplied entry. For now this consistes of
+ * loading the type and index of the entry into the first
+ * three bytes of the image (if it is long enough -- if not
+ * just load the low order byte of the index into the first
+ * byte of the image).
*
- * Return: SUCCEED
+ * The helper functions verify that the correct version of
+ * serialize is being called, and then call serialize
+ * proper.
+ *
+ * Return: SUCCEED if successful, FAIL otherwise.
*
* Programmer: John Mainzer
- * 6/10/04
+ * 9/19/07
*
*-------------------------------------------------------------------------
*/
herr_t
-size(H5F_t H5_ATTR_UNUSED * f,
- void * thing,
- size_t * size_ptr)
+serialize(const H5F_t H5_ATTR_UNUSED *f, void *image_ptr, size_t len, void *thing)
{
- test_entry_t * entry_ptr;
- test_entry_t * base_addr;
+ test_entry_t *entry;
+ test_entry_t *base_addr;
+ int32_t type;
+ int32_t idx;
- HDassert( size_ptr );
- HDassert( thing );
+ HDassert(image_ptr);
+ HDassert(thing);
- entry_ptr = (test_entry_t *)thing;
- base_addr = entries[entry_ptr->type];
+ entry = (test_entry_t *)thing;
- HDassert( entry_ptr->index >= 0 );
- HDassert( entry_ptr->index <= max_indices[entry_ptr->type] );
- HDassert( entry_ptr == &(base_addr[entry_ptr->index]) );
- HDassert( entry_ptr == entry_ptr->self );
- HDassert( entry_ptr->header.addr == entry_ptr->addr );
- HDassert( ( entry_ptr->type == VARIABLE_ENTRY_TYPE ) || \
- ( entry_ptr->size == entry_sizes[entry_ptr->type] ) );
+ HDassert(entry->self == entry);
+ HDassert(entry->size == len);
- *size_ptr = entry_ptr->size;
+ /* shouldn't serialize the entry unless it is dirty */
+ HDassert(entry->is_dirty);
+
+ type = entry->type;
+ idx = entry->index;
+
+ HDassert((type >= 0) && (type < NUMBER_OF_ENTRY_TYPES));
+ HDassert((idx >= 0) && (idx <= max_indices[type]));
+
+ base_addr = entries[type];
+
+ HDassert(entry == &(base_addr[idx]));
+ HDassert(entry->num_flush_ops >= 0);
+ HDassert(entry->num_flush_ops < MAX_FLUSH_OPS);
+
+ /* null out the image to avoid spurious failures */
+ HDmemset(image_ptr, 0, len);
+
+ if((type == PICO_ENTRY_TYPE) || (type == VARIABLE_ENTRY_TYPE) ||
+ (type == NOTIFY_ENTRY_TYPE )) {
+ HDassert(entry->size >= PICO_ENTRY_SIZE);
+ *((char *)image_ptr) = (char)((entry->index) & 0xFF);
+ } /* end if */
+ else {
+ HDassert(entry->size >= NANO_ENTRY_SIZE);
+ *((char *)image_ptr) = (char)((entry->type) & 0xFF);
+ *(((char *)image_ptr) + 1) = (char)(((entry->index) & 0xFF00) >> 8);
+ *(((char *)image_ptr) + 2) = (char)((entry->index) & 0xFF);
+ } /* end else */
+
+ /* We no longer do the actual write through an callback -- this is
+ * as close to that callback as we will get. Hence mark the entry
+ * clean here. If all goes well, it will be flushed shortly.
+ */
+ entry->is_dirty = FALSE;
+
+ /* since the entry is about to be written to disk, we can mark it
+ * as initialized.
+ */
+ if(entry->at_main_addr)
+ entry->written_to_main_addr = TRUE;
+ else
+ entry->written_to_alt_addr = TRUE;
+
+ /* do book keeping */
+ (entry->serializes)++;
+ entry->serialized = TRUE;
return(SUCCEED);
-} /* size() */
+} /* serialize() */
herr_t
-pico_size(H5F_t * f, void * thing, size_t * size_ptr)
+pico_serialize(const H5F_t H5_ATTR_UNUSED *f, void *image_ptr, size_t len, void *thing)
{
- HDassert ( ((test_entry_t *)thing)->type == PICO_ENTRY_TYPE );
- return(size(f, thing, size_ptr));
+ return serialize(f, image_ptr, len, thing);
}
herr_t
-nano_size(H5F_t * f, void * thing, size_t * size_ptr)
+nano_serialize(const H5F_t H5_ATTR_UNUSED *f, void *image_ptr, size_t len, void *thing)
{
- HDassert ( ((test_entry_t *)thing)->type == NANO_ENTRY_TYPE );
- return(size(f, thing, size_ptr));
+ return serialize(f, image_ptr, len, thing);
}
herr_t
-micro_size(H5F_t * f, void * thing, size_t * size_ptr)
+micro_serialize(const H5F_t H5_ATTR_UNUSED *f, void *image_ptr, size_t len, void *thing)
{
- HDassert ( ((test_entry_t *)thing)->type == MICRO_ENTRY_TYPE );
- return(size(f, thing, size_ptr));
+ return serialize(f, image_ptr, len, thing);
}
herr_t
-tiny_size(H5F_t * f, void * thing, size_t * size_ptr)
+tiny_serialize(const H5F_t H5_ATTR_UNUSED *f, void *image_ptr, size_t len, void *thing)
{
- HDassert ( ((test_entry_t *)thing)->type == TINY_ENTRY_TYPE );
- return(size(f, thing, size_ptr));
+ return serialize(f, image_ptr, len, thing);
}
herr_t
-small_size(H5F_t * f, void * thing, size_t * size_ptr)
+small_serialize(const H5F_t H5_ATTR_UNUSED *f, void *image_ptr, size_t len, void *thing)
{
- HDassert ( ((test_entry_t *)thing)->type == SMALL_ENTRY_TYPE );
- return(size(f, thing, size_ptr));
+ return serialize(f, image_ptr, len, thing);
}
herr_t
-medium_size(H5F_t * f, void * thing, size_t * size_ptr)
+medium_serialize(const H5F_t H5_ATTR_UNUSED *f, void *image_ptr, size_t len,
+ void *thing)
{
- HDassert ( ((test_entry_t *)thing)->type == MEDIUM_ENTRY_TYPE );
- return(size(f, thing, size_ptr));
+ return serialize(f, image_ptr, len, thing);
}
herr_t
-large_size(H5F_t * f, void * thing, size_t * size_ptr)
+large_serialize(const H5F_t H5_ATTR_UNUSED *f, void *image_ptr, size_t len, void *thing)
{
- HDassert ( ((test_entry_t *)thing)->type == LARGE_ENTRY_TYPE );
- return(size(f, thing, size_ptr));
+ return serialize(f, image_ptr, len, thing);
}
herr_t
-huge_size(H5F_t * f, void * thing, size_t * size_ptr)
+huge_serialize(const H5F_t H5_ATTR_UNUSED *f, void *image_ptr, size_t len, void *thing)
{
- HDassert ( ((test_entry_t *)thing)->type == HUGE_ENTRY_TYPE );
- return(size(f, thing, size_ptr));
+ return serialize(f, image_ptr, len, thing);
}
herr_t
-monster_size(H5F_t * f, void * thing, size_t * size_ptr)
+monster_serialize(const H5F_t H5_ATTR_UNUSED *f, void *image_ptr, size_t len,
+ void *thing)
{
- HDassert ( ((test_entry_t *)thing)->type == MONSTER_ENTRY_TYPE );
- return(size(f, thing, size_ptr));
+ return serialize(f, image_ptr, len, thing);
}
herr_t
-variable_size(H5F_t * f, void * thing, size_t * size_ptr)
+variable_serialize(const H5F_t H5_ATTR_UNUSED *f, void *image_ptr, size_t len,
+ void *thing)
{
- HDassert ( ((test_entry_t *)thing)->type == VARIABLE_ENTRY_TYPE );
- return(size(f, thing, size_ptr));
+ return serialize(f, image_ptr, len, thing);
}
herr_t
-notify_size(H5F_t * f, void * thing, size_t * size_ptr)
+notify_serialize(const H5F_t H5_ATTR_UNUSED *f, void *image_ptr, size_t len,
+ void *thing)
{
- HDassert ( ((test_entry_t *)thing)->type == NOTIFY_ENTRY_TYPE );
- return(size(f, thing, size_ptr));
+ return serialize(f, image_ptr, len, thing);
}
@@ -1220,32 +1462,39 @@ notify_size(H5F_t * f, void * thing, size_t * size_ptr)
*-------------------------------------------------------------------------
*/
static herr_t
-notify(H5C_notify_action_t action, void *thing)
+notify(H5C_notify_action_t action, void *thing, int32_t entry_type)
{
- test_entry_t * entry_ptr;
+ test_entry_t *entry;
test_entry_t *base_addr;
HDassert(thing);
- entry_ptr = (test_entry_t *)thing;
- base_addr = entries[entry_ptr->type];
+ entry = (test_entry_t *)thing;
+ base_addr = entries[entry->type];
- HDassert( entry_ptr->index >= 0 );
- HDassert( entry_ptr->index <= max_indices[entry_ptr->type] );
- HDassert( entry_ptr == &(base_addr[entry_ptr->index]) );
- HDassert( entry_ptr == entry_ptr->self );
- HDassert( entry_ptr->header.addr == entry_ptr->addr );
- HDassert( ( entry_ptr->type == VARIABLE_ENTRY_TYPE ) || \
- ( entry_ptr->size == entry_sizes[entry_ptr->type] ) );
+ HDassert(entry->index >= 0);
+ HDassert(entry->index <= max_indices[entry->type]);
+ HDassert((entry->type >= 0) && (entry->type < NUMBER_OF_ENTRY_TYPES));
+ HDassert(entry->type == entry_type);
+ HDassert(entry == &(base_addr[entry->index]));
+ HDassert(entry == entry->self);
+ HDassert(entry->header.addr == entry->addr);
+ HDassert((entry->type == VARIABLE_ENTRY_TYPE) || \
+ (entry->size == entry_sizes[entry->type]));
/* Increment count for appropriate action */
switch(action) {
- case H5C_NOTIFY_ACTION_AFTER_INSERT: /* Entry has been added to the cache */
- entry_ptr->notify_after_insert_count++;
+ case H5C_NOTIFY_ACTION_AFTER_INSERT: /* Entry has been added */
+ case H5C_NOTIFY_ACTION_AFTER_LOAD: /* to the cache. */
+ entry->notify_after_insert_count++;
break;
+ case H5C_NOTIFY_ACTION_AFTER_FLUSH:
+ /* do nothing */
+ break;
+
case H5C_NOTIFY_ACTION_BEFORE_EVICT: /* Entry is about to be evicted from cache */
- entry_ptr->notify_before_evict_count++;
+ entry->notify_before_evict_count++;
break;
default:
@@ -1258,11 +1507,160 @@ notify(H5C_notify_action_t action, void *thing)
herr_t
notify_notify(H5C_notify_action_t action, void *thing)
{
- HDassert ( ((test_entry_t *)thing)->type == NOTIFY_ENTRY_TYPE );
- return(notify(action, thing));
+ return(notify(action, thing, NOTIFY_ENTRY_TYPE));
}
+
+/*-------------------------------------------------------------------------
+ * Function: free_icr & friends
+ *
+ * Purpose: Nominally, this callback is supposed to free the
+ * in core representation of the entry.
+ *
+ * In the context of this test bed, we use it to do
+ * do all the processing we used to do on a destroy.
+ * In particular, we use it to release all the pins
+ * that this entry may have on other entries.
+ *
+ * The helper functions verify that the correct version of
+ * serialize is being called, and then call free_icr
+ * proper.
+ *
+ * Return: SUCCEED
+ *
+ * Programmer: John Mainzer
+ * 9/19/07
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+free_icr(test_entry_t *entry, int32_t entry_type)
+{
+ test_entry_t *base_addr;
+ HDassert(entry);
+
+ base_addr = entries[entry->type];
+
+ HDassert(entry->type == entry_type);
+ HDassert(entry->index >= 0);
+ HDassert(entry->index <= max_indices[entry->type]);
+ HDassert(entry == &(base_addr[entry->index]));
+ HDassert(entry == entry->self);
+ HDassert(entry->cache_ptr != NULL);
+ HDassert(entry->cache_ptr->magic == H5C__H5C_T_MAGIC);
+ HDassert((entry->header.destroy_in_progress) ||
+ (entry->header.addr == entry->addr));
+ HDassert(entry->header.size == entry->size);
+ HDassert((entry->type == VARIABLE_ENTRY_TYPE) ||
+ (entry->size == entry_sizes[entry->type]));
+
+ if(entry->num_pins > 0) {
+ int i;
+
+ for(i = 0; i < entry->num_pins; i++) {
+ test_entry_t *pinned_entry;
+ test_entry_t *pinned_base_addr;
+
+ pinned_base_addr = entries[entry->pin_type[i]];
+ pinned_entry = &(pinned_base_addr[entry->pin_idx[i]]);
+
+ HDassert(0 <= pinned_entry->type);
+ HDassert(pinned_entry->type < NUMBER_OF_ENTRY_TYPES);
+ HDassert(pinned_entry->type == entry->pin_type[i]);
+ HDassert(pinned_entry->index >= 0);
+ HDassert(pinned_entry->index <= max_indices[pinned_entry->type]);
+ HDassert(pinned_entry->index == entry->pin_idx[i]);
+ HDassert(pinned_entry == pinned_entry->self);
+ HDassert(pinned_entry->header.is_pinned);
+ HDassert(pinned_entry->is_pinned);
+ HDassert(pinned_entry->pinning_ref_count > 0);
+
+ pinned_entry->pinning_ref_count--;
+
+ if(pinned_entry->pinning_ref_count <= 0) {
+ HDassert(pinned_entry->file_ptr);
+
+ unpin_entry(pinned_entry->type, pinned_entry->index);
+ } /* end if */
+
+ entry->pin_type[i] = -1;
+ entry->pin_idx[i] = -1;
+ } /* end if */
+ entry->num_pins = 0;
+ } /* end if */
+
+ entry->destroyed = TRUE;
+ entry->cache_ptr = NULL;
+
+ return(SUCCEED);
+} /* free_icr() */
+
+herr_t
+pico_free_icr(void *thing)
+{
+ return free_icr((test_entry_t *)thing, PICO_ENTRY_TYPE);
+}
+
+herr_t
+nano_free_icr(void *thing)
+{
+ return free_icr((test_entry_t *)thing, NANO_ENTRY_TYPE);
+}
+
+herr_t
+micro_free_icr(void *thing)
+{
+ return free_icr((test_entry_t *)thing, MICRO_ENTRY_TYPE);
+}
+
+herr_t
+tiny_free_icr(void *thing)
+{
+ return free_icr((test_entry_t *)thing, TINY_ENTRY_TYPE);
+}
+
+herr_t
+small_free_icr(void *thing)
+{
+ return free_icr((test_entry_t *)thing, SMALL_ENTRY_TYPE);
+}
+
+herr_t
+medium_free_icr(void *thing)
+{
+ return free_icr((test_entry_t *)thing, MEDIUM_ENTRY_TYPE);
+}
+
+herr_t
+large_free_icr(void *thing)
+{
+ return free_icr((test_entry_t *)thing, LARGE_ENTRY_TYPE);
+}
+
+herr_t
+huge_free_icr(void *thing)
+{
+ return free_icr((test_entry_t *)thing, HUGE_ENTRY_TYPE);
+}
+
+herr_t
+monster_free_icr(void *thing)
+{
+ return free_icr((test_entry_t *)thing, MONSTER_ENTRY_TYPE);
+}
+
+herr_t
+variable_free_icr(void *thing)
+{
+ return free_icr((test_entry_t *)thing, VARIABLE_ENTRY_TYPE);
+}
+
+herr_t
+notify_free_icr(void *thing)
+{
+ return free_icr((test_entry_t *)thing, NOTIFY_ENTRY_TYPE);
+}
/**************************************************************************/
@@ -1565,17 +1963,10 @@ execute_flush_op(H5F_t * file_ptr,
HDassert( op_ptr->size <= VARIABLE_ENTRY_SIZE );
entry_ptr->size = op_ptr->size;
- (*flags_ptr) |= H5C_CALLBACK__SIZE_CHANGED_FLAG;
- entry_ptr->flush_op_self_resize_in_progress = TRUE;
- /* if the entry is in the process of being destroyed,
- * set the header size to match the entry size so as
- * to avoid a spurious failure in the destroy callback.
- */
- if ( entry_ptr->header.destroy_in_progress ) {
+ (*flags_ptr) |= H5C__SERIALIZE_RESIZED_FLAG;
- entry_ptr->header.size = entry_ptr->size;
- }
+ entry_ptr->flush_op_self_resize_in_progress = TRUE;
} else {
@@ -1587,7 +1978,29 @@ execute_flush_op(H5F_t * file_ptr,
break;
case FLUSH_OP__MOVE:
- move_entry(cache_ptr, op_ptr->type, op_ptr->idx, op_ptr->flag);
+ if((entry_ptr->type == op_ptr->type) &&
+ (entry_ptr->index == op_ptr->idx)) {
+
+ /* the flush operation is acting on the entry to
+ * which it is attached. Handle this here:
+ */
+
+ HDassert(((*flags_ptr) & H5C__SERIALIZE_RESIZED_FLAG) != 0);
+ (*flags_ptr) |= H5C__SERIALIZE_MOVED_FLAG;
+
+ if(op_ptr->flag) {
+ HDassert(entry_ptr->addr == entry_ptr->alt_addr);
+ entry_ptr->addr = entry_ptr->main_addr;
+ entry_ptr->at_main_addr = TRUE;
+ } /* end if */
+ else {
+ HDassert(entry_ptr->addr == entry_ptr->main_addr);
+ entry_ptr->addr = entry_ptr->alt_addr;
+ entry_ptr->at_main_addr = FALSE;
+ } /* end else */
+ } /* end if */
+ else
+ move_entry(cache_ptr, op_ptr->type, op_ptr->idx, op_ptr->flag);
break;
case FLUSH_OP__ORDER:
@@ -1596,6 +2009,33 @@ execute_flush_op(H5F_t * file_ptr,
(*op_ptr->order_ptr)++;
break;
+ case FLUSH_OP__EXPUNGE:
+ /* the expunge flush op exists to allow us to simulate the
+ * case in which an entry is removed from the cashe as the
+ * the result of the flush of a second entry. At present,
+ * this can only happen via the take ownership flag, but
+ * we will make this test feature more general to as to make
+ * tests easier to write.
+ *
+ * When this operation is executed, the target entry is
+ * removed from the cache without being flushed if dirty
+ * via the expunge_entry() test function (which calls
+ * H5C_expunge_entry()). Note that this flush operation
+ * must always be executed on an entry other than the
+ * entry being flushed.
+ */
+ HDassert( ( entry_ptr->type != op_ptr->type ) ||
+ ( entry_ptr->index != op_ptr->idx ) );
+ expunge_entry(file_ptr, op_ptr->type, op_ptr->idx);
+ break;
+
+ case FLUSH_OP__DEST_FLUSH_DEP:
+ HDassert( ( entry_ptr->type != op_ptr->type ) ||
+ ( entry_ptr->index != op_ptr->idx ) );
+ destroy_flush_dependency(op_ptr->type, op_ptr->idx,
+ entry_ptr->type, entry_ptr->index);
+ break;
+
default:
pass = FALSE;
failure_mssg = "Undefined flush op code.";
@@ -1721,6 +2161,8 @@ reset_entries(void)
base_addr[j].self = &(base_addr[j]);
base_addr[j].cache_ptr = NULL;
+ base_addr[j].written_to_main_addr = FALSE;
+ base_addr[j].written_to_alt_addr = FALSE;
base_addr[j].addr = addr;
base_addr[j].at_main_addr = TRUE;
base_addr[j].main_addr = addr;
@@ -1728,8 +2170,8 @@ reset_entries(void)
base_addr[j].size = entry_size;
base_addr[j].type = i;
base_addr[j].index = j;
- base_addr[j].reads = 0;
- base_addr[j].writes = 0;
+ base_addr[j].serializes = 0;
+ base_addr[j].deserializes = 0;
base_addr[j].is_dirty = FALSE;
base_addr[j].is_protected = FALSE;
base_addr[j].is_read_only = FALSE;
@@ -1755,10 +2197,10 @@ reset_entries(void)
}
base_addr[j].flush_op_self_resize_in_progress = FALSE;
- base_addr[j].loaded = FALSE;
- base_addr[j].cleared = FALSE;
- base_addr[j].flushed = FALSE;
+ base_addr[j].deserialized = FALSE;
+ base_addr[j].serialized = FALSE;
base_addr[j].destroyed = FALSE;
+ base_addr[j].expunged = FALSE;
base_addr[j].flush_dep_par_type = -1;
base_addr[j].flush_dep_par_idx = -1;
@@ -1987,15 +2429,24 @@ verify_entry_status(H5C_t * cache_ptr,
unsigned u; /* Local index variable */
if ( ( ! expected[i].in_cache ) &&
- ( ( expected[i].is_dirty ) ||
- ( expected[i].is_protected ) ||
- ( expected[i].is_pinned ) ) ) {
+ ( ( expected[i].is_protected ) || ( expected[i].is_pinned ) ) ) {
pass = FALSE;
sprintf(msg, "%d: Contradictory data in expected[%d].\n", tag, i);
failure_mssg = msg;
}
+ if ( ( ! expected[i].in_cache ) &&
+ ( expected[i].is_dirty ) &&
+ ( ! entry_ptr->expunged ) ) {
+
+ pass = FALSE;
+ sprintf(msg,
+ "%d: expected[%d] specs non-expunged, dirty, non-resident.\n",
+ tag, i);
+ failure_mssg = msg;
+ }
+
if ( pass ) {
in_cache = entry_in_cache(cache_ptr, expected[i].entry_type,
@@ -2161,23 +2612,20 @@ verify_entry_status(H5C_t * cache_ptr,
if ( pass ) {
- if ( ( entry_ptr->loaded != expected[i].loaded ) ||
- ( entry_ptr->cleared != expected[i].cleared ) ||
- ( entry_ptr->flushed != expected[i].flushed ) ||
+ if ( ( entry_ptr->deserialized != expected[i].deserialized ) ||
+ ( entry_ptr->serialized != expected[i].serialized ) ||
( entry_ptr->destroyed != expected[i].destroyed ) ) {
pass = FALSE;
sprintf(msg,
- "%d entry (%d,%d) loaded = %d(%d), clrd = %d(%d), flshd = %d(%d), dest = %d(%d)\n",
+ "%d entry (%d,%d) deserialized = %d(%d), serialized = %d(%d), dest = %d(%d)\n",
tag,
(int)expected[i].entry_type,
(int)expected[i].entry_index,
- (int)(entry_ptr->loaded),
- (int)(expected[i].loaded),
- (int)(entry_ptr->cleared),
- (int)(expected[i].cleared),
- (int)(entry_ptr->flushed),
- (int)(expected[i].flushed),
+ (int)(entry_ptr->deserialized),
+ (int)(expected[i].deserialized),
+ (int)(entry_ptr->serialized),
+ (int)(expected[i].serialized),
(int)(entry_ptr->destroyed),
(int)(expected[i].destroyed));
failure_mssg = msg;
@@ -2372,20 +2820,37 @@ verify_unprotected(void)
} /* verify_unprotected() */
-/*-------------------------------------------------------------------------
- * Function: setup_cache()
+/*****************************************************************************
*
- * Purpose: Allocate a cache of the desired size and configure it for
- * use in the test bed. Return a pointer to the new cache
- * structure.
+ * Function: setup_cache()
*
- * Return: Pointer to new cache, or NULL on failure.
+ * Purpose: Open an HDF file. This will allocate an instance and
+ * initialize an associated instance of H5C_t. However,
+ * we want to test an instance of H5C_t, so allocate and
+ * initialize one with the file ID returned by the call to
+ * H5Fcreate(). Return a pointer to this instance of H5C_t.
*
- * Programmer: John Mainzer
- * 6/11/04
+ * Observe that we open a HDF file because the cache now
+ * writes directly to file, and we need the file I/O facilities
+ * associated with the file.
*
- *-------------------------------------------------------------------------
- */
+ * To avoid tripping on error check code, must allocate enough
+ * space in the file to hold all the test entries and their
+ * alternates. This is a little sticky, as the addresses of
+ * all the test entries are determined at compile time.
+ *
+ * Deal with this by choosing BASE_ADDR large enough that
+ * the base address of the allocate space will be less than
+ * or equal to BASE_ADDR, and then requesting an extra BASE_ADDR
+ * bytes, so we don't have to wory about exceeding the allocation.
+ *
+ * Return: Success: Ptr to H5C_t
+ *
+ * Failure: NULL
+ *
+ * Programmer: JRM -- 9/13/07
+ *
+ *****************************************************************************/
H5F_t *
setup_cache(size_t max_cache_size,
@@ -2650,8 +3115,11 @@ setup_cache(size_t max_cache_size,
/*-------------------------------------------------------------------------
* Function: takedown_cache()
*
- * Purpose: Flush the specified cache and disable it. If requested,
- * dump stats first. If pass is FALSE, do nothing.
+ * Purpose: Flush the specified cache and destroy it. If requested,
+ * dump stats first. Then close and delete the associate
+ * file.
+ *
+ * If pass is FALSE, do nothing.
*
* Return: void
*
@@ -2678,7 +3146,7 @@ takedown_cache(H5F_t * file_ptr,
flush_cache(file_ptr, TRUE, FALSE, FALSE);
- H5C_dest(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT);
+ H5C_dest(file_ptr, H5P_DATASET_XFER_DEFAULT);
if ( saved_cache != NULL ) {
@@ -2753,6 +3221,11 @@ takedown_cache(H5F_t * file_ptr,
* Programmer: John Mainzer
* 7/6/06
*
+ * Changes: Added code to set entry_ptr->expunged to TRUE if
+ * H5C_expunge_entry() returns without error.
+ *
+ * JRM -- 8/21/14
+ *
*-------------------------------------------------------------------------
*/
@@ -2787,7 +3260,7 @@ expunge_entry(H5F_t * file_ptr,
HDassert( ! ( entry_ptr->header.is_pinned ) );
HDassert( ! ( entry_ptr->is_pinned ) );
- result = H5C_expunge_entry(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT,
+ result = H5C_expunge_entry(file_ptr, H5P_DATASET_XFER_DEFAULT,
&(types[type]), entry_ptr->addr, H5C__NO_FLAGS_SET);
if ( result < 0 ) {
@@ -2795,6 +3268,9 @@ expunge_entry(H5F_t * file_ptr,
pass = FALSE;
failure_mssg = "error in H5C_expunge_entry().";
+ } else {
+
+ entry_ptr->expunged = TRUE;
}
}
@@ -2837,11 +3313,11 @@ flush_cache(H5F_t * file_ptr,
if(destroy_entries)
result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT,
- H5P_DATASET_XFER_DEFAULT, H5C__FLUSH_INVALIDATE_FLAG);
+ H5C__FLUSH_INVALIDATE_FLAG);
else
result = H5C_flush_cache(file_ptr, H5P_DATASET_XFER_DEFAULT,
- H5P_DATASET_XFER_DEFAULT, H5C__NO_FLAGS_SET);
+ H5C__NO_FLAGS_SET);
if(dump_stats)
H5C_stats(cache_ptr, "test cache", dump_detailed_stats);
@@ -2921,8 +3397,8 @@ insert_entry(H5F_t * file_ptr,
entry_ptr->is_dirty = TRUE;
- result = H5C_insert_entry(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT,
- &(types[type]), entry_ptr->addr, (void *)entry_ptr, flags);
+ result = H5C_insert_entry(file_ptr, H5P_DATASET_XFER_DEFAULT,
+ &(types[type]), entry_ptr->addr, (void *)entry_ptr, flags);
if ( ( result < 0 ) ||
( entry_ptr->header.is_protected ) ||
@@ -2951,6 +3427,7 @@ insert_entry(H5F_t * file_ptr,
}
HDassert(entry_ptr->cache_ptr == NULL);
+ entry_ptr->file_ptr = file_ptr;
entry_ptr->cache_ptr = cache_ptr;
if(insert_pinned)
@@ -3174,8 +3651,8 @@ protect_entry(H5F_t * file_ptr,
HDassert( entry_ptr == entry_ptr->self );
HDassert( !(entry_ptr->is_protected) );
- cache_entry_ptr = (H5C_cache_entry_t *)H5C_protect(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT,
- &(types[type]), entry_ptr->addr, NULL, H5C__NO_FLAGS_SET);
+ cache_entry_ptr = (H5C_cache_entry_t *)H5C_protect(file_ptr, H5P_DATASET_XFER_DEFAULT,
+ &(types[type]), entry_ptr->addr, &entry_ptr->addr, H5C__NO_FLAGS_SET);
if ( ( cache_entry_ptr != (void *)entry_ptr ) ||
( !(entry_ptr->header.is_protected) ) ||
@@ -3214,6 +3691,7 @@ protect_entry(H5F_t * file_ptr,
( entry_ptr->cache_ptr == cache_ptr ) );
entry_ptr->cache_ptr = cache_ptr;
+ entry_ptr->file_ptr = file_ptr;
entry_ptr->is_protected = TRUE;
}
@@ -3270,8 +3748,8 @@ protect_entry_ro(H5F_t * file_ptr,
( ( entry_ptr->is_read_only ) &&
( entry_ptr->ro_ref_count > 0 ) ) );
- cache_entry_ptr = (H5C_cache_entry_t *)H5C_protect(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT,
- &(types[type]), entry_ptr->addr, NULL, H5C__READ_ONLY_FLAG);
+ cache_entry_ptr = (H5C_cache_entry_t *)H5C_protect(file_ptr, H5P_DATASET_XFER_DEFAULT,
+ &(types[type]), entry_ptr->addr, &entry_ptr->addr, H5C__READ_ONLY_FLAG);
if ( ( cache_entry_ptr != (void *)entry_ptr ) ||
( !(entry_ptr->header.is_protected) ) ||
@@ -3290,6 +3768,7 @@ protect_entry_ro(H5F_t * file_ptr,
( entry_ptr->cache_ptr == cache_ptr ) );
entry_ptr->cache_ptr = cache_ptr;
+ entry_ptr->file_ptr = file_ptr;
entry_ptr->is_protected = TRUE;
entry_ptr->is_read_only = TRUE;
entry_ptr->ro_ref_count++;
@@ -3479,8 +3958,8 @@ unprotect_entry(H5F_t * file_ptr,
if(flags & H5C__DIRTIED_FLAG)
entry_ptr->is_dirty = TRUE;
- result = H5C_unprotect(file_ptr, H5P_DATASET_XFER_DEFAULT, H5P_DATASET_XFER_DEFAULT,
- &(types[type]), entry_ptr->addr, (void *)entry_ptr, flags);
+ result = H5C_unprotect(file_ptr, H5P_DATASET_XFER_DEFAULT,
+ entry_ptr->addr, (void *)entry_ptr, flags);
if ( ( result < 0 ) ||
( ( entry_ptr->header.is_protected ) &&
@@ -3563,6 +4042,7 @@ unprotect_entry(H5F_t * file_ptr,
void
row_major_scan_forward(H5F_t * file_ptr,
+ int32_t max_index,
int32_t lag,
hbool_t verbose,
hbool_t reset_stats,
@@ -3579,6 +4059,7 @@ row_major_scan_forward(H5F_t * file_ptr,
H5C_t * cache_ptr = NULL;
int32_t type = 0;
int32_t idx;
+ int32_t local_max_index;
if ( verbose )
HDfprintf(stdout, "%s(): entering.\n", FUNC);
@@ -3601,208 +4082,283 @@ row_major_scan_forward(H5F_t * file_ptr,
{
idx = -lag;
- while ( ( pass ) && ( idx <= (max_indices[type] + lag) ) )
+ local_max_index = MIN(max_index, max_indices[type]);
+
+ while ( ( pass ) && ( idx <= (local_max_index + lag) ) )
{
+ int32_t tmp_idx;
+
if ( verbose ) {
HDfprintf(stdout, "%d:%d: ", type, idx);
}
- if ( ( pass ) && ( do_inserts ) && ( (idx + lag) >= 0 ) &&
- ( (idx + lag) <= max_indices[type] ) &&
- ( ((idx + lag) % 2) == 0 ) &&
- ( ! entry_in_cache(cache_ptr, type, (idx + lag)) ) ) {
+ tmp_idx = idx + lag;
+ if ( ( pass ) && ( do_inserts ) && ( tmp_idx >= 0 ) &&
+ ( tmp_idx <= local_max_index ) &&
+ ( (tmp_idx % 2) == 0 ) &&
+ ( ! entry_in_cache(cache_ptr, type, tmp_idx) ) ) {
if ( verbose )
- HDfprintf(stdout, "(i, %d, %d) ", type, (idx + lag));
+ HDfprintf(stdout, "1(i, %d, %d) ", type, tmp_idx);
- insert_entry(file_ptr, type, (idx + lag), H5C__NO_FLAGS_SET);
- }
+ insert_entry(file_ptr, type, tmp_idx, H5C__NO_FLAGS_SET);
+ HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
+ }
- if ( ( pass ) && ( (idx + lag - 1) >= 0 ) &&
- ( (idx + lag - 1) <= max_indices[type] ) &&
- ( ( (idx + lag - 1) % 3 ) == 0 ) ) {
+ tmp_idx--;
+ if ( ( pass ) && ( tmp_idx >= 0 ) &&
+ ( tmp_idx <= local_max_index ) &&
+ ( ( tmp_idx % 3 ) == 0 ) ) {
if ( verbose )
- HDfprintf(stdout, "(p, %d, %d) ", type, (idx + lag - 1));
+ HDfprintf(stdout, "2(p, %d, %d) ", type, tmp_idx);
+
+ protect_entry(file_ptr, type, tmp_idx);
- protect_entry(file_ptr, type, (idx + lag - 1));
+ HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
}
- if ( ( pass ) && ( (idx + lag - 2) >= 0 ) &&
- ( (idx + lag - 2) <= max_indices[type] ) &&
- ( ( (idx + lag - 2) % 3 ) == 0 ) ) {
+ tmp_idx--;
+ if ( ( pass ) && ( tmp_idx >= 0 ) &&
+ ( tmp_idx <= local_max_index ) &&
+ ( ( tmp_idx % 3 ) == 0 ) ) {
if ( verbose )
- HDfprintf(stdout, "(u, %d, %d) ", type, (idx + lag - 2));
+ HDfprintf(stdout, "3(u, %d, %d) ", type, tmp_idx);
- unprotect_entry(file_ptr, type, idx+lag-2, H5C__NO_FLAGS_SET);
+ unprotect_entry(file_ptr, type, tmp_idx, H5C__NO_FLAGS_SET);
+
+ HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
}
+ /* (don't decrement tmp_idx) */
+ if ( ( pass ) && ( do_moves ) && ( tmp_idx >= 0 ) &&
+ ( tmp_idx <= local_max_index ) &&
+ ( ( tmp_idx % 3 ) == 0 ) ) {
- if ( ( pass ) && ( do_moves ) && ( (idx + lag - 2) >= 0 ) &&
- ( (idx + lag - 2) <= max_indices[type] ) &&
- ( ( (idx + lag - 2) % 3 ) == 0 ) ) {
+ if ( verbose )
+ HDfprintf(stdout, "4(r, %d, %d, %d) ",
+ type, tmp_idx, (int)move_to_main_addr);
- move_entry(cache_ptr, type, (idx + lag - 2),
- move_to_main_addr);
- }
+ move_entry(cache_ptr, type, tmp_idx, move_to_main_addr);
+ HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
+ }
- if ( ( pass ) && ( (idx + lag - 3) >= 0 ) &&
- ( (idx + lag - 3) <= max_indices[type] ) &&
- ( ( (idx + lag - 3) % 5 ) == 0 ) ) {
+ tmp_idx--;
+ if ( ( pass ) && ( tmp_idx >= 0 ) &&
+ ( tmp_idx <= local_max_index ) &&
+ ( ( tmp_idx % 5 ) == 0 ) ) {
if ( verbose )
- HDfprintf(stdout, "(p, %d, %d) ", type, (idx + lag - 3));
+ HDfprintf(stdout, "5(p, %d, %d) ", type, tmp_idx);
+
+ protect_entry(file_ptr, type, tmp_idx);
- protect_entry(file_ptr, type, (idx + lag - 3));
+ HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
}
- if ( ( pass ) && ( (idx + lag - 5) >= 0 ) &&
- ( (idx + lag - 5) <= max_indices[type] ) &&
- ( ( (idx + lag - 5) % 5 ) == 0 ) ) {
+ tmp_idx -= 2;
+ if ( ( pass ) && ( tmp_idx >= 0 ) &&
+ ( tmp_idx <= local_max_index ) &&
+ ( ( tmp_idx % 5 ) == 0 ) ) {
if ( verbose )
- HDfprintf(stdout, "(u, %d, %d) ", type, (idx + lag - 5));
+ HDfprintf(stdout, "6(u, %d, %d) ", type, tmp_idx);
+
+ unprotect_entry(file_ptr, type, tmp_idx, H5C__NO_FLAGS_SET);
- unprotect_entry(file_ptr, type, idx+lag-5, H5C__NO_FLAGS_SET);
+ HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
}
if ( do_mult_ro_protects )
{
- if ( ( pass ) && ( (idx + lag - 5) >= 0 ) &&
- ( (idx + lag - 5) < max_indices[type] ) &&
- ( (idx + lag - 5) % 9 == 0 ) ) {
+ /* (don't decrement tmp_idx) */
+ if ( ( pass ) && ( tmp_idx >= 0 ) &&
+ ( tmp_idx < local_max_index ) &&
+ ( tmp_idx % 9 == 0 ) ) {
if ( verbose )
- HDfprintf(stdout, "(p-ro, %d, %d) ", type,
- (idx + lag - 5));
+ HDfprintf(stdout, "7(p-ro, %d, %d) ", type, tmp_idx);
- protect_entry_ro(file_ptr, type, (idx + lag - 5));
+ protect_entry_ro(file_ptr, type, tmp_idx);
+
+ HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
}
- if ( ( pass ) && ( (idx + lag - 6) >= 0 ) &&
- ( (idx + lag - 6) < max_indices[type] ) &&
- ( (idx + lag - 6) % 11 == 0 ) ) {
+ tmp_idx--;
+ if ( ( pass ) && ( tmp_idx >= 0 ) &&
+ ( tmp_idx < local_max_index ) &&
+ ( tmp_idx % 11 == 0 ) ) {
if ( verbose )
- HDfprintf(stdout, "(p-ro, %d, %d) ", type,
- (idx + lag - 6));
+ HDfprintf(stdout, "8(p-ro, %d, %d) ", type, tmp_idx);
+
+ protect_entry_ro(file_ptr, type, tmp_idx);
- protect_entry_ro(file_ptr, type, (idx + lag - 6));
+ HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
}
- if ( ( pass ) && ( (idx + lag - 7) >= 0 ) &&
- ( (idx + lag - 7) < max_indices[type] ) &&
- ( (idx + lag - 7) % 13 == 0 ) ) {
+ tmp_idx--;
+ if ( ( pass ) && ( tmp_idx >= 0 ) &&
+ ( tmp_idx < local_max_index ) &&
+ ( tmp_idx % 13 == 0 ) ) {
if ( verbose )
- HDfprintf(stdout, "(p-ro, %d, %d) ", type,
- (idx + lag - 7));
+ HDfprintf(stdout, "9(p-ro, %d, %d) ", type, tmp_idx);
+
+ protect_entry_ro(file_ptr, type, tmp_idx);
- protect_entry_ro(file_ptr, type, (idx + lag - 7));
+ HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
}
- if ( ( pass ) && ( (idx + lag - 7) >= 0 ) &&
- ( (idx + lag - 7) < max_indices[type] ) &&
- ( (idx + lag - 7) % 9 == 0 ) ) {
+ /* (don't decrement tmp_idx) */
+ if ( ( pass ) && ( tmp_idx >= 0 ) &&
+ ( tmp_idx < local_max_index ) &&
+ ( tmp_idx % 9 == 0 ) ) {
if ( verbose )
- HDfprintf(stdout, "(u-ro, %d, %d) ", type,
- (idx + lag - 7));
+ HDfprintf(stdout, "10(u-ro, %d, %d) ", type, tmp_idx);
- unprotect_entry(file_ptr, type, (idx + lag - 7), H5C__NO_FLAGS_SET);
+ unprotect_entry(file_ptr, type, tmp_idx, H5C__NO_FLAGS_SET);
+
+ HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
}
- if ( ( pass ) && ( (idx + lag - 8) >= 0 ) &&
- ( (idx + lag - 8) < max_indices[type] ) &&
- ( (idx + lag - 8) % 11 == 0 ) ) {
+ tmp_idx--;
+ if ( ( pass ) && ( tmp_idx >= 0 ) &&
+ ( tmp_idx < local_max_index ) &&
+ ( tmp_idx % 11 == 0 ) ) {
if ( verbose )
- HDfprintf(stdout, "(u-ro, %d, %d) ", type,
- (idx + lag - 8));
+ HDfprintf(stdout, "11(u-ro, %d, %d) ", type, tmp_idx);
+
+ unprotect_entry(file_ptr, type, tmp_idx, H5C__NO_FLAGS_SET);
- unprotect_entry(file_ptr, type, (idx + lag - 8), H5C__NO_FLAGS_SET);
+ HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
}
- if ( ( pass ) && ( (idx + lag - 9) >= 0 ) &&
- ( (idx + lag - 9) < max_indices[type] ) &&
- ( (idx + lag - 9) % 13 == 0 ) ) {
+ tmp_idx--;
+ if ( ( pass ) && ( tmp_idx >= 0 ) &&
+ ( tmp_idx < local_max_index ) &&
+ ( tmp_idx % 13 == 0 ) ) {
if ( verbose )
- HDfprintf(stdout, "(u-ro, %d, %d) ", type,
- (idx + lag - 9));
+ HDfprintf(stdout, "12(u-ro, %d, %d) ", type, tmp_idx);
+
+ unprotect_entry(file_ptr, type, tmp_idx, H5C__NO_FLAGS_SET);
- unprotect_entry(file_ptr, type, (idx + lag - 9), H5C__NO_FLAGS_SET);
+ HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
}
} /* if ( do_mult_ro_protects ) */
- if ( ( pass ) && ( idx >= 0 ) && ( idx <= max_indices[type] ) ) {
+ if ( ( pass ) && ( idx >= 0 ) && ( idx <= local_max_index ) ) {
if ( verbose )
- HDfprintf(stdout, "(p, %d, %d) ", type, idx);
+ HDfprintf(stdout, "13(p, %d, %d) ", type, idx);
protect_entry(file_ptr, type, idx);
+
+ HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
}
- if ( ( pass ) && ( (idx - lag + 2) >= 0 ) &&
- ( (idx - lag + 2) <= max_indices[type] ) &&
- ( ( (idx - lag + 2) % 7 ) == 0 ) ) {
+ tmp_idx = idx - lag + 2;
+ if ( ( pass ) && ( tmp_idx >= 0 ) &&
+ ( tmp_idx <= local_max_index ) &&
+ ( ( tmp_idx % 7 ) == 0 ) ) {
if ( verbose )
- HDfprintf(stdout, "(u, %d, %d) ", type, (idx - lag + 2));
+ HDfprintf(stdout, "14(u, %d, %d) ", type, tmp_idx);
+
+ unprotect_entry(file_ptr, type, tmp_idx, H5C__NO_FLAGS_SET);
- unprotect_entry(file_ptr, type, idx-lag+2, H5C__NO_FLAGS_SET);
+ HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
}
- if ( ( pass ) && ( (idx - lag + 1) >= 0 ) &&
- ( (idx - lag + 1) <= max_indices[type] ) &&
- ( ( (idx - lag + 1) % 7 ) == 0 ) ) {
+ tmp_idx--;
+ if ( ( pass ) && ( tmp_idx >= 0 ) &&
+ ( tmp_idx <= local_max_index ) &&
+ ( ( tmp_idx % 7 ) == 0 ) ) {
if ( verbose )
- HDfprintf(stdout, "(p, %d, %d) ", type, (idx - lag + 1));
+ HDfprintf(stdout, "15(p, %d, %d) ", type, tmp_idx);
- protect_entry(file_ptr, type, (idx - lag + 1));
+ protect_entry(file_ptr, type, tmp_idx);
+
+ HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
}
if ( do_destroys ) {
- if ( ( pass ) && ( (idx - lag) >= 0 ) &&
- ( ( idx - lag) <= max_indices[type] ) ) {
+ tmp_idx = idx - lag;
+ if ( ( pass ) && ( tmp_idx >= 0 ) &&
+ ( tmp_idx <= local_max_index ) ) {
- switch ( (idx - lag) %4 ) {
+ switch ( tmp_idx %4 ) {
case 0: /* we just did an insert */
- unprotect_entry(file_ptr, type, idx - lag, H5C__NO_FLAGS_SET);
+
+ if ( verbose )
+ HDfprintf(stdout, "16(u, %d, %d) ", type, tmp_idx);
+
+ unprotect_entry(file_ptr, type, tmp_idx, H5C__NO_FLAGS_SET);
+
+ HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
break;
case 1:
- if ( (entries[type])[idx-lag].is_dirty ) {
+ if ( (entries[type])[tmp_idx].is_dirty ) {
+
+ if ( verbose )
+ HDfprintf(stdout, "17(u, %d, %d) ", type, tmp_idx);
+
+ unprotect_entry(file_ptr, type, tmp_idx, H5C__NO_FLAGS_SET);
- unprotect_entry(file_ptr, type, idx - lag, H5C__NO_FLAGS_SET);
+ HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
} else {
- unprotect_entry(file_ptr, type, idx - lag,
+ if ( verbose )
+ HDfprintf(stdout, "18(u, %d, %d) ", type, tmp_idx);
+
+ unprotect_entry(file_ptr, type, tmp_idx,
(dirty_unprotects ? H5C__DIRTIED_FLAG : H5C__NO_FLAGS_SET));
+
+ HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
}
break;
- case 2: /* we just did an insrt */
- unprotect_entry(file_ptr, type, idx - lag, H5C__DELETED_FLAG);
+ case 2: /* we just did an insert */
+
+ if ( verbose )
+ HDfprintf(stdout, "19(u-del, %d, %d) ", type, tmp_idx);
+
+ unprotect_entry(file_ptr, type, tmp_idx, H5C__DELETED_FLAG);
+
+ HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
break;
case 3:
- if ( (entries[type])[idx-lag].is_dirty ) {
+ if ( (entries[type])[tmp_idx].is_dirty ) {
+
+ if ( verbose )
+ HDfprintf(stdout, "20(u-del, %d, %d) ", type, tmp_idx);
+
+ unprotect_entry(file_ptr, type, tmp_idx, H5C__DELETED_FLAG);
- unprotect_entry(file_ptr, type, idx - lag, H5C__DELETED_FLAG);
+ HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
} else {
- unprotect_entry(file_ptr, type, idx - lag,
+ if ( verbose )
+ HDfprintf(stdout, "21(u-del, %d, %d) ", type, tmp_idx);
+
+ unprotect_entry(file_ptr, type, tmp_idx,
(dirty_destroys ? H5C__DIRTIED_FLAG : H5C__NO_FLAGS_SET)
| H5C__DELETED_FLAG);
+
+ HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
}
break;
@@ -3814,14 +4370,17 @@ row_major_scan_forward(H5F_t * file_ptr,
} else {
- if ( ( pass ) && ( (idx - lag) >= 0 ) &&
- ( ( idx - lag) <= max_indices[type] ) ) {
+ tmp_idx = idx - lag;
+ if ( ( pass ) && ( tmp_idx >= 0 ) &&
+ ( tmp_idx <= local_max_index ) ) {
if ( verbose )
- HDfprintf(stdout, "(u, %d, %d) ", type, (idx - lag));
+ HDfprintf(stdout, "22(u, %d, %d) ", type, tmp_idx);
- unprotect_entry(file_ptr, type, idx - lag,
+ unprotect_entry(file_ptr, type, tmp_idx,
(dirty_unprotects ? H5C__DIRTIED_FLAG : H5C__NO_FLAGS_SET));
+
+ HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
}
}
@@ -3965,6 +4524,7 @@ hl_row_major_scan_forward(H5F_t * file_ptr,
void
row_major_scan_backward(H5F_t * file_ptr,
+ int32_t max_index,
int32_t lag,
hbool_t verbose,
hbool_t reset_stats,
@@ -3981,6 +4541,7 @@ row_major_scan_backward(H5F_t * file_ptr,
H5C_t * cache_ptr = NULL;
int32_t type = NUMBER_OF_ENTRY_TYPES - 1;
int32_t idx;
+ int32_t local_max_index;
if ( verbose )
HDfprintf(stdout, "%s(): Entering.\n", FUNC);
@@ -4000,142 +4561,152 @@ row_major_scan_backward(H5F_t * file_ptr,
while ( ( pass ) && ( type >= 0 ) )
{
- idx = max_indices[type] + lag;
+ local_max_index = MIN(max_index, max_indices[type]);
+
+ idx = local_max_index + lag;
while ( ( pass ) && ( idx >= -lag ) )
{
- if ( ( pass ) && ( do_inserts ) && ( (idx - lag) >= 0 ) &&
- ( (idx - lag) <= max_indices[type] ) &&
- ( ((idx - lag) % 2) == 1 ) &&
- ( ! entry_in_cache(cache_ptr, type, (idx - lag)) ) ) {
+ int32_t tmp_idx;
+
+ tmp_idx = idx - lag;
+ if ( ( pass ) && ( do_inserts ) && ( tmp_idx >= 0 ) &&
+ ( tmp_idx <= local_max_index ) &&
+ ( (tmp_idx % 2) == 1 ) &&
+ ( ! entry_in_cache(cache_ptr, type, tmp_idx) ) ) {
if ( verbose )
- HDfprintf(stdout, "(i, %d, %d) ", type, (idx - lag));
+ HDfprintf(stdout, "(i, %d, %d) ", type, tmp_idx);
- insert_entry(file_ptr, type, (idx - lag), H5C__NO_FLAGS_SET);
+ insert_entry(file_ptr, type, tmp_idx, H5C__NO_FLAGS_SET);
}
-
- if ( ( pass ) && ( (idx - lag + 1) >= 0 ) &&
- ( (idx - lag + 1) <= max_indices[type] ) &&
- ( ( (idx - lag + 1) % 3 ) == 0 ) ) {
+ tmp_idx++;
+ if ( ( pass ) && ( tmp_idx >= 0 ) &&
+ ( tmp_idx <= local_max_index ) &&
+ ( ( tmp_idx % 3 ) == 0 ) ) {
if ( verbose )
- HDfprintf(stdout, "(p, %d, %d) ", type, (idx - lag + 1));
+ HDfprintf(stdout, "(p, %d, %d) ", type, tmp_idx);
- protect_entry(file_ptr, type, (idx - lag + 1));
+ protect_entry(file_ptr, type, tmp_idx);
}
- if ( ( pass ) && ( (idx - lag + 2) >= 0 ) &&
- ( (idx - lag + 2) <= max_indices[type] ) &&
- ( ( (idx - lag + 2) % 3 ) == 0 ) ) {
+ tmp_idx++;
+ if ( ( pass ) && ( tmp_idx >= 0 ) &&
+ ( tmp_idx <= local_max_index ) &&
+ ( ( tmp_idx % 3 ) == 0 ) ) {
if ( verbose )
- HDfprintf(stdout, "(u, %d, %d) ", type, (idx - lag + 2));
+ HDfprintf(stdout, "(u, %d, %d) ", type, tmp_idx);
- unprotect_entry(file_ptr, type, idx-lag+2, H5C__NO_FLAGS_SET);
+ unprotect_entry(file_ptr, type, tmp_idx, H5C__NO_FLAGS_SET);
}
+ /* (don't increment tmp_idx) */
+ if ( ( pass ) && ( do_moves ) && ( tmp_idx >= 0 ) &&
+ ( tmp_idx <= local_max_index ) &&
+ ( ( tmp_idx % 3 ) == 0 ) ) {
- if ( ( pass ) && ( do_moves ) && ( (idx - lag + 2) >= 0 ) &&
- ( (idx - lag + 2) <= max_indices[type] ) &&
- ( ( (idx - lag + 2) % 3 ) == 0 ) ) {
+ if ( verbose )
+ HDfprintf(stdout, "(r, %d, %d, %d) ",
+ type, tmp_idx, (int)move_to_main_addr);
- move_entry(cache_ptr, type, (idx - lag + 2),
- move_to_main_addr);
+ move_entry(cache_ptr, type, tmp_idx, move_to_main_addr);
}
-
- if ( ( pass ) && ( (idx - lag + 3) >= 0 ) &&
- ( (idx - lag + 3) <= max_indices[type] ) &&
- ( ( (idx - lag + 3) % 5 ) == 0 ) ) {
+ tmp_idx++;
+ if ( ( pass ) && ( tmp_idx >= 0 ) &&
+ ( tmp_idx <= local_max_index ) &&
+ ( ( tmp_idx % 5 ) == 0 ) ) {
if ( verbose )
- HDfprintf(stdout, "(p, %d, %d) ", type, (idx - lag + 3));
+ HDfprintf(stdout, "(p, %d, %d) ", type, tmp_idx);
protect_entry(file_ptr, type, (idx - lag + 3));
}
- if ( ( pass ) && ( (idx - lag + 5) >= 0 ) &&
- ( (idx - lag + 5) <= max_indices[type] ) &&
- ( ( (idx - lag + 5) % 5 ) == 0 ) ) {
+ tmp_idx += 2;
+ if ( ( pass ) && ( tmp_idx >= 0 ) &&
+ ( tmp_idx <= local_max_index ) &&
+ ( ( tmp_idx % 5 ) == 0 ) ) {
if ( verbose )
- HDfprintf(stdout, "(u, %d, %d) ", type, (idx - lag + 5));
+ HDfprintf(stdout, "(u, %d, %d) ", type, tmp_idx);
- unprotect_entry(file_ptr, type, idx-lag+5, H5C__NO_FLAGS_SET);
+ unprotect_entry(file_ptr, type, tmp_idx, H5C__NO_FLAGS_SET);
}
+ /* (don't increment tmp_idx) */
if ( do_mult_ro_protects )
{
- if ( ( pass ) && ( (idx - lag + 5) >= 0 ) &&
- ( (idx - lag + 5) < max_indices[type] ) &&
- ( (idx - lag + 5) % 9 == 0 ) ) {
+ if ( ( pass ) && ( tmp_idx >= 0 ) &&
+ ( tmp_idx < local_max_index ) &&
+ ( tmp_idx % 9 == 0 ) ) {
if ( verbose )
- HDfprintf(stdout, "(p-ro, %d, %d) ", type,
- (idx - lag + 5));
+ HDfprintf(stdout, "(p-ro, %d, %d) ", type, tmp_idx);
- protect_entry_ro(file_ptr, type, (idx - lag + 5));
+ protect_entry_ro(file_ptr, type, tmp_idx);
}
- if ( ( pass ) && ( (idx - lag + 6) >= 0 ) &&
- ( (idx - lag + 6) < max_indices[type] ) &&
- ( (idx - lag + 6) % 11 == 0 ) ) {
+ tmp_idx++;
+ if ( ( pass ) && ( tmp_idx >= 0 ) &&
+ ( tmp_idx < local_max_index ) &&
+ ( tmp_idx % 11 == 0 ) ) {
if ( verbose )
- HDfprintf(stdout, "(p-ro, %d, %d) ", type,
- (idx - lag + 6));
+ HDfprintf(stdout, "(p-ro, %d, %d) ", type, tmp_idx);
- protect_entry_ro(file_ptr, type, (idx - lag + 6));
+ protect_entry_ro(file_ptr, type, tmp_idx);
}
- if ( ( pass ) && ( (idx - lag + 7) >= 0 ) &&
- ( (idx - lag + 7) < max_indices[type] ) &&
- ( (idx - lag + 7) % 13 == 0 ) ) {
+ tmp_idx++;
+ if ( ( pass ) && ( tmp_idx >= 0 ) &&
+ ( tmp_idx < local_max_index ) &&
+ ( tmp_idx % 13 == 0 ) ) {
if ( verbose )
- HDfprintf(stdout, "(p-ro, %d, %d) ", type,
- (idx - lag + 7));
+ HDfprintf(stdout, "(p-ro, %d, %d) ", type, tmp_idx);
- protect_entry_ro(file_ptr, type, (idx - lag + 7));
+ protect_entry_ro(file_ptr, type, tmp_idx);
}
- if ( ( pass ) && ( (idx - lag + 7) >= 0 ) &&
- ( (idx - lag + 7) < max_indices[type] ) &&
- ( (idx - lag + 7) % 9 == 0 ) ) {
+ /* (don't increment tmp_idx) */
+ if ( ( pass ) && ( tmp_idx >= 0 ) &&
+ ( tmp_idx < local_max_index ) &&
+ ( tmp_idx % 9 == 0 ) ) {
if ( verbose )
- HDfprintf(stdout, "(u-ro, %d, %d) ", type,
- (idx - lag + 7));
+ HDfprintf(stdout, "(u-ro, %d, %d) ", type, tmp_idx);
- unprotect_entry(file_ptr, type, (idx - lag + 7), H5C__NO_FLAGS_SET);
+ unprotect_entry(file_ptr, type, tmp_idx, H5C__NO_FLAGS_SET);
}
- if ( ( pass ) && ( (idx - lag + 8) >= 0 ) &&
- ( (idx - lag + 8) < max_indices[type] ) &&
- ( (idx - lag + 8) % 11 == 0 ) ) {
+ tmp_idx++;
+ if ( ( pass ) && ( tmp_idx >= 0 ) &&
+ ( tmp_idx < local_max_index ) &&
+ ( tmp_idx % 11 == 0 ) ) {
if ( verbose )
- HDfprintf(stdout, "(u-ro, %d, %d) ", type,
- (idx - lag + 8));
+ HDfprintf(stdout, "(u-ro, %d, %d) ", type, tmp_idx);
- unprotect_entry(file_ptr, type, (idx - lag + 8), H5C__NO_FLAGS_SET);
+ unprotect_entry(file_ptr, type, tmp_idx, H5C__NO_FLAGS_SET);
}
- if ( ( pass ) && ( (idx - lag + 9) >= 0 ) &&
- ( (idx - lag + 9) < max_indices[type] ) &&
- ( (idx - lag + 9) % 13 == 0 ) ) {
+ tmp_idx++;
+ if ( ( pass ) && ( tmp_idx >= 0 ) &&
+ ( tmp_idx < local_max_index ) &&
+ ( tmp_idx % 13 == 0 ) ) {
if ( verbose )
- HDfprintf(stdout, "(u-ro, %d, %d) ", type,
- (idx - lag + 9));
+ HDfprintf(stdout, "(u-ro, %d, %d) ", type, tmp_idx);
- unprotect_entry(file_ptr, type, (idx - lag + 9), H5C__NO_FLAGS_SET);
+ unprotect_entry(file_ptr, type, tmp_idx, H5C__NO_FLAGS_SET);
}
} /* if ( do_mult_ro_protects ) */
- if ( ( pass ) && ( idx >= 0 ) && ( idx <= max_indices[type] ) ) {
+ if ( ( pass ) && ( idx >= 0 ) && ( idx <= local_max_index ) ) {
if ( verbose )
HDfprintf(stdout, "(p, %d, %d) ", type, idx);
@@ -4143,32 +4714,33 @@ row_major_scan_backward(H5F_t * file_ptr,
protect_entry(file_ptr, type, idx);
}
-
- if ( ( pass ) && ( (idx + lag - 2) >= 0 ) &&
- ( (idx + lag - 2) <= max_indices[type] ) &&
- ( ( (idx + lag - 2) % 7 ) == 0 ) ) {
+ tmp_idx = idx + lag - 2;
+ if ( ( pass ) && ( tmp_idx >= 0 ) &&
+ ( tmp_idx <= local_max_index ) &&
+ ( ( tmp_idx % 7 ) == 0 ) ) {
if ( verbose )
- HDfprintf(stdout, "(u, %d, %d) ", type, (idx + lag - 2));
+ HDfprintf(stdout, "(u, %d, %d) ", type, tmp_idx);
- unprotect_entry(file_ptr, type, idx+lag-2, H5C__NO_FLAGS_SET);
+ unprotect_entry(file_ptr, type, tmp_idx, H5C__NO_FLAGS_SET);
}
- if ( ( pass ) && ( (idx + lag - 1) >= 0 ) &&
- ( (idx + lag - 1) <= max_indices[type] ) &&
- ( ( (idx + lag - 1) % 7 ) == 0 ) ) {
+ tmp_idx++;
+ if ( ( pass ) && ( tmp_idx >= 0 ) &&
+ ( tmp_idx <= local_max_index ) &&
+ ( ( tmp_idx % 7 ) == 0 ) ) {
if ( verbose )
- HDfprintf(stdout, "(p, %d, %d) ", type, (idx + lag - 1));
+ HDfprintf(stdout, "(p, %d, %d) ", type, tmp_idx);
- protect_entry(file_ptr, type, (idx + lag - 1));
+ protect_entry(file_ptr, type, tmp_idx);
}
if ( do_destroys ) {
if ( ( pass ) && ( (idx + lag) >= 0 ) &&
- ( ( idx + lag) <= max_indices[type] ) ) {
+ ( ( idx + lag) <= local_max_index ) ) {
switch ( (idx + lag) % 4 ) {
@@ -4211,7 +4783,7 @@ row_major_scan_backward(H5F_t * file_ptr,
} else {
if ( ( pass ) && ( (idx + lag) >= 0 ) &&
- ( ( idx + lag) <= max_indices[type] ) ) {
+ ( ( idx + lag) <= local_max_index ) ) {
if ( verbose )
HDfprintf(stdout, "(u, %d, %d) ", type, (idx + lag));
@@ -4361,6 +4933,7 @@ hl_row_major_scan_backward(H5F_t * file_ptr,
void
col_major_scan_forward(H5F_t * file_ptr,
+ int32_t max_index,
int32_t lag,
hbool_t verbose,
hbool_t reset_stats,
@@ -4372,14 +4945,19 @@ col_major_scan_forward(H5F_t * file_ptr,
H5C_t * cache_ptr = NULL;
int32_t type = 0;
int32_t idx;
+ int32_t local_max_index[NUMBER_OF_ENTRY_TYPES];
if ( verbose )
HDfprintf(stdout, "%s: entering.\n", FUNC);
if ( pass ) {
+ int i;
cache_ptr = file_ptr->shared->cache;
+ for ( i = 0; i < NUMBER_OF_ENTRY_TYPES; i++ )
+ local_max_index[i] = MIN(max_index, max_indices[i]);
+
HDassert( lag > 5 );
if ( reset_stats ) {
@@ -4397,7 +4975,7 @@ col_major_scan_forward(H5F_t * file_ptr,
while ( ( pass ) && ( type < NUMBER_OF_ENTRY_TYPES ) )
{
if ( ( pass ) && ( do_inserts ) && ( (idx + lag) >= 0 ) &&
- ( (idx + lag) <= max_indices[type] ) &&
+ ( (idx + lag) <= local_max_index[type] ) &&
( ((idx + lag) % 3) == 0 ) &&
( ! entry_in_cache(cache_ptr, type, (idx + lag)) ) ) {
@@ -4407,7 +4985,9 @@ col_major_scan_forward(H5F_t * file_ptr,
insert_entry(file_ptr, type, (idx + lag), H5C__NO_FLAGS_SET);
}
- if ( ( pass ) && ( idx >= 0 ) && ( idx <= max_indices[type] ) ) {
+ if ( ( pass ) &&
+ ( idx >= 0 ) &&
+ ( idx <= local_max_index[type] ) ) {
if ( verbose )
HDfprintf(stdout, "(p, %d, %d) ", type, idx);
@@ -4416,7 +4996,7 @@ col_major_scan_forward(H5F_t * file_ptr,
}
if ( ( pass ) && ( (idx - lag) >= 0 ) &&
- ( (idx - lag) <= max_indices[type] ) ) {
+ ( (idx - lag) <= local_max_index[type] ) ) {
if ( verbose )
HDfprintf(stdout, "(u, %d, %d) ", type, (idx - lag));
@@ -4529,7 +5109,7 @@ hl_col_major_scan_forward(H5F_t * file_ptr,
}
if ( ( pass ) && ( i >= 0 ) &&
- ( i <= max_indices[type] ) ) {
+ ( i <= local_max_index ) ) {
if ( verbose )
HDfprintf(stdout, "(u, %d, %d) ", type, i);
@@ -4577,6 +5157,7 @@ hl_col_major_scan_forward(H5F_t * file_ptr,
void
col_major_scan_backward(H5F_t * file_ptr,
+ int32_t max_index,
int32_t lag,
hbool_t verbose,
hbool_t reset_stats,
@@ -4589,16 +5170,21 @@ col_major_scan_backward(H5F_t * file_ptr,
int mile_stone = 1;
int32_t type;
int32_t idx;
+ int32_t local_max_index[NUMBER_OF_ENTRY_TYPES];
if ( verbose )
HDfprintf(stdout, "%s: entering.\n", FUNC);
if ( pass ) {
+ int i;
cache_ptr = file_ptr->shared->cache;
HDassert( cache_ptr != NULL );
+ for ( i = 0; i < NUMBER_OF_ENTRY_TYPES; i++ )
+ local_max_index[i] = MIN(max_index, max_indices[i]);
+
HDassert( lag > 5 );
if ( reset_stats ) {
@@ -4607,7 +5193,7 @@ col_major_scan_backward(H5F_t * file_ptr,
}
}
- idx = MAX_ENTRIES + lag;
+ idx = local_max_index[NUMBER_OF_ENTRY_TYPES - 1] + lag;
if ( verbose ) /* 1 */
HDfprintf(stdout, "%s: point %d.\n", FUNC, mile_stone++);
@@ -4620,7 +5206,7 @@ col_major_scan_backward(H5F_t * file_ptr,
while ( ( pass ) && ( type >= 0 ) )
{
if ( ( pass ) && ( do_inserts) && ( (idx - lag) >= 0 ) &&
- ( (idx - lag) <= max_indices[type] ) &&
+ ( (idx - lag) <= local_max_index[type] ) &&
( ((idx - lag) % 3) == 0 ) &&
( ! entry_in_cache(cache_ptr, type, (idx - lag)) ) ) {
@@ -4630,7 +5216,9 @@ col_major_scan_backward(H5F_t * file_ptr,
insert_entry(file_ptr, type, (idx - lag), H5C__NO_FLAGS_SET);
}
- if ( ( pass ) && ( idx >= 0 ) && ( idx <= max_indices[type] ) ) {
+ if ( ( pass ) &&
+ ( idx >= 0 ) &&
+ ( idx <= local_max_index[type] ) ) {
if ( verbose )
HDfprintf(stdout, "(p, %d, %d) ", type, idx);
@@ -4639,7 +5227,7 @@ col_major_scan_backward(H5F_t * file_ptr,
}
if ( ( pass ) && ( (idx + lag) >= 0 ) &&
- ( (idx + lag) <= max_indices[type] ) ) {
+ ( (idx + lag) <= local_max_index[type] ) ) {
if ( verbose )
HDfprintf(stdout, "(u, %d, %d) ", type, (idx + lag));
@@ -5445,3 +6033,73 @@ validate_mdc_config(hid_t file_id,
} /* validate_mdc_config() */
+
+#if 0 /* debugging functions -- normally commented out */
+/*-------------------------------------------------------------------------
+ * Function: dump_LRU
+ *
+ * Purpose: Display a summarize list of the contents of the LRU
+ * from head to tail.
+ *
+ * Return: void
+ *
+ * Programmer: John Mainzer
+ * 2/16/15
+ *
+ *-------------------------------------------------------------------------
+ */
+void
+dump_LRU(H5F_t * file_ptr)
+{
+ const char * hdr_0 =
+ " Entry Entry Entry Entry Entry \n";
+ const char * hdr_1 =
+ " Num: Dirty: Size: Addr: Type: \n";
+ const char * hdr_2 =
+ "==============================================================\n";
+ int i = 0;
+ H5C_cache_entry_t * entry_ptr = NULL;
+ H5C_t *cache_ptr = file_ptr->shared->cache;
+
+ HDassert(cache_ptr);
+ HDassert(cache_ptr->magic == H5C__H5C_T_MAGIC);
+
+ entry_ptr = cache_ptr->LRU_head_ptr;
+
+ HDfprintf(stdout,
+ "\n\nIndex len/size/clean size/dirty size = %d/%lld/%lld/%lld\n",
+ cache_ptr->index_len, (long long)(cache_ptr->index_size),
+ (long long)(cache_ptr->clean_index_size),
+ (long long)(cache_ptr->dirty_index_size));
+ HDfprintf(stdout, "\nLRU len/size = %d/%lld.\n\n",
+ cache_ptr->LRU_list_len, (long long)(cache_ptr->LRU_list_size));
+
+ if ( entry_ptr != NULL )
+ {
+ HDfprintf(stdout, "%s%s%s", hdr_0, hdr_1, hdr_2);
+ }
+
+ while ( entry_ptr != NULL )
+ {
+ HDfprintf(stdout,
+ " %3d %d %10lld 0x%010llx %s(%d)\n",
+ i,
+ (int)(entry_ptr->is_dirty),
+ (long long)(entry_ptr->size),
+ (long long)(entry_ptr->addr),
+ entry_ptr->type->name,
+ entry_ptr->type->id);
+ i++;
+ entry_ptr = entry_ptr->next;
+ }
+
+ if ( cache_ptr->LRU_list_len > 0 )
+ {
+ HDfprintf(stdout, "%s\n", hdr_2);
+ }
+
+ return;
+
+} /* dump_LRU() */
+
+#endif /* debugging functions -- normally commented out */
diff --git a/test/cache_common.h b/test/cache_common.h
index 48b95d8..737c53f 100644
--- a/test/cache_common.h
+++ b/test/cache_common.h
@@ -138,12 +138,14 @@
* directly pinned by a single entry.
*/
-#define FLUSH_OP__NO_OP 0
-#define FLUSH_OP__DIRTY 1
-#define FLUSH_OP__RESIZE 2
-#define FLUSH_OP__MOVE 3
-#define FLUSH_OP__ORDER 4
-#define FLUSH_OP__MAX_OP 4
+#define FLUSH_OP__NO_OP 0
+#define FLUSH_OP__DIRTY 1
+#define FLUSH_OP__RESIZE 2
+#define FLUSH_OP__MOVE 3
+#define FLUSH_OP__ORDER 4
+#define FLUSH_OP__EXPUNGE 5
+#define FLUSH_OP__DEST_FLUSH_DEP 6
+#define FLUSH_OP__MAX_OP 6
#define MAX_FLUSH_OPS 10 /* Maximum number of flush operations
* that can be associated with a
@@ -214,10 +216,32 @@ typedef struct test_entry_t
struct test_entry_t * self; /* pointer to this entry -- used for
* sanity checking.
*/
+ H5F_t * file_ptr; /* pointer to the file in which the
+ * entry resides, or NULL if the entry
+ * is not in a file.
+ */
H5C_t * cache_ptr; /* pointer to the cache in which
* the entry resides, or NULL if the
* entry is not in cache.
*/
+ hbool_t written_to_main_addr;
+ /* Flag indicating whether an image
+ * of the entry has been written to
+ * its main address. Since we no
+ * longer have a flush callback, we
+ * set this field to true whenever the
+ * entry is serialized while at its
+ * main address.
+ */
+ hbool_t written_to_alt_addr;
+ /* Flag indicating whether an image
+ * of the entry has been written to
+ * its alternate address. Since we no
+ * longer have a flush callback, we
+ * set this field to true whenever the
+ * entry is serialized while at its
+ * alternate address.
+ */
haddr_t addr; /* where the cache thinks this entry
* is located
*/
@@ -239,11 +263,11 @@ typedef struct test_entry_t
*/
int32_t index; /* index in its entry array
*/
- int32_t reads; /* number of times this entry has
- * been loaded.
+ int32_t serializes; /* number of times this entry has
+ * been serialized.
*/
- int32_t writes; /* number of times this entry has
- * been written
+ int32_t deserializes; /* number of times this entry has
+ * been deserialized
*/
hbool_t is_dirty; /* entry has been modified since
* last write
@@ -302,16 +326,16 @@ typedef struct test_entry_t
* checking code that would otherwise
* cause a false test failure.
*/
- hbool_t loaded; /* entry has been loaded since the
- * last time it was reset.
+ hbool_t deserialized; /* entry has been deserialized since
+ * the last time it was reset.
*/
- hbool_t cleared; /* entry has been cleared since the
+ hbool_t serialized; /* entry has been serialized since the
* last time it was reset.
*/
- hbool_t flushed; /* entry has been flushed since the
+ hbool_t destroyed; /* entry has been destroyed since the
* last time it was reset.
*/
- hbool_t destroyed; /* entry has been destroyed since the
+ hbool_t expunged; /* entry has been expunged since the
* last time it was reset.
*/
int flush_dep_par_type; /* Entry type of flush dependency parent */
@@ -471,9 +495,6 @@ if ( ( (cache_ptr) == NULL ) || \
(i).flash_threshold = (e).flash_threshold; \
(i).decr_mode = (e).decr_mode; \
(i).upper_hr_threshold = (e).upper_hr_threshold; \
- (i).flash_incr_mode = (e).flash_incr_mode; \
- (i).flash_multiple = (e).flash_multiple; \
- (i).flash_threshold = (e).flash_threshold; \
(i).decrement = (e).decrement; \
(i).apply_max_decrement = (e).apply_max_decrement; \
(i).max_decrement = (e).max_decrement; \
@@ -490,15 +511,14 @@ struct expected_entry_status
int entry_type;
int entry_index;
size_t size;
- unsigned char in_cache;
- unsigned char at_main_addr;
- unsigned char is_dirty;
- unsigned char is_protected;
- unsigned char is_pinned;
- unsigned char loaded;
- unsigned char cleared;
- unsigned char flushed;
- unsigned char destroyed;
+ hbool_t in_cache;
+ hbool_t at_main_addr;
+ hbool_t is_dirty;
+ hbool_t is_protected;
+ hbool_t is_pinned;
+ hbool_t deserialized;
+ hbool_t serialized;
+ hbool_t destroyed;
int flush_dep_par_type; /* Entry type of flush dependency parent */
int flush_dep_par_idx; /* Index of flush dependency parent */
uint64_t child_flush_dep_height_rc[H5C__NUM_FLUSH_DEP_HEIGHTS];
@@ -514,12 +534,9 @@ struct expected_entry_status
/* global variable externs: */
-extern const char *FILENAME[3];
-
+extern haddr_t saved_actual_base_addr;
extern hbool_t write_permitted;
extern hbool_t pass; /* set to false on error */
-extern hbool_t skip_long_tests;
-extern hbool_t run_full_test;
extern const char *failure_mssg;
extern test_entry_t * entries[NUMBER_OF_ENTRY_TYPES];
@@ -609,6 +626,7 @@ void resize_entry(H5F_t * file_ptr,
H5F_t *setup_cache(size_t max_cache_size, size_t min_clean_size);
void row_major_scan_forward(H5F_t * file_ptr,
+ int32_t max_index,
int32_t lag,
hbool_t verbose,
hbool_t reset_stats,
@@ -631,6 +649,7 @@ void hl_row_major_scan_forward(H5F_t * file_ptr,
hbool_t do_inserts);
void row_major_scan_backward(H5F_t * file_ptr,
+ int32_t max_index,
int32_t lag,
hbool_t verbose,
hbool_t reset_stats,
@@ -653,6 +672,7 @@ void hl_row_major_scan_backward(H5F_t * file_ptr,
hbool_t do_inserts);
void col_major_scan_forward(H5F_t * file_ptr,
+ int32_t max_index,
int32_t lag,
hbool_t verbose,
hbool_t reset_stats,
@@ -671,6 +691,7 @@ void hl_col_major_scan_forward(H5F_t * file_ptr,
int dirty_unprotects);
void col_major_scan_backward(H5F_t * file_ptr,
+ int32_t max_index,
int32_t lag,
hbool_t verbose,
hbool_t reset_stats,
@@ -747,5 +768,10 @@ void validate_mdc_config(hid_t file_id,
hbool_t compare_init,
int test_num);
+/** Debugging functions -- normally commented out ***/
+#if 0
+void dump_LRU(H5F_t * file_ptr);
+#endif
+
#endif /* _CACHE_COMMON_H */
diff --git a/test/cache_tagging.c b/test/cache_tagging.c
index 9209f6d..84c9b34 100644
--- a/test/cache_tagging.c
+++ b/test/cache_tagging.c
@@ -457,7 +457,7 @@ static int evict_entries(hid_t fid)
/* Evict all we can from the cache to examine full tag creation tree */
/* This function will likely return failure since the root group
* is still protected. Thus, don't check its return value. */
- H5C_flush_cache(f, H5P_DEFAULT, H5P_DEFAULT, H5C__FLUSH_INVALIDATE_FLAG);
+ H5C_flush_cache(f, H5P_DEFAULT, H5C__FLUSH_INVALIDATE_FLAG);
return 0;
@@ -3866,13 +3866,13 @@ check_invalid_tag_application(void)
/* Call H5HL_protect to protect the local heap created above. */
/* This should fail as no tag is set up during the protect call */
- if (( lheap = H5HL_protect(f, H5AC_ind_dxpl_id, addr, H5AC_WRITE)) != NULL ) TEST_ERROR;
+ if (( lheap = H5HL_protect(f, H5AC_ind_dxpl_id, addr, H5AC__NO_FLAGS_SET)) != NULL ) TEST_ERROR;
/* Again, set up a valid tag in the DXPL */
if ( H5AC_tag(H5AC_ind_dxpl_id, (haddr_t)25, NULL) < 0) TEST_ERROR;
/* Call H5HL_protect again to protect the local heap. This should succeed. */
- if (( lheap = H5HL_protect(f, H5AC_ind_dxpl_id, addr, H5AC_WRITE)) == NULL ) TEST_ERROR;
+ if (( lheap = H5HL_protect(f, H5AC_ind_dxpl_id, addr, H5AC__NO_FLAGS_SET)) == NULL ) TEST_ERROR;
/* Now unprotect the heap, as we're done with the test. */
if ( H5HL_unprotect(lheap) < 0 ) TEST_ERROR;
diff --git a/test/dt_arith.c b/test/dt_arith.c
index 8ededc7..b3f5cad 100644
--- a/test/dt_arith.c
+++ b/test/dt_arith.c
@@ -5032,8 +5032,32 @@ run_int_fp_conv(const char *name)
#endif
#endif /* H5_SIZEOF_LONG!=H5_SIZEOF_INT */
#if H5_SIZEOF_LONG_LONG!=H5_SIZEOF_LONG
+#if H5_LLONG_TO_LDOUBLE_CORRECT
nerrors += test_conv_int_fp(name, TEST_NORMAL, H5T_NATIVE_LLONG, H5T_NATIVE_LDOUBLE);
+#else /* H5_LLONG_TO_LDOUBLE_CORRECT */
+ {
+ char str[256]; /*hello string */
+
+ HDsnprintf(str, sizeof(str), "Testing %s %s -> %s conversions",
+ name, "long long", "long double");
+ printf("%-70s", str);
+ SKIPPED();
+ HDputs(" Test skipped due to compiler error in handling conversion.");
+ }
+#endif /* H5_LLONG_TO_LDOUBLE_CORRECT */
+#if H5_LLONG_TO_LDOUBLE_CORRECT
nerrors += test_conv_int_fp(name, TEST_NORMAL, H5T_NATIVE_ULLONG, H5T_NATIVE_LDOUBLE);
+#else /* H5_LLONG_TO_LDOUBLE_CORRECT */
+ {
+ char str[256]; /*hello string */
+
+ HDsnprintf(str, sizeof(str), "Testing %s %s -> %s conversions",
+ name, "unsigned long long", "long double");
+ printf("%-70s", str);
+ SKIPPED();
+ HDputs(" Test skipped due to compiler not handling conversion.");
+ }
+#endif /* H5_LLONG_TO_LDOUBLE_CORRECT */
#endif
#endif
@@ -5134,8 +5158,40 @@ run_fp_int_conv(const char *name)
#endif /*H5_SIZEOF_LONG!=H5_SIZEOF_INT && H5_SIZEOF_LONG_DOUBLE!=0 */
#if H5_SIZEOF_LONG_LONG!=H5_SIZEOF_LONG && H5_SIZEOF_LONG_DOUBLE!=0
+#ifdef H5_LDOUBLE_TO_LLONG_ACCURATE
nerrors += test_conv_int_fp(name, test_values, H5T_NATIVE_LDOUBLE, H5T_NATIVE_LLONG);
+#else /*H5_LDOUBLE_TO_LLONG_ACCURATE*/
+ {
+ char str[256]; /*string */
+
+ HDsnprintf(str, sizeof(str), "Testing %s %s -> %s conversions",
+ name, "long double", "long long");
+ printf("%-70s", str);
+ SKIPPED();
+#if H5_SIZEOF_LONG_DOUBLE!=0
+ HDputs(" Test skipped due to hardware conversion error.");
+#else
+ HDputs(" Test skipped due to disabled long double.");
+#endif
+ }
+#endif /*H5_LDOUBLE_TO_LLONG_ACCURATE*/
+#if defined(H5_LDOUBLE_TO_LLONG_ACCURATE)
nerrors += test_conv_int_fp(name, test_values, H5T_NATIVE_LDOUBLE, H5T_NATIVE_ULLONG);
+#else /*H5_LDOUBLE_TO_LLONG_ACCURATE*/
+ {
+ char str[256]; /*string */
+
+ HDsnprintf(str, sizeof(str), "Testing %s %s -> %s conversions",
+ name, "long double", "unsigned long long");
+ printf("%-70s", str);
+ SKIPPED();
+#if H5_SIZEOF_LONG_DOUBLE!=0
+ HDputs(" Test skipped due to hardware conversion error.");
+#else
+ HDputs(" Test skipped due to disabled long double.");
+#endif
+ }
+#endif /*H5_LDOUBLE_TO_LLONG_ACCURATE*/
#endif
#endif
#ifndef H5_VMS
diff --git a/test/earray.c b/test/earray.c
index 8a355c8..feaa15e 100644
--- a/test/earray.c
+++ b/test/earray.c
@@ -160,11 +160,26 @@ typedef struct earray_test_t {
/* Local prototypes */
/* Metadata cache (H5AC) callbacks */
-static earray_test_t *earray_cache_test_load(H5F_t *f, hid_t dxpl_id, haddr_t addr, const void *udata, void *udata2);
-static herr_t earray_cache_test_flush(H5F_t *f, hid_t dxpl_id, hbool_t destroy, haddr_t addr, earray_test_t *test, unsigned * flags_ptr);
-static herr_t earray_cache_test_clear(H5F_t *f, earray_test_t *test, hbool_t destroy);
-static herr_t earray_cache_test_size(const H5F_t *f, const earray_test_t *test, size_t *size_ptr);
-static herr_t earray_cache_test_dest(H5F_t *f, earray_test_t *test);
+
+static herr_t earray_cache_test_get_load_size(const void *udata_ptr,
+ size_t *image_len_ptr);
+
+static void *earray_cache_test_deserialize(const void *image_ptr,
+ size_t len,
+ void *udata_ptr,
+ hbool_t *dirty_ptr);
+
+static herr_t earray_cache_test_image_len(const void *thing,
+ size_t *image_len_ptr,
+ hbool_t *compressed_ptr,
+ size_t * compressed_len_ptr);
+
+static herr_t earray_cache_test_serialize(const H5F_t *f,
+ void *image_ptr,
+ size_t len,
+ void *thing);
+
+static herr_t earray_cache_test_free_icr(void *thing);
/* Local variables */
@@ -181,13 +196,19 @@ h5_stat_size_t empty_size_g;
/* H5EA test object inherits cache-like properties from H5AC */
const H5AC_class_t H5AC_EARRAY_TEST[1] = {{
- H5AC_TEST_ID,
- (H5AC_load_func_t)earray_cache_test_load,
- (H5AC_flush_func_t)earray_cache_test_flush,
- (H5AC_dest_func_t)earray_cache_test_dest,
- (H5AC_clear_func_t)earray_cache_test_clear,
- (H5AC_notify_func_t)NULL,
- (H5AC_size_func_t)earray_cache_test_size,
+ /* id */ H5AC_TEST_ID,
+ /* name */ "earray test",
+ /* mem_type */ H5FD_MEM_DEFAULT,
+ /* flags */ H5AC__CLASS_NO_IO_FLAG,
+ /* get_load_size */ (H5AC_get_load_size_func_t)earray_cache_test_get_load_size,
+ /* deserialize */ (H5AC_deserialize_func_t)earray_cache_test_deserialize,
+ /* image_len */ (H5AC_image_len_func_t)earray_cache_test_image_len,
+ /* pre_serialize */ (H5AC_pre_serialize_func_t)NULL,
+ /* serialize */ (H5AC_serialize_func_t)earray_cache_test_serialize,
+ /* notify */ (H5AC_notify_func_t)NULL,
+ /* free_icr */ (H5AC_free_icr_func_t)earray_cache_test_free_icr,
+ /* clear */ NULL,
+ /* fsf_size */ NULL,
}};
@@ -610,196 +631,244 @@ error:
/*-------------------------------------------------------------------------
- * Function: earray_cache_test_load
+ * Function: earray_cache_test_get_load_size()
*
- * Purpose: Loads an extensible array test object from the disk.
+ * Purpose: place holder function -- should never be called
*
- * Return: Success: Pointer to a new extensible array test object
- * Failure: NULL
*
- * Programmer: Quincey Koziol
- * koziol@hdfgroup.org
- * May 26 2009
+ * A generic discussion of metadata cache callbacks of this type
+ * may be found in H5Cprivate.h:
+ *
+ * Return: Success: SUCCEED
+ * Failure: FAIL
+ *
+ * Programmer: John Mainzer
+ * 8/2/14
*
*-------------------------------------------------------------------------
*/
-static earray_test_t *
-earray_cache_test_load(H5F_t H5_ATTR_UNUSED *f, hid_t H5_ATTR_UNUSED dxpl_id, haddr_t H5_ATTR_UNUSED addr, const void H5_ATTR_UNUSED *udata1, void H5_ATTR_UNUSED *udata2)
+static herr_t
+earray_cache_test_get_load_size(const void *udata_ptr, size_t *image_len_ptr)
{
- /* Check arguments */
- HDassert(f);
- HDassert(H5F_addr_defined(addr));
+ HDassert(udata_ptr);
+ HDassert(image_len_ptr);
/* Should never be called */
HDassert(0 && "Can't be called!");
- return(NULL);
-} /* end earray_cache_test_load() */
+ *image_len_ptr = 0;
+
+ return(SUCCEED);
+
+} /* end earray_cache_test_get_load_size() */
/*-------------------------------------------------------------------------
- * Function: earray_cache_test_flush
+ * Function: earray_cache_test_deserialize
*
- * Purpose: Flushes a dirty extensible array test object to disk.
+ * Purpose: place holder function -- should never be called.
*
- * Return: Non-negative on success/Negative on failure
*
- * Programmer: Quincey Koziol
- * koziol@hdfgroup.org
- * May 26 2009
+ * A generic discussion of metadata cache callbacks of this type
+ * may be found in H5Cprivate.h:
+ *
+ * Return: Success: Pointer to in core representation
+ * Failure: NULL
+ *
+ * Programmer: John Mainzer
+ * 8/2/14
*
*-------------------------------------------------------------------------
*/
-static herr_t
-earray_cache_test_flush(H5F_t H5_ATTR_UNUSED *f, hid_t H5_ATTR_UNUSED dxpl_id, hbool_t destroy, haddr_t H5_ATTR_UNUSED addr, earray_test_t *test, unsigned H5_ATTR_UNUSED * flags_ptr)
+static void *
+earray_cache_test_deserialize(const void *image_ptr,
+ size_t len,
+ void *udata_ptr,
+ hbool_t *dirty_ptr)
{
- /* check arguments */
- HDassert(f);
- HDassert(H5F_addr_defined(addr));
- HDassert(test);
-
- if(test->cache_info.is_dirty) {
- /* Check for out of order flush */
- if(test->fd_info->base_obj)
- TEST_ERROR
-
- /* Check which index this entry corresponds to */
- if((uint64_t)0 == test->idx) {
- /* Check for out of order flush */
- if(test->fd_info->idx0_obj || test->fd_info->idx0_elem)
- TEST_ERROR
+ HDassert(image_ptr);
+ HDassert(len > 0 );
+ HDassert(udata_ptr);
+ HDassert(dirty_ptr);
- /* Set flag for object flush */
- test->fd_info->idx0_obj = TRUE;
- } /* end if */
- else if((uint64_t)1 == test->idx) {
- /* Check for out of order flush */
- if(test->fd_info->idx1_obj || test->fd_info->idx1_elem)
- TEST_ERROR
- /* Set flag for object flush */
- test->fd_info->idx1_obj = TRUE;
- } /* end if */
- else if((uint64_t)10000 == test->idx) {
- /* Check for out of order flush */
- if(test->fd_info->idx10000_obj || test->fd_info->idx10000_elem)
- TEST_ERROR
-
- /* Set flag for object flush */
- test->fd_info->idx10000_obj = TRUE;
- } /* end if */
- else if((uint64_t)-1 == test->idx) {
- /* Set flag for object flush */
- test->fd_info->base_obj = TRUE;
- } /* end if */
-
- /* Mark the entry as clean */
- test->cache_info.is_dirty = FALSE;
- } /* end if */
-
- if(destroy)
- if(earray_cache_test_dest(f, test) < 0)
- TEST_ERROR
+ /* Should never be called */
+ HDassert(0 && "Can't be called!");
- return(SUCCEED);
+ return(NULL);
-error:
- return(FAIL);
-} /* earray_cache_test_flush() */
+} /* end earray_cache_test_deserialize() */
/*-------------------------------------------------------------------------
- * Function: earray_cache_test_dest
+ * Function: earray_cache_test_image_len
*
- * Purpose: Destroys an extensible array test object in memory.
+ * Purpose: test code place holder function -- just set *image_len_ptr to
+ * one.
*
- * Return: Non-negative on success/Negative on failure
*
- * Programmer: Quincey Koziol
- * koziol@hdfgroup.org
- * May 26 2009
+ * A generic discussion of metadata cache callbacks of this type
+ * may be found in H5Cprivate.h:
+ *
+ * Return: Success: SUCCEED
+ * Failure: FAIL
+ *
+ * Programmer: John Mainzer
+ * 8/2/14
*
*-------------------------------------------------------------------------
*/
-herr_t
-earray_cache_test_dest(H5F_t H5_ATTR_UNUSED *f, earray_test_t *test)
+static herr_t
+earray_cache_test_image_len(const void *thing, size_t *image_len_ptr,
+ hbool_t H5_ATTR_UNUSED * compressed_ptr, size_t H5_ATTR_UNUSED * compressed_len_ptr)
{
- /*
- * Check arguments.
- */
- HDassert(test);
- /* Free the shared info itself */
- HDfree(test);
+ HDassert(thing);
+ HDassert(image_len_ptr);
+
+ /* Set size value */
+ /* (hard-code to 1) */
+ *image_len_ptr = 1;
return(SUCCEED);
-} /* end earray_cache_test_dest() */
+
+} /* end earray_cache_test_image_len() */
+
+
+/********************************/
+/* no H5O_cache_pre_serialize() */
+/********************************/
/*-------------------------------------------------------------------------
- * Function: earray_cache_test_clear
+ * Function: earray_cache_test_serialize
*
- * Purpose: Mark an extensible array test object in memory as non-dirty.
+ * Purpose: Validate the contents of the instance of earray_test_t.
*
- * Return: Non-negative on success/Negative on failure
*
- * Programmer: Quincey Koziol
- * koziol@hdfgroup.org
- * May 26 2009
+ * A generic discussion of metadata cache callbacks of this type
+ * may be found in H5Cprivate.h:
+ *
+ *
+ * Return: Success: SUCCEED
+ * Failure: FAIL
+ *
+ * Programmer: John Mainzer
+ * 8/2/14
*
*-------------------------------------------------------------------------
*/
static herr_t
-earray_cache_test_clear(H5F_t *f, earray_test_t *test, hbool_t destroy)
+earray_cache_test_serialize(const H5F_t *f,
+ void *image_ptr,
+ H5_ATTR_UNUSED size_t len,
+ void *thing)
{
- /*
- * Check arguments.
- */
+ earray_test_t *test = NULL;
+
+ HDassert(f);
+ HDassert(image_ptr);
+ HDassert(thing);
+
+ test = (earray_test_t *)thing;
+
HDassert(test);
+ HDassert(test->cache_info.magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
+ HDassert((const H5AC_class_t *)(test->cache_info.type) ==
+ &(H5AC_EARRAY_TEST[0]));
- /* Reset the dirty flag. */
- test->cache_info.is_dirty = FALSE;
+ /* Check for out of order flush */
+ if(test->fd_info->base_obj)
+ TEST_ERROR
- if(destroy)
- if(earray_cache_test_dest(f, test) < 0)
+ /* Check which index this entry corresponds to */
+ if((uint64_t)0 == test->idx) {
+ /* Check for out of order flush */
+ if(test->fd_info->idx0_obj || test->fd_info->idx0_elem)
TEST_ERROR
+ /* Set flag for object flush */
+ test->fd_info->idx0_obj = TRUE;
+ } /* end if */
+ else if((uint64_t)1 == test->idx) {
+ /* Check for out of order flush */
+ if(test->fd_info->idx1_obj || test->fd_info->idx1_elem)
+ TEST_ERROR
+
+ /* Set flag for object flush */
+ test->fd_info->idx1_obj = TRUE;
+ } /* end if */
+ else if((uint64_t)10000 == test->idx) {
+ /* Check for out of order flush */
+ if(test->fd_info->idx10000_obj || test->fd_info->idx10000_elem)
+ TEST_ERROR
+
+ /* Set flag for object flush */
+ test->fd_info->idx10000_obj = TRUE;
+ } /* end if */
+ else if((uint64_t)-1 == test->idx) {
+ /* Set flag for object flush */
+ test->fd_info->base_obj = TRUE;
+ } /* end if */
+
return(SUCCEED);
error:
+
return(FAIL);
-} /* end earray_cache_test_clear() */
+
+} /* end earray_cache_test_serialize() */
+
+
+/******************************************/
+/* no earray_cache_test_notify() function */
+/******************************************/
/*-------------------------------------------------------------------------
- * Function: earray_cache_test_size
+ * Function: earray_cache_test_free_icr
*
- * Purpose: Compute the size in bytes of an extensible array test object
- * on disk, and return it in *size_ptr. On failure,
- * the value of *size_ptr is undefined.
+ * Purpose: Destroy an extensible array test object in memory.
*
- * Return: Non-negative on success/Negative on failure
*
- * Programmer: Quincey Koziol
- * koziol@hdfgroup.org
- * May 26 2009
+ * A generic discussion of metadata cache callbacks of this type
+ * may be found in H5Cprivate.h:
+ *
+ *
+ * Return: Success: SUCCEED
+ * Failure: FAIL
+ *
+ * Programmer: John Mainzer
+ * 8/2/14
*
*-------------------------------------------------------------------------
*/
static herr_t
-earray_cache_test_size(const H5F_t H5_ATTR_UNUSED *f, const earray_test_t H5_ATTR_UNUSED *test, size_t *size_ptr)
+earray_cache_test_free_icr(void *thing)
{
- /* check arguments */
- HDassert(f);
+ earray_test_t *test = NULL;
+
+ HDassert(thing);
+
+ test = (earray_test_t *)thing;
+
HDassert(test);
- HDassert(size_ptr);
- /* Set size value */
- /* (hard-code to 1) */
- *size_ptr = 1;
+ /* the metadata cache sets cache_info.magic to
+ * H5C__H5C_CACHE_ENTRY_T_BAD_MAGIC before calling the
+ * free_icr routine. Hence the following assert:
+ */
+
+ HDassert(test->cache_info.magic == H5C__H5C_CACHE_ENTRY_T_BAD_MAGIC);
+ HDassert((const H5AC_class_t *)(test->cache_info.type) ==
+ &(H5AC_EARRAY_TEST[0]));
+
+ /* Free the shared info itself */
+ HDfree(test);
return(SUCCEED);
-} /* earray_cache_test_size() */
+
+} /* end earray_cache_test_free_icr() */
/*-------------------------------------------------------------------------
@@ -1541,7 +1610,7 @@ test_flush_depend(hid_t fapl, H5EA_create_t *cparam, earray_test_param_t H5_ATTR
TEST_ERROR
/* Protect the base entry */
- if(NULL == (base_entry = (earray_test_t *)H5AC_protect(f, H5P_DATASET_XFER_DEFAULT, H5AC_EARRAY_TEST, base_addr, NULL, H5AC_WRITE)))
+ if(NULL == (base_entry = (earray_test_t *)H5AC_protect(f, H5P_DATASET_XFER_DEFAULT, H5AC_EARRAY_TEST, base_addr, NULL, H5AC__NO_FLAGS_SET)))
TEST_ERROR
/* Unprotect & unpin the base entry */
@@ -1553,7 +1622,7 @@ test_flush_depend(hid_t fapl, H5EA_create_t *cparam, earray_test_param_t H5_ATTR
TEST_ERROR
/* Protect the test entry */
- if(NULL == (entry1 = (earray_test_t *)H5AC_protect(f, H5P_DATASET_XFER_DEFAULT, H5AC_EARRAY_TEST, addr1, NULL, H5AC_WRITE)))
+ if(NULL == (entry1 = (earray_test_t *)H5AC_protect(f, H5P_DATASET_XFER_DEFAULT, H5AC_EARRAY_TEST, addr1, NULL, H5AC__NO_FLAGS_SET)))
TEST_ERROR
/* Unprotect & unpin the test entry */
@@ -1565,7 +1634,7 @@ test_flush_depend(hid_t fapl, H5EA_create_t *cparam, earray_test_param_t H5_ATTR
TEST_ERROR
/* Protect the test entry */
- if(NULL == (entry2 = (earray_test_t *)H5AC_protect(f, H5P_DATASET_XFER_DEFAULT, H5AC_EARRAY_TEST, addr2, NULL, H5AC_WRITE)))
+ if(NULL == (entry2 = (earray_test_t *)H5AC_protect(f, H5P_DATASET_XFER_DEFAULT, H5AC_EARRAY_TEST, addr2, NULL, H5AC__NO_FLAGS_SET)))
TEST_ERROR
/* Unprotect & unpin the test entry */
@@ -1577,7 +1646,7 @@ test_flush_depend(hid_t fapl, H5EA_create_t *cparam, earray_test_param_t H5_ATTR
TEST_ERROR
/* Protect the test entry */
- if(NULL == (entry3 = (earray_test_t *)H5AC_protect(f, H5P_DATASET_XFER_DEFAULT, H5AC_EARRAY_TEST, addr3, NULL, H5AC_WRITE)))
+ if(NULL == (entry3 = (earray_test_t *)H5AC_protect(f, H5P_DATASET_XFER_DEFAULT, H5AC_EARRAY_TEST, addr3, NULL, H5AC__NO_FLAGS_SET)))
TEST_ERROR
/* Unprotect & unpin the test entry */
diff --git a/test/gen_bogus.c b/test/gen_bogus.c
index df1e81f..e9ce686 100644
--- a/test/gen_bogus.c
+++ b/test/gen_bogus.c
@@ -61,7 +61,7 @@ int main(void)
if((did = H5Dcreate2(fid, "/Dataset1", H5T_NATIVE_INT, sid, H5P_DEFAULT, dcpl, H5P_DEFAULT)) < 0) goto error;
if(H5Dclose(did) < 0) goto error;
- /* Set "fail if unknown" message flag for bogus message */
+ /* Set "fail if unknown and open for write" message flag for bogus message */
bogus_flags = H5O_MSG_FLAG_FAIL_IF_UNKNOWN_AND_OPEN_FOR_WRITE;
if(H5Pset(dcpl, H5O_BOGUS_MSG_FLAGS_NAME, &bogus_flags) < 0) goto error;
@@ -69,12 +69,20 @@ int main(void)
if((did = H5Dcreate2(fid, "/Dataset2", H5T_NATIVE_INT, sid, H5P_DEFAULT, dcpl, H5P_DEFAULT)) < 0) goto error;
if(H5Dclose(did) < 0) goto error;
+ /* Set "fail if unknown always" message flag for bogus message */
+ bogus_flags = H5O_MSG_FLAG_FAIL_IF_UNKNOWN_ALWAYS;
+ if(H5Pset(dcpl, H5O_BOGUS_MSG_FLAGS_NAME, &bogus_flags) < 0) goto error;
+
+ /* Create third dataset, with "fail if unknown always" message flag */
+ if((did = H5Dcreate2(fid, "/Dataset3", H5T_NATIVE_INT, sid, H5P_DEFAULT, dcpl, H5P_DEFAULT)) < 0) goto error;
+ if(H5Dclose(did) < 0) goto error;
+
/* Set "mark if unknown" message flag for bogus message */
bogus_flags = H5O_MSG_FLAG_MARK_IF_UNKNOWN;
if(H5Pset(dcpl, H5O_BOGUS_MSG_FLAGS_NAME, &bogus_flags) < 0) goto error;
- /* Create second dataset, with "mark if unknown" message flag */
- if((did = H5Dcreate2(fid, "/Dataset3", H5T_NATIVE_INT, sid, H5P_DEFAULT, dcpl, H5P_DEFAULT)) < 0) goto error;
+ /* Create fourth dataset, with "mark if unknown" message flag */
+ if((did = H5Dcreate2(fid, "/Dataset4", H5T_NATIVE_INT, sid, H5P_DEFAULT, dcpl, H5P_DEFAULT)) < 0) goto error;
if(H5Dclose(did) < 0) goto error;
/* Close dataset creation property list */
diff --git a/test/gen_plist.c b/test/gen_plist.c
index e77af73..cd3748b 100644
--- a/test/gen_plist.c
+++ b/test/gen_plist.c
@@ -63,26 +63,26 @@ main(void)
1 /*TRUE*/,
0 /*FALSE*/,
( 2 * 2048 * 1024),
- 0.3f,
+ 0.3,
(64 * 1024 * 1024),
(4 * 1024 * 1024),
60000,
H5C_incr__threshold,
- 0.8f,
- 3.0f,
+ 0.8,
+ 3.0,
1 /*TRUE*/,
(8 * 1024 * 1024),
H5C_flash_incr__add_space,
- 2.0f,
- 0.25f,
+ 2.0,
+ 0.25,
H5C_decr__age_out_with_threshold,
- 0.997f,
- 0.8f,
+ 0.997,
+ 0.8,
1 /*TRUE*/,
(3 * 1024 * 1024),
3,
0 /*FALSE*/,
- 0.2f,
+ 0.2,
(256 * 2048),
H5AC_METADATA_WRITE_STRATEGY__PROCESS_0_ONLY};
diff --git a/test/h5test.h b/test/h5test.h
index fa0c11b..5b203c6 100644
--- a/test/h5test.h
+++ b/test/h5test.h
@@ -158,7 +158,7 @@ H5TEST_DLL void ParseTestVerbosity(char *argv);
H5TEST_DLL int GetTestNumErrs(void);
H5TEST_DLL void IncTestNumErrs(void);
H5TEST_DLL const void *GetTestParameters(void);
-H5TEST_DLL int TestErrPrintf(const char *format, ...) __attribute__ ((format (printf, 1, 2)));
+H5TEST_DLL int TestErrPrintf(const char *format, ...) H5_ATTR_FORMAT(printf, 1, 2);
H5TEST_DLL void SetTest(const char *testname, int action);
H5TEST_DLL void TestAlarmOn(void);
H5TEST_DLL void TestAlarmOff(void);
diff --git a/test/lheap.c b/test/lheap.c
index 51ae25b..bdb6360 100644
--- a/test/lheap.c
+++ b/test/lheap.c
@@ -94,7 +94,7 @@ main(void)
H5Eprint2(H5E_DEFAULT, stdout);
goto error;
}
- if (NULL == (heap = H5HL_protect(f, H5P_DATASET_XFER_DEFAULT, heap_addr, H5AC_WRITE))) {
+ if (NULL == (heap = H5HL_protect(f, H5P_DATASET_XFER_DEFAULT, heap_addr, H5AC__NO_FLAGS_SET))) {
H5_FAILED();
H5Eprint2(H5E_DEFAULT, stdout);
goto error;
@@ -144,7 +144,7 @@ main(void)
if(j > 4)
buf[j] = '\0';
- if (NULL == (heap = H5HL_protect(f, H5P_DATASET_XFER_DEFAULT, heap_addr, H5AC_READ))) {
+ if (NULL == (heap = H5HL_protect(f, H5P_DATASET_XFER_DEFAULT, heap_addr, H5AC__READ_ONLY_FLAG))) {
H5_FAILED();
H5Eprint2(H5E_DEFAULT, stdout);
goto error;
diff --git a/test/mf.c b/test/mf.c
index 93667de..67ebc4e 100644
--- a/test/mf.c
+++ b/test/mf.c
@@ -608,12 +608,12 @@ test_mf_eoa_extend(const char *env_h5_drvr, hid_t fapl)
char filename[FILENAME_LEN]; /* Filename to use */
H5F_t *f = NULL; /* Internal file object pointer */
h5_stat_size_t file_size, new_file_size; /* File size */
- H5FD_mem_t type;
+ H5FD_mem_t type;
haddr_t addr;
- htri_t extended;
- haddr_t ma_addr=HADDR_UNDEF, new_ma_addr=HADDR_UNDEF;
- hsize_t ma_size=0, new_ma_size=0;
- hbool_t contig_addr_vfd; /* Whether VFD used has a contigous address space */
+ htri_t was_extended;
+ haddr_t ma_addr=HADDR_UNDEF, new_ma_addr=HADDR_UNDEF;
+ hsize_t ma_size=0, new_ma_size=0;
+ hbool_t contig_addr_vfd; /* Whether VFD used has a contigous address space */
TESTING("H5MF_try_extend() of file allocation: test 1");
@@ -685,9 +685,9 @@ test_mf_eoa_extend(const char *env_h5_drvr, hid_t fapl)
FAIL_STACK_ERROR
/* should succeed */
- extended = H5MF_try_extend(f, H5P_DATASET_XFER_DEFAULT, type, (haddr_t)addr, (hsize_t)TEST_BLOCK_SIZE30, (hsize_t)TEST_BLOCK_SIZE50);
+ was_extended = H5MF_try_extend(f, H5P_DATASET_XFER_DEFAULT, type, (haddr_t)addr, (hsize_t)TEST_BLOCK_SIZE30, (hsize_t)TEST_BLOCK_SIZE50);
- if(extended <= 0)
+ if(was_extended <= 0)
TEST_ERROR
/* nothing should be changed in meta_aggr */
@@ -744,10 +744,10 @@ test_mf_eoa_extend(const char *env_h5_drvr, hid_t fapl)
if(new_ma_addr != ma_addr)
TEST_ERROR
- extended = H5MF_try_extend(f, H5P_DATASET_XFER_DEFAULT, type, (haddr_t)addr, (hsize_t)(TEST_BLOCK_SIZE30-10), (hsize_t)(TEST_BLOCK_SIZE50));
+ was_extended = H5MF_try_extend(f, H5P_DATASET_XFER_DEFAULT, type, (haddr_t)addr, (hsize_t)(TEST_BLOCK_SIZE30-10), (hsize_t)(TEST_BLOCK_SIZE50));
/* should not succeed */
- if(extended > 0)
+ if(was_extended > 0)
TEST_ERROR
/* nothing should be changed in meta_aggr */
@@ -1454,7 +1454,7 @@ test_mf_fs_extend(hid_t fapl)
frspace_state_t state; /* State of free space*/
H5MF_sect_ud_t udata;
H5FS_section_info_t *node;
- htri_t extended;
+ htri_t was_extended;
TESTING("H5MF_try_extend() of free-space manager:test 1");
@@ -1548,10 +1548,10 @@ test_mf_fs_extend(hid_t fapl)
TEST_ERROR
/* Try to extend the allocated block */
- extended = H5MF_try_extend(f, H5P_DATASET_XFER_DEFAULT, type, (haddr_t)TEST_BLOCK_ADDR70, (hsize_t)TEST_BLOCK_SIZE30, (hsize_t)TEST_BLOCK_SIZE50);
+ was_extended = H5MF_try_extend(f, H5P_DATASET_XFER_DEFAULT, type, (haddr_t)TEST_BLOCK_ADDR70, (hsize_t)TEST_BLOCK_SIZE30, (hsize_t)TEST_BLOCK_SIZE50);
/* should succeed */
- if(extended <= 0)
+ if(was_extended <= 0)
TEST_ERROR
/* Section B is removed from free-space manager */
@@ -1666,10 +1666,10 @@ test_mf_fs_extend(hid_t fapl)
TEST_ERROR
/* Try to extend the allocated block */
- extended = H5MF_try_extend(f, H5P_DATASET_XFER_DEFAULT, type, (haddr_t)TEST_BLOCK_ADDR70, (hsize_t)TEST_BLOCK_SIZE30, (hsize_t)(TEST_BLOCK_SIZE50+10));
+ was_extended = H5MF_try_extend(f, H5P_DATASET_XFER_DEFAULT, type, (haddr_t)TEST_BLOCK_ADDR70, (hsize_t)TEST_BLOCK_SIZE30, (hsize_t)(TEST_BLOCK_SIZE50+10));
/* Should not be able to extend the allocated block */
- if(extended)
+ if(was_extended)
TEST_ERROR
/* free-space info should remain the same */
@@ -1779,10 +1779,10 @@ test_mf_fs_extend(hid_t fapl)
TEST_ERROR
/* Try to extend the allocated block */
- extended = H5MF_try_extend(f, H5P_DATASET_XFER_DEFAULT, type, (haddr_t)TEST_BLOCK_ADDR70, (hsize_t)TEST_BLOCK_SIZE30, (hsize_t)(TEST_BLOCK_SIZE40));
+ was_extended = H5MF_try_extend(f, H5P_DATASET_XFER_DEFAULT, type, (haddr_t)TEST_BLOCK_ADDR70, (hsize_t)TEST_BLOCK_SIZE30, (hsize_t)(TEST_BLOCK_SIZE40));
/* Should succeed in extending the allocated block */
- if(extended <=0)
+ if(was_extended <=0)
TEST_ERROR
/* Should have 1 section of size=10 left in free-space manager */
@@ -1892,10 +1892,10 @@ test_mf_fs_extend(hid_t fapl)
TEST_ERROR
/* Try to extend the allocated block */
- extended = H5MF_try_extend(f, H5P_DATASET_XFER_DEFAULT, type, (haddr_t)TEST_BLOCK_ADDR70, (hsize_t)(TEST_BLOCK_SIZE30-10), (hsize_t)TEST_BLOCK_SIZE50);
+ was_extended = H5MF_try_extend(f, H5P_DATASET_XFER_DEFAULT, type, (haddr_t)TEST_BLOCK_ADDR70, (hsize_t)(TEST_BLOCK_SIZE30-10), (hsize_t)TEST_BLOCK_SIZE50);
/* Should not succeed in extending the allocated block */
- if(extended)
+ if(was_extended)
TEST_ERROR
/* Free-space info should be the same */
@@ -3241,7 +3241,7 @@ test_mf_aggr_extend(const char *env_h5_drvr, hid_t fapl)
haddr_t new_addr, addr, saddr;
haddr_t ma_addr=HADDR_UNDEF, new_ma_addr=HADDR_UNDEF, sdata_addr=HADDR_UNDEF;
hsize_t ma_size=0, new_ma_size=0, sdata_size=0;
- htri_t extended;
+ htri_t was_extended;
hbool_t contig_addr_vfd; /* Whether VFD used has a contigous address space */
TESTING("H5MF_try_extend() of meta/sdata aggregator: test 1");
@@ -3286,10 +3286,10 @@ test_mf_aggr_extend(const char *env_h5_drvr, hid_t fapl)
new_addr = addr - 10;
/* Try to extend the block by an amount < (% * aggr->alloc_size) */
- extended = H5MF_try_extend(f, H5P_DATASET_XFER_DEFAULT, type, (haddr_t)new_addr, (hsize_t)10, (hsize_t)(TEST_BLOCK_SIZE50));
+ was_extended = H5MF_try_extend(f, H5P_DATASET_XFER_DEFAULT, type, (haddr_t)new_addr, (hsize_t)10, (hsize_t)(TEST_BLOCK_SIZE50));
/* should succeed */
- if(!extended)
+ if(!was_extended)
TEST_ERROR
H5MF_aggr_query(f, &(f->shared->meta_aggr), &new_ma_addr, &new_ma_size);
@@ -3302,10 +3302,10 @@ test_mf_aggr_extend(const char *env_h5_drvr, hid_t fapl)
H5MF_xfree(f, type, H5P_DATASET_XFER_DEFAULT, addr, (hsize_t)TEST_BLOCK_SIZE50);
/* Try to extend the block by an amount > (% * aggr->alloc_size) but amount < aggr->alloc_size */
- extended = H5MF_try_extend(f, H5P_DATASET_XFER_DEFAULT, type, (haddr_t)new_addr, (hsize_t)10, (hsize_t)(TEST_BLOCK_SIZE700));
+ was_extended = H5MF_try_extend(f, H5P_DATASET_XFER_DEFAULT, type, (haddr_t)new_addr, (hsize_t)10, (hsize_t)(TEST_BLOCK_SIZE700));
/* should succeed */
- if(!extended)
+ if(!was_extended)
TEST_ERROR
H5MF_aggr_query(f, &(f->shared->meta_aggr), &new_ma_addr, &new_ma_size);
@@ -3318,10 +3318,10 @@ test_mf_aggr_extend(const char *env_h5_drvr, hid_t fapl)
H5MF_xfree(f, type, H5P_DATASET_XFER_DEFAULT, addr, (hsize_t)TEST_BLOCK_SIZE700);
/* Try to extend the block by an amount > (% * aggr->alloc_size) but amount > aggr->alloc_size */
- extended = H5MF_try_extend(f, H5P_DATASET_XFER_DEFAULT, type, (haddr_t)new_addr, (hsize_t)10, (hsize_t)(TEST_BLOCK_SIZE2058));
+ was_extended = H5MF_try_extend(f, H5P_DATASET_XFER_DEFAULT, type, (haddr_t)new_addr, (hsize_t)10, (hsize_t)(TEST_BLOCK_SIZE2058));
/* should succeed */
- if(!extended)
+ if(!was_extended)
TEST_ERROR
H5MF_aggr_query(f, &(f->shared->meta_aggr), &new_ma_addr, &new_ma_size);
@@ -3384,9 +3384,9 @@ test_mf_aggr_extend(const char *env_h5_drvr, hid_t fapl)
new_addr = addr - 10;
/* should be able to fulfill request from the aggreqator itself */
- extended = H5MF_try_extend(f, H5P_DATASET_XFER_DEFAULT, type, (haddr_t)new_addr, (hsize_t)10, (hsize_t)(TEST_BLOCK_SIZE50));
+ was_extended = H5MF_try_extend(f, H5P_DATASET_XFER_DEFAULT, type, (haddr_t)new_addr, (hsize_t)10, (hsize_t)(TEST_BLOCK_SIZE50));
- if(!extended)
+ if(!was_extended)
TEST_ERROR
H5MF_aggr_query(f, &(f->shared->meta_aggr), &new_ma_addr, &new_ma_size);
@@ -3454,9 +3454,9 @@ test_mf_aggr_extend(const char *env_h5_drvr, hid_t fapl)
new_addr = addr - 10;
/* unable to fulfill request from the aggreqator itself */
- extended = H5MF_try_extend(f, H5P_DATASET_XFER_DEFAULT, type, (haddr_t)new_addr, (hsize_t)10, (hsize_t)(TEST_BLOCK_SIZE50));
+ was_extended = H5MF_try_extend(f, H5P_DATASET_XFER_DEFAULT, type, (haddr_t)new_addr, (hsize_t)10, (hsize_t)(TEST_BLOCK_SIZE50));
- if(extended)
+ if(was_extended)
TEST_ERROR
H5MF_aggr_query(f, &(f->shared->meta_aggr), &new_ma_addr, &new_ma_size);
@@ -3772,7 +3772,7 @@ test_mf_align_eoa(const char *env_h5_drvr, hid_t fapl, hid_t new_fapl)
haddr_t addr1, addr2;
haddr_t ma_addr=HADDR_UNDEF;
hsize_t ma_size=0;
- htri_t extended;
+ htri_t was_extended;
frspace_state_t state;
hsize_t alignment=0, mis_align=0, tmp=0, accum=0;
hbool_t have_alloc_vfd; /* Whether VFD used has an 'alloc' callback */
@@ -3978,9 +3978,9 @@ test_mf_align_eoa(const char *env_h5_drvr, hid_t fapl, hid_t new_fapl)
FAIL_STACK_ERROR
/* try to extend the block */
- extended = H5MF_try_extend(f, H5P_DATASET_XFER_DEFAULT, type, (haddr_t)addr1, (hsize_t)TEST_BLOCK_SIZE50, (hsize_t)TEST_BLOCK_SIZE30);
+ was_extended = H5MF_try_extend(f, H5P_DATASET_XFER_DEFAULT, type, (haddr_t)addr1, (hsize_t)TEST_BLOCK_SIZE50, (hsize_t)TEST_BLOCK_SIZE30);
- if (extended <=0) TEST_ERROR
+ if (was_extended <=0) TEST_ERROR
if(H5Fclose(file) < 0)
FAIL_STACK_ERROR
@@ -4052,7 +4052,7 @@ test_mf_align_fs(const char *env_h5_drvr, hid_t fapl, hid_t new_fapl)
haddr_t addr;
frspace_state_t state;
H5MF_sect_ud_t udata;
- htri_t extended;
+ htri_t was_extended;
hsize_t alignment=0, tmp=0, mis_align=0;
hbool_t have_alloc_vfd; /* Whether VFD used has an 'alloc' callback */
@@ -4197,9 +4197,9 @@ test_mf_align_fs(const char *env_h5_drvr, hid_t fapl, hid_t new_fapl)
TEST_ERROR
/* try to extend the block */
- extended = H5MF_try_extend(f, H5P_DATASET_XFER_DEFAULT, type, (haddr_t)addr, (hsize_t)TEST_BLOCK_SIZE600, (hsize_t)TEST_BLOCK_SIZE200);
+ was_extended = H5MF_try_extend(f, H5P_DATASET_XFER_DEFAULT, type, (haddr_t)addr, (hsize_t)TEST_BLOCK_SIZE600, (hsize_t)TEST_BLOCK_SIZE200);
- if (extended <=0) TEST_ERROR
+ if (was_extended <=0) TEST_ERROR
/* space should be decreased by 200, # of sections remain the same */
state.tot_space -= TEST_BLOCK_SIZE200;
diff --git a/test/ohdr.c b/test/ohdr.c
index 0ed3d97..45f2238 100644
--- a/test/ohdr.c
+++ b/test/ohdr.c
@@ -210,7 +210,7 @@ test_ohdr_cache(char *filename, hid_t fapl)
FAIL_STACK_ERROR
/* Protect local heap (which actually pins it in the cache) */
- if(NULL == (lheap = H5HL_protect(f, my_dxpl, lheap_addr, H5AC_READ)))
+ if(NULL == (lheap = H5HL_protect(f, my_dxpl, lheap_addr, H5AC__READ_ONLY_FLAG)))
FAIL_STACK_ERROR
/* Create an object header */
@@ -230,7 +230,7 @@ test_ohdr_cache(char *filename, hid_t fapl)
FAIL_STACK_ERROR
/* Protect local heap (which actually pins it in the cache) */
- if(NULL == (lheap2 = H5HL_protect(f, my_dxpl, lheap_addr2, H5AC_READ)))
+ if(NULL == (lheap2 = H5HL_protect(f, my_dxpl, lheap_addr2, H5AC__READ_ONLY_FLAG)))
FAIL_STACK_ERROR
/* Unprotect local heap (which actually unpins it from the cache) */
@@ -247,7 +247,7 @@ test_ohdr_cache(char *filename, hid_t fapl)
FAIL_STACK_ERROR
/* Protect local heap (which actually pins it in the cache) */
- if(NULL == (lheap3 = H5HL_protect(f, my_dxpl, lheap_addr3, H5AC_READ)))
+ if(NULL == (lheap3 = H5HL_protect(f, my_dxpl, lheap_addr3, H5AC__READ_ONLY_FLAG)))
FAIL_STACK_ERROR
/* Unprotect local heap (which actually unpins it from the cache) */
@@ -665,7 +665,9 @@ main(void)
PASSED();
- /* Test reading datasets with undefined object header messages */
+ /* Test reading datasets with undefined object header messages
+ * and the various "fail/mark if unknown" object header message flags
+ */
HDputs("Accessing objects with unknown header messages:");
{
hid_t file2; /* File ID for 'bogus' object file */
@@ -687,7 +689,7 @@ main(void)
PASSED();
- TESTING("object with unknown header message & 'fail if unknown and open for write' flag set");
+ TESTING("object in r/o file with unknown header message & 'fail if unknown and open for write' flag set");
/* Open the dataset with the unknown header message, and "fail if unknown and open for write" flag */
if((dset = H5Dopen2(file2, "/Dataset2", H5P_DEFAULT)) < 0)
@@ -697,10 +699,23 @@ main(void)
PASSED();
+ TESTING("object in r/o file with unknown header message & 'fail if unknown always' flag set");
+
+ /* Attempt to open the dataset with the unknown header message, and "fail if unknown always" flag */
+ H5E_BEGIN_TRY {
+ dset = H5Dopen2(file2, "/Dataset3", H5P_DEFAULT);
+ } H5E_END_TRY;
+ if(dset >= 0) {
+ H5Dclose(dset);
+ TEST_ERROR
+ } /* end if */
+
+ PASSED();
+
TESTING("object with unknown header message & 'mark if unknown' flag set");
/* Copy object with "mark if unknown" flag on message into file that can be modified */
- if(H5Ocopy(file2, "/Dataset3", file, "/Dataset3", H5P_DEFAULT, H5P_DEFAULT) < 0)
+ if(H5Ocopy(file2, "/Dataset4", file, "/Dataset4", H5P_DEFAULT, H5P_DEFAULT) < 0)
TEST_ERROR
/* Close the file we created (to flush changes to file) */
@@ -712,7 +727,7 @@ main(void)
TEST_ERROR
/* Open the dataset with the "mark if unknown" message */
- if((dset = H5Dopen2(file, "/Dataset3", H5P_DEFAULT)) < 0)
+ if((dset = H5Dopen2(file, "/Dataset4", H5P_DEFAULT)) < 0)
TEST_ERROR
/* Check that the "unknown" message was _NOT_ marked */
@@ -732,7 +747,7 @@ main(void)
TEST_ERROR
/* Open the dataset with the "mark if unknown" message */
- if((dset = H5Dopen2(file, "/Dataset3", H5P_DEFAULT)) < 0)
+ if((dset = H5Dopen2(file, "/Dataset4", H5P_DEFAULT)) < 0)
TEST_ERROR
/* Create data space */
@@ -764,7 +779,7 @@ main(void)
TEST_ERROR
/* Re-open the dataset with the "mark if unknown" message */
- if((dset = H5Dopen2(file, "/Dataset3", H5P_DEFAULT)) < 0)
+ if((dset = H5Dopen2(file, "/Dataset4", H5P_DEFAULT)) < 0)
TEST_ERROR
/* Check that the "unknown" message was marked */
@@ -785,7 +800,7 @@ main(void)
if((file2 = H5Fopen(testfile, H5F_ACC_RDWR, H5P_DEFAULT)) < 0)
TEST_ERROR
- TESTING("object with unknown header message & 'fail if unknown and open for write' flag set");
+ TESTING("object in r/w file with unknown header message & 'fail if unknown and open for write' flag set");
/* Attempt to open the dataset with the unknown header message, and "fail if unknown and open for write" flag */
H5E_BEGIN_TRY {
@@ -796,6 +811,19 @@ main(void)
TEST_ERROR
} /* end if */
+ PASSED();
+
+ TESTING("object in r/w file with unknown header message & 'fail if unknown always' flag set");
+
+ /* Attempt to open the dataset with the unknown header message, and "fail if unknown always" flag */
+ H5E_BEGIN_TRY {
+ dset = H5Dopen2(file2, "/Dataset3", H5P_DEFAULT);
+ } H5E_END_TRY;
+ if(dset >= 0) {
+ H5Dclose(dset);
+ TEST_ERROR
+ } /* end if */
+
/* Close the file with the bogus objects */
if(H5Fclose(file2) < 0)
TEST_ERROR
diff --git a/test/tbogus.h5 b/test/tbogus.h5
index 906921c..875fbd8 100644
--- a/test/tbogus.h5
+++ b/test/tbogus.h5
Binary files differ
diff --git a/test/testfiles/plist_files/dxpl_be b/test/testfiles/plist_files/dxpl_be
index 5ff2ea0..b5194c8 100644
--- a/test/testfiles/plist_files/dxpl_be
+++ b/test/testfiles/plist_files/dxpl_be
Binary files differ
diff --git a/test/testfiles/plist_files/dxpl_le b/test/testfiles/plist_files/dxpl_le
index 5ff2ea0..b5194c8 100644
--- a/test/testfiles/plist_files/dxpl_le
+++ b/test/testfiles/plist_files/dxpl_le
Binary files differ
diff --git a/test/testfiles/plist_files/fapl_be b/test/testfiles/plist_files/fapl_be
index 0b050d0..65e2070 100644
--- a/test/testfiles/plist_files/fapl_be
+++ b/test/testfiles/plist_files/fapl_be
Binary files differ
diff --git a/test/testfiles/plist_files/fapl_le b/test/testfiles/plist_files/fapl_le
index 0b050d0..65e2070 100644
--- a/test/testfiles/plist_files/fapl_le
+++ b/test/testfiles/plist_files/fapl_le
Binary files differ
diff --git a/test/testfiles/plist_files/lapl_be b/test/testfiles/plist_files/lapl_be
index e58bfb4..385cfc5 100644
--- a/test/testfiles/plist_files/lapl_be
+++ b/test/testfiles/plist_files/lapl_be
Binary files differ
diff --git a/test/testfiles/plist_files/lapl_le b/test/testfiles/plist_files/lapl_le
index e58bfb4..385cfc5 100644
--- a/test/testfiles/plist_files/lapl_le
+++ b/test/testfiles/plist_files/lapl_le
Binary files differ
diff --git a/test/tid.c b/test/tid.c
index 85d26c9..68cebf3 100644
--- a/test/tid.c
+++ b/test/tid.c
@@ -533,12 +533,211 @@ out:
return -1;
}
+ /* Test removing ids in callback for H5Iclear_type */
+
+/* There was a rare bug where, if an id free callback being called by
+ * H5I_clear_type() removed another id in that type, a segfault could occur.
+ * This test tests for that error (and freeing ids "out of order" within
+ * H5Iclear_type() in general). */
+/* Macro definitions */
+#define TEST_RCT_MAX_NOBJS 25
+#define TEST_RCT_MIN_NOBJS 5
+#define TEST_RCT_NITER 50
+
+/* Structure to hold the list of objects */
+typedef struct {
+ struct test_rct_obj_t *list; /* List of objects */
+ long nobjs; /* Number of objects in list */
+ long nobjs_rem; /* Number of objects in list that have not been freed */
+} test_rct_list_t;
+
+/* Structure for an object */
+typedef struct test_rct_obj_t {
+ hid_t id; /* ID for this object */
+ int nfrees; /* Number of times this object has been freed */
+ hbool_t freeing; /* Whether we are currently freeing this object directly (through H5Idec_ref()) */
+ test_rct_list_t *obj_list; /* List of all objects */
+} test_rct_obj_t;
+
+/* Free callback */
+static herr_t test_rct_free(void *_obj) {
+ test_rct_obj_t *obj = (test_rct_obj_t *)_obj;
+ long rem_idx, i;
+ herr_t ret; /* return value */
+
+ /* Mark this object as freed */
+ obj->nfrees++;
+ obj->obj_list->nobjs_rem--;
+
+ /* Check freeing and nobjs_rem */
+ if(!obj->freeing && (obj->obj_list->nobjs_rem > 0)) {
+ /* Remove a random object from the list */
+ rem_idx = HDrandom() % obj->obj_list->nobjs_rem;
+
+ /* Scan the list, finding the rem_idx'th object that has not been
+ * freed */
+ for(i = 0; i < obj->obj_list->nobjs; i++)
+ if(obj->obj_list->list[i].nfrees == 0) {
+ if(rem_idx == 0)
+ break;
+ else
+ rem_idx--;
+ } /* end if */
+ if(i == obj->obj_list->nobjs) {
+ ERROR("invalid obj_list");
+ goto out;
+ } /* end if */
+ else {
+ /* Remove the object. Mark as "freeing" so its own callback does
+ * not free another object. */
+ obj->obj_list->list[i].freeing = TRUE;
+ ret = H5Idec_ref(obj->obj_list->list[i].id);
+ CHECK(ret, FAIL, "H5Idec_ref");
+ if(ret == FAIL)
+ goto out;
+ obj->obj_list->list[i].freeing = FALSE;
+ } /* end else */
+ } /* end if */
+
+ /* Verify nobjs_rem is non-negative */
+ if(obj->obj_list->nobjs_rem < 0) {
+ ERROR("invalid nobjs_rem");
+ goto out;
+ } /* end if */
+
+ return 0;
+
+out:
+ return -1;
+} /* end test_rct_free() */
+
+/* Test function */
+static int test_remove_clear_type(void)
+{
+ H5I_type_t obj_type;
+ test_rct_list_t obj_list;
+ test_rct_obj_t list[TEST_RCT_MAX_NOBJS];
+ long i, j;
+ long nobjs_found;
+ hsize_t nmembers;
+ herr_t ret; /* return value */
+
+ /* Register type */
+ obj_type = H5Iregister_type((size_t)8, 0, test_rct_free);
+ CHECK(obj_type, H5I_BADID, "H5Iregister_type");
+ if(obj_type == H5I_BADID)
+ goto out;
+
+ /* Init obj_list.list */
+ obj_list.list = list;
+
+ for(i = 0; i < TEST_RCT_NITER; i++) {
+ /* Build object list */
+ obj_list.nobjs = obj_list.nobjs_rem = TEST_RCT_MIN_NOBJS + (HDrandom() % (long)(TEST_RCT_MAX_NOBJS - TEST_RCT_MIN_NOBJS + 1));
+ for(j = 0; j < obj_list.nobjs; j++) {
+ list[j].nfrees = 0;
+ list[j].freeing = FALSE;
+ list[j].obj_list = &obj_list;
+ list[j].id = H5Iregister(obj_type, &list[j]);
+ CHECK(list[j].id, FAIL, "H5Iregister");
+ if(list[j].id == FAIL)
+ goto out;
+ if(HDrandom() % 2) {
+ ret = H5Iinc_ref(list[j].id);
+ CHECK(ret, FAIL, "H5Iinc_ref");
+ if(ret == FAIL)
+ goto out;
+ } /* end if */
+ } /* end for */
+
+ /* Clear the type */
+ ret = H5Iclear_type(obj_type, FALSE);
+ CHECK(ret, FAIL, "H5Iclear_type");
+ if(ret == FAIL)
+ goto out;
+
+ /* Verify list */
+ nobjs_found = 0;
+ for(j = 0; j < obj_list.nobjs; j++) {
+ if(list[j].nfrees == 0)
+ nobjs_found++;
+ else {
+ VERIFY(list[j].nfrees, (long)1, "list[j].nfrees");
+ if(list[j].nfrees != (long)1)
+ goto out;
+ } /* end else */
+ VERIFY(list[j].freeing, FALSE, "list[j].freeing");
+ if(list[j].freeing != FALSE)
+ goto out;
+ } /* end for */
+
+ /* Verify number of objects */
+ VERIFY(obj_list.nobjs_rem, nobjs_found, "obj_list.nobjs_rem");
+ if(obj_list.nobjs_rem != nobjs_found)
+ goto out;
+ ret = H5Inmembers(obj_type, &nmembers);
+ CHECK(ret, FAIL, "H5Inmembers");
+ if(ret == FAIL)
+ goto out;
+ VERIFY(nmembers, (size_t)nobjs_found, "H5Inmembers");
+ if(nmembers != (size_t)nobjs_found)
+ goto out;
+
+ /* Clear the type with force set to TRUE */
+ ret = H5Iclear_type(obj_type, TRUE);
+ CHECK(ret, FAIL, "H5Iclear_type");
+ if(ret == FAIL)
+ goto out;
+
+ /* Verify list */
+ for(j = 0; j < obj_list.nobjs; j++) {
+ VERIFY(list[j].nfrees, (long)1, "list[j].nfrees");
+ if(list[j].nfrees != (long)1)
+ goto out;
+ VERIFY(list[j].freeing, FALSE, "list[j].freeing");
+ if(list[j].freeing != FALSE)
+ goto out;
+ } /* end for */
+
+ /* Verify number of objects is 0 */
+ VERIFY(obj_list.nobjs_rem, (long)0, "obj_list.nobjs_rem");
+ if(obj_list.nobjs_rem != (long)0)
+ goto out;
+ ret = H5Inmembers(obj_type, &nmembers);
+ CHECK(ret, FAIL, "H5Inmembers");
+ if(ret == FAIL)
+ goto out;
+ VERIFY(nmembers, (size_t)0, "H5Inmembers");
+ if(nmembers != (size_t)0)
+ goto out;
+ } /* end for */
+
+ /* Destroy type */
+ ret = H5Idestroy_type(obj_type);
+ CHECK(ret, FAIL, "H5Idestroy_type");
+ if(ret == FAIL)
+ goto out;
+
+ return 0;
+
+out:
+ /* Cleanup. For simplicity, just destroy the types and ignore errors. */
+ H5E_BEGIN_TRY
+ H5Idestroy_type(obj_type);
+ H5E_END_TRY
+ return -1;
+} /* end test_remove_clear_type() */
+
void test_ids(void)
{
+ /* Set the random # seed */
+ HDsrandom((unsigned)HDtime(NULL));
+
if (basic_id_test() < 0) TestErrPrintf("Basic ID test failed\n");
if (id_predefined_test() < 0) TestErrPrintf("Predefined ID type test failed\n");
if (test_is_valid() < 0) TestErrPrintf("H5Iis_valid test failed\n");
if (test_get_type() < 0) TestErrPrintf("H5Iget_type test failed\n");
if (test_id_type_list() < 0) TestErrPrintf("ID type list test failed\n");
+ if (test_remove_clear_type() < 0) TestErrPrintf("ID remove during H5Iclear_type test failed\n");
}
diff --git a/test/trefer.c b/test/trefer.c
index 203b602..df4ea76 100644
--- a/test/trefer.c
+++ b/test/trefer.c
@@ -515,7 +515,7 @@ test_reference_region(void)
hsize_t high[SPACE2_RANK]; /* Selection bounds */
hdset_reg_ref_t *wbuf, /* buffer to write to disk */
*rbuf; /* buffer read from disk */
- hdset_reg_ref_t nvrbuf[3]={{0},{101},{1000000000}}; /* buffer with non-valid refs */
+ hdset_reg_ref_t nvrbuf[3]={{0},{101},{255}}; /* buffer with non-valid refs */
uint8_t *dwbuf, /* Buffer for writing numeric data to disk */
*drbuf; /* Buffer for reading numeric data from disk */
uint8_t *tu8; /* Temporary pointer to uint8 data */
@@ -742,7 +742,7 @@ test_reference_region(void)
VERIFY(ret, 36, "H5Sget_select_npoints");
ret = (int)H5Sget_select_hyper_nblocks(sid2);
VERIFY(ret, 1, "H5Sget_select_hyper_nblocks");
- coords = HDmalloc(ret * SPACE2_RANK * sizeof(hsize_t) * 2); /* allocate space for the hyperslab blocks */
+ coords = (hsize_t *)HDmalloc(ret * SPACE2_RANK * sizeof(hsize_t) * 2); /* allocate space for the hyperslab blocks */
ret = H5Sget_select_hyper_blocklist(sid2, (hsize_t)0, (hsize_t)ret, coords);
CHECK(ret, FAIL, "H5Sget_select_hyper_blocklist");
VERIFY(coords[0], 2, "Hyperslab Coordinates");
@@ -770,7 +770,7 @@ test_reference_region(void)
VERIFY(ret, 10, "H5Sget_select_npoints");
ret = (int)H5Sget_select_elem_npoints(sid2);
VERIFY(ret, 10, "H5Sget_select_elem_npoints");
- coords = HDmalloc(ret * SPACE2_RANK * sizeof(hsize_t)); /* allocate space for the element points */
+ coords = (hsize_t *)HDmalloc(ret * SPACE2_RANK * sizeof(hsize_t)); /* allocate space for the element points */
ret = H5Sget_select_elem_pointlist(sid2, (hsize_t)0, (hsize_t)ret, coords);
CHECK(ret, FAIL, "H5Sget_select_elem_pointlist");
VERIFY(coords[0], coord1[0][0], "Element Coordinates");
diff --git a/test/tskiplist.c b/test/tskiplist.c
index 07e63fd..62c5f8e 100644
--- a/test/tskiplist.c
+++ b/test/tskiplist.c
@@ -1171,6 +1171,208 @@ test_skiplist_free(void)
/****************************************************************
**
+** test_skiplist_try_free_safe(): Test H5SL (skip list) code.
+** Tests 'try_free_safe' operation in skip lists.
+**
+****************************************************************/
+/* Macro definitions */
+#define TEST_TFS_MAX_NOBJS 100
+#define TEST_TFS_MIN_NOBJS 5
+#define TEST_TFS_NITER 50
+
+/* Structure to hold the list of objects */
+typedef struct {
+ H5SL_t *slist; /* Skiplist holding the objects */
+ struct test_tfs_obj_t *list; /* Linear list of objects */
+ int nobjs; /* Number of objects in list */
+ int nobjs_rem; /* Number of objects in list that have not been freed */
+} test_tfs_list_t;
+
+/* Structure for an object */
+typedef struct test_tfs_obj_t {
+ int idx; /* Index (key) for this object */
+ int nfrees; /* Number of times this object has been freed */
+} test_tfs_obj_t;
+
+/* op_data struct for H5SL_iterate() */
+typedef struct test_tfs_it_ud_t {
+ test_tfs_list_t *obj_list; /* List of objects */
+ int last_idx; /* Index of last object visited in iteration */
+ int ncalls; /* Number of times this callback was called */
+} test_tfs_it_ud_t;
+
+/* iterate callback */
+static herr_t test_tfs_iter(void *_obj, void *key, void *_udata) {
+ test_tfs_obj_t *obj = (test_tfs_obj_t *)_obj;
+ test_tfs_it_ud_t *udata = (test_tfs_it_ud_t *)_udata;
+
+ /* Check consistency */
+ VERIFY((void *)&obj->idx, key, "obj->idx");
+ VERIFY(obj, &udata->obj_list->list[obj->idx], "obj_list->list[obj->idx]");
+
+ /* Increment number of calls */
+ udata->ncalls++;
+
+ /* Verify we were given the correct object */
+ do {
+ udata->last_idx++;
+ } while(udata->obj_list->list[udata->last_idx].nfrees != 0);
+ VERIFY(udata->last_idx, obj->idx, "H5SL_iterate");
+
+ return 0;
+} /* end test_tfs_iter() */
+
+/* try_free_safe callback */
+static htri_t test_tfs_free(void *_obj, void *key, void *_obj_list) {
+ test_tfs_obj_t *obj = (test_tfs_obj_t *)_obj;
+ test_tfs_list_t *obj_list = (test_tfs_list_t *)_obj_list;
+ test_tfs_it_ud_t iter_ud;
+ int nrems, rem_idx, i, j;
+ test_tfs_obj_t *obj_ret;
+ herr_t ret; /* return value */
+ htri_t ret_value;
+
+ /* Check consistency */
+ VERIFY((void *)&obj->idx, key, "obj->idx");
+ VERIFY(obj, &obj_list->list[obj->idx], "obj_list->list[obj->idx]");
+
+ /* Mark this object as freed (to make sure it isn't recursively freed, that
+ * is not something we support, we will undo this if we decide later not to
+ * free the object) */
+ obj->nfrees++;
+ obj_list->nobjs_rem--;
+
+ /* Decide how many objects to remove */
+ nrems = (int)(HDrandom() % (long)3);
+
+ /* Remove objects */
+ for(i = 0; i < nrems; i++)
+ /* Check nobjs_rem */
+ if(obj_list->nobjs_rem > 0) {
+ /* Remove a random object from the list */
+ rem_idx = (int)(HDrandom() % (long)obj_list->nobjs_rem);
+
+ /* Scan the list, finding the rem_idx'th object that has not been
+ * freed */
+ for(j = 0; j < obj_list->nobjs; j++)
+ if(obj_list->list[j].nfrees == 0) {
+ if(rem_idx == 0)
+ break;
+ else
+ rem_idx--;
+ } /* end if */
+ if(j == obj_list->nobjs)
+ ERROR("invalid obj_list");
+ else {
+ /* Remove the object */
+ obj_ret = (test_tfs_obj_t *)H5SL_remove(obj_list->slist, &j);
+ CHECK(obj_ret, NULL, "H5SL_remove");
+ obj_ret->nfrees++;
+ obj_list->nobjs_rem--;
+ } /* end else */
+ } /* end if */
+
+ /* Mark this object as not freed so we know to expect it in the iterate call
+ */
+ obj->nfrees--;
+ obj_list->nobjs_rem++;
+
+ /* Iterate over skip list (maybe) */
+ if(HDrandom() % (long)5) {
+ iter_ud.obj_list = obj_list;
+ iter_ud.last_idx = -1;
+ iter_ud.ncalls = 0;
+ ret = H5SL_iterate(obj_list->slist, test_tfs_iter, &iter_ud);
+ CHECK(ret, FAIL, "H5SL_iterate");
+ VERIFY(iter_ud.ncalls, obj_list->nobjs_rem, "H5SL_iterate");
+ } /* end if */
+
+ /* Verify nobjs_rem is non-negative */
+ if(obj_list->nobjs_rem < 0)
+ ERROR("invalid nobjs_rem");
+
+ /* Decide whether this object should be freed */
+ if(HDrandom() % (long)2) {
+ /* Free the object */
+ ret_value = TRUE;
+ obj->nfrees++;
+ obj_list->nobjs_rem--;
+ } /* end if */
+ else
+ /* Do not free the object */
+ ret_value = FALSE;
+
+ return ret_value;
+} /* end test_tfs_free() */
+
+/* Test function */
+static void
+test_skiplist_try_free_safe(void)
+{
+ test_tfs_list_t obj_list;
+ test_tfs_obj_t list[TEST_TFS_MAX_NOBJS];
+ int i, j;
+ int nobjs_found;
+ hsize_t count;
+ herr_t ret; /* Generic return value */
+
+ /* Output message about test being performed */
+ MESSAGE(7, ("Testing Skip List 'Try Free Safe' Operation\n"));
+
+ /* Create a skip list */
+ obj_list.slist = H5SL_create(H5SL_TYPE_INT, NULL);
+ CHECK(obj_list.slist, NULL, "H5SL_create");
+
+ /* Init obj_list.list */
+ obj_list.list = list;
+ for(j = 0; j < TEST_TFS_MAX_NOBJS; j++)
+ list[j].idx = j;
+
+ for(i = 0; i < TEST_TFS_NITER; i++) {
+ /* Build object list */
+ obj_list.nobjs = obj_list.nobjs_rem = (int)(TEST_TFS_MIN_NOBJS + (HDrandom() % (long)(TEST_TFS_MAX_NOBJS - TEST_TFS_MIN_NOBJS + 1)));
+ for(j = 0; j < obj_list.nobjs; j++) {
+ list[j].nfrees = 0;
+ ret = H5SL_insert(obj_list.slist, &list[j], &list[j].idx);
+ CHECK(ret, FAIL, "H5SL_insert");
+ } /* end for */
+
+ /* Call H5S_try_free_safe() - free most of the items in the skip list in
+ * a safe manner */
+ ret = H5SL_try_free_safe(obj_list.slist, test_tfs_free, &obj_list);
+ CHECK(ret, FAIL, "H5SL_try_free_safe");
+
+ /* Verify list */
+ nobjs_found = 0;
+ for(j = 0; j < obj_list.nobjs; j++)
+ if(list[j].nfrees == 0)
+ nobjs_found++;
+ else
+ VERIFY(list[j].nfrees, (long)1, "list[j].nfrees");
+
+ /* Verify number of objects */
+ VERIFY(obj_list.nobjs_rem, nobjs_found, "obj_list.nobjs_rem");
+ count = H5SL_count(obj_list.slist);
+ VERIFY(count, (size_t)nobjs_found, "H5SL_count");
+
+ /* Release the skip list, forcibly freeing all nodes (will not make
+ * callbacks) */
+ ret = H5SL_release(obj_list.slist);
+ CHECK(ret, FAIL, "H5SL_release");
+
+ /* Verify number of objects is 0 */
+ count = H5SL_count(obj_list.slist);
+ VERIFY(count, (size_t)0, "H5SL_count");
+ } /* end for */
+
+ /* Close the skip list */
+ ret = H5SL_close(obj_list.slist);
+ CHECK(ret, FAIL, "H5SL_close");
+
+} /* end test_skiplist_try_free_safe() */
+
+/****************************************************************
+**
** test_skiplist_less(): Test H5SL (skip list) code.
** Tests 'less' operation in skip lists.
**
@@ -1577,6 +1779,7 @@ test_skiplist(void)
test_skiplist_add(); /* Test 'add' operation */
test_skiplist_destroy(); /* Test 'destroy' operation */
test_skiplist_free(); /* Test 'free' operation */
+ test_skiplist_try_free_safe(); /* Test 'try_free_safe' operation */
test_skiplist_less(); /* Test 'less' operation */
test_skiplist_greater(); /* Test 'greater' operation */
test_skiplist_below(); /* Test 'below' operation */
generated by cgit v0.12 at 2024-12-27 07:24:56 (GMT)