H5Pset_chunk_cache
(
hid_t dapl_id
,
size_t rdcc_nslots
,
size_t rdcc_nbytes
,
double rdcc_w0
)
H5Pset_chunk_cache
is used to adjust the chunk cache parameters on a per-dataset basis, as
opposed to a global setting for the file. The optimum chunk cache
parameters vary wildly with different data layout and access patterns, so
for optimal performance they must be set individually for each dataset.
It may also be beneficial to reduce the size of the chunk cache for
datasets whose performance is not important in order to save memory space.
H5Pset_chunk_cache
sets the number of elements, the total number of bytes, and the preemption
policy value in the raw data chunk cache on a dataset access property
list. After calling this function, the values set in the property list
will override the values in the file's file access property list.
The raw data chunk cache inserts chunks into the cache by first computing
a hash value using the address of a chunk, then using that hash value as
the chunk's index into the table of cached chunks. The size of this
hash table, i.e., and the number of possible hash values, is determined by
the rdcc_nslots
parameter. If a different chunk in the cache
has the same hash value, this causes a collision, which reduces
efficiency. If inserting the chunk into cache would cause the cache to be
too big, then the cache is pruned according to the rdcc_w0
parameter.
hid_t dapl_id
| IN: Dataset access property list identifier. | |
size_t rdcc_nslots
| IN:The number of chunk slots in the raw data chunk cache for this
dataset. Increasing this value reduces the number of cache
collisions, but slightly increases the memory used. Due to the
hashing strategy, this value should ideally be a prime number. As a
rule of thumb, this value should be at least 10 times the number of
chunks that can fit in rdcc_nbytes bytes. For maximum
performance, this value should be set approximately 100 times that
number of chunks.
The default value is | |
size_t rdcc_nbytes
| IN: The total size of the raw data chunk cache for this dataset. In
most cases increasing this number will improve performance, as long
as you have enough free memory.
The default size is 1 MB. If the value passed is
| |
double rdcc_w0
| IN: The chunk preemption policy for this dataset. This must be
between 0 and 1 inclusive and indicates
the weighting according to which chunks which have been fully read
or written are penalized when determining which chunks to flush from
cache. A value of 0 means fully read or written chunks
are treated no differently than other chunks (the preemption is
strictly LRU) while a value of 1 means fully read or
written chunks are always preempted before other chunks. If your
application only reads or writes data once, this can be safely set
to 1 . Otherwise, this should be set lower, depending
on how often you re-read or re-write the same data.
The default value is |
H5Pset_chunk_cache(dapl_id, 12421, 16*1024*1024, H5D_CHUNK_CACHE_W0_DEFAULT);
SUBROUTINE h5pset_chunk_cache_f(dapl_id, rdcc_nslots, rdcc_nbytes, rdcc_w0, hdferr) IMPLICIT NONE INTEGER(HID_T), INTENT(IN) :: dapl_id ! Dataset access property list ! identifier. INTEGER(SIZE_T), INTENT(IN) :: rdcc_nslots ! The number of chunk slots in the ! raw data chunk cache for this ! dataset. INTEGER(SIZE_T), INTENT(IN) :: rdcc_nbytes ! The total size of the raw data ! chunk cache for this dataset. REAL, INTENT(IN) :: rdcc_w0 ! The chunk preemption policy for ! this dataset. INTEGER, INTENT(OUT) :: hdferr ! Error code ! 0 on success and -1 on failure END SUBROUTINE h5pset_chunk_cache_f
H5Pget_chunk_cache
,
H5Pset_cache
Release | Change |
1.8.3 | C function introduced in this release. |