summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorQuincey Koziol <koziol@hdfgroup.org>2004-06-05 19:06:24 (GMT)
committerQuincey Koziol <koziol@hdfgroup.org>2004-06-05 19:06:24 (GMT)
commit60c6500fad6e102ed3535f12d3f3edf55ff6fed6 (patch)
treea2bbe48ab81cd52ad8a6de3f668f4bf2e3448bb7
parent085f120d19bd0c465b9f3d518637612febc3ae01 (diff)
downloadhdf5-60c6500fad6e102ed3535f12d3f3edf55ff6fed6.zip
hdf5-60c6500fad6e102ed3535f12d3f3edf55ff6fed6.tar.gz
hdf5-60c6500fad6e102ed3535f12d3f3edf55ff6fed6.tar.bz2
[svn-r8614] Purpose:
Refactor code Description: Move chunk and contiguous cached raw data from file information to dataset information. This simplifies a number of internal interfaces, aligns the code with it's purpose better and should allow more optimizations to the chunked data I/O performance. Platforms tested: Solaris 2.7 (arabica) FreeBSD 4.10 (sleipnir) h5committest
Diffstat
-rw-r--r--src/H5.c3
-rw-r--r--src/H5D.c228
-rw-r--r--src/H5Dcompact.c50
-rw-r--r--src/H5Dcontig.c365
-rw-r--r--src/H5Dio.c74
-rw-r--r--src/H5Distore.c1065
-rw-r--r--src/H5Dpkg.h54
-rw-r--r--src/H5Dprivate.h55
-rw-r--r--src/H5Dseq.c182
-rw-r--r--src/H5F.c474
-rw-r--r--src/H5FDprivate.h4
-rw-r--r--src/H5Fcompact.c50
-rw-r--r--src/H5Fcontig.c365
-rw-r--r--src/H5Fistore.c1065
-rw-r--r--src/H5Fpkg.h74
-rw-r--r--src/H5Fprivate.h80
-rw-r--r--src/H5Fseq.c182
-rw-r--r--src/H5Olayout.c4
-rw-r--r--src/H5Smpio.c45
-rw-r--r--src/H5Spkg.h16
-rw-r--r--src/H5Sprivate.h54
-rw-r--r--src/H5Sselect.c40
22 files changed, 2220 insertions, 2309 deletions
diff --git a/src/H5.c b/src/H5.c
index 94e90d8..4050736 100644
--- a/src/H5.c
+++ b/src/H5.c
@@ -251,6 +251,9 @@ H5_term_library(void)
if (func) {
fprintf(stderr, "HDF5: infinite loop closing library\n");
fprintf(stderr, " %s\n", loop);
+#ifndef NDEBUG
+ HDabort();
+#endif /* NDEBUG */
}
}
diff --git a/src/H5D.c b/src/H5D.c
index 81043ec..8a53ae5 100644
--- a/src/H5D.c
+++ b/src/H5D.c
@@ -48,19 +48,19 @@ static int interface_initialize_g = 0;
/* Local functions */
static herr_t H5D_init_interface(void);
static herr_t H5D_init_storage(H5D_t *dataset, hbool_t full_overwrite, hid_t dxpl_id);
-static int H5D_crt_fill_value_cmp(const void *value1, const void *value2, size_t size);
-static int H5D_crt_ext_file_list_cmp(const void *value1, const void *value2, size_t size);
-static int H5D_crt_data_pipeline_cmp(const void *value1, const void *value2, size_t size);
static H5D_t * H5D_new(hid_t dcpl_id, hbool_t creating, hbool_t vl_type);
static H5D_t * H5D_create(H5G_entry_t *loc, const char *name, hid_t type_id,
const H5S_t *space, hid_t dcpl_id, hid_t dxpl_id);
static H5D_t * H5D_open_oid(const H5G_entry_t *ent, hid_t dxpl_id);
-static herr_t H5D_get_space_status(const H5D_t *dset, H5D_space_status_t *allocation, hid_t dxpl_id);
-static hsize_t H5D_get_storage_size(const H5D_t *dset, hid_t dxpl_id);
+static herr_t H5D_get_space_status(H5D_t *dset, H5D_space_status_t *allocation, hid_t dxpl_id);
+static hsize_t H5D_get_storage_size(H5D_t *dset, hid_t dxpl_id);
static haddr_t H5D_get_offset(const H5D_t *dset);
static herr_t H5D_extend(H5D_t *dataset, const hsize_t *size, hid_t dxpl_id);
static herr_t H5D_set_extent(H5D_t *dataset, const hsize_t *size, hid_t dxpl_id);
static herr_t H5D_close(H5D_t *dataset);
+static int H5D_crt_fill_value_cmp(const void *value1, const void *value2, size_t size);
+static int H5D_crt_ext_file_list_cmp(const void *value1, const void *value2, size_t size);
+static int H5D_crt_data_pipeline_cmp(const void *value1, const void *value2, size_t size);
/* Internal data structure for computing variable-length dataset's total size */
typedef struct {
@@ -82,6 +82,9 @@ H5FL_BLK_DEFINE_STATIC(vlen_vl_buf);
/* Declare a free list to manage other blocks of VL data */
H5FL_BLK_DEFINE_STATIC(vlen_fl_buf);
+/* Declare the external PQ free list for the sieve buffer information */
+H5FL_BLK_EXTERN(sieve_buf);
+
/* Define a static "default" dataset structure to use to initialize new datasets */
static H5D_t H5D_def_dset;
@@ -188,7 +191,7 @@ H5D_init_interface(void)
*/
H5P_genclass_t *crt_pclass;
H5D_layout_t layout = H5D_CRT_LAYOUT_DEF;
- int chunk_ndims = H5D_CRT_CHUNK_DIM_DEF;
+ unsigned chunk_ndims = H5D_CRT_CHUNK_DIM_DEF;
size_t chunk_size[H5O_LAYOUT_NDIMS] = H5D_CRT_CHUNK_SIZE_DEF;
H5O_fill_t fill = H5D_CRT_FILL_VALUE_DEF;
H5D_alloc_time_t alloc_time = H5D_CRT_ALLOC_TIME_DEF;
@@ -1316,7 +1319,7 @@ done:
*-------------------------------------------------------------------------
*/
static herr_t
-H5D_get_space_status(const H5D_t *dset, H5D_space_status_t *allocation, hid_t dxpl_id)
+H5D_get_space_status(H5D_t *dset, H5D_space_status_t *allocation, hid_t dxpl_id)
{
H5S_t *space; /* Dataset's dataspace */
hsize_t space_allocated; /* The number of bytes allocated for chunks */
@@ -1854,7 +1857,7 @@ done:
HDONE_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to unprotect dataset object header")
FUNC_LEAVE_NOAPI(ret_value)
-}
+} /* end H5D_update_entry_info() */
/*-------------------------------------------------------------------------
@@ -1926,6 +1929,7 @@ H5D_create(H5G_entry_t *loc, const char *name, hid_t type_id, const H5S_t *space
unsigned chunk_ndims = 0; /* Dimensionality of chunk */
H5P_genplist_t *dc_plist=NULL; /* New Property list */
hbool_t has_vl_type=FALSE; /* Flag to indicate a VL-type for dataset */
+ hbool_t chunk_init=FALSE; /* Flag to indicate that chunk information was initialized */
H5D_t *ret_value; /* Return value */
FUNC_ENTER_NOAPI(H5D_create, NULL)
@@ -2135,6 +2139,13 @@ H5D_create(H5G_entry_t *loc, const char *name, hid_t type_id, const H5S_t *space
/* Compute the total size of a chunk */
for (u=1, new_dset->layout.u.chunk.size=new_dset->layout.u.chunk.dim[0]; u<new_dset->layout.u.chunk.ndims; u++)
new_dset->layout.u.chunk.size *= new_dset->layout.u.chunk.dim[u];
+
+ /* Initialize the chunk cache for the dataset */
+ if(H5D_istore_init(file,new_dset)<0)
+ HGOTO_ERROR (H5E_DATASET, H5E_CANTINIT, NULL, "can't initialize chunk cache")
+
+ /* Indicate that the chunk information was initialized */
+ chunk_init=TRUE;
} /* end case */
break;
@@ -2185,6 +2196,10 @@ H5D_create(H5G_entry_t *loc, const char *name, hid_t type_id, const H5S_t *space
done:
if (!ret_value && new_dset) {
+ if(new_dset->layout.type==H5D_CHUNKED && chunk_init) {
+ if(H5D_istore_dest(new_dset->ent.file,H5AC_dxpl_id,new_dset)<0)
+ HDONE_ERROR(H5E_DATASET, H5E_CANTRELEASE, NULL, "unable to destroy chunk cache")
+ } /* end if */
if (new_dset->space) {
if(H5S_close(new_dset->space)<0)
HDONE_ERROR(H5E_DATASET, H5E_CLOSEERROR, NULL, "unable to release dataspace")
@@ -2210,7 +2225,7 @@ done:
}
FUNC_LEAVE_NOAPI(ret_value)
-}
+} /* end H5D_create() */
/*-------------------------------------------------------------------------
@@ -2435,11 +2450,11 @@ H5D_open_oid(const H5G_entry_t *ent, hid_t dxpl_id)
break;
case H5D_CHUNKED:
- /*
- * Chunked storage. The creation plist's dimension is one less than
- * the chunk dimension because the chunk includes a dimension for the
- * individual bytes of the data type.
- */
+ /*
+ * Chunked storage. The creation plist's dimension is one less than
+ * the chunk dimension because the chunk includes a dimension for the
+ * individual bytes of the data type.
+ */
{
unsigned chunk_ndims; /* Dimensionality of chunk */
@@ -2449,6 +2464,10 @@ H5D_open_oid(const H5G_entry_t *ent, hid_t dxpl_id)
HGOTO_ERROR(H5E_DATASET, H5E_CANTSET, NULL, "can't set chunk dimensions")
if(H5P_set(plist, H5D_CRT_CHUNK_SIZE_NAME, dataset->layout.u.chunk.dim) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_CANTSET, NULL, "can't set chunk size")
+
+ /* Initialize the chunk cache for the dataset */
+ if(H5D_istore_init(dataset->ent.file,dataset)<0)
+ HGOTO_ERROR (H5E_DATASET, H5E_CANTINIT, NULL, "can't initialize chunk cache")
}
break;
@@ -2608,6 +2627,46 @@ H5D_close(H5D_t *dataset)
/* check args */
assert(dataset && dataset->ent.file);
+ /* Dump debugging info */
+#ifdef H5D_ISTORE_DEBUG
+ H5D_istore_stats(dataset, FALSE);
+#endif /* H5F_ISTORE_DEBUG */
+
+ /* Free cached information for each kind of dataset */
+ switch(dataset->layout.type) {
+ case H5D_CONTIGUOUS:
+ /* Free the data sieve buffer, if it's been allocated */
+ if(dataset->cache.contig.sieve_buf) {
+ assert(dataset->cache.contig.sieve_dirty==0); /* The buffer had better be flushed... */
+ dataset->cache.contig.sieve_buf = H5FL_BLK_FREE (sieve_buf,dataset->cache.contig.sieve_buf);
+ } /* end if */
+ break;
+
+ case H5D_CHUNKED:
+ /* Flush and destroy chunks in the cache */
+ if(H5D_istore_dest(dataset->ent.file,H5AC_dxpl_id,dataset)<0)
+ HGOTO_ERROR(H5E_DATASET, H5E_CANTRELEASE, FAIL, "unable to destroy chunk cache")
+ break;
+
+ case H5D_COMPACT:
+ /* Update header message of layout for compact dataset. */
+ if(dataset->layout.u.compact.dirty) {
+ if(H5O_modify(&(dataset->ent), H5O_LAYOUT_ID, 0, 0, 1, &(dataset->layout), H5AC_dxpl_id)<0)
+ HGOTO_ERROR(H5E_DATASET, H5E_CANTRELEASE, FAIL, "unable to update layout message")
+ dataset->layout.u.compact.dirty = FALSE;
+ } /* end if */
+
+ /* Free the buffer for the raw data for compact datasets */
+ dataset->layout.u.compact.buf=H5MM_xfree(dataset->layout.u.compact.buf);
+ break;
+
+ default:
+ assert ("not implemented yet" && 0);
+#ifdef NDEBUG
+ HGOTO_ERROR (H5E_IO, H5E_UNSUPPORTED, FAIL, "unsupported storage layout")
+#endif /* NDEBUG */
+ } /* end switch */
+
/*
* Release datatype, dataspace and creation property list -- there isn't
* much we can do if one of these fails, so we just continue.
@@ -2615,13 +2674,6 @@ H5D_close(H5D_t *dataset)
free_failed=(H5T_close(dataset->type)<0 || H5S_close(dataset->space)<0 ||
H5I_dec_ref(dataset->dcpl_id) < 0);
- /* Update header message of layout for compact dataset. */
- if(dataset->layout.type==H5D_COMPACT && dataset->layout.u.compact.dirty) {
- if(H5O_modify(&(dataset->ent), H5O_LAYOUT_ID, 0, 0, 1, &(dataset->layout), H5AC_dxpl_id)<0)
- HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to update layout message")
- dataset->layout.u.compact.dirty = FALSE;
- } /* end if */
-
/* Remove the dataset from the list of opened objects in the file */
if(H5FO_delete(dataset->ent.file, H5AC_dxpl_id, dataset->ent.header)<0)
HGOTO_ERROR(H5E_DATASET, H5E_CANTRELEASE, FAIL, "can't remove dataset from list of open objects")
@@ -2638,9 +2690,7 @@ H5D_close(H5D_t *dataset)
* above).
*/
dataset->ent.file = NULL;
- /* Free the buffer for the raw data for compact datasets */
- if(dataset->layout.type==H5D_COMPACT)
- dataset->layout.u.compact.buf=H5MM_xfree(dataset->layout.u.compact.buf);
+
H5FL_FREE(H5D_t,dataset);
if (free_failed)
@@ -2701,7 +2751,7 @@ H5D_extend (H5D_t *dataset, const hsize_t *size, hid_t dxpl_id)
/* Update the index values for the cached chunks for this dataset */
if(H5D_CHUNKED == dataset->layout.type)
- if(H5F_istore_update_cache(dataset->ent.file, dxpl_id, &dataset->layout, space) < 0)
+ if(H5D_istore_update_cache(dataset->ent.file, dxpl_id, dataset) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_WRITEERROR, FAIL, "unable to update cached chunk indices")
/* Allocate space for the new parts of the dataset, if appropriate */
@@ -2845,7 +2895,7 @@ H5D_alloc_storage (H5F_t *f, hid_t dxpl_id, H5D_t *dset/*in,out*/, H5D_time_allo
case H5D_CONTIGUOUS:
if(layout->u.contig.addr==HADDR_UNDEF) {
/* Reserve space in the file for the entire array */
- if (H5F_contig_create (f, dxpl_id, layout/*out*/)<0)
+ if (H5D_contig_create (f, dxpl_id, dset/*out*/)<0)
HGOTO_ERROR (H5E_IO, H5E_CANTINIT, FAIL, "unable to initialize contiguous storage")
/* Indicate that we set the storage addr */
@@ -2859,7 +2909,7 @@ H5D_alloc_storage (H5F_t *f, hid_t dxpl_id, H5D_t *dset/*in,out*/, H5D_time_allo
case H5D_CHUNKED:
if(layout->u.chunk.addr==HADDR_UNDEF) {
/* Create the root of the B-tree that describes chunked storage */
- if (H5F_istore_create (f, dxpl_id, layout/*out*/)<0)
+ if (H5D_istore_create (f, dxpl_id, layout/*out*/)<0)
HGOTO_ERROR (H5E_IO, H5E_CANTINIT, FAIL, "unable to initialize chunked storage")
/* Indicate that we set the storage addr */
@@ -2973,42 +3023,40 @@ done:
static herr_t
H5D_init_storage(H5D_t *dset, hbool_t full_overwrite, hid_t dxpl_id)
{
- hssize_t snpoints; /* Number of points in space (for error checking) */
- size_t npoints; /* Number of points in space */
- H5S_t *space; /* Dataset's dataspace */
herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_NOAPI_NOINIT(H5D_init_storage)
assert(dset);
- /* Get the dataset's dataspace */
- space=dset->space;
-
- /* Get the number of elements in the dataset's dataspace */
- snpoints = H5S_GET_SIMPLE_EXTENT_NPOINTS(space);
- assert(snpoints>=0);
- H5_ASSIGN_OVERFLOW(npoints,snpoints,hssize_t,size_t);
-
switch (dset->layout.type) {
case H5D_COMPACT:
- /* If we will be immediately overwriting the values, don't bother to clear them */
- if(!full_overwrite) {
- /* If the fill value is defined, initialize the data buffer with it */
- if(dset->fill.buf)
- /* Initialize the cached data buffer with the fill value */
- H5V_array_fill(dset->layout.u.compact.buf, dset->fill.buf, dset->fill.size, npoints);
- else /* If the fill value is default, zero set data buf. */
- HDmemset(dset->layout.u.compact.buf, 0, dset->layout.u.compact.size);
- } /* end if */
+ {
+ hssize_t snpoints; /* Number of points in space (for error checking) */
+ size_t npoints; /* Number of points in space */
+
+ /* Get the number of elements in the dataset's dataspace */
+ snpoints = H5S_GET_SIMPLE_EXTENT_NPOINTS(dset->space);
+ assert(snpoints>=0);
+ H5_ASSIGN_OVERFLOW(npoints,snpoints,hssize_t,size_t);
+
+ /* If we will be immediately overwriting the values, don't bother to clear them */
+ if(!full_overwrite) {
+ /* If the fill value is defined, initialize the data buffer with it */
+ if(dset->fill.buf)
+ /* Initialize the cached data buffer with the fill value */
+ H5V_array_fill(dset->layout.u.compact.buf, dset->fill.buf, dset->fill.size, npoints);
+ else /* If the fill value is default, zero set data buf. */
+ HDmemset(dset->layout.u.compact.buf, 0, dset->layout.u.compact.size);
+ } /* end if */
+ }
break;
case H5D_CONTIGUOUS:
/* Don't write default fill values to external files */
/* If we will be immediately overwriting the values, don't bother to clear them */
if((dset->efl.nused==0 || dset->fill.buf) && !full_overwrite) {
- if (H5F_contig_fill(dset->ent.file, dxpl_id, &(dset->layout),
- space, &dset->fill, H5T_get_size(dset->type))<0)
+ if (H5D_contig_fill(dset->ent.file, dxpl_id, dset)<0)
HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to allocate all chunks of dataset")
} /* end if */
break;
@@ -3018,23 +3066,8 @@ H5D_init_storage(H5D_t *dset, hbool_t full_overwrite, hid_t dxpl_id)
* Allocate file space
* for all chunks now and initialize each chunk with the fill value.
*/
- {
- H5P_genplist_t *plist; /* Property list */
- int ndims;
- hsize_t dim[H5O_LAYOUT_NDIMS];
-
- /* Get dataset's creation property list */
- if (NULL == (plist = H5I_object(dset->dcpl_id)))
- HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataset creation property list")
-
- /* We only handle simple data spaces so far */
- if ((ndims=H5S_get_simple_extent_dims(space, dim, NULL))<0)
- HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to get simple data space info")
- dim[ndims] = dset->layout.u.chunk.dim[ndims];
-
- if (H5F_istore_allocate(dset->ent.file, dxpl_id, &(dset->layout), dim, plist, full_overwrite)<0)
- HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to allocate all chunks of dataset")
- } /* end if */
+ if (H5D_istore_allocate(dset->ent.file, dxpl_id, dset, full_overwrite)<0)
+ HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to allocate all chunks of dataset")
break;
default:
@@ -3046,7 +3079,7 @@ H5D_init_storage(H5D_t *dset, hbool_t full_overwrite, hid_t dxpl_id)
done:
FUNC_LEAVE_NOAPI(ret_value)
-}
+} /* end H5D_init_storage() */
/*-------------------------------------------------------------------------
@@ -3108,7 +3141,7 @@ done:
*-------------------------------------------------------------------------
*/
static hsize_t
-H5D_get_storage_size(const H5D_t *dset, hid_t dxpl_id)
+H5D_get_storage_size(H5D_t *dset, hid_t dxpl_id)
{
hsize_t ret_value;
@@ -3119,7 +3152,7 @@ H5D_get_storage_size(const H5D_t *dset, hid_t dxpl_id)
if(dset->layout.u.chunk.addr == HADDR_UNDEF)
ret_value=0;
else
- ret_value = H5F_istore_allocated(dset->ent.file, dxpl_id, &dset->layout);
+ ret_value = H5D_istore_allocated(dset->ent.file, dxpl_id, dset);
break;
case H5D_CONTIGUOUS:
@@ -3700,7 +3733,7 @@ H5D_set_extent(H5D_t *dset, const hsize_t *size, hid_t dxpl_id)
/* Update the index values for the cached chunks for this dataset */
if(H5D_CHUNKED == dset->layout.type)
- if(H5F_istore_update_cache(dset->ent.file, dxpl_id, &dset->layout, space) < 0)
+ if(H5D_istore_update_cache(dset->ent.file, dxpl_id, dset) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_WRITEERROR, FAIL, "unable to update cached chunk indices")
/* Allocate space for the new parts of the dataset, if appropriate */
@@ -3715,23 +3748,18 @@ H5D_set_extent(H5D_t *dset, const hsize_t *size, hid_t dxpl_id)
*-------------------------------------------------------------------------
*/
if(shrink && H5D_CHUNKED == dset->layout.type) {
- H5P_genplist_t *plist;
H5D_dxpl_cache_t dxpl_cache; /* Cached data transfer properties */
- /* Get the dataset creation property list */
- if(NULL == (plist = H5I_object(dset->dcpl_id)))
- HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dset creation property list")
-
/* Fill the DXPL cache values for later use */
if (H5D_get_dxpl_cache(dxpl_id,&dxpl_cache)<0)
HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't fill dxpl cache")
/* Remove excess chunks */
- if(H5F_istore_prune_by_extent(dset->ent.file, &dxpl_cache, dxpl_id, &dset->layout, space) < 0)
+ if(H5D_istore_prune_by_extent(dset->ent.file, &dxpl_cache, dxpl_id, dset) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_WRITEERROR, FAIL, "unable to remove chunks ")
/* Reset the elements outsize the new dimensions, but in existing chunks */
- if(H5F_istore_initialize_by_extent(dset->ent.file, &dxpl_cache, dxpl_id, &dset->layout, plist, space) < 0)
+ if(H5D_istore_initialize_by_extent(dset->ent.file, &dxpl_cache, dxpl_id, dset) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_WRITEERROR, FAIL, "unable to initialize chunks ")
} /* end if */
} /* end if */
@@ -3761,7 +3789,7 @@ done:
*-------------------------------------------------------------------------
*/
herr_t
-H5D_flush(const H5F_t *f, hid_t dxpl_id)
+H5D_flush(H5F_t *f, hid_t dxpl_id, unsigned flags)
{
int num_dsets; /* Number of datasets in file */
hid_t *id_list=NULL; /* list of dataset IDs */
@@ -3788,11 +3816,43 @@ H5D_flush(const H5F_t *f, hid_t dxpl_id)
for(j=0; j<num_dsets; j++) {
if(NULL==(dataset=H5I_object_verify(id_list[j], H5I_DATASET)))
HGOTO_ERROR(H5E_FILE, H5E_CANTINIT, FAIL, "unable to get dataset object")
- if(dataset->layout.type==H5D_COMPACT && dataset->layout.u.compact.dirty) {
- if(H5O_modify(&(dataset->ent), H5O_LAYOUT_ID, 0, 0, 1, &(dataset->layout), dxpl_id)<0)
- HGOTO_ERROR(H5E_FILE, H5E_CANTINIT, FAIL, "unable to update layout message")
- dataset->layout.u.compact.dirty = FALSE;
- } /* end if */
+
+ /* Flush cached information for each kind of dataset */
+ switch(dataset->layout.type) {
+ case H5D_CONTIGUOUS:
+ /* flush the raw data buffer, if we have a dirty one */
+ if (dataset->cache.contig.sieve_buf && dataset->cache.contig.sieve_dirty) {
+ /* Write dirty data sieve buffer to file */
+ if (H5F_block_write(f, H5FD_MEM_DRAW, dataset->cache.contig.sieve_loc,
+ dataset->cache.contig.sieve_size, dxpl_id, dataset->cache.contig.sieve_buf) < 0)
+ HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "block write failed")
+
+ /* Reset sieve buffer dirty flag */
+ dataset->cache.contig.sieve_dirty=0;
+ } /* end if */
+ break;
+
+ case H5D_CHUNKED:
+ /* Flush the raw data cache */
+ if (H5D_istore_flush(f, dxpl_id, dataset, flags & (H5F_FLUSH_INVALIDATE | H5F_FLUSH_CLEAR_ONLY)) < 0)
+ HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "unable to flush raw data cache")
+ break;
+
+ case H5D_COMPACT:
+ if(dataset->layout.u.compact.dirty) {
+ if(H5O_modify(&(dataset->ent), H5O_LAYOUT_ID, 0, 0, 1, &(dataset->layout), dxpl_id)<0)
+ HGOTO_ERROR(H5E_FILE, H5E_CANTINIT, FAIL, "unable to update layout message")
+ dataset->layout.u.compact.dirty = FALSE;
+ } /* end if */
+ break;
+
+ default:
+ assert ("not implemented yet" && 0);
+#ifdef NDEBUG
+ HGOTO_ERROR (H5E_IO, H5E_UNSUPPORTED, FAIL, "unsupported storage layout")
+#endif /* NDEBUG */
+ } /* end switch */
+
}
} /* end if */
@@ -3835,7 +3895,7 @@ H5Ddebug(hid_t dset_id, unsigned UNUSED flags)
/* Print B-tree information */
if (H5D_CHUNKED==dset->layout.type) {
- (void)H5F_istore_dump_btree(dset->ent.file, H5AC_dxpl_id, stdout, dset->layout.u.chunk.ndims, dset->layout.u.chunk.addr);
+ (void)H5D_istore_dump_btree(dset->ent.file, H5AC_dxpl_id, stdout, dset->layout.u.chunk.ndims, dset->layout.u.chunk.addr);
} else if (H5D_CONTIGUOUS==dset->layout.type) {
HDfprintf(stdout, " %-10s %a\n", "Address:", dset->layout.u.contig.addr);
}
diff --git a/src/H5Dcompact.c b/src/H5Dcompact.c
index 4f5b75e..3701221 100644
--- a/src/H5Dcompact.c
+++ b/src/H5Dcompact.c
@@ -17,21 +17,22 @@
* August 5, 2002
*
* Purpose: Compact dataset I/O functions. These routines are similar
- * H5F_contig_* and H5F_istore_*.
+ * H5D_contig_* and H5D_istore_*.
*/
-#define H5F_PACKAGE /*suppress error about including H5Fpkg */
+#define H5D_PACKAGE /*suppress error about including H5Dpkg */
/* Pablo information */
/* (Put before include files to avoid problems with inline functions) */
-#define PABLO_MASK H5Fcompact_mask
+#define PABLO_MASK H5Dcompact_mask
-#include "H5private.h"
-#include "H5Eprivate.h"
-#include "H5Fpkg.h"
-#include "H5Oprivate.h"
-#include "H5FDprivate.h" /*file driver */
-#include "H5FLprivate.h" /*Free Lists */
+#include "H5private.h" /* Generic Functions */
+#include "H5Dpkg.h" /* Dataset functions */
+#include "H5Eprivate.h" /* Error handling */
+#include "H5Fprivate.h" /* Files */
+#include "H5FDprivate.h" /* File drivers */
+#include "H5FLprivate.h" /* Free Lists */
+#include "H5Oprivate.h" /* Object headers */
#include "H5Vprivate.h" /* Vector and array functions */
/* Interface initialization */
@@ -40,7 +41,7 @@ static int interface_initialize_g = 0;
/*-------------------------------------------------------------------------
- * Function: H5F_compact_readvv
+ * Function: H5D_compact_readvv
*
* Purpose: Reads some data vectors from a dataset into a buffer.
* The data is in compact dataset. The address is relative
@@ -60,26 +61,28 @@ static int interface_initialize_g = 0;
*-------------------------------------------------------------------------
*/
ssize_t
-H5F_compact_readvv(H5F_t UNUSED *f, const H5O_layout_t *layout,
+H5D_compact_readvv(H5F_t UNUSED *f, hid_t UNUSED dxpl_id, const H5D_t *dset,
size_t dset_max_nseq, size_t *dset_curr_seq, size_t dset_size_arr[], hsize_t dset_offset_arr[],
size_t mem_max_nseq, size_t *mem_curr_seq, size_t mem_size_arr[], hsize_t mem_offset_arr[],
- hid_t UNUSED dxpl_id, void *buf)
+ void *buf)
{
ssize_t ret_value; /* Return value */
- FUNC_ENTER_NOAPI(H5F_compact_readvv, FAIL);
+ FUNC_ENTER_NOAPI(H5D_compact_readvv, FAIL);
+
+ assert(dset);
/* Use the vectorized memory copy routine to do actual work */
- if((ret_value=H5V_memcpyvv(buf,mem_max_nseq,mem_curr_seq,mem_size_arr,mem_offset_arr,layout->u.compact.buf,dset_max_nseq,dset_curr_seq,dset_size_arr,dset_offset_arr))<0)
+ if((ret_value=H5V_memcpyvv(buf,mem_max_nseq,mem_curr_seq,mem_size_arr,mem_offset_arr,dset->layout.u.compact.buf,dset_max_nseq,dset_curr_seq,dset_size_arr,dset_offset_arr))<0)
HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "vectorized memcpy failed");
done:
FUNC_LEAVE_NOAPI(ret_value);
-} /* end H5F_compact_readvv() */
+} /* end H5D_compact_readvv() */
/*-------------------------------------------------------------------------
- * Function: H5F_compact_writevv
+ * Function: H5D_compact_writevv
*
* Purpose: Writes some data vectors from a dataset into a buffer.
* The data is in compact dataset. The address is relative
@@ -102,22 +105,23 @@ done:
*-------------------------------------------------------------------------
*/
ssize_t
-H5F_compact_writevv(H5F_t UNUSED *f, H5O_layout_t *layout,
+H5D_compact_writevv(H5F_t UNUSED *f, hid_t UNUSED dxpl_id, H5D_t *dset,
size_t dset_max_nseq, size_t *dset_curr_seq, size_t dset_size_arr[], hsize_t dset_offset_arr[],
size_t mem_max_nseq, size_t *mem_curr_seq, size_t mem_size_arr[], hsize_t mem_offset_arr[],
- hid_t UNUSED dxpl_id, const void *buf)
+ const void *buf)
{
ssize_t ret_value; /* Return value */
- FUNC_ENTER_NOAPI(H5F_compact_writevv, FAIL);
+ FUNC_ENTER_NOAPI(H5D_compact_writevv, FAIL);
+
+ assert(dset);
/* Use the vectorized memory copy routine to do actual work */
- if((ret_value=H5V_memcpyvv(layout->u.compact.buf,dset_max_nseq,dset_curr_seq,dset_size_arr,dset_offset_arr,buf,mem_max_nseq,mem_curr_seq,mem_size_arr,mem_offset_arr))<0)
+ if((ret_value=H5V_memcpyvv(dset->layout.u.compact.buf,dset_max_nseq,dset_curr_seq,dset_size_arr,dset_offset_arr,buf,mem_max_nseq,mem_curr_seq,mem_size_arr,mem_offset_arr))<0)
HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "vectorized memcpy failed");
- layout->u.compact.dirty = TRUE;
+ dset->layout.u.compact.dirty = TRUE;
done:
FUNC_LEAVE_NOAPI(ret_value);
-} /* end H5F_compact_writevv() */
-
+} /* end H5D_compact_writevv() */
diff --git a/src/H5Dcontig.c b/src/H5Dcontig.c
index 35b9700..47fdace 100644
--- a/src/H5Dcontig.c
+++ b/src/H5Dcontig.c
@@ -18,20 +18,20 @@
*
* Purpose:
* Contiguous dataset I/O functions. These routines are similar to
- * the H5F_istore_* routines and really only an abstract way of dealing
- * with the data sieve buffer from H5F_seg_read/write.
+ * the H5D_istore_* routines and really only an abstract way of dealing
+ * with the data sieve buffer from H5F_seq_read/write.
*/
-#define H5F_PACKAGE /*suppress error about including H5Fpkg */
+#define H5D_PACKAGE /*suppress error about including H5Dpkg */
/* Pablo information */
/* (Put before include files to avoid problems with inline functions) */
-#define PABLO_MASK H5Fcontig_mask
+#define PABLO_MASK H5Dcontig_mask
#include "H5private.h" /* Generic Functions */
-#include "H5Dprivate.h" /* Dataset functions */
+#include "H5Dpkg.h" /* Dataset functions */
#include "H5Eprivate.h" /* Error handling */
-#include "H5Fpkg.h" /* Files */
+#include "H5Fprivate.h" /* Files */
#include "H5FDprivate.h" /* File drivers */
#include "H5FLprivate.h" /* Free Lists */
#include "H5MFprivate.h" /* File memory management */
@@ -46,8 +46,8 @@
#include "H5FDmpiposix.h"
/* Private prototypes */
-static herr_t H5F_contig_write(H5F_t *f, hsize_t max_data, haddr_t addr,
- const size_t size, hid_t dxpl_id, const void *buf);
+static herr_t H5D_contig_write(H5F_t *f, hid_t dxpl_id, H5D_t *dset,
+ hsize_t offset, size_t size, const void *buf);
/* Interface initialization */
static int interface_initialize_g = 0;
@@ -64,7 +64,7 @@ H5FL_BLK_DEFINE_STATIC(zero_fill);
/*-------------------------------------------------------------------------
- * Function: H5F_contig_create
+ * Function: H5D_contig_create
*
* Purpose: Allocate file space for a contiguously stored dataset
*
@@ -78,27 +78,27 @@ H5FL_BLK_DEFINE_STATIC(zero_fill);
*-------------------------------------------------------------------------
*/
herr_t
-H5F_contig_create(H5F_t *f, hid_t dxpl_id, struct H5O_layout_t *layout)
+H5D_contig_create(H5F_t *f, hid_t dxpl_id, H5D_t *dset)
{
herr_t ret_value=SUCCEED; /* Return value */
- FUNC_ENTER_NOAPI(H5F_contig_create, FAIL);
+ FUNC_ENTER_NOAPI(H5D_contig_create, FAIL);
/* check args */
assert(f);
- assert(layout);
+ assert(dset);
/* Allocate space for the contiguous data */
- if (HADDR_UNDEF==(layout->u.contig.addr=H5MF_alloc(f, H5FD_MEM_DRAW, dxpl_id, layout->u.contig.size)))
+ if (HADDR_UNDEF==(dset->layout.u.contig.addr=H5MF_alloc(f, H5FD_MEM_DRAW, dxpl_id, dset->layout.u.contig.size)))
HGOTO_ERROR (H5E_IO, H5E_NOSPACE, FAIL, "unable to reserve file space");
done:
FUNC_LEAVE_NOAPI(ret_value);
-} /* end H5F_contig_create */
+} /* end H5D_contig_create */
/*-------------------------------------------------------------------------
- * Function: H5F_contig_fill
+ * Function: H5D_contig_fill
*
* Purpose: Write fill values to a contiguously stored dataset.
*
@@ -115,16 +115,15 @@ done:
*-------------------------------------------------------------------------
*/
herr_t
-H5F_contig_fill(H5F_t *f, hid_t dxpl_id, struct H5O_layout_t *layout,
- const struct H5S_t *space,
- const struct H5O_fill_t *fill, size_t elmt_size)
+H5D_contig_fill(H5F_t *f, hid_t dxpl_id, H5D_t *dset)
{
hssize_t snpoints; /* Number of points in space (for error checking) */
size_t npoints; /* Number of points in space */
size_t ptsperbuf; /* Maximum # of points which fit in the buffer */
+ size_t elmt_size; /* Size of each element */
size_t bufsize=64*1024; /* Size of buffer to write */
size_t size; /* Current # of points to write */
- haddr_t addr; /* Offset of dataset */
+ hsize_t offset; /* Offset of dataset */
void *buf = NULL; /* Buffer for fill value writing */
#ifdef H5_HAVE_PARALLEL
MPI_Comm mpi_comm=MPI_COMM_NULL; /* MPI communicator for file */
@@ -136,67 +135,44 @@ H5F_contig_fill(H5F_t *f, hid_t dxpl_id, struct H5O_layout_t *layout,
int non_zero_fill_f=(-1); /* Indicate that a non-zero fill-value was used */
herr_t ret_value=SUCCEED; /* Return value */
- FUNC_ENTER_NOAPI(H5F_contig_fill, FAIL);
+ FUNC_ENTER_NOAPI(H5D_contig_fill, FAIL);
/* Check args */
assert(f);
assert(TRUE==H5P_isa_class(dxpl_id,H5P_DATASET_XFER));
- assert(layout && H5D_CONTIGUOUS==layout->type);
- assert(H5F_addr_defined(layout->u.contig.addr));
- assert(layout->u.contig.size>0);
- assert(space);
- assert(elmt_size>0);
+ assert(dset && H5D_CONTIGUOUS==dset->layout.type);
+ assert(H5F_addr_defined(dset->layout.u.contig.addr));
+ assert(dset->layout.u.contig.size>0);
+ assert(dset->space);
#ifdef H5_HAVE_PARALLEL
- /* Retrieve up MPI parameters */
- if(IS_H5FD_MPIO(f)) {
+ /* Retrieve MPI parameters */
+ if(IS_H5FD_MPI(f)) {
/* Get the MPI communicator */
- if (MPI_COMM_NULL == (mpi_comm=H5FD_mpio_communicator(f->shared->lf)))
+ if (MPI_COMM_NULL == (mpi_comm=H5F_mpi_get_comm(f)))
HGOTO_ERROR(H5E_INTERNAL, H5E_MPI, FAIL, "Can't retrieve MPI communicator");
- /* Get the MPI rank & size */
- if ((mpi_rank=H5FD_mpio_mpi_rank(f->shared->lf))<0)
+ /* Get the MPI rank */
+ if ((mpi_rank=H5F_mpi_get_rank(f))<0)
HGOTO_ERROR(H5E_INTERNAL, H5E_MPI, FAIL, "Can't retrieve MPI rank");
/* Set the MPI-capable file driver flag */
using_mpi=1;
} /* end if */
- else if(IS_H5FD_MPIPOSIX(f)) {
- /* Get the MPI communicator */
- if (MPI_COMM_NULL == (mpi_comm=H5FD_mpiposix_communicator(f->shared->lf)))
- HGOTO_ERROR(H5E_INTERNAL, H5E_MPI, FAIL, "Can't retrieve MPI communicator");
-
- /* Get the MPI rank & size */
- if ((mpi_rank=H5FD_mpiposix_mpi_rank(f->shared->lf))<0)
- HGOTO_ERROR(H5E_INTERNAL, H5E_MPI, FAIL, "Can't retrieve MPI rank");
-
- /* Set the MPI-capable file driver flag */
- using_mpi=1;
- } /* end if */
-#ifdef H5_HAVE_FPHDF5
- else if (IS_H5FD_FPHDF5(f)) {
- /* Get the FPHDF5 barrier communicator */
- if (MPI_COMM_NULL == (mpi_comm = H5FD_fphdf5_barrier_communicator(f->shared->lf)))
- HGOTO_ERROR(H5E_INTERNAL, H5E_MPI, FAIL, "Can't retrieve MPI communicator");
-
- /* Get the MPI rank & size */
- if ((mpi_rank = H5FD_fphdf5_mpi_rank(f->shared->lf)) < 0)
- HGOTO_ERROR(H5E_INTERNAL, H5E_MPI, FAIL, "Can't retrieve MPI rank");
-
- /* Set the MPI-capable file driver flag */
- using_mpi = 1;
- } /* end if */
-#endif /* H5_HAVE_FPHDF5 */
#endif /* H5_HAVE_PARALLEL */
+ /* Get size of elements */
+ elmt_size=H5T_get_size(dset->type);
+ assert(elmt_size>0);
+
/* Get the number of elements in the dataset's dataspace */
- snpoints = H5S_GET_SIMPLE_EXTENT_NPOINTS(space);
+ snpoints = H5S_GET_SIMPLE_EXTENT_NPOINTS(dset->space);
assert(snpoints>=0);
H5_ASSIGN_OVERFLOW(npoints,snpoints,hssize_t,size_t);
/* If fill value is not library default, use it to set the element size */
- if(fill->buf)
- elmt_size=fill->size;
+ if(dset->fill.buf)
+ elmt_size=dset->fill.size;
/*
* Fill the entire current extent with the fill value. We can do
@@ -207,12 +183,12 @@ H5F_contig_fill(H5F_t *f, hid_t dxpl_id, struct H5O_layout_t *layout,
bufsize = ptsperbuf*elmt_size;
/* Fill the buffer with the user's fill value */
- if(fill->buf) {
+ if(dset->fill.buf) {
/* Allocate temporary buffer */
if ((buf=H5FL_BLK_MALLOC(non_zero_fill,bufsize))==NULL)
HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for fill buffer");
- H5V_array_fill(buf, fill->buf, elmt_size, ptsperbuf);
+ H5V_array_fill(buf, dset->fill.buf, elmt_size, ptsperbuf);
/* Indicate that a non-zero fill buffer was used */
non_zero_fill_f=1;
@@ -237,7 +213,7 @@ H5F_contig_fill(H5F_t *f, hid_t dxpl_id, struct H5O_layout_t *layout,
} /* end else */
/* Start at the beginning of the dataset */
- addr = layout->u.contig.addr;
+ offset = 0;
/* Loop through writing the fill value to the dataset */
while (npoints>0) {
@@ -249,7 +225,7 @@ H5F_contig_fill(H5F_t *f, hid_t dxpl_id, struct H5O_layout_t *layout,
/* Write the chunks out from only one process */
/* !! Use the internal "independent" DXPL!! -QAK */
if(H5_PAR_META_WRITE==mpi_rank) {
- if (H5F_contig_write(f, (hsize_t)size, addr, size, H5AC_ind_dxpl_id, buf)<0)
+ if (H5D_contig_write(f, H5AC_ind_dxpl_id, dset, offset, size, buf)<0)
HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to write fill value to dataset");
} /* end if */
@@ -259,14 +235,14 @@ H5F_contig_fill(H5F_t *f, hid_t dxpl_id, struct H5O_layout_t *layout,
else {
#endif /* H5_HAVE_PARALLEL */
H5_CHECK_OVERFLOW(size,size_t,hsize_t);
- if (H5F_contig_write(f, (hsize_t)size, addr, size, dxpl_id, buf)<0)
+ if (H5D_contig_write(f, dxpl_id, dset, offset, size, buf)<0)
HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to write fill value to dataset");
#ifdef H5_HAVE_PARALLEL
} /* end else */
#endif /* H5_HAVE_PARALLEL */
npoints -= MIN(ptsperbuf, npoints);
- addr += size;
+ offset += size;
} /* end while */
#ifdef H5_HAVE_PARALLEL
@@ -293,11 +269,11 @@ done:
} /* end if */
FUNC_LEAVE_NOAPI(ret_value);
-}
+} /* end H5D_contig_fill() */
/*-------------------------------------------------------------------------
- * Function: H5F_contig_delete
+ * Function: H5D_contig_delete
*
* Purpose: Delete the file space for a contiguously stored dataset
*
@@ -311,31 +287,60 @@ done:
*-------------------------------------------------------------------------
*/
herr_t
-H5F_contig_delete(H5F_t *f, hid_t dxpl_id, const struct H5O_layout_t *layout)
+H5D_contig_delete(H5F_t *f, hid_t dxpl_id, const struct H5O_layout_t *layout)
{
herr_t ret_value=SUCCEED; /* Return value */
- FUNC_ENTER_NOAPI(H5F_contig_delete, FAIL);
+ FUNC_ENTER_NOAPI(H5D_contig_delete, FAIL);
/* check args */
assert(f);
assert(layout);
- /* Check for overlap with the sieve buffer and reset it */
- if (H5F_sieve_overlap_clear(f, dxpl_id, layout->u.contig.addr, layout->u.contig.size)<0)
- HGOTO_ERROR(H5E_OHDR, H5E_CANTFREE, FAIL, "unable to clear sieve buffer");
-
/* Free the file space for the chunk */
if (H5MF_xfree(f, H5FD_MEM_DRAW, dxpl_id, layout->u.contig.addr, layout->u.contig.size)<0)
HGOTO_ERROR(H5E_OHDR, H5E_CANTFREE, FAIL, "unable to free object header");
done:
FUNC_LEAVE_NOAPI(ret_value);
-} /* end H5F_contig_delete */
+} /* end H5D_contig_delete */
+
+
+/*-------------------------------------------------------------------------
+ * Function: H5D_contig_get_addr
+ *
+ * Purpose: Get the offset of the contiguous data on disk
+ *
+ * Return: Non-negative on success/Negative on failure
+ *
+ * Programmer: Quincey Koziol
+ * June 2, 2004
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+haddr_t
+H5D_contig_get_addr(const H5D_t *dset)
+{
+ haddr_t ret_value; /* Return value */
+
+ FUNC_ENTER_NOAPI(H5D_contig_get_addr, HADDR_UNDEF);
+
+ /* check args */
+ assert(dset);
+ assert(dset->layout.type==H5D_CONTIGUOUS);
+
+ /* Get the address */
+ ret_value=dset->layout.u.contig.addr;
+
+done:
+ FUNC_LEAVE_NOAPI(ret_value);
+} /* end H5D_contig_get_addr */
/*-------------------------------------------------------------------------
- * Function: H5F_contig_write
+ * Function: H5D_contig_write
*
* Purpose: Writes some data from a dataset into a buffer.
* The data is contiguous. The address is relative to the base
@@ -352,32 +357,34 @@ done:
*-------------------------------------------------------------------------
*/
static herr_t
-H5F_contig_write(H5F_t *f, hsize_t max_data, haddr_t addr,
- const size_t size, hid_t dxpl_id, const void *buf)
+H5D_contig_write(H5F_t *f, hid_t dxpl_id, H5D_t *dset,
+ hsize_t offset, size_t size, const void *buf)
{
- hsize_t dset_off=0; /* Offset in dataset */
- hsize_t mem_off=0; /* Offset in memory */
+ hsize_t dset_off=offset; /* Offset in dataset */
size_t dset_len=size; /* Length in dataset */
+ size_t dset_curr_seq=0; /* "Current sequence" in dataset */
+ hsize_t mem_off=0; /* Offset in memory */
size_t mem_len=size; /* Length in memory */
size_t mem_curr_seq=0; /* "Current sequence" in memory */
- size_t dset_curr_seq=0; /* "Current sequence" in dataset */
herr_t ret_value=SUCCEED; /* Return value */
- FUNC_ENTER_NOAPI(H5F_contig_write, FAIL);
+ FUNC_ENTER_NOAPI(H5D_contig_write, FAIL);
assert (f);
+ assert (dset);
assert (buf);
- if (H5F_contig_writevv(f, max_data, addr, 1, &dset_curr_seq, &dset_len, &dset_off, 1, &mem_curr_seq, &mem_len, &mem_off, dxpl_id, buf)<0)
+ if (H5D_contig_writevv(f, dxpl_id, dset, dset->layout.u.contig.addr, dset->layout.u.contig.size,
+ 1, &dset_curr_seq, &dset_len, &dset_off, 1, &mem_curr_seq, &mem_len, &mem_off, buf)<0)
HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "vector write failed");
done:
FUNC_LEAVE_NOAPI(ret_value);
-} /* end H5F_contig_write() */
+} /* end H5D_contig_write() */
/*-------------------------------------------------------------------------
- * Function: H5F_contig_readvv
+ * Function: H5D_contig_readvv
*
* Purpose: Reads some data vectors from a dataset into a buffer.
* The data is contiguous. The address is the start of the dataset,
@@ -397,10 +404,11 @@ done:
*-------------------------------------------------------------------------
*/
ssize_t
-H5F_contig_readvv(H5F_t *f, hsize_t _max_data, haddr_t _addr,
+H5D_contig_readvv(H5F_t *f, hid_t dxpl_id, H5D_t *dset,
+ haddr_t dset_addr, hsize_t dset_size,
size_t dset_max_nseq, size_t *dset_curr_seq, size_t dset_len_arr[], hsize_t dset_offset_arr[],
size_t mem_max_nseq, size_t *mem_curr_seq, size_t mem_len_arr[], hsize_t mem_offset_arr[],
- hid_t dxpl_id, void *_buf)
+ void *_buf)
{
unsigned char *buf=(unsigned char *)_buf; /* Pointer to buffer to fill */
haddr_t abs_eoa; /* Absolute end of file address */
@@ -412,14 +420,15 @@ H5F_contig_readvv(H5F_t *f, hsize_t _max_data, haddr_t _addr,
size_t v; /* Counting variable */
ssize_t ret_value=0; /* Return value */
- FUNC_ENTER_NOAPI(H5F_contig_readvv, FAIL);
+ FUNC_ENTER_NOAPI(H5D_contig_readvv, FAIL);
/* Check args */
assert(f);
+ assert(dset);
assert(buf);
/* Check if data sieving is enabled */
- if(f->shared->lf->feature_flags&H5FD_FEAT_DATA_SIEVE) {
+ if(H5F_HAS_FEATURE(f,H5FD_FEAT_DATA_SIEVE)) {
haddr_t sieve_start, sieve_end; /* Start & end locations of sieve buffer */
haddr_t contig_end; /* End locations of block to write */
size_t sieve_size; /* size of sieve buffer */
@@ -429,7 +438,7 @@ H5F_contig_readvv(H5F_t *f, hsize_t _max_data, haddr_t _addr,
v=*mem_curr_seq;
/* No data sieve buffer yet, go allocate one */
- if(f->shared->sieve_buf==NULL) {
+ if(dset->cache.contig.sieve_buf==NULL) {
/* Choose smallest buffer to write */
if(mem_len_arr[v]<dset_len_arr[u])
size=mem_len_arr[v];
@@ -437,46 +446,46 @@ H5F_contig_readvv(H5F_t *f, hsize_t _max_data, haddr_t _addr,
size=dset_len_arr[u];
/* Compute offset on disk */
- addr=_addr+dset_offset_arr[u];
+ addr=dset_addr+dset_offset_arr[u];
/* Compute offset in memory */
buf = (unsigned char *)_buf + mem_offset_arr[v];
/* Set up the buffer parameters */
- max_data=_max_data-dset_offset_arr[u];
+ max_data=dset_size-dset_offset_arr[u];
/* Check if we can actually hold the I/O request in the sieve buffer */
- if(size>f->shared->sieve_buf_size) {
+ if(size>dset->cache.contig.sieve_buf_size) {
if (H5F_block_read(f, H5FD_MEM_DRAW, addr, size, dxpl_id, buf)<0)
HGOTO_ERROR(H5E_IO, H5E_READERROR, FAIL, "block read failed");
} /* end if */
else {
/* Allocate room for the data sieve buffer */
- if (NULL==(f->shared->sieve_buf=H5FL_BLK_MALLOC(sieve_buf,f->shared->sieve_buf_size)))
+ if (NULL==(dset->cache.contig.sieve_buf=H5FL_BLK_MALLOC(sieve_buf,dset->cache.contig.sieve_buf_size)))
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed");
/* Determine the new sieve buffer size & location */
- f->shared->sieve_loc=addr;
+ dset->cache.contig.sieve_loc=addr;
/* Make certain we don't read off the end of the file */
- if (HADDR_UNDEF==(abs_eoa=H5FD_get_eoa(f->shared->lf)))
+ if (HADDR_UNDEF==(abs_eoa=H5F_get_eoa(f)))
HGOTO_ERROR(H5E_FILE, H5E_CANTOPENFILE, FAIL, "unable to determine file size");
/* Adjust absolute EOA address to relative EOA address */
- rel_eoa=abs_eoa-f->shared->base_addr;
+ rel_eoa=abs_eoa-H5F_get_base_addr(f);
/* Compute the size of the sieve buffer */
- H5_ASSIGN_OVERFLOW(f->shared->sieve_size,MIN(rel_eoa-f->shared->sieve_loc,MIN(max_data,f->shared->sieve_buf_size)),hsize_t,size_t);
+ H5_ASSIGN_OVERFLOW(dset->cache.contig.sieve_size,MIN3(rel_eoa-dset->cache.contig.sieve_loc,max_data,dset->cache.contig.sieve_buf_size),hsize_t,size_t);
/* Read the new sieve buffer */
- if (H5F_block_read(f, H5FD_MEM_DRAW, f->shared->sieve_loc, f->shared->sieve_size, dxpl_id, f->shared->sieve_buf)<0)
+ if (H5F_block_read(f, H5FD_MEM_DRAW, dset->cache.contig.sieve_loc, dset->cache.contig.sieve_size, dxpl_id, dset->cache.contig.sieve_buf)<0)
HGOTO_ERROR(H5E_IO, H5E_READERROR, FAIL, "block read failed");
/* Grab the data out of the buffer (must be first piece of data in buffer ) */
- HDmemcpy(buf,f->shared->sieve_buf,size);
+ HDmemcpy(buf,dset->cache.contig.sieve_buf,size);
/* Reset sieve buffer dirty flag */
- f->shared->sieve_dirty=0;
+ dset->cache.contig.sieve_dirty=0;
} /* end else */
/* Update memory information */
@@ -496,8 +505,8 @@ H5F_contig_readvv(H5F_t *f, hsize_t _max_data, haddr_t _addr,
} /* end if */
/* Stash local copies of these value */
- sieve_start=f->shared->sieve_loc;
- sieve_size=f->shared->sieve_size;
+ sieve_start=dset->cache.contig.sieve_loc;
+ sieve_size=dset->cache.contig.sieve_size;
sieve_end=sieve_start+sieve_size;
/* Works through sequences as fast as possible */
@@ -509,7 +518,7 @@ H5F_contig_readvv(H5F_t *f, hsize_t _max_data, haddr_t _addr,
size=dset_len_arr[u];
/* Compute offset on disk */
- addr=_addr+dset_offset_arr[u];
+ addr=dset_addr+dset_offset_arr[u];
/* Compute offset in memory */
buf = (unsigned char *)_buf + mem_offset_arr[v];
@@ -519,7 +528,7 @@ H5F_contig_readvv(H5F_t *f, hsize_t _max_data, haddr_t _addr,
/* If entire read is within the sieve buffer, read it from the buffer */
if(addr>=sieve_start && contig_end<sieve_end) {
- unsigned char *base_sieve_buf=f->shared->sieve_buf+(addr-sieve_start);
+ unsigned char *base_sieve_buf=dset->cache.contig.sieve_buf+(addr-sieve_start);
/* Grab the data out of the buffer */
HDmemcpy(buf,base_sieve_buf,size);
@@ -527,18 +536,18 @@ H5F_contig_readvv(H5F_t *f, hsize_t _max_data, haddr_t _addr,
/* Entire request is not within this data sieve buffer */
else {
/* Check if we can actually hold the I/O request in the sieve buffer */
- if(size>f->shared->sieve_buf_size) {
+ if(size>dset->cache.contig.sieve_buf_size) {
/* Check for any overlap with the current sieve buffer */
if((sieve_start>=addr && sieve_start<(contig_end+1))
|| ((sieve_end-1)>=addr && (sieve_end-1)<(contig_end+1))) {
/* Flush the sieve buffer, if it's dirty */
- if(f->shared->sieve_dirty) {
+ if(dset->cache.contig.sieve_dirty) {
/* Write to file */
- if (H5F_block_write(f, H5FD_MEM_DRAW, sieve_start, sieve_size, dxpl_id, f->shared->sieve_buf)<0)
+ if (H5F_block_write(f, H5FD_MEM_DRAW, sieve_start, sieve_size, dxpl_id, dset->cache.contig.sieve_buf)<0)
HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "block write failed");
/* Reset sieve buffer dirty flag */
- f->shared->sieve_dirty=0;
+ dset->cache.contig.sieve_dirty=0;
} /* end if */
} /* end if */
@@ -549,46 +558,46 @@ H5F_contig_readvv(H5F_t *f, hsize_t _max_data, haddr_t _addr,
/* Element size fits within the buffer size */
else {
/* Flush the sieve buffer if it's dirty */
- if(f->shared->sieve_dirty) {
+ if(dset->cache.contig.sieve_dirty) {
/* Write to file */
- if (H5F_block_write(f, H5FD_MEM_DRAW, sieve_start, sieve_size, dxpl_id, f->shared->sieve_buf)<0)
+ if (H5F_block_write(f, H5FD_MEM_DRAW, sieve_start, sieve_size, dxpl_id, dset->cache.contig.sieve_buf)<0)
HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "block write failed");
/* Reset sieve buffer dirty flag */
- f->shared->sieve_dirty=0;
+ dset->cache.contig.sieve_dirty=0;
} /* end if */
/* Determine the new sieve buffer size & location */
- f->shared->sieve_loc=addr;
+ dset->cache.contig.sieve_loc=addr;
/* Make certain we don't read off the end of the file */
- if (HADDR_UNDEF==(abs_eoa=H5FD_get_eoa(f->shared->lf)))
+ if (HADDR_UNDEF==(abs_eoa=H5F_get_eoa(f)))
HGOTO_ERROR(H5E_FILE, H5E_CANTOPENFILE, FAIL, "unable to determine file size");
/* Adjust absolute EOA address to relative EOA address */
- rel_eoa=abs_eoa-f->shared->base_addr;
+ rel_eoa=abs_eoa-H5F_get_base_addr(f);
/* Only need this when resizing sieve buffer */
- max_data=_max_data-dset_offset_arr[u];
+ max_data=dset_size-dset_offset_arr[u];
/* Compute the size of the sieve buffer */
/* Don't read off the end of the file, don't read past the end of the data element and don't read more than the buffer size */
- H5_ASSIGN_OVERFLOW(f->shared->sieve_size,MIN(rel_eoa-f->shared->sieve_loc,MIN(max_data,f->shared->sieve_buf_size)),hsize_t,size_t);
+ H5_ASSIGN_OVERFLOW(dset->cache.contig.sieve_size,MIN3(rel_eoa-dset->cache.contig.sieve_loc,max_data,dset->cache.contig.sieve_buf_size),hsize_t,size_t);
/* Update local copies of sieve information */
- sieve_start=f->shared->sieve_loc;
- sieve_size=f->shared->sieve_size;
+ sieve_start=dset->cache.contig.sieve_loc;
+ sieve_size=dset->cache.contig.sieve_size;
sieve_end=sieve_start+sieve_size;
/* Read the new sieve buffer */
- if (H5F_block_read(f, H5FD_MEM_DRAW, f->shared->sieve_loc, f->shared->sieve_size, dxpl_id, f->shared->sieve_buf)<0)
+ if (H5F_block_read(f, H5FD_MEM_DRAW, dset->cache.contig.sieve_loc, dset->cache.contig.sieve_size, dxpl_id, dset->cache.contig.sieve_buf)<0)
HGOTO_ERROR(H5E_IO, H5E_READERROR, FAIL, "block read failed");
/* Grab the data out of the buffer (must be first piece of data in buffer ) */
- HDmemcpy(buf,f->shared->sieve_buf,size);
+ HDmemcpy(buf,dset->cache.contig.sieve_buf,size);
/* Reset sieve buffer dirty flag */
- f->shared->sieve_dirty=0;
+ dset->cache.contig.sieve_dirty=0;
} /* end else */
} /* end else */
@@ -618,7 +627,7 @@ H5F_contig_readvv(H5F_t *f, hsize_t _max_data, haddr_t _addr,
size=dset_len_arr[u];
/* Compute offset on disk */
- addr=_addr+dset_offset_arr[u];
+ addr=dset_addr+dset_offset_arr[u];
/* Compute offset in memory */
buf = (unsigned char *)_buf + mem_offset_arr[v];
@@ -650,11 +659,11 @@ H5F_contig_readvv(H5F_t *f, hsize_t _max_data, haddr_t _addr,
done:
FUNC_LEAVE_NOAPI(ret_value);
-} /* end H5F_contig_readvv() */
+} /* end H5D_contig_readvv() */
/*-------------------------------------------------------------------------
- * Function: H5F_contig_writevv
+ * Function: H5D_contig_writevv
*
* Purpose: Writes some data vectors into a dataset from vectors into a
* buffer. The address is the start of the dataset,
@@ -674,10 +683,11 @@ done:
*-------------------------------------------------------------------------
*/
ssize_t
-H5F_contig_writevv(H5F_t *f, hsize_t _max_data, haddr_t _addr,
+H5D_contig_writevv(H5F_t *f, hid_t dxpl_id, H5D_t *dset,
+ haddr_t dset_addr, hsize_t dset_size,
size_t dset_max_nseq, size_t *dset_curr_seq, size_t dset_len_arr[], hsize_t dset_offset_arr[],
size_t mem_max_nseq, size_t *mem_curr_seq, size_t mem_len_arr[], hsize_t mem_offset_arr[],
- hid_t dxpl_id, const void *_buf)
+ const void *_buf)
{
const unsigned char *buf=_buf; /* Pointer to buffer to fill */
haddr_t abs_eoa; /* Absolute end of file address */
@@ -689,14 +699,15 @@ H5F_contig_writevv(H5F_t *f, hsize_t _max_data, haddr_t _addr,
size_t v; /* Counting variable */
ssize_t ret_value=0; /* Return value */
- FUNC_ENTER_NOAPI(H5F_contig_writevv, FAIL);
+ FUNC_ENTER_NOAPI(H5D_contig_writevv, FAIL);
/* Check args */
assert(f);
+ assert(dset);
assert(buf);
/* Check if data sieving is enabled */
- if(f->shared->lf->feature_flags&H5FD_FEAT_DATA_SIEVE) {
+ if(H5F_HAS_FEATURE(f,H5FD_FEAT_DATA_SIEVE)) {
haddr_t sieve_start, sieve_end; /* Start & end locations of sieve buffer */
haddr_t contig_end; /* End locations of block to write */
size_t sieve_size; /* size of sieve buffer */
@@ -706,7 +717,7 @@ H5F_contig_writevv(H5F_t *f, hsize_t _max_data, haddr_t _addr,
v=*mem_curr_seq;
/* No data sieve buffer yet, go allocate one */
- if(f->shared->sieve_buf==NULL) {
+ if(dset->cache.contig.sieve_buf==NULL) {
/* Choose smallest buffer to write */
if(mem_len_arr[v]<dset_len_arr[u])
size=mem_len_arr[v];
@@ -714,49 +725,49 @@ H5F_contig_writevv(H5F_t *f, hsize_t _max_data, haddr_t _addr,
size=dset_len_arr[u];
/* Compute offset on disk */
- addr=_addr+dset_offset_arr[u];
+ addr=dset_addr+dset_offset_arr[u];
/* Compute offset in memory */
buf = (const unsigned char *)_buf + mem_offset_arr[v];
/* Set up the buffer parameters */
- max_data=_max_data-dset_offset_arr[u];
+ max_data=dset_size-dset_offset_arr[u];
/* Check if we can actually hold the I/O request in the sieve buffer */
- if(size>f->shared->sieve_buf_size) {
+ if(size>dset->cache.contig.sieve_buf_size) {
if (H5F_block_write(f, H5FD_MEM_DRAW, addr, size, dxpl_id, buf)<0)
HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "block write failed");
} /* end if */
else {
/* Allocate room for the data sieve buffer */
- if (NULL==(f->shared->sieve_buf=H5FL_BLK_MALLOC(sieve_buf,f->shared->sieve_buf_size)))
+ if (NULL==(dset->cache.contig.sieve_buf=H5FL_BLK_MALLOC(sieve_buf,dset->cache.contig.sieve_buf_size)))
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed");
/* Determine the new sieve buffer size & location */
- f->shared->sieve_loc=addr;
+ dset->cache.contig.sieve_loc=addr;
/* Make certain we don't read off the end of the file */
- if (HADDR_UNDEF==(abs_eoa=H5FD_get_eoa(f->shared->lf)))
+ if (HADDR_UNDEF==(abs_eoa=H5F_get_eoa(f)))
HGOTO_ERROR(H5E_FILE, H5E_CANTOPENFILE, FAIL, "unable to determine file size");
/* Adjust absolute EOA address to relative EOA address */
- rel_eoa=abs_eoa-f->shared->base_addr;
+ rel_eoa=abs_eoa-H5F_get_base_addr(f);
/* Compute the size of the sieve buffer */
- H5_ASSIGN_OVERFLOW(f->shared->sieve_size,MIN(rel_eoa-f->shared->sieve_loc,MIN(max_data,f->shared->sieve_buf_size)),hsize_t,size_t);
+ H5_ASSIGN_OVERFLOW(dset->cache.contig.sieve_size,MIN3(rel_eoa-dset->cache.contig.sieve_loc,max_data,dset->cache.contig.sieve_buf_size),hsize_t,size_t);
/* Check if there is any point in reading the data from the file */
- if(f->shared->sieve_size>size) {
+ if(dset->cache.contig.sieve_size>size) {
/* Read the new sieve buffer */
- if (H5F_block_read(f, H5FD_MEM_DRAW, f->shared->sieve_loc, f->shared->sieve_size, dxpl_id, f->shared->sieve_buf)<0)
+ if (H5F_block_read(f, H5FD_MEM_DRAW, dset->cache.contig.sieve_loc, dset->cache.contig.sieve_size, dxpl_id, dset->cache.contig.sieve_buf)<0)
HGOTO_ERROR(H5E_IO, H5E_READERROR, FAIL, "block read failed");
} /* end if */
/* Grab the data out of the buffer (must be first piece of data in buffer ) */
- HDmemcpy(f->shared->sieve_buf,buf,size);
+ HDmemcpy(dset->cache.contig.sieve_buf,buf,size);
/* Set sieve buffer dirty flag */
- f->shared->sieve_dirty=1;
+ dset->cache.contig.sieve_dirty=1;
} /* end else */
/* Update memory information */
@@ -776,8 +787,8 @@ H5F_contig_writevv(H5F_t *f, hsize_t _max_data, haddr_t _addr,
} /* end if */
/* Stash local copies of these value */
- sieve_start=f->shared->sieve_loc;
- sieve_size=f->shared->sieve_size;
+ sieve_start=dset->cache.contig.sieve_loc;
+ sieve_size=dset->cache.contig.sieve_size;
sieve_end=sieve_start+sieve_size;
/* Works through sequences as fast as possible */
@@ -789,7 +800,7 @@ H5F_contig_writevv(H5F_t *f, hsize_t _max_data, haddr_t _addr,
size=dset_len_arr[u];
/* Compute offset on disk */
- addr=_addr+dset_offset_arr[u];
+ addr=dset_addr+dset_offset_arr[u];
/* Compute offset in memory */
buf = (const unsigned char *)_buf + mem_offset_arr[v];
@@ -799,35 +810,35 @@ H5F_contig_writevv(H5F_t *f, hsize_t _max_data, haddr_t _addr,
/* If entire write is within the sieve buffer, write it to the buffer */
if(addr>=sieve_start && contig_end<sieve_end) {
- unsigned char *base_sieve_buf=f->shared->sieve_buf+(addr-sieve_start);
+ unsigned char *base_sieve_buf=dset->cache.contig.sieve_buf+(addr-sieve_start);
/* Put the data into the sieve buffer */
HDmemcpy(base_sieve_buf,buf,size);
/* Set sieve buffer dirty flag */
- f->shared->sieve_dirty=1;
+ dset->cache.contig.sieve_dirty=1;
} /* end if */
/* Entire request is not within this data sieve buffer */
else {
/* Check if we can actually hold the I/O request in the sieve buffer */
- if(size>f->shared->sieve_buf_size) {
+ if(size>dset->cache.contig.sieve_buf_size) {
/* Check for any overlap with the current sieve buffer */
if((sieve_start>=addr && sieve_start<(contig_end+1))
|| ((sieve_end-1)>=addr && (sieve_end-1)<(contig_end+1))) {
/* Flush the sieve buffer, if it's dirty */
- if(f->shared->sieve_dirty) {
+ if(dset->cache.contig.sieve_dirty) {
/* Write to file */
- if (H5F_block_write(f, H5FD_MEM_DRAW, sieve_start, sieve_size, dxpl_id, f->shared->sieve_buf)<0)
+ if (H5F_block_write(f, H5FD_MEM_DRAW, sieve_start, sieve_size, dxpl_id, dset->cache.contig.sieve_buf)<0)
HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "block write failed");
/* Reset sieve buffer dirty flag */
- f->shared->sieve_dirty=0;
+ dset->cache.contig.sieve_dirty=0;
} /* end if */
/* Force the sieve buffer to be re-read the next time */
- f->shared->sieve_loc=HADDR_UNDEF;
- f->shared->sieve_size=0;
+ dset->cache.contig.sieve_loc=HADDR_UNDEF;
+ dset->cache.contig.sieve_size=0;
} /* end if */
/* Write directly from the user's buffer */
@@ -838,81 +849,81 @@ H5F_contig_writevv(H5F_t *f, hsize_t _max_data, haddr_t _addr,
else {
/* Check if it is possible to (exactly) prepend or append to existing (dirty) sieve buffer */
if(((addr+size)==sieve_start || addr==sieve_end) &&
- (size+sieve_size)<=f->shared->sieve_buf_size &&
- f->shared->sieve_dirty) {
+ (size+sieve_size)<=dset->cache.contig.sieve_buf_size &&
+ dset->cache.contig.sieve_dirty) {
/* Prepend to existing sieve buffer */
if((addr+size)==sieve_start) {
/* Move existing sieve information to correct location */
- HDmemmove(f->shared->sieve_buf+size,f->shared->sieve_buf,sieve_size);
+ HDmemmove(dset->cache.contig.sieve_buf+size,dset->cache.contig.sieve_buf,sieve_size);
/* Copy in new information (must be first in sieve buffer) */
- HDmemcpy(f->shared->sieve_buf,buf,size);
+ HDmemcpy(dset->cache.contig.sieve_buf,buf,size);
/* Adjust sieve location */
- f->shared->sieve_loc=addr;
+ dset->cache.contig.sieve_loc=addr;
} /* end if */
/* Append to existing sieve buffer */
else {
/* Copy in new information */
- HDmemcpy(f->shared->sieve_buf+sieve_size,buf,size);
+ HDmemcpy(dset->cache.contig.sieve_buf+sieve_size,buf,size);
} /* end else */
/* Adjust sieve size */
- f->shared->sieve_size += size;
+ dset->cache.contig.sieve_size += size;
/* Update local copies of sieve information */
- sieve_start=f->shared->sieve_loc;
- sieve_size=f->shared->sieve_size;
+ sieve_start=dset->cache.contig.sieve_loc;
+ sieve_size=dset->cache.contig.sieve_size;
sieve_end=sieve_start+sieve_size;
} /* end if */
/* Can't add the new data onto the existing sieve buffer */
else {
/* Flush the sieve buffer if it's dirty */
- if(f->shared->sieve_dirty) {
+ if(dset->cache.contig.sieve_dirty) {
/* Write to file */
- if (H5F_block_write(f, H5FD_MEM_DRAW, sieve_start, sieve_size, dxpl_id, f->shared->sieve_buf)<0)
+ if (H5F_block_write(f, H5FD_MEM_DRAW, sieve_start, sieve_size, dxpl_id, dset->cache.contig.sieve_buf)<0)
HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "block write failed");
/* Reset sieve buffer dirty flag */
- f->shared->sieve_dirty=0;
+ dset->cache.contig.sieve_dirty=0;
} /* end if */
/* Determine the new sieve buffer size & location */
- f->shared->sieve_loc=addr;
+ dset->cache.contig.sieve_loc=addr;
/* Make certain we don't read off the end of the file */
- if (HADDR_UNDEF==(abs_eoa=H5FD_get_eoa(f->shared->lf)))
+ if (HADDR_UNDEF==(abs_eoa=H5F_get_eoa(f)))
HGOTO_ERROR(H5E_FILE, H5E_CANTOPENFILE, FAIL, "unable to determine file size");
/* Adjust absolute EOA address to relative EOA address */
- rel_eoa=abs_eoa-f->shared->base_addr;
+ rel_eoa=abs_eoa-H5F_get_base_addr(f);
/* Only need this when resizing sieve buffer */
- max_data=_max_data-dset_offset_arr[u];
+ max_data=dset_size-dset_offset_arr[u];
/* Compute the size of the sieve buffer */
/* Don't read off the end of the file, don't read past the end of the data element and don't read more than the buffer size */
- H5_ASSIGN_OVERFLOW(f->shared->sieve_size,MIN(rel_eoa-f->shared->sieve_loc,MIN(max_data,f->shared->sieve_buf_size)),hsize_t,size_t);
+ H5_ASSIGN_OVERFLOW(dset->cache.contig.sieve_size,MIN3(rel_eoa-dset->cache.contig.sieve_loc,max_data,dset->cache.contig.sieve_buf_size),hsize_t,size_t);
/* Update local copies of sieve information */
- sieve_start=f->shared->sieve_loc;
- sieve_size=f->shared->sieve_size;
+ sieve_start=dset->cache.contig.sieve_loc;
+ sieve_size=dset->cache.contig.sieve_size;
sieve_end=sieve_start+sieve_size;
/* Check if there is any point in reading the data from the file */
- if(f->shared->sieve_size>size) {
+ if(dset->cache.contig.sieve_size>size) {
/* Read the new sieve buffer */
- if (H5F_block_read(f, H5FD_MEM_DRAW, f->shared->sieve_loc, f->shared->sieve_size, dxpl_id, f->shared->sieve_buf)<0)
+ if (H5F_block_read(f, H5FD_MEM_DRAW, dset->cache.contig.sieve_loc, dset->cache.contig.sieve_size, dxpl_id, dset->cache.contig.sieve_buf)<0)
HGOTO_ERROR(H5E_IO, H5E_READERROR, FAIL, "block read failed");
} /* end if */
/* Grab the data out of the buffer (must be first piece of data in buffer ) */
- HDmemcpy(f->shared->sieve_buf,buf,size);
+ HDmemcpy(dset->cache.contig.sieve_buf,buf,size);
/* Set sieve buffer dirty flag */
- f->shared->sieve_dirty=1;
+ dset->cache.contig.sieve_dirty=1;
} /* end else */
} /* end else */
@@ -944,7 +955,7 @@ H5F_contig_writevv(H5F_t *f, hsize_t _max_data, haddr_t _addr,
size=dset_len_arr[u];
/* Compute offset on disk */
- addr=_addr+dset_offset_arr[u];
+ addr=dset_addr+dset_offset_arr[u];
/* Compute offset in memory */
buf = (const unsigned char *)_buf + mem_offset_arr[v];
@@ -976,5 +987,5 @@ H5F_contig_writevv(H5F_t *f, hsize_t _max_data, haddr_t _addr,
done:
FUNC_LEAVE_NOAPI(ret_value);
-} /* end H5F_contig_writevv() */
+} /* end H5D_contig_writevv() */
diff --git a/src/H5Dio.c b/src/H5Dio.c
index 7347d8f..b74483f 100644
--- a/src/H5Dio.c
+++ b/src/H5Dio.c
@@ -1082,9 +1082,11 @@ H5D_contig_read(hsize_t nelmts, H5D_t *dataset, const H5T_t *mem_type,
|| dataset->efl.nused>0 ||
dataset->layout.type==H5D_COMPACT);
H5_CHECK_OVERFLOW(nelmts,hsize_t,size_t);
- status = (sconv->read)(dataset->ent.file, &(dataset->layout),
- &dataset->dcpl_cache, (H5D_storage_t *)&(dataset->efl), (size_t)nelmts, H5T_get_size(dataset->type),
- file_space, mem_space, dxpl_cache, dxpl_id, buf/*out*/);
+ status = (sconv->read)(dataset->ent.file, dxpl_cache, dxpl_id,
+ dataset, (H5D_storage_t *)&(dataset->efl),
+ (size_t)nelmts, H5T_get_size(dataset->type),
+ file_space, mem_space,
+ buf/*out*/);
#ifdef H5S_DEBUG
H5_timer_end(&(sconv->stats[1].read_timer), &timer);
sconv->stats[1].read_nbytes += nelmts * H5T_get_size(dataset->type);
@@ -1179,9 +1181,10 @@ H5D_contig_read(hsize_t nelmts, H5D_t *dataset, const H5T_t *mem_type,
|| (dataset->layout.type==H5D_CHUNKED && H5F_addr_defined(dataset->layout.u.chunk.addr)))
|| dataset->efl.nused>0 ||
dataset->layout.type==H5D_COMPACT);
- n = H5S_select_fgath(dataset->ent.file, &(dataset->layout),
- &dataset->dcpl_cache, (H5D_storage_t *)&(dataset->efl), file_space,
- &file_iter, smine_nelmts, dxpl_cache, dxpl_id, tconv_buf/*out*/);
+ n = H5S_select_fgath(dataset->ent.file, dxpl_cache, dxpl_id,
+ dataset, (H5D_storage_t *)&(dataset->efl),
+ file_space, &file_iter, smine_nelmts,
+ tconv_buf/*out*/);
#ifdef H5S_DEBUG
H5_timer_end(&(sconv->stats[1].gath_timer), &timer);
@@ -1309,9 +1312,11 @@ H5D_contig_write(hsize_t nelmts, H5D_t *dataset, const H5T_t *mem_type, const H5
H5_timer_begin(&timer);
#endif
H5_CHECK_OVERFLOW(nelmts,hsize_t,size_t);
- status = (sconv->write)(dataset->ent.file, &(dataset->layout),
- &dataset->dcpl_cache, (H5D_storage_t *)&(dataset->efl), (size_t)nelmts, H5T_get_size(dataset->type),
- file_space, mem_space, dxpl_cache, dxpl_id, buf);
+ status = (sconv->write)(dataset->ent.file, dxpl_cache, dxpl_id,
+ dataset, (H5D_storage_t *)&(dataset->efl),
+ (size_t)nelmts, H5T_get_size(dataset->type),
+ file_space, mem_space,
+ buf);
#ifdef H5S_DEBUG
H5_timer_end(&(sconv->stats[0].write_timer), &timer);
sconv->stats[0].write_nbytes += nelmts * H5T_get_size(mem_type);
@@ -1419,9 +1424,10 @@ H5D_contig_write(hsize_t nelmts, H5D_t *dataset, const H5T_t *mem_type, const H5
#ifdef H5S_DEBUG
H5_timer_begin(&timer);
#endif
- n = H5S_select_fgath(dataset->ent.file, &(dataset->layout),
- &dataset->dcpl_cache, (H5D_storage_t *)&(dataset->efl), file_space,
- &bkg_iter, smine_nelmts, dxpl_cache, dxpl_id, bkg_buf/*out*/);
+ n = H5S_select_fgath(dataset->ent.file, dxpl_cache, dxpl_id,
+ dataset, (H5D_storage_t *)&(dataset->efl),
+ file_space, &bkg_iter, smine_nelmts,
+ bkg_buf/*out*/);
#ifdef H5S_DEBUG
H5_timer_end(&(sconv->stats[0].bkg_timer), &timer);
@@ -1444,9 +1450,10 @@ H5D_contig_write(hsize_t nelmts, H5D_t *dataset, const H5T_t *mem_type, const H5
#ifdef H5S_DEBUG
H5_timer_begin(&timer);
#endif
- status = H5S_select_fscat(dataset->ent.file, &(dataset->layout),
- &dataset->dcpl_cache, (H5D_storage_t *)&(dataset->efl), file_space, &file_iter,
- smine_nelmts, dxpl_cache, dxpl_id, tconv_buf);
+ status = H5S_select_fscat(dataset->ent.file, dxpl_cache, dxpl_id,
+ dataset, (H5D_storage_t *)&(dataset->efl),
+ file_space, &file_iter, smine_nelmts,
+ tconv_buf);
#ifdef H5S_DEBUG
H5_timer_end(&(sconv->stats[0].scat_timer), &timer);
sconv->stats[0].scat_nbytes += smine_nelmts * dst_type_size;
@@ -1565,9 +1572,11 @@ UNUSED
store.chunk.index = chunk_info->index;
/* Perform the actual read operation */
- status = (sconv->read)(dataset->ent.file, &(dataset->layout),
- &dataset->dcpl_cache, &store, chunk_info->chunk_points, H5T_get_size(dataset->type),
- chunk_info->fspace, chunk_info->mspace, dxpl_cache, dxpl_id, buf);
+ status = (sconv->read)(dataset->ent.file, dxpl_cache, dxpl_id,
+ dataset, &store,
+ chunk_info->chunk_points, H5T_get_size(dataset->type),
+ chunk_info->fspace, chunk_info->mspace,
+ buf);
/* Check return value from optimized read */
if (status<0)
@@ -1681,9 +1690,10 @@ UNUSED
assert(((dataset->layout.type==H5D_CONTIGUOUS && H5F_addr_defined(dataset->layout.u.contig.addr))
|| (dataset->layout.type==H5D_CHUNKED && H5F_addr_defined(dataset->layout.u.chunk.addr)))
|| dataset->efl.nused>0 || dataset->layout.type==H5D_COMPACT);
- n = H5S_select_fgath(dataset->ent.file, &(dataset->layout),
- &dataset->dcpl_cache, &store, chunk_info->fspace,
- &file_iter, smine_nelmts, dxpl_cache, dxpl_id, tconv_buf/*out*/);
+ n = H5S_select_fgath(dataset->ent.file, dxpl_cache, dxpl_id,
+ dataset, &store,
+ chunk_info->fspace, &file_iter, smine_nelmts,
+ tconv_buf/*out*/);
#ifdef H5S_DEBUG
H5_timer_end(&(sconv->stats[1].gath_timer), &timer);
@@ -1888,9 +1898,11 @@ nelmts, H5D_t *dataset, const H5T_t *mem_type, const H5S_t *mem_space,
store.chunk.index = chunk_info->index;
/* Perform the actual write operation */
- status = (sconv->write)(dataset->ent.file, &(dataset->layout),
- &dataset->dcpl_cache, &store, chunk_info->chunk_points, H5T_get_size(dataset->type),
- chunk_info->fspace, chunk_info->mspace, dxpl_cache, dxpl_id, buf);
+ status = (sconv->write)(dataset->ent.file, dxpl_cache, dxpl_id,
+ dataset, &store,
+ chunk_info->chunk_points, H5T_get_size(dataset->type),
+ chunk_info->fspace, chunk_info->mspace,
+ buf);
/* Check return value from optimized write */
if (status<0)
@@ -2035,9 +2047,10 @@ nelmts, H5D_t *dataset, const H5T_t *mem_type, const H5S_t *mem_space,
#ifdef H5S_DEBUG
H5_timer_begin(&timer);
#endif
- n = H5S_select_fgath(dataset->ent.file, &(dataset->layout),
- &dataset->dcpl_cache, &store, chunk_info->fspace,
- &bkg_iter, smine_nelmts, dxpl_cache, dxpl_id, bkg_buf/*out*/);
+ n = H5S_select_fgath(dataset->ent.file, dxpl_cache, dxpl_id,
+ dataset, &store,
+ chunk_info->fspace, &bkg_iter, smine_nelmts,
+ bkg_buf/*out*/);
#ifdef H5S_DEBUG
H5_timer_end(&(sconv->stats[0].bkg_timer), &timer);
@@ -2061,9 +2074,10 @@ nelmts, H5D_t *dataset, const H5T_t *mem_type, const H5S_t *mem_space,
#ifdef H5S_DEBUG
H5_timer_begin(&timer);
#endif
- status = H5S_select_fscat(dataset->ent.file, &(dataset->layout),
- &dataset->dcpl_cache, &store, chunk_info->fspace,
- &file_iter, smine_nelmts, dxpl_cache, dxpl_id, tconv_buf);
+ status = H5S_select_fscat(dataset->ent.file, dxpl_cache, dxpl_id,
+ dataset, &store,
+ chunk_info->fspace, &file_iter, smine_nelmts,
+ tconv_buf);
#ifdef H5S_DEBUG
H5_timer_end(&(sconv->stats[0].scat_timer), &timer);
diff --git a/src/H5Distore.c b/src/H5Distore.c
index bf4cc66..75433fd 100644
--- a/src/H5Distore.c
+++ b/src/H5Distore.c
@@ -41,17 +41,17 @@
*/
#define H5B_PACKAGE /*suppress error about including H5Bpkg */
-#define H5F_PACKAGE /*suppress error about including H5Fpkg */
+#define H5D_PACKAGE /*suppress error about including H5Dpkg */
/* Pablo information */
/* (Put before include files to avoid problems with inline functions) */
-#define PABLO_MASK H5Fistore_mask
+#define PABLO_MASK H5Distore_mask
#include "H5private.h" /* Generic Functions */
#include "H5Bpkg.h" /* B-link trees */
-#include "H5Dprivate.h" /* Datasets */
+#include "H5Dpkg.h" /* Datasets */
#include "H5Eprivate.h" /* Error handling */
-#include "H5Fpkg.h" /* Files */
+#include "H5Fprivate.h" /* Files */
#include "H5FLprivate.h" /* Free Lists */
#include "H5Iprivate.h" /* IDs */
#include "H5MFprivate.h" /* File space management */
@@ -90,7 +90,7 @@
* and the operating system can also eliminate a read operation.
*/
-/*#define H5F_ISTORE_DEBUG */
+/*#define H5D_ISTORE_DEBUG */
/* Interface initialization */
static int interface_initialize_g = 0;
@@ -100,14 +100,12 @@ static int interface_initialize_g = 0;
* Given a B-tree node return the dimensionality of the chunks pointed to by
* that node.
*/
-#define H5F_ISTORE_NDIMS(X) ((int)(((X)->sizeof_rkey-8)/8))
+#define H5D_ISTORE_NDIMS(X) ((int)(((X)->sizeof_rkey-8)/8))
/* Raw data chunks are cached. Each entry in the cache is: */
-typedef struct H5F_rdcc_ent_t {
+typedef struct H5D_rdcc_ent_t {
hbool_t locked; /*entry is locked in cache */
hbool_t dirty; /*needs to be written to disk? */
- H5O_layout_t layout; /*the layout message */
- H5O_pline_t pline; /*filter pipeline message */
hssize_t offset[H5O_LAYOUT_NDIMS]; /*chunk name */
size_t rd_count; /*bytes remaining to be read */
size_t wr_count; /*bytes remaining to be written */
@@ -115,10 +113,10 @@ typedef struct H5F_rdcc_ent_t {
size_t alloc_size; /*amount allocated for the chunk */
uint8_t *chunk; /*the unfiltered chunk data */
unsigned idx; /*index in hash table */
- struct H5F_rdcc_ent_t *next;/*next item in doubly-linked list */
- struct H5F_rdcc_ent_t *prev;/*previous item in doubly-linked list */
-} H5F_rdcc_ent_t;
-typedef H5F_rdcc_ent_t *H5F_rdcc_ent_ptr_t; /* For free lists */
+ struct H5D_rdcc_ent_t *next;/*next item in doubly-linked list */
+ struct H5D_rdcc_ent_t *prev;/*previous item in doubly-linked list */
+} H5D_rdcc_ent_t;
+typedef H5D_rdcc_ent_t *H5D_rdcc_ent_ptr_t; /* For free lists */
/*
* B-tree key. A key contains the minimum logical N-dimensional address and
@@ -134,97 +132,94 @@ typedef H5F_rdcc_ent_t *H5F_rdcc_ent_ptr_t; /* For free lists */
*
* The chunk's file address is part of the B-tree and not part of the key.
*/
-typedef struct H5F_istore_key_t {
+typedef struct H5D_istore_key_t {
size_t nbytes; /*size of stored data */
hssize_t offset[H5O_LAYOUT_NDIMS]; /*logical offset to start*/
unsigned filter_mask; /*excluded filters */
-} H5F_istore_key_t;
+} H5D_istore_key_t;
-typedef struct H5F_istore_ud1_t {
- H5F_istore_key_t key; /*key values */
+typedef struct H5D_istore_ud1_t {
+ H5D_istore_key_t key; /*key values */
haddr_t addr; /*file address of chunk */
H5O_layout_t mesg; /*layout message */
hsize_t total_storage; /*output from iterator */
FILE *stream; /*debug output stream */
hsize_t *dims; /*dataset dimensions */
-} H5F_istore_ud1_t;
+} H5D_istore_ud1_t;
-#define H5F_HASH_DIVISOR 1 /* Attempt to spread out the hashing */
- /* This should be the same size as the alignment of */
- /* of the smallest file format object written to the file. */
-#define H5F_HASH(F,ADDR) H5F_addr_hash((ADDR/H5F_HASH_DIVISOR),(F)->shared->rdcc.nslots)
+#define H5D_HASH(D,ADDR) H5F_addr_hash(ADDR,(D)->cache.chunk.nslots)
/* Private prototypes */
-static haddr_t H5F_istore_get_addr(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout,
- const hssize_t offset[], H5F_istore_ud1_t *_udata);
-static void *H5F_istore_chunk_alloc(size_t size, const H5O_pline_t *pline);
-static void *H5F_istore_chunk_xfree(void *chk, const H5O_pline_t *pline);
+static haddr_t H5D_istore_get_addr(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout,
+ const hssize_t offset[], H5D_istore_ud1_t *_udata);
+static void *H5D_istore_chunk_alloc(size_t size, const H5O_pline_t *pline);
+static void *H5D_istore_chunk_xfree(void *chk, const H5O_pline_t *pline);
/* B-tree iterator callbacks */
-static int H5F_istore_iter_allocated(H5F_t *f, hid_t dxpl_id, void *left_key, haddr_t addr,
+static int H5D_istore_iter_allocated(H5F_t *f, hid_t dxpl_id, void *left_key, haddr_t addr,
void *right_key, void *_udata);
-static int H5F_istore_iter_dump(H5F_t *f, hid_t dxpl_id, void *left_key, haddr_t addr,
+static int H5D_istore_iter_dump(H5F_t *f, hid_t dxpl_id, void *left_key, haddr_t addr,
void *right_key, void *_udata);
-static int H5F_istore_prune_extent(H5F_t *f, hid_t dxpl_id, void *_lt_key, haddr_t addr,
+static int H5D_istore_prune_extent(H5F_t *f, hid_t dxpl_id, void *_lt_key, haddr_t addr,
void *_rt_key, void *_udata);
/* B-tree callbacks */
-static size_t H5F_istore_sizeof_rkey(H5F_t *f, const void *_udata);
-static herr_t H5F_istore_new_node(H5F_t *f, hid_t dxpl_id, H5B_ins_t, void *_lt_key,
+static size_t H5D_istore_sizeof_rkey(H5F_t *f, const void *_udata);
+static herr_t H5D_istore_new_node(H5F_t *f, hid_t dxpl_id, H5B_ins_t, void *_lt_key,
void *_udata, void *_rt_key,
haddr_t *addr_p /*out*/);
-static int H5F_istore_cmp2(H5F_t *f, hid_t dxpl_id, void *_lt_key, void *_udata,
+static int H5D_istore_cmp2(H5F_t *f, hid_t dxpl_id, void *_lt_key, void *_udata,
void *_rt_key);
-static int H5F_istore_cmp3(H5F_t *f, hid_t dxpl_id, void *_lt_key, void *_udata,
+static int H5D_istore_cmp3(H5F_t *f, hid_t dxpl_id, void *_lt_key, void *_udata,
void *_rt_key);
-static herr_t H5F_istore_found(H5F_t *f, hid_t dxpl_id, haddr_t addr, const void *_lt_key,
+static herr_t H5D_istore_found(H5F_t *f, hid_t dxpl_id, haddr_t addr, const void *_lt_key,
void *_udata, const void *_rt_key);
-static H5B_ins_t H5F_istore_insert(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *_lt_key,
+static H5B_ins_t H5D_istore_insert(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *_lt_key,
hbool_t *lt_key_changed, void *_md_key,
void *_udata, void *_rt_key,
hbool_t *rt_key_changed,
haddr_t *new_node/*out*/);
-static H5B_ins_t H5F_istore_remove( H5F_t *f, hid_t dxpl_id, haddr_t addr, void *_lt_key,
+static H5B_ins_t H5D_istore_remove( H5F_t *f, hid_t dxpl_id, haddr_t addr, void *_lt_key,
hbool_t *lt_key_changed, void *_udata, void *_rt_key,
hbool_t *rt_key_changed);
-static herr_t H5F_istore_decode_key(H5F_t *f, H5B_t *bt, uint8_t *raw,
+static herr_t H5D_istore_decode_key(H5F_t *f, H5B_t *bt, uint8_t *raw,
void *_key);
-static herr_t H5F_istore_encode_key(H5F_t *f, H5B_t *bt, uint8_t *raw,
+static herr_t H5D_istore_encode_key(H5F_t *f, H5B_t *bt, uint8_t *raw,
void *_key);
-static herr_t H5F_istore_debug_key(FILE *stream, H5F_t *f, hid_t dxpl_id,
+static herr_t H5D_istore_debug_key(FILE *stream, H5F_t *f, hid_t dxpl_id,
int indent, int fwidth, const void *key,
const void *udata);
/* inherits B-tree like properties from H5B */
H5B_class_t H5B_ISTORE[1] = {{
H5B_ISTORE_ID, /*id */
- sizeof(H5F_istore_key_t), /*sizeof_nkey */
- H5F_istore_sizeof_rkey, /*get_sizeof_rkey */
- H5F_istore_new_node, /*new */
- H5F_istore_cmp2, /*cmp2 */
- H5F_istore_cmp3, /*cmp3 */
- H5F_istore_found, /*found */
- H5F_istore_insert, /*insert */
+ sizeof(H5D_istore_key_t), /*sizeof_nkey */
+ H5D_istore_sizeof_rkey, /*get_sizeof_rkey */
+ H5D_istore_new_node, /*new */
+ H5D_istore_cmp2, /*cmp2 */
+ H5D_istore_cmp3, /*cmp3 */
+ H5D_istore_found, /*found */
+ H5D_istore_insert, /*insert */
FALSE, /*follow min branch? */
FALSE, /*follow max branch? */
- H5F_istore_remove, /*remove */
- H5F_istore_decode_key, /*decode */
- H5F_istore_encode_key, /*encode */
- H5F_istore_debug_key, /*debug */
+ H5D_istore_remove, /*remove */
+ H5D_istore_decode_key, /*decode */
+ H5D_istore_encode_key, /*encode */
+ H5D_istore_debug_key, /*debug */
}};
/* Declare a free list to manage H5F_rdcc_ent_t objects */
-H5FL_DEFINE_STATIC(H5F_rdcc_ent_t);
+H5FL_DEFINE_STATIC(H5D_rdcc_ent_t);
/* Declare a free list to manage the H5F_rdcc_ent_ptr_t sequence information */
-H5FL_SEQ_DEFINE_STATIC(H5F_rdcc_ent_ptr_t);
+H5FL_SEQ_DEFINE_STATIC(H5D_rdcc_ent_ptr_t);
/* Declare a free list to manage the chunk sequence information */
H5FL_BLK_DEFINE_STATIC(chunk);
/*-------------------------------------------------------------------------
- * Function: H5F_istore_sizeof_rkey
+ * Function: H5D_istore_sizeof_rkey
*
* Purpose: Returns the size of a raw key for the specified UDATA. The
* size of the key is dependent on the number of dimensions for
@@ -243,13 +238,13 @@ H5FL_BLK_DEFINE_STATIC(chunk);
*-------------------------------------------------------------------------
*/
static size_t
-H5F_istore_sizeof_rkey(H5F_t UNUSED *f, const void *_udata)
+H5D_istore_sizeof_rkey(H5F_t UNUSED *f, const void *_udata)
{
- const H5F_istore_ud1_t *udata = (const H5F_istore_ud1_t *) _udata;
+ const H5D_istore_ud1_t *udata = (const H5D_istore_ud1_t *) _udata;
size_t nbytes;
/* Use FUNC_ENTER_NOAPI_NOINIT_NOFUNC here to avoid performance issues */
- FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5F_istore_sizeof_rkey);
+ FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5D_istore_sizeof_rkey);
assert(udata);
assert(udata->mesg.u.chunk.ndims > 0 && udata->mesg.u.chunk.ndims <= H5O_LAYOUT_NDIMS);
@@ -259,11 +254,11 @@ H5F_istore_sizeof_rkey(H5F_t UNUSED *f, const void *_udata)
udata->mesg.u.chunk.ndims*8; /*dimension indices */
FUNC_LEAVE_NOAPI(nbytes);
-}
+} /* end H5D_istore_sizeof_rkey() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_decode_key
+ * Function: H5D_istore_decode_key
*
* Purpose: Decodes a raw key into a native key for the B-tree
*
@@ -277,14 +272,14 @@ H5F_istore_sizeof_rkey(H5F_t UNUSED *f, const void *_udata)
*-------------------------------------------------------------------------
*/
static herr_t
-H5F_istore_decode_key(H5F_t UNUSED *f, H5B_t *bt, uint8_t *raw, void *_key)
+H5D_istore_decode_key(H5F_t UNUSED *f, H5B_t *bt, uint8_t *raw, void *_key)
{
- H5F_istore_key_t *key = (H5F_istore_key_t *) _key;
+ H5D_istore_key_t *key = (H5D_istore_key_t *) _key;
int i;
- int ndims = H5F_ISTORE_NDIMS(bt);
+ int ndims = H5D_ISTORE_NDIMS(bt);
herr_t ret_value=SUCCEED; /* Return value */
- FUNC_ENTER_NOAPI(H5F_istore_decode_key, FAIL);
+ FUNC_ENTER_NOAPI(H5D_istore_decode_key, FAIL);
/* check args */
assert(f);
@@ -301,11 +296,11 @@ H5F_istore_decode_key(H5F_t UNUSED *f, H5B_t *bt, uint8_t *raw, void *_key)
done:
FUNC_LEAVE_NOAPI(ret_value);
-}
+} /* end H5D_istore_decode_key() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_encode_key
+ * Function: H5D_istore_encode_key
*
* Purpose: Encode a key from native format to raw format.
*
@@ -319,14 +314,14 @@ done:
*-------------------------------------------------------------------------
*/
static herr_t
-H5F_istore_encode_key(H5F_t UNUSED *f, H5B_t *bt, uint8_t *raw, void *_key)
+H5D_istore_encode_key(H5F_t UNUSED *f, H5B_t *bt, uint8_t *raw, void *_key)
{
- H5F_istore_key_t *key = (H5F_istore_key_t *) _key;
- int ndims = H5F_ISTORE_NDIMS(bt);
+ H5D_istore_key_t *key = (H5D_istore_key_t *) _key;
+ int ndims = H5D_ISTORE_NDIMS(bt);
int i;
herr_t ret_value=SUCCEED; /* Return value */
- FUNC_ENTER_NOAPI(H5F_istore_encode_key, FAIL);
+ FUNC_ENTER_NOAPI(H5D_istore_encode_key, FAIL);
/* check args */
assert(f);
@@ -343,11 +338,11 @@ H5F_istore_encode_key(H5F_t UNUSED *f, H5B_t *bt, uint8_t *raw, void *_key)
done:
FUNC_LEAVE_NOAPI(ret_value);
-}
+} /* end H5D_istore_encode_key() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_debug_key
+ * Function: H5D_istore_debug_key
*
* Purpose: Prints a key.
*
@@ -361,15 +356,15 @@ done:
*-------------------------------------------------------------------------
*/
static herr_t
-H5F_istore_debug_key (FILE *stream, H5F_t UNUSED *f, hid_t UNUSED dxpl_id, int indent, int fwidth,
+H5D_istore_debug_key (FILE *stream, H5F_t UNUSED *f, hid_t UNUSED dxpl_id, int indent, int fwidth,
const void *_key, const void *_udata)
{
- const H5F_istore_key_t *key = (const H5F_istore_key_t *)_key;
- const H5F_istore_ud1_t *udata = (const H5F_istore_ud1_t *)_udata;
+ const H5D_istore_key_t *key = (const H5D_istore_key_t *)_key;
+ const H5D_istore_ud1_t *udata = (const H5D_istore_ud1_t *)_udata;
unsigned u;
herr_t ret_value=SUCCEED; /* Return value */
- FUNC_ENTER_NOAPI(H5F_istore_debug_key, FAIL);
+ FUNC_ENTER_NOAPI(H5D_istore_debug_key, FAIL);
assert (key);
@@ -385,11 +380,11 @@ H5F_istore_debug_key (FILE *stream, H5F_t UNUSED *f, hid_t UNUSED dxpl_id, int i
done:
FUNC_LEAVE_NOAPI(ret_value);
-}
+} /* end H5D_istore_debug_key() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_cmp2
+ * Function: H5D_istore_cmp2
*
* Purpose: Compares two keys sort of like strcmp(). The UDATA pointer
* is only to supply extra information not carried in the keys
@@ -410,15 +405,15 @@ done:
*-------------------------------------------------------------------------
*/
static int
-H5F_istore_cmp2(H5F_t UNUSED *f, hid_t UNUSED dxpl_id, void *_lt_key, void *_udata,
+H5D_istore_cmp2(H5F_t UNUSED *f, hid_t UNUSED dxpl_id, void *_lt_key, void *_udata,
void *_rt_key)
{
- H5F_istore_key_t *lt_key = (H5F_istore_key_t *) _lt_key;
- H5F_istore_key_t *rt_key = (H5F_istore_key_t *) _rt_key;
- H5F_istore_ud1_t *udata = (H5F_istore_ud1_t *) _udata;
+ H5D_istore_key_t *lt_key = (H5D_istore_key_t *) _lt_key;
+ H5D_istore_key_t *rt_key = (H5D_istore_key_t *) _rt_key;
+ H5D_istore_ud1_t *udata = (H5D_istore_ud1_t *) _udata;
int ret_value;
- FUNC_ENTER_NOAPI(H5F_istore_cmp2, FAIL);
+ FUNC_ENTER_NOAPI(H5D_istore_cmp2, FAIL);
assert(lt_key);
assert(rt_key);
@@ -430,11 +425,11 @@ H5F_istore_cmp2(H5F_t UNUSED *f, hid_t UNUSED dxpl_id, void *_lt_key, void *_uda
done:
FUNC_LEAVE_NOAPI(ret_value);
-}
+} /* end H5D_istore_cmp2() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_cmp3
+ * Function: H5D_istore_cmp3
*
* Purpose: Compare the requested datum UDATA with the left and right
* keys of the B-tree.
@@ -463,15 +458,15 @@ done:
*-------------------------------------------------------------------------
*/
static int
-H5F_istore_cmp3(H5F_t UNUSED *f, hid_t UNUSED dxpl_id, void *_lt_key, void *_udata,
+H5D_istore_cmp3(H5F_t UNUSED *f, hid_t UNUSED dxpl_id, void *_lt_key, void *_udata,
void *_rt_key)
{
- H5F_istore_key_t *lt_key = (H5F_istore_key_t *) _lt_key;
- H5F_istore_key_t *rt_key = (H5F_istore_key_t *) _rt_key;
- H5F_istore_ud1_t *udata = (H5F_istore_ud1_t *) _udata;
+ H5D_istore_key_t *lt_key = (H5D_istore_key_t *) _lt_key;
+ H5D_istore_key_t *rt_key = (H5D_istore_key_t *) _rt_key;
+ H5D_istore_ud1_t *udata = (H5D_istore_ud1_t *) _udata;
int ret_value = 0;
- FUNC_ENTER_NOAPI(H5F_istore_cmp3, FAIL);
+ FUNC_ENTER_NOAPI(H5D_istore_cmp3, FAIL);
assert(lt_key);
assert(rt_key);
@@ -488,11 +483,11 @@ H5F_istore_cmp3(H5F_t UNUSED *f, hid_t UNUSED dxpl_id, void *_lt_key, void *_uda
done:
FUNC_LEAVE_NOAPI(ret_value);
-}
+} /* end H5D_istore_cmp3() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_new_node
+ * Function: H5D_istore_new_node
*
* Purpose: Adds a new entry to an i-storage B-tree. We can assume that
* the domain represented by UDATA doesn't intersect the domain
@@ -512,17 +507,17 @@ done:
*-------------------------------------------------------------------------
*/
static herr_t
-H5F_istore_new_node(H5F_t *f, hid_t dxpl_id, H5B_ins_t op,
+H5D_istore_new_node(H5F_t *f, hid_t dxpl_id, H5B_ins_t op,
void *_lt_key, void *_udata, void *_rt_key,
haddr_t *addr_p/*out*/)
{
- H5F_istore_key_t *lt_key = (H5F_istore_key_t *) _lt_key;
- H5F_istore_key_t *rt_key = (H5F_istore_key_t *) _rt_key;
- H5F_istore_ud1_t *udata = (H5F_istore_ud1_t *) _udata;
+ H5D_istore_key_t *lt_key = (H5D_istore_key_t *) _lt_key;
+ H5D_istore_key_t *rt_key = (H5D_istore_key_t *) _rt_key;
+ H5D_istore_ud1_t *udata = (H5D_istore_ud1_t *) _udata;
unsigned u;
herr_t ret_value=SUCCEED; /* Return value */
- FUNC_ENTER_NOAPI(H5F_istore_new_node, FAIL);
+ FUNC_ENTER_NOAPI(H5D_istore_new_node, FAIL);
/* check args */
assert(f);
@@ -565,11 +560,11 @@ H5F_istore_new_node(H5F_t *f, hid_t dxpl_id, H5B_ins_t op,
done:
FUNC_LEAVE_NOAPI(ret_value);
-}
+} /* end H5D_istore_new_node() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_found
+ * Function: H5D_istore_found
*
* Purpose: This function is called when the B-tree search engine has
* found the leaf entry that points to a chunk of storage that
@@ -596,15 +591,15 @@ done:
*-------------------------------------------------------------------------
*/
static herr_t
-H5F_istore_found(H5F_t UNUSED *f, hid_t UNUSED dxpl_id, haddr_t addr, const void *_lt_key,
+H5D_istore_found(H5F_t UNUSED *f, hid_t UNUSED dxpl_id, haddr_t addr, const void *_lt_key,
void *_udata, const void UNUSED *_rt_key)
{
- H5F_istore_ud1_t *udata = (H5F_istore_ud1_t *) _udata;
- const H5F_istore_key_t *lt_key = (const H5F_istore_key_t *) _lt_key;
+ H5D_istore_ud1_t *udata = (H5D_istore_ud1_t *) _udata;
+ const H5D_istore_key_t *lt_key = (const H5D_istore_key_t *) _lt_key;
unsigned u;
herr_t ret_value=SUCCEED; /* Return value */
- FUNC_ENTER_NOAPI(H5F_istore_found, FAIL);
+ FUNC_ENTER_NOAPI(H5D_istore_found, FAIL);
/* Check arguments */
assert(f);
@@ -628,11 +623,11 @@ H5F_istore_found(H5F_t UNUSED *f, hid_t UNUSED dxpl_id, haddr_t addr, const void
done:
FUNC_LEAVE_NOAPI(ret_value);
-}
+} /* end H5D_istore_found() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_insert
+ * Function: H5D_istore_insert
*
* Purpose: This function is called when the B-tree insert engine finds
* the node to use to insert new data. The UDATA argument
@@ -664,21 +659,21 @@ done:
*-------------------------------------------------------------------------
*/
static H5B_ins_t
-H5F_istore_insert(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *_lt_key,
+H5D_istore_insert(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *_lt_key,
hbool_t UNUSED *lt_key_changed,
void *_md_key, void *_udata, void *_rt_key,
hbool_t UNUSED *rt_key_changed,
haddr_t *new_node_p/*out*/)
{
- H5F_istore_key_t *lt_key = (H5F_istore_key_t *) _lt_key;
- H5F_istore_key_t *md_key = (H5F_istore_key_t *) _md_key;
- H5F_istore_key_t *rt_key = (H5F_istore_key_t *) _rt_key;
- H5F_istore_ud1_t *udata = (H5F_istore_ud1_t *) _udata;
+ H5D_istore_key_t *lt_key = (H5D_istore_key_t *) _lt_key;
+ H5D_istore_key_t *md_key = (H5D_istore_key_t *) _md_key;
+ H5D_istore_key_t *rt_key = (H5D_istore_key_t *) _rt_key;
+ H5D_istore_ud1_t *udata = (H5D_istore_ud1_t *) _udata;
int cmp;
unsigned u;
H5B_ins_t ret_value;
- FUNC_ENTER_NOAPI(H5F_istore_insert, H5B_INS_ERROR);
+ FUNC_ENTER_NOAPI(H5D_istore_insert, H5B_INS_ERROR);
/* check args */
assert(f);
@@ -691,7 +686,7 @@ H5F_istore_insert(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *_lt_key,
assert(rt_key_changed);
assert(new_node_p);
- cmp = H5F_istore_cmp3(f, dxpl_id, lt_key, udata, rt_key);
+ cmp = H5D_istore_cmp3(f, dxpl_id, lt_key, udata, rt_key);
assert(cmp <= 0);
if (cmp < 0) {
@@ -771,11 +766,11 @@ H5F_istore_insert(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *_lt_key,
done:
FUNC_LEAVE_NOAPI(ret_value);
-}
+} /* end H5D_istore_insert() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_iter_allocated
+ * Function: H5D_istore_iter_allocated
*
* Purpose: Simply counts the number of chunks for a dataset.
*
@@ -795,22 +790,22 @@ done:
*-------------------------------------------------------------------------
*/
static int
-H5F_istore_iter_allocated (H5F_t UNUSED *f, hid_t UNUSED dxpl_id, void *_lt_key, haddr_t UNUSED addr,
+H5D_istore_iter_allocated (H5F_t UNUSED *f, hid_t UNUSED dxpl_id, void *_lt_key, haddr_t UNUSED addr,
void UNUSED *_rt_key, void *_udata)
{
- H5F_istore_ud1_t *bt_udata = (H5F_istore_ud1_t *)_udata;
- H5F_istore_key_t *lt_key = (H5F_istore_key_t *)_lt_key;
+ H5D_istore_ud1_t *bt_udata = (H5D_istore_ud1_t *)_udata;
+ H5D_istore_key_t *lt_key = (H5D_istore_key_t *)_lt_key;
- FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5F_istore_iter_allocated);
+ FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5D_istore_iter_allocated);
bt_udata->total_storage += lt_key->nbytes;
FUNC_LEAVE_NOAPI(H5B_ITER_CONT);
-} /* H5F_istore_iter_allocated() */
+} /* H5D_istore_iter_allocated() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_iter_dump
+ * Function: H5D_istore_iter_dump
*
* Purpose: If the UDATA.STREAM member is non-null then debugging
* information is written to that stream.
@@ -831,14 +826,14 @@ H5F_istore_iter_allocated (H5F_t UNUSED *f, hid_t UNUSED dxpl_id, void *_lt_key,
*-------------------------------------------------------------------------
*/
static int
-H5F_istore_iter_dump (H5F_t UNUSED *f, hid_t UNUSED dxpl_id, void *_lt_key, haddr_t UNUSED addr,
+H5D_istore_iter_dump (H5F_t UNUSED *f, hid_t UNUSED dxpl_id, void *_lt_key, haddr_t UNUSED addr,
void UNUSED *_rt_key, void *_udata)
{
- H5F_istore_ud1_t *bt_udata = (H5F_istore_ud1_t *)_udata;
- H5F_istore_key_t *lt_key = (H5F_istore_key_t *)_lt_key;
+ H5D_istore_ud1_t *bt_udata = (H5D_istore_ud1_t *)_udata;
+ H5D_istore_key_t *lt_key = (H5D_istore_key_t *)_lt_key;
unsigned u;
- FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5F_istore_iter_dump);
+ FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5D_istore_iter_dump);
if (bt_udata->stream) {
if (0==bt_udata->total_storage) {
@@ -859,14 +854,14 @@ H5F_istore_iter_dump (H5F_t UNUSED *f, hid_t UNUSED dxpl_id, void *_lt_key, hadd
}
FUNC_LEAVE_NOAPI(H5B_ITER_CONT);
-} /* H5F_istore_iter_dump() */
+} /* H5D_istore_iter_dump() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_init
+ * Function: H5D_istore_init
*
- * Purpose: Initialize the raw data chunk cache for a file. This is
- * called when the file handle is initialized.
+ * Purpose: Initialize the raw data chunk cache for a dataset. This is
+ * called when the dataset is initialized.
*
* Return: Non-negative on success/Negative on failure
*
@@ -878,28 +873,29 @@ H5F_istore_iter_dump (H5F_t UNUSED *f, hid_t UNUSED dxpl_id, void *_lt_key, hadd
*-------------------------------------------------------------------------
*/
herr_t
-H5F_istore_init (H5F_t *f)
+H5D_istore_init (H5F_t *f, H5D_t *dset)
{
- H5F_rdcc_t *rdcc = &(f->shared->rdcc);
+ H5D_rdcc_t *rdcc = &(dset->cache.chunk);
herr_t ret_value=SUCCEED; /* Return value */
- FUNC_ENTER_NOAPI(H5F_istore_init, FAIL);
+ FUNC_ENTER_NOAPI(H5D_istore_init, FAIL);
- HDmemset (rdcc, 0, sizeof(H5F_rdcc_t));
- if (f->shared->rdcc_nbytes>0 && f->shared->rdcc_nelmts>0) {
- rdcc->nslots = f->shared->rdcc_nelmts;
- rdcc->slot = H5FL_SEQ_CALLOC (H5F_rdcc_ent_ptr_t,rdcc->nslots);
+ HDmemset (rdcc, 0, sizeof(H5D_rdcc_t));
+ if (H5F_RDCC_NBYTES(f)>0 && H5F_RDCC_NELMTS(f)>0) {
+ rdcc->nbytes=H5F_RDCC_NBYTES(f);
+ rdcc->nslots = H5F_RDCC_NELMTS(f);
+ rdcc->slot = H5FL_SEQ_CALLOC (H5D_rdcc_ent_ptr_t,rdcc->nslots);
if (NULL==rdcc->slot)
HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed");
- }
+ } /* end if */
done:
FUNC_LEAVE_NOAPI(ret_value);
-}
+} /* end H5D_istore_init() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_flush_entry
+ * Function: H5D_istore_flush_entry
*
* Purpose: Writes a chunk to disk. If RESET is non-zero then the
* entry is cleared -- it's slightly faster to flush a chunk if
@@ -916,8 +912,8 @@ done:
*-------------------------------------------------------------------------
*/
static herr_t
-H5F_istore_flush_entry(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache,
- hid_t dxpl_id, H5F_rdcc_ent_t *ent, hbool_t reset)
+H5D_istore_flush_entry(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache,
+ hid_t dxpl_id, H5D_t *dset, H5D_rdcc_ent_t *ent, hbool_t reset)
{
herr_t ret_value=SUCCEED; /*return value */
unsigned u; /*counters */
@@ -925,7 +921,7 @@ H5F_istore_flush_entry(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache,
size_t alloc; /*bytes allocated for BUF */
hbool_t point_of_no_return = FALSE;
- FUNC_ENTER_NOAPI_NOINIT(H5F_istore_flush_entry);
+ FUNC_ENTER_NOAPI_NOINIT(H5D_istore_flush_entry);
assert(f);
assert(ent);
@@ -933,18 +929,18 @@ H5F_istore_flush_entry(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache,
buf = ent->chunk;
if (ent->dirty) {
- H5F_istore_ud1_t udata; /*pass through B-tree */
+ H5D_istore_ud1_t udata; /*pass through B-tree */
- udata.mesg = ent->layout;
+ udata.mesg = dset->layout;
udata.key.filter_mask = 0;
udata.addr = HADDR_UNDEF;
udata.key.nbytes = ent->chunk_size;
- for (u=0; u<ent->layout.u.chunk.ndims; u++)
+ for (u=0; u<dset->layout.u.chunk.ndims; u++)
udata.key.offset[u] = ent->offset[u];
alloc = ent->alloc_size;
/* Should the chunk be filtered before writing it to disk? */
- if (ent->pline.nused) {
+ if (dset->dcpl_cache.pline.nused) {
if (!reset) {
/*
* Copy the chunk to a new buffer before running it through
@@ -966,36 +962,33 @@ H5F_istore_flush_entry(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache,
point_of_no_return = TRUE;
ent->chunk = NULL;
}
- if (H5Z_pipeline(&ent->pline, 0, &(udata.key.filter_mask), dxpl_cache->err_detect,
- dxpl_cache->filter_cb, &(udata.key.nbytes), &alloc, &buf)<0) {
- HGOTO_ERROR(H5E_PLINE, H5E_WRITEERROR, FAIL,
- "output pipeline failed");
- }
+ if (H5Z_pipeline(&(dset->dcpl_cache.pline), 0, &(udata.key.filter_mask), dxpl_cache->err_detect,
+ dxpl_cache->filter_cb, &(udata.key.nbytes), &alloc, &buf)<0)
+ HGOTO_ERROR(H5E_PLINE, H5E_WRITEERROR, FAIL, "output pipeline failed")
}
/*
* Create the chunk it if it doesn't exist, or reallocate the chunk if
* its size changed. Then write the data into the file.
*/
- if (H5B_insert(f, dxpl_id, H5B_ISTORE, ent->layout.u.chunk.addr, &udata)<0)
+ if (H5B_insert(f, dxpl_id, H5B_ISTORE, dset->layout.u.chunk.addr, &udata)<0)
HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "unable to allocate chunk");
if (H5F_block_write(f, H5FD_MEM_DRAW, udata.addr, udata.key.nbytes, dxpl_id, buf)<0)
HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "unable to write raw data to file");
/* Mark cache entry as clean */
ent->dirty = FALSE;
- f->shared->rdcc.nflushes++;
- }
+ dset->cache.chunk.nflushes++;
+ } /* end if */
/* Reset, but do not free or removed from list */
if (reset) {
point_of_no_return = FALSE;
- H5O_reset(H5O_LAYOUT_ID, &ent->layout);
- if (buf==ent->chunk) buf = NULL;
+ if(buf==ent->chunk)
+ buf = NULL;
if(ent->chunk!=NULL)
- ent->chunk = H5F_istore_chunk_xfree(ent->chunk,&ent->pline);
- H5O_reset(H5O_PLINE_ID, &ent->pline);
- }
+ ent->chunk = H5D_istore_chunk_xfree(ent->chunk,&(dset->dcpl_cache.pline));
+ } /* end if */
done:
/* Free the temp buffer only if it's different than the entry chunk */
@@ -1009,17 +1002,16 @@ done:
* list.
*/
if (ret_value<0 && point_of_no_return) {
- H5O_reset(H5O_LAYOUT_ID, &ent->layout);
if(ent->chunk)
- ent->chunk = H5F_istore_chunk_xfree(ent->chunk,&ent->pline);
- H5O_reset(H5O_PLINE_ID, &ent->pline);
- }
+ ent->chunk = H5D_istore_chunk_xfree(ent->chunk,&(dset->dcpl_cache.pline));
+ } /* end if */
+
FUNC_LEAVE_NOAPI(ret_value);
-}
+} /* end H5D_istore_flush_entry() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_preempt
+ * Function: H5D_istore_preempt
*
* Purpose: Preempts the specified entry from the cache, flushing it to
* disk if necessary.
@@ -1037,12 +1029,13 @@ done:
*-------------------------------------------------------------------------
*/
static herr_t
-H5F_istore_preempt(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id, H5F_rdcc_ent_t * ent, hbool_t flush)
+H5D_istore_preempt(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id,
+ H5D_t *dset, H5D_rdcc_ent_t * ent, hbool_t flush)
{
- H5F_rdcc_t *rdcc = &(f->shared->rdcc);
+ H5D_rdcc_t *rdcc = &(dset->cache.chunk);
herr_t ret_value=SUCCEED; /* Return value */
- FUNC_ENTER_NOAPI_NOINIT(H5F_istore_preempt);
+ FUNC_ENTER_NOAPI_NOINIT(H5D_istore_preempt);
assert(f);
assert(ent);
@@ -1051,15 +1044,13 @@ H5F_istore_preempt(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id,
if(flush) {
/* Flush */
- if(H5F_istore_flush_entry(f, dxpl_cache, dxpl_id, ent, TRUE) < 0)
+ if(H5D_istore_flush_entry(f, dxpl_cache, dxpl_id, dset, ent, TRUE) < 0)
HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "cannot flush indexed storage buffer");
}
else {
/* Don't flush, just free chunk */
- H5O_reset(H5O_LAYOUT_ID, &ent->layout);
if(ent->chunk != NULL)
- ent->chunk = H5F_istore_chunk_xfree(ent->chunk,&ent->pline);
- H5O_reset(H5O_PLINE_ID, &ent->pline);
+ ent->chunk = H5D_istore_chunk_xfree(ent->chunk,&(dset->dcpl_cache.pline));
}
/* Unlink from list */
@@ -1080,15 +1071,15 @@ H5F_istore_preempt(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id,
--rdcc->nused;
/* Free */
- H5FL_FREE(H5F_rdcc_ent_t, ent);
+ H5FL_FREE(H5D_rdcc_ent_t, ent);
done:
FUNC_LEAVE_NOAPI(ret_value);
-}
+} /* end H5D_istore_preempt() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_flush
+ * Function: H5D_istore_flush
*
* Purpose: Writes all dirty chunks to disk and optionally preempts them
* from the cache.
@@ -1105,15 +1096,15 @@ done:
*-------------------------------------------------------------------------
*/
herr_t
-H5F_istore_flush (H5F_t *f, hid_t dxpl_id, unsigned flags)
+H5D_istore_flush (H5F_t *f, hid_t dxpl_id, H5D_t *dset, unsigned flags)
{
H5D_dxpl_cache_t dxpl_cache; /* Cached data transfer properties */
- H5F_rdcc_t *rdcc = &(f->shared->rdcc);
+ H5D_rdcc_t *rdcc = &(dset->cache.chunk);
int nerrors=0;
- H5F_rdcc_ent_t *ent=NULL, *next=NULL;
+ H5D_rdcc_ent_t *ent=NULL, *next=NULL;
herr_t ret_value=SUCCEED; /* Return value */
- FUNC_ENTER_NOAPI(H5F_istore_flush, FAIL);
+ FUNC_ENTER_NOAPI(H5D_istore_flush, FAIL);
/* Fill the DXPL cache values for later use */
if (H5D_get_dxpl_cache(dxpl_id,&dxpl_cache)<0)
@@ -1126,24 +1117,24 @@ H5F_istore_flush (H5F_t *f, hid_t dxpl_id, unsigned flags)
ent->dirty = FALSE;
} /* end if */
else if ((flags&H5F_FLUSH_INVALIDATE)) {
- if (H5F_istore_preempt(f, &dxpl_cache, dxpl_id, ent, TRUE )<0)
+ if (H5D_istore_preempt(f, &dxpl_cache, dxpl_id, dset, ent, TRUE )<0)
nerrors++;
} else {
- if (H5F_istore_flush_entry(f, &dxpl_cache, dxpl_id, ent, FALSE)<0)
+ if (H5D_istore_flush_entry(f, &dxpl_cache, dxpl_id, dset, ent, FALSE)<0)
nerrors++;
}
- }
+ } /* end for */
if (nerrors)
HGOTO_ERROR (H5E_IO, H5E_CANTFLUSH, FAIL, "unable to flush one or more raw data chunks");
done:
FUNC_LEAVE_NOAPI(ret_value);
-}
+} /* end H5D_istore_flush() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_dest
+ * Function: H5D_istore_dest
*
* Purpose: Destroy the entire chunk cache by flushing dirty entries,
* preempting all entries, and freeing the cache itself.
@@ -1160,42 +1151,42 @@ done:
*-------------------------------------------------------------------------
*/
herr_t
-H5F_istore_dest (H5F_t *f, hid_t dxpl_id)
+H5D_istore_dest (H5F_t *f, hid_t dxpl_id, H5D_t *dset)
{
H5D_dxpl_cache_t dxpl_cache; /* Cached data transfer properties */
- H5F_rdcc_t *rdcc = &(f->shared->rdcc);
+ H5D_rdcc_t *rdcc = &(dset->cache.chunk);
int nerrors=0;
- H5F_rdcc_ent_t *ent=NULL, *next=NULL;
+ H5D_rdcc_ent_t *ent=NULL, *next=NULL;
herr_t ret_value=SUCCEED; /* Return value */
- FUNC_ENTER_NOAPI(H5F_istore_dest, FAIL);
+ FUNC_ENTER_NOAPI(H5D_istore_dest, FAIL);
/* Fill the DXPL cache values for later use */
if (H5D_get_dxpl_cache(dxpl_id,&dxpl_cache)<0)
HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't fill dxpl cache")
for (ent=rdcc->head; ent; ent=next) {
-#ifdef H5F_ISTORE_DEBUG
+#ifdef H5D_ISTORE_DEBUG
HDfputc('c', stderr);
HDfflush(stderr);
#endif
next = ent->next;
- if (H5F_istore_preempt(f, &dxpl_cache, dxpl_id, ent, TRUE )<0)
+ if (H5D_istore_preempt(f, &dxpl_cache, dxpl_id, dset, ent, TRUE )<0)
nerrors++;
}
if (nerrors)
HGOTO_ERROR (H5E_IO, H5E_CANTFLUSH, FAIL, "unable to flush one or more raw data chunks");
- H5FL_SEQ_FREE (H5F_rdcc_ent_ptr_t,rdcc->slot);
- HDmemset (rdcc, 0, sizeof(H5F_rdcc_t));
+ H5FL_SEQ_FREE (H5D_rdcc_ent_ptr_t,rdcc->slot);
+ HDmemset (rdcc, 0, sizeof(H5D_rdcc_t));
done:
FUNC_LEAVE_NOAPI(ret_value);
-}
+} /* end H5D_istore_dest() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_prune
+ * Function: H5D_istore_prune
*
* Purpose: Prune the cache by preempting some things until the cache has
* room for something which is SIZE bytes. Only unlocked
@@ -1213,18 +1204,19 @@ done:
*-------------------------------------------------------------------------
*/
static herr_t
-H5F_istore_prune (H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id, size_t size)
+H5D_istore_prune (H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id, H5D_t *dset,
+ size_t size)
{
int i, j, nerrors=0;
- H5F_rdcc_t *rdcc = &(f->shared->rdcc);
- size_t total = f->shared->rdcc_nbytes;
+ H5D_rdcc_t *rdcc = &(dset->cache.chunk);
+ size_t total = rdcc->nbytes;
const int nmeth=2; /*number of methods */
int w[1]; /*weighting as an interval */
- H5F_rdcc_ent_t *p[2], *cur; /*list pointers */
- H5F_rdcc_ent_t *n[2]; /*list next pointers */
+ H5D_rdcc_ent_t *p[2], *cur; /*list pointers */
+ H5D_rdcc_ent_t *n[2]; /*list next pointers */
herr_t ret_value=SUCCEED; /* Return value */
- FUNC_ENTER_NOAPI_NOINIT(H5F_istore_prune);
+ FUNC_ENTER_NOAPI_NOINIT(H5D_istore_prune);
/*
* Preemption is accomplished by having multiple pointers (currently two)
@@ -1236,7 +1228,7 @@ H5F_istore_prune (H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id, s
* begins. The pointers participating in the list traversal are each
* given a chance at preemption before any of the pointers are advanced.
*/
- w[0] = (int)(rdcc->nused * f->shared->rdcc_w0);
+ w[0] = (int)(rdcc->nused * H5F_RDCC_W0(f));
p[0] = rdcc->head;
p[1] = NULL;
@@ -1263,7 +1255,7 @@ H5F_istore_prune (H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id, s
* written or partially read.
*/
cur = p[0];
-#ifdef H5F_ISTORE_DEBUG
+#ifdef H5D_ISTORE_DEBUG
HDputc('.', stderr);
HDfflush(stderr);
#endif
@@ -1275,7 +1267,7 @@ H5F_istore_prune (H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id, s
* resort preemption.
*/
cur = p[1];
-#ifdef H5F_ISTORE_DEBUG
+#ifdef H5D_ISTORE_DEBUG
HDputc(':', stderr);
HDfflush(stderr);
#endif
@@ -1292,7 +1284,7 @@ H5F_istore_prune (H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id, s
if (n[j]==cur)
n[j] = cur->next;
}
- if (H5F_istore_preempt(f, dxpl_cache, dxpl_id, cur, TRUE)<0)
+ if (H5D_istore_preempt(f, dxpl_cache, dxpl_id, dset, cur, TRUE)<0)
nerrors++;
}
}
@@ -1309,11 +1301,11 @@ H5F_istore_prune (H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id, s
done:
FUNC_LEAVE_NOAPI(ret_value);
-}
+} /* end H5D_istore_prune() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_lock
+ * Function: H5D_istore_lock
*
* Purpose: Return a pointer to a dataset chunk. The pointer points
* directly into the chunk cache and should not be freed
@@ -1347,24 +1339,29 @@ done:
*-------------------------------------------------------------------------
*/
static void *
-H5F_istore_lock(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id, const H5O_layout_t *layout,
- const H5O_pline_t *pline, const H5O_fill_t *fill, H5D_fill_time_t fill_time,
- H5F_istore_ud1_t *udata,
- const H5D_storage_t *store, hbool_t relax,
- unsigned *idx_hint/*in,out*/)
+H5D_istore_lock(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id,
+ H5D_t *dset, const H5D_storage_t *store,
+ H5D_istore_ud1_t *udata, hbool_t relax, unsigned *idx_hint/*in,out*/)
{
- int idx=0; /*hash index number */
- hsize_t temp_idx=0; /* temporary index number */
+ unsigned idx=0; /*hash index number */
hbool_t found = FALSE; /*already in cache? */
- H5F_rdcc_t *rdcc = &(f->shared->rdcc);/*raw data chunk cache*/
- H5F_rdcc_ent_t *ent = NULL; /*cache entry */
+ const H5O_pline_t *pline=&(dset->dcpl_cache.pline); /* I/O pipeline info */
+ const H5O_layout_t *layout=&(dset->layout); /* Dataset layout */
+ const H5O_fill_t *fill=&(dset->dcpl_cache.fill); /* Fill value info */
+ H5D_fill_time_t fill_time=dset->dcpl_cache.fill_time; /* Fill time */
+ H5D_rdcc_t *rdcc = &(dset->cache.chunk);/*raw data chunk cache*/
+ H5D_rdcc_ent_t *ent = NULL; /*cache entry */
unsigned u; /*counters */
size_t chunk_size=0; /*size of a chunk */
void *chunk=NULL; /*the file chunk */
void *ret_value; /*return value */
- FUNC_ENTER_NOAPI_NOINIT(H5F_istore_lock);
+ FUNC_ENTER_NOAPI_NOINIT(H5D_istore_lock);
+ assert(f);
+ assert(dset);
+ assert(store);
+ assert(dxpl_cache);
assert(TRUE==H5P_isa_class(dxpl_id,H5P_DATASET_XFER));
/* Get the chunk's size */
@@ -1373,20 +1370,18 @@ H5F_istore_lock(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id, con
/* Search for the chunk in the cache */
if (rdcc->nslots>0) {
- temp_idx = store->chunk.index + (hsize_t)(layout->u.chunk.addr);
- idx=H5F_HASH(f,temp_idx);
+ idx=H5D_HASH(dset,store->chunk.index);
ent = rdcc->slot[idx];
- if (ent && layout->u.chunk.ndims==ent->layout.u.chunk.ndims &&
- H5F_addr_eq(layout->u.chunk.addr, ent->layout.u.chunk.addr)) {
- for (u=0, found=TRUE; u<ent->layout.u.chunk.ndims; u++) {
+ if (ent) {
+ for (u=0, found=TRUE; u<dset->layout.u.chunk.ndims; u++) {
if (store->chunk.offset[u]!=ent->offset[u]) {
found = FALSE;
break;
- }
- }
- }
- }
+ } /* end if */
+ } /* end for */
+ } /* end if */
+ } /* end if */
if (found) {
/*
@@ -1401,16 +1396,16 @@ H5F_istore_lock(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id, con
* buffer with the file contents. Count this as a hit instead of a
* miss because we saved ourselves lots of work.
*/
-#ifdef H5F_ISTORE_DEBUG
+#ifdef H5D_ISTORE_DEBUG
HDputc('w', stderr);
HDfflush(stderr);
#endif
rdcc->nhits++;
- if (NULL==(chunk=H5F_istore_chunk_alloc (chunk_size,pline)))
+ if (NULL==(chunk=H5D_istore_chunk_alloc (chunk_size,pline)))
HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed for raw data chunk");
} else {
- H5F_istore_ud1_t tmp_udata; /*B-tree pass-through */
+ H5D_istore_ud1_t tmp_udata; /*B-tree pass-through */
haddr_t chunk_addr; /* Address of chunk on disk */
if(udata!=NULL)
@@ -1423,7 +1418,7 @@ H5F_istore_lock(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id, con
* Not in the cache. Read it from the file and count this as a miss
* if it's in the file or an init if it isn't.
*/
- chunk_addr = H5F_istore_get_addr(f, dxpl_id, layout, store->chunk.offset, udata);
+ chunk_addr = H5D_istore_get_addr(f, dxpl_id, layout, store->chunk.offset, udata);
} /* end else */
if (H5F_addr_defined(chunk_addr)) {
@@ -1435,7 +1430,7 @@ H5F_istore_lock(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id, con
/* Chunk size on disk isn't [likely] the same size as the final chunk
* size in memory, so allocate memory big enough. */
chunk_alloc = udata->key.nbytes;
- if (NULL==(chunk = H5F_istore_chunk_alloc (chunk_alloc,pline)))
+ if (NULL==(chunk = H5D_istore_chunk_alloc (chunk_alloc,pline)))
HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed for raw data chunk");
if (H5F_block_read(f, H5FD_MEM_DRAW, chunk_addr, udata->key.nbytes, dxpl_id, chunk)<0)
HGOTO_ERROR (H5E_IO, H5E_READERROR, NULL, "unable to read raw data chunk");
@@ -1454,7 +1449,7 @@ H5F_istore_lock(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id, con
/* Chunk size on disk isn't [likely] the same size as the final chunk
* size in memory, so allocate memory big enough. */
- if (NULL==(chunk = H5F_istore_chunk_alloc (chunk_size,pline)))
+ if (NULL==(chunk = H5D_istore_chunk_alloc (chunk_size,pline)))
HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed for raw data chunk");
if (H5P_is_fill_value_defined(fill, &fill_status) < 0)
@@ -1482,31 +1477,29 @@ H5F_istore_lock(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id, con
}
assert (found || chunk_size>0);
- if (!found && rdcc->nslots>0 && chunk_size<=f->shared->rdcc_nbytes &&
+ if (!found && rdcc->nslots>0 && chunk_size<=dset->cache.chunk.nbytes &&
(!ent || !ent->locked)) {
/*
* Add the chunk to the cache only if the slot is not already locked.
* Preempt enough things from the cache to make room.
*/
if (ent) {
-#ifdef H5F_ISTORE_DEBUG
+#ifdef H5D_ISTORE_DEBUG
HDputc('#', stderr);
HDfflush(stderr);
#endif
- if (H5F_istore_preempt(f, dxpl_cache, dxpl_id, ent, TRUE)<0)
+ if (H5D_istore_preempt(f, dxpl_cache, dxpl_id, dset, ent, TRUE)<0)
HGOTO_ERROR(H5E_IO, H5E_CANTINIT, NULL, "unable to preempt chunk from cache");
}
- if (H5F_istore_prune(f, dxpl_cache, dxpl_id, chunk_size)<0)
+ if (H5D_istore_prune(f, dxpl_cache, dxpl_id, dset, chunk_size)<0)
HGOTO_ERROR(H5E_IO, H5E_CANTINIT, NULL, "unable to preempt chunk(s) from cache");
/* Create a new entry */
- ent = H5FL_MALLOC(H5F_rdcc_ent_t);
+ ent = H5FL_MALLOC(H5D_rdcc_ent_t);
ent->locked = 0;
ent->dirty = FALSE;
ent->chunk_size = chunk_size;
ent->alloc_size = chunk_size;
- H5O_copy(H5O_LAYOUT_ID, layout, &ent->layout);
- H5O_copy(H5O_PLINE_ID, pline, &ent->pline);
for (u=0; u<layout->u.chunk.ndims; u++)
ent->offset[u] = store->chunk.offset[u];
ent->rd_count = chunk_size;
@@ -1578,13 +1571,13 @@ H5F_istore_lock(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id, con
done:
if (!ret_value)
if(chunk)
- H5F_istore_chunk_xfree (chunk,pline);
+ H5D_istore_chunk_xfree (chunk,pline);
FUNC_LEAVE_NOAPI(ret_value);
-}
+} /* end H5D_istore_lock() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_unlock
+ * Function: H5D_istore_unlock
*
* Purpose: Unlocks a previously locked chunk. The LAYOUT, COMP, and
* OFFSET arguments should be the same as for H5F_rdcc_lock().
@@ -1610,16 +1603,16 @@ done:
*-------------------------------------------------------------------------
*/
static herr_t
-H5F_istore_unlock(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id,
- const H5O_layout_t *layout, const H5O_pline_t *pline, hbool_t dirty,
- const H5D_storage_t *store, unsigned idx_hint, uint8_t *chunk, size_t naccessed)
+H5D_istore_unlock(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id,
+ H5D_t *dset, const H5D_storage_t *store,
+ hbool_t dirty, unsigned idx_hint, uint8_t *chunk, size_t naccessed)
{
- H5F_rdcc_t *rdcc = &(f->shared->rdcc);
- H5F_rdcc_ent_t *ent = NULL;
+ H5D_rdcc_t *rdcc = &(dset->cache.chunk);
+ H5D_rdcc_ent_t *ent = NULL;
int found = -1;
unsigned u;
- FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5F_istore_unlock);
+ FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5D_istore_unlock);
if (UINT_MAX==idx_hint) {
/*not in cache*/
@@ -1638,23 +1631,21 @@ H5F_istore_unlock(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id,
* don't discard the `const' qualifier.
*/
if (dirty) {
- H5F_rdcc_ent_t x;
+ H5D_rdcc_ent_t x;
HDmemset (&x, 0, sizeof x);
x.dirty = TRUE;
- H5O_copy (H5O_LAYOUT_ID, layout, &x.layout);
- H5O_copy (H5O_PLINE_ID, pline, &x.pline);
- for (u=0; u<layout->u.chunk.ndims; u++)
+ for (u=0; u<dset->layout.u.chunk.ndims; u++)
x.offset[u] = store->chunk.offset[u];
- assert(layout->u.chunk.size>0);
- H5_ASSIGN_OVERFLOW(x.chunk_size,layout->u.chunk.size,hsize_t,size_t);
+ assert(dset->layout.u.chunk.size>0);
+ H5_ASSIGN_OVERFLOW(x.chunk_size,dset->layout.u.chunk.size,hsize_t,size_t);
x.alloc_size = x.chunk_size;
x.chunk = chunk;
- H5F_istore_flush_entry (f, dxpl_cache, dxpl_id, &x, TRUE);
+ H5D_istore_flush_entry (f, dxpl_cache, dxpl_id, dset, &x, TRUE);
} else {
if(chunk)
- H5F_istore_chunk_xfree (chunk,pline);
+ H5D_istore_chunk_xfree (chunk,&(dset->dcpl_cache.pline));
}
} else {
/*
@@ -1672,11 +1663,11 @@ H5F_istore_unlock(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id,
}
FUNC_LEAVE_NOAPI(SUCCEED);
-}
+} /* end H5D_istore_unlock() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_readvv
+ * Function: H5D_istore_readvv
*
* Purpose: Reads a multi-dimensional buffer from (part of) an indexed raw
* storage array.
@@ -1691,25 +1682,25 @@ H5F_istore_unlock(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id,
*-------------------------------------------------------------------------
*/
ssize_t
-H5F_istore_readvv(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id,
- const H5O_layout_t *layout, const struct H5D_dcpl_cache_t *dcpl_cache, const H5D_storage_t *store,
+H5D_istore_readvv(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id,
+ H5D_t *dset, const H5D_storage_t *store,
size_t chunk_max_nseq, size_t *chunk_curr_seq, size_t chunk_len_arr[], hsize_t chunk_offset_arr[],
size_t mem_max_nseq, size_t *mem_curr_seq, size_t mem_len_arr[], hsize_t mem_offset_arr[],
void *buf)
{
- H5F_istore_ud1_t udata; /*B-tree pass-through */
+ H5D_istore_ud1_t udata; /*B-tree pass-through */
haddr_t chunk_addr; /* Chunk address on disk */
size_t u; /* Local index variables */
ssize_t ret_value; /* Return value */
- FUNC_ENTER_NOAPI(H5F_istore_readvv, FAIL);
+ FUNC_ENTER_NOAPI(H5D_istore_readvv, FAIL);
/* Check args */
assert(f);
assert(dxpl_cache);
- assert(layout && H5D_CHUNKED==layout->type);
- assert(layout->u.chunk.ndims>0 && layout->u.chunk.ndims<=H5O_LAYOUT_NDIMS);
- assert(dcpl_cache);
+ assert(dset && H5D_CHUNKED==dset->layout.type);
+ assert(dset->layout.u.chunk.ndims>0 && dset->layout.u.chunk.ndims<=H5O_LAYOUT_NDIMS);
+ assert(store);
assert(chunk_len_arr);
assert(chunk_offset_arr);
assert(mem_len_arr);
@@ -1717,19 +1708,19 @@ H5F_istore_readvv(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache, hid_t dxp
assert(buf);
#ifndef NDEBUG
- for (u=0; u<layout->u.chunk.ndims; u++)
+ for (u=0; u<dset->layout.u.chunk.ndims; u++)
assert(store->chunk.offset[u]>=0); /*negative coordinates not supported (yet) */
#endif
/* Get the address of this chunk on disk */
#ifdef QAK
HDfprintf(stderr,"%s: chunk_coords={",FUNC);
-for(u=0; u<layout->u.chunk.ndims; u++)
- HDfprintf(stderr,"%Hd%s",chunk_coords[u],(u<(layout->u.chunk.ndims-1) ? ", " : "}\n"));
+for(u=0; u<dset->layout.u.chunk.ndims; u++)
+ HDfprintf(stderr,"%Hd%s",chunk_coords[u],(u<(dset->layout.u.chunk.ndims-1) ? ", " : "}\n"));
#endif /* QAK */
- chunk_addr=H5F_istore_get_addr(f, dxpl_id, layout, store->chunk.offset, &udata);
+ chunk_addr=H5D_istore_get_addr(f, dxpl_id, &(dset->layout), store->chunk.offset, &udata);
#ifdef QAK
-HDfprintf(stderr,"%s: chunk_addr=%a, chunk_size=%Hu\n",FUNC,chunk_addr,layout->u.chunk.size);
+HDfprintf(stderr,"%s: chunk_addr=%a, chunk_size=%Hu\n",FUNC,chunk_addr,dset->layout.u.chunk.size);
HDfprintf(stderr,"%s: chunk_len_arr[%Zu]=%Zu\n",FUNC,*chunk_curr_seq,chunk_len_arr[*chunk_curr_seq]);
HDfprintf(stderr,"%s: chunk_offset_arr[%Zu]=%Hu\n",FUNC,*chunk_curr_seq,chunk_offset_arr[*chunk_curr_seq]);
HDfprintf(stderr,"%s: mem_len_arr[%Zu]=%Zu\n",FUNC,*mem_curr_seq,mem_len_arr[*mem_curr_seq]);
@@ -1742,9 +1733,9 @@ HDfprintf(stderr,"%s: mem_offset_arr[%Zu]=%Hu\n",FUNC,*mem_curr_seq,mem_offset_a
* for the chunk has been defined, then don't load the chunk into the
* cache, just write the data to it directly.
*/
- if (layout->u.chunk.size>f->shared->rdcc_nbytes && dcpl_cache->pline.nused==0 &&
+ if (dset->layout.u.chunk.size>dset->cache.chunk.nbytes && dset->dcpl_cache.pline.nused==0 &&
chunk_addr!=HADDR_UNDEF) {
- if ((ret_value=H5F_contig_readvv(f, (hsize_t)layout->u.chunk.size, chunk_addr, chunk_max_nseq, chunk_curr_seq, chunk_len_arr, chunk_offset_arr, mem_max_nseq, mem_curr_seq, mem_len_arr, mem_offset_arr, dxpl_id, buf))<0)
+ if ((ret_value=H5D_contig_readvv(f, dxpl_id, dset, chunk_addr, (hsize_t)dset->layout.u.chunk.size, chunk_max_nseq, chunk_curr_seq, chunk_len_arr, chunk_offset_arr, mem_max_nseq, mem_curr_seq, mem_len_arr, mem_offset_arr, buf))<0)
HGOTO_ERROR (H5E_IO, H5E_READERROR, FAIL, "unable to read raw data to file");
} /* end if */
else {
@@ -1756,8 +1747,8 @@ HDfprintf(stderr,"%s: mem_offset_arr[%Zu]=%Hu\n",FUNC,*mem_curr_seq,mem_offset_a
* Lock the chunk, copy from application to chunk, then unlock the
* chunk.
*/
- if (NULL==(chunk=H5F_istore_lock(f, dxpl_cache, dxpl_id, layout, &dcpl_cache->pline, &dcpl_cache->fill, dcpl_cache->fill_time,
- &udata, store, FALSE, &idx_hint)))
+ if (NULL==(chunk=H5D_istore_lock(f, dxpl_cache, dxpl_id, dset, store,
+ &udata, FALSE, &idx_hint)))
HGOTO_ERROR(H5E_IO, H5E_READERROR, FAIL, "unable to read raw data chunk");
/* Use the vectorized memory copy routine to do actual work */
@@ -1765,8 +1756,8 @@ HDfprintf(stderr,"%s: mem_offset_arr[%Zu]=%Hu\n",FUNC,*mem_curr_seq,mem_offset_a
HGOTO_ERROR(H5E_IO, H5E_READERROR, FAIL, "vectorized memcpy failed");
H5_CHECK_OVERFLOW(naccessed,ssize_t,size_t);
- if (H5F_istore_unlock(f, dxpl_cache, dxpl_id, layout, &dcpl_cache->pline, FALSE,
- store, idx_hint, chunk, (size_t)naccessed)<0)
+ if (H5D_istore_unlock(f, dxpl_cache, dxpl_id, dset, store,
+ FALSE, idx_hint, chunk, (size_t)naccessed)<0)
HGOTO_ERROR(H5E_IO, H5E_READERROR, FAIL, "unable to unlock raw data chunk");
/* Set return value */
@@ -1775,11 +1766,11 @@ HDfprintf(stderr,"%s: mem_offset_arr[%Zu]=%Hu\n",FUNC,*mem_curr_seq,mem_offset_a
done:
FUNC_LEAVE_NOAPI(ret_value);
-} /* H5F_istore_readvv() */
+} /* H5D_istore_readvv() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_writevv
+ * Function: H5D_istore_writevv
*
* Purpose: Writes a multi-dimensional buffer to (part of) an indexed raw
* storage array.
@@ -1794,26 +1785,25 @@ done:
*-------------------------------------------------------------------------
*/
ssize_t
-H5F_istore_writevv(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache,
- hid_t dxpl_id, const H5O_layout_t *layout,
- const struct H5D_dcpl_cache_t *dcpl_cache, const H5D_storage_t *store,
+H5D_istore_writevv(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache,
+ hid_t dxpl_id, H5D_t *dset, const H5D_storage_t *store,
size_t chunk_max_nseq, size_t *chunk_curr_seq, size_t chunk_len_arr[], hsize_t chunk_offset_arr[],
size_t mem_max_nseq, size_t *mem_curr_seq, size_t mem_len_arr[], hsize_t mem_offset_arr[],
const void *buf)
{
- H5F_istore_ud1_t udata; /*B-tree pass-through */
+ H5D_istore_ud1_t udata; /*B-tree pass-through */
haddr_t chunk_addr; /* Chunk address on disk */
size_t u; /* Local index variables */
ssize_t ret_value; /* Return value */
- FUNC_ENTER_NOAPI(H5F_istore_writevv, FAIL);
+ FUNC_ENTER_NOAPI(H5D_istore_writevv, FAIL);
/* Check args */
assert(f);
assert(dxpl_cache);
- assert(layout && H5D_CHUNKED==layout->type);
- assert(layout->u.chunk.ndims>0 && layout->u.chunk.ndims<=H5O_LAYOUT_NDIMS);
- assert(dcpl_cache);
+ assert(dset && H5D_CHUNKED==dset->layout.type);
+ assert(dset->layout.u.chunk.ndims>0 && dset->layout.u.chunk.ndims<=H5O_LAYOUT_NDIMS);
+ assert(store);
assert(chunk_len_arr);
assert(chunk_offset_arr);
assert(mem_len_arr);
@@ -1821,19 +1811,19 @@ H5F_istore_writevv(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache,
assert(buf);
#ifndef NDEBUG
- for (u=0; u<layout->u.chunk.ndims; u++)
+ for (u=0; u<dset->layout.u.chunk.ndims; u++)
assert(store->chunk.offset[u]>=0); /*negative coordinates not supported (yet) */
#endif
/* Get the address of this chunk on disk */
#ifdef QAK
HDfprintf(stderr,"%s: chunk_coords={",FUNC);
-for(u=0; u<layout->u.chunk.ndims; u++)
- HDfprintf(stderr,"%Hd%s",chunk_coords[u],(u<(layout->u.chunk.ndims-1) ? ", " : "}\n"));
+for(u=0; u<dset->layout.u.chunk.ndims; u++)
+ HDfprintf(stderr,"%Hd%s",chunk_coords[u],(u<(dset->layout.u.chunk.ndims-1) ? ", " : "}\n"));
#endif /* QAK */
- chunk_addr=H5F_istore_get_addr(f, dxpl_id, layout, store->chunk.offset, &udata);
+ chunk_addr=H5D_istore_get_addr(f, dxpl_id, &(dset->layout), store->chunk.offset, &udata);
#ifdef QAK
-HDfprintf(stderr,"%s: chunk_addr=%a, chunk_size=%Hu\n",FUNC,chunk_addr,layout->u.chunk.size);
+HDfprintf(stderr,"%s: chunk_addr=%a, chunk_size=%Hu\n",FUNC,chunk_addr,dset->layout.u.chunk.size);
HDfprintf(stderr,"%s: chunk_len_arr[%Zu]=%Zu\n",FUNC,*chunk_curr_seq,chunk_len_arr[*chunk_curr_seq]);
HDfprintf(stderr,"%s: chunk_offset_arr[%Zu]=%Hu\n",FUNC,*chunk_curr_seq,chunk_offset_arr[*chunk_curr_seq]);
HDfprintf(stderr,"%s: mem_len_arr[%Zu]=%Zu\n",FUNC,*mem_curr_seq,mem_len_arr[*mem_curr_seq]);
@@ -1851,14 +1841,14 @@ HDfprintf(stderr,"%s: mem_offset_arr[%Zu]=%Hu\n",FUNC,*mem_curr_seq,mem_offset_a
* writing to other elements in the same chunk. Do a direct
* write-through of only the elements requested.
*/
- if ((layout->u.chunk.size>f->shared->rdcc_nbytes && dcpl_cache->pline.nused==0 && chunk_addr!=HADDR_UNDEF)
- || (IS_H5FD_MPI(f) && (H5F_ACC_RDWR & f->shared->flags))) {
+ if ((dset->layout.u.chunk.size>dset->cache.chunk.nbytes && dset->dcpl_cache.pline.nused==0 && chunk_addr!=HADDR_UNDEF)
+ || (IS_H5FD_MPI(f) && (H5F_ACC_RDWR & H5F_get_intent(f)))) {
#ifdef H5_HAVE_PARALLEL
/* Additional sanity check when operating in parallel */
- if (chunk_addr==HADDR_UNDEF || dcpl_cache->pline.nused>0)
+ if (chunk_addr==HADDR_UNDEF || dset->dcpl_cache.pline.nused>0)
HGOTO_ERROR (H5E_IO, H5E_WRITEERROR, FAIL, "unable to locate raw data chunk");
#endif /* H5_HAVE_PARALLEL */
- if ((ret_value=H5F_contig_writevv(f, (hsize_t)layout->u.chunk.size, chunk_addr, chunk_max_nseq, chunk_curr_seq, chunk_len_arr, chunk_offset_arr, mem_max_nseq, mem_curr_seq, mem_len_arr, mem_offset_arr, dxpl_id, buf))<0)
+ if ((ret_value=H5D_contig_writevv(f, dxpl_id, dset, chunk_addr, (hsize_t)dset->layout.u.chunk.size, chunk_max_nseq, chunk_curr_seq, chunk_len_arr, chunk_offset_arr, mem_max_nseq, mem_curr_seq, mem_len_arr, mem_offset_arr, buf))<0)
HGOTO_ERROR (H5E_IO, H5E_WRITEERROR, FAIL, "unable to write raw data to file");
} /* end if */
else {
@@ -1871,13 +1861,13 @@ HDfprintf(stderr,"%s: mem_offset_arr[%Zu]=%Hu\n",FUNC,*mem_curr_seq,mem_offset_a
* Lock the chunk, copy from application to chunk, then unlock the
* chunk.
*/
- if(chunk_max_nseq==1 && chunk_len_arr[0] == layout->u.chunk.size)
+ if(chunk_max_nseq==1 && chunk_len_arr[0] == dset->layout.u.chunk.size)
relax = TRUE;
else
relax = FALSE;
- if (NULL==(chunk=H5F_istore_lock(f, dxpl_cache, dxpl_id, layout, &dcpl_cache->pline, &dcpl_cache->fill, dcpl_cache->fill_time,
- &udata, store, relax, &idx_hint)))
+ if (NULL==(chunk=H5D_istore_lock(f, dxpl_cache, dxpl_id, dset, store,
+ &udata, relax, &idx_hint)))
HGOTO_ERROR (H5E_IO, H5E_WRITEERROR, FAIL, "unable to read raw data chunk");
/* Use the vectorized memory copy routine to do actual work */
@@ -1885,8 +1875,8 @@ HDfprintf(stderr,"%s: mem_offset_arr[%Zu]=%Hu\n",FUNC,*mem_curr_seq,mem_offset_a
HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "vectorized memcpy failed");
H5_CHECK_OVERFLOW(naccessed,ssize_t,size_t);
- if (H5F_istore_unlock(f, dxpl_cache, dxpl_id, layout, &dcpl_cache->pline, TRUE,
- store, idx_hint, chunk, (size_t)naccessed)<0)
+ if (H5D_istore_unlock(f, dxpl_cache, dxpl_id, dset, store,
+ TRUE, idx_hint, chunk, (size_t)naccessed)<0)
HGOTO_ERROR (H5E_IO, H5E_WRITEERROR, FAIL, "uanble to unlock raw data chunk");
/* Set return value */
@@ -1895,11 +1885,11 @@ HDfprintf(stderr,"%s: mem_offset_arr[%Zu]=%Hu\n",FUNC,*mem_curr_seq,mem_offset_a
done:
FUNC_LEAVE_NOAPI(ret_value);
-} /* H5F_istore_writevv() */
+} /* H5D_istore_writevv() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_create
+ * Function: H5D_istore_create
*
* Purpose: Creates a new indexed-storage B-tree and initializes the
* istore struct with information about the storage. The
@@ -1919,15 +1909,15 @@ done:
*-------------------------------------------------------------------------
*/
herr_t
-H5F_istore_create(H5F_t *f, hid_t dxpl_id, H5O_layout_t *layout /*out */ )
+H5D_istore_create(H5F_t *f, hid_t dxpl_id, H5O_layout_t *layout /*out */ )
{
- H5F_istore_ud1_t udata;
+ H5D_istore_ud1_t udata;
#ifndef NDEBUG
unsigned u;
#endif
herr_t ret_value=SUCCEED; /* Return value */
- FUNC_ENTER_NOAPI(H5F_istore_create, FAIL);
+ FUNC_ENTER_NOAPI(H5D_istore_create, FAIL);
/* Check args */
assert(f);
@@ -1944,11 +1934,11 @@ H5F_istore_create(H5F_t *f, hid_t dxpl_id, H5O_layout_t *layout /*out */ )
done:
FUNC_LEAVE_NOAPI(ret_value);
-}
+} /* end H5D_istore_create() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_allocated
+ * Function: H5D_istore_allocated
*
* Purpose: Return the number of bytes allocated in the file for storage
* of raw data under the specified B-tree (ADDR is the address
@@ -1967,15 +1957,15 @@ done:
*-------------------------------------------------------------------------
*/
hsize_t
-H5F_istore_allocated(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout)
+H5D_istore_allocated(H5F_t *f, hid_t dxpl_id, H5D_t *dset)
{
- H5F_rdcc_t *rdcc = &(f->shared->rdcc); /*raw data chunk cache */
- H5F_rdcc_ent_t *ent; /*cache entry */
+ H5D_rdcc_t *rdcc = &(dset->cache.chunk); /*raw data chunk cache */
+ H5D_rdcc_ent_t *ent; /*cache entry */
H5D_dxpl_cache_t dxpl_cache; /* Cached data transfer properties */
- H5F_istore_ud1_t udata;
+ H5D_istore_ud1_t udata;
hsize_t ret_value; /* Return value */
- FUNC_ENTER_NOAPI(H5F_istore_allocated, 0);
+ FUNC_ENTER_NOAPI(H5D_istore_allocated, 0);
/* Fill the DXPL cache values for later use */
if (H5D_get_dxpl_cache(dxpl_id,&dxpl_cache)<0)
@@ -1983,17 +1973,14 @@ H5F_istore_allocated(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout)
/* Search for cached chunks that haven't been written out */
for(ent = rdcc->head; ent; ent = ent->next) {
- /* Make certain we are dealing with the correct B-tree, etc */
- if (H5F_addr_eq(layout->u.chunk.addr, ent->layout.u.chunk.addr)) {
- /* Flush the chunk out to disk, to make certain the size is correct later */
- if (H5F_istore_flush_entry(f, &dxpl_cache, dxpl_id, ent, FALSE)<0)
- HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, 0, "cannot flush indexed storage buffer");
- } /* end if */
+ /* Flush the chunk out to disk, to make certain the size is correct later */
+ if (H5D_istore_flush_entry(f, &dxpl_cache, dxpl_id, dset, ent, FALSE)<0)
+ HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, 0, "cannot flush indexed storage buffer");
} /* end for */
HDmemset(&udata, 0, sizeof udata);
- udata.mesg.u.chunk.ndims = layout->u.chunk.ndims;
- if (H5B_iterate(f, dxpl_id, H5B_ISTORE, H5F_istore_iter_allocated, layout->u.chunk.addr, &udata)<0)
+ udata.mesg.u.chunk.ndims = dset->layout.u.chunk.ndims;
+ if (H5B_iterate(f, dxpl_id, H5B_ISTORE, H5D_istore_iter_allocated, dset->layout.u.chunk.addr, &udata)<0)
HGOTO_ERROR(H5E_IO, H5E_CANTINIT, 0, "unable to iterate over chunk B-tree");
/* Set return value */
@@ -2001,11 +1988,11 @@ H5F_istore_allocated(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout)
done:
FUNC_LEAVE_NOAPI(ret_value);
-} /* end H5F_istore_allocated() */
+} /* end H5D_istore_allocated() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_get_addr
+ * Function: H5D_istore_get_addr
*
* Purpose: Get the file address of a chunk if file space has been
* assigned. Save the retrieved information in the udata
@@ -2023,15 +2010,15 @@ done:
*-------------------------------------------------------------------------
*/
static haddr_t
-H5F_istore_get_addr(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout,
- const hssize_t offset[], H5F_istore_ud1_t *_udata)
+H5D_istore_get_addr(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout,
+ const hssize_t offset[], H5D_istore_ud1_t *_udata)
{
- H5F_istore_ud1_t tmp_udata; /* Information about a chunk */
- H5F_istore_ud1_t *udata; /* Pointer to information about a chunk */
+ H5D_istore_ud1_t tmp_udata; /* Information about a chunk */
+ H5D_istore_ud1_t *udata; /* Pointer to information about a chunk */
unsigned u;
haddr_t ret_value; /* Return value */
- FUNC_ENTER_NOAPI_NOINIT(H5F_istore_get_addr);
+ FUNC_ENTER_NOAPI_NOINIT(H5D_istore_get_addr);
assert(f);
assert(layout && (layout->u.chunk.ndims > 0));
@@ -2058,11 +2045,11 @@ H5F_istore_get_addr(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout,
done:
FUNC_LEAVE_NOAPI(ret_value);
-} /* H5F_istore_get_addr() */
+} /* H5D_istore_get_addr() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_chunk_alloc
+ * Function: H5D_istore_chunk_alloc
*
* Purpose: Allocate space for a chunk in memory. This routine allocates
* memory space for non-filtered chunks from a block free list
@@ -2078,11 +2065,11 @@ done:
*-------------------------------------------------------------------------
*/
static void *
-H5F_istore_chunk_alloc(size_t size, const H5O_pline_t *pline)
+H5D_istore_chunk_alloc(size_t size, const H5O_pline_t *pline)
{
void *ret_value=NULL; /* Return value */
- FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5F_istore_chunk_alloc);
+ FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5D_istore_chunk_alloc);
assert(size);
assert(pline);
@@ -2093,11 +2080,11 @@ H5F_istore_chunk_alloc(size_t size, const H5O_pline_t *pline)
ret_value=H5FL_BLK_MALLOC(chunk,size);
FUNC_LEAVE_NOAPI(ret_value);
-} /* H5F_istore_chunk_alloc() */
+} /* H5D_istore_chunk_alloc() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_chunk_xfree
+ * Function: H5D_istore_chunk_xfree
*
* Purpose: Free space for a chunk in memory. This routine allocates
* memory space for non-filtered chunks from a block free list
@@ -2113,9 +2100,9 @@ H5F_istore_chunk_alloc(size_t size, const H5O_pline_t *pline)
*-------------------------------------------------------------------------
*/
static void *
-H5F_istore_chunk_xfree(void *chk, const H5O_pline_t *pline)
+H5D_istore_chunk_xfree(void *chk, const H5O_pline_t *pline)
{
- FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5F_istore_chunk_xfree);
+ FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5D_istore_chunk_xfree);
assert(pline);
@@ -2127,11 +2114,11 @@ H5F_istore_chunk_xfree(void *chk, const H5O_pline_t *pline)
} /* end if */
FUNC_LEAVE_NOAPI(NULL);
-} /* H5F_istore_chunk_xfree() */
+} /* H5D_istore_chunk_xfree() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_allocate
+ * Function: H5D_istore_allocate
*
* Purpose: Allocate file space for all chunks that are not allocated yet.
* Return SUCCEED if all needed allocation succeed, otherwise
@@ -2145,6 +2132,9 @@ H5F_istore_chunk_xfree(void *chk, const H5O_pline_t *pline)
* This should be changed to do a direct flush independent
* of the cache value.
*
+ * This routine might be called before the dcpl_cache is set up
+ * correctly, so don't use those values.
+ *
* Programmer: Albert Cheng
* June 26, 1998
*
@@ -2171,8 +2161,8 @@ H5F_istore_chunk_xfree(void *chk, const H5O_pline_t *pline)
*-------------------------------------------------------------------------
*/
herr_t
-H5F_istore_allocate(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout,
- const hsize_t *space_dim, H5P_genplist_t *dc_plist, hbool_t full_overwrite)
+H5D_istore_allocate(H5F_t *f, hid_t dxpl_id, const H5D_t *dset,
+ hbool_t full_overwrite)
{
hssize_t chunk_offset[H5O_LAYOUT_NDIMS]; /* Offset of current chunk */
hsize_t chunk_size; /* Size of chunk in bytes */
@@ -2181,7 +2171,7 @@ H5F_istore_allocate(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout,
H5D_fill_time_t fill_time; /* When to write fill values */
H5D_fill_value_t fill_status; /* The fill value status */
unsigned should_fill=0; /* Whether fill values should be written */
- H5F_istore_ud1_t udata; /* B-tree pass-through for creating chunk */
+ H5D_istore_ud1_t udata; /* B-tree pass-through for creating chunk */
void *chunk=NULL; /* Chunk buffer for writing fill values */
H5P_genplist_t *dx_plist; /* Data xfer property list */
#ifdef H5_HAVE_PARALLEL
@@ -2197,18 +2187,28 @@ H5F_istore_allocate(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout,
unsigned u; /* Local index variable */
H5Z_EDC_t edc; /* Decide whether to enable EDC for read */
H5Z_cb_t cb_struct;
+ H5P_genplist_t *dc_plist; /* Property list */
+ int space_ndims; /* Dataset's space rank */
+ hsize_t space_dim[H5O_LAYOUT_NDIMS]; /* Dataset's dataspace dimensions */
herr_t ret_value=SUCCEED; /* Return value */
- FUNC_ENTER_NOAPI(H5F_istore_allocate, FAIL);
+ FUNC_ENTER_NOAPI(H5D_istore_allocate, FAIL);
/* Check args */
assert(f);
- assert(space_dim);
- assert(layout && H5D_CHUNKED==layout->type);
- assert(layout->u.chunk.ndims>0 && layout->u.chunk.ndims<=H5O_LAYOUT_NDIMS);
- assert(H5F_addr_defined(layout->u.chunk.addr));
assert(TRUE==H5P_isa_class(dxpl_id,H5P_DATASET_XFER));
- assert(dc_plist);
+ assert(dset && H5D_CHUNKED==dset->layout.type);
+ assert(dset->layout.u.chunk.ndims>0 && dset->layout.u.chunk.ndims<=H5O_LAYOUT_NDIMS);
+ assert(H5F_addr_defined(dset->layout.u.chunk.addr));
+
+ /* Get dataset's creation property list */
+ if (NULL == (dc_plist = H5I_object(dset->dcpl_id)))
+ HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataset creation property list")
+
+ /* We only handle simple data spaces so far */
+ if ((space_ndims=H5S_get_simple_extent_dims(dset->space, space_dim, NULL))<0)
+ HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to get simple data space info")
+ space_dim[space_ndims] = dset->layout.u.chunk.dim[space_ndims];
/* Get necessary properties from dataset creation property list */
if(H5P_get(dc_plist, H5D_CRT_FILL_VALUE_NAME, &fill) < 0)
@@ -2227,54 +2227,28 @@ H5F_istore_allocate(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout,
HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't get filter callback struct");
#ifdef H5_HAVE_PARALLEL
- /* Retrieve up MPI parameters */
- if(IS_H5FD_MPIO(f)) {
+ /* Retrieve MPI parameters */
+ if(IS_H5FD_MPI(f)) {
/* Get the MPI communicator */
- if (MPI_COMM_NULL == (mpi_comm=H5FD_mpio_communicator(f->shared->lf)))
+ if (MPI_COMM_NULL == (mpi_comm=H5F_mpi_get_comm(f)))
HGOTO_ERROR(H5E_INTERNAL, H5E_MPI, FAIL, "Can't retrieve MPI communicator");
- /* Get the MPI rank & size */
- if ((mpi_rank=H5FD_mpio_mpi_rank(f->shared->lf))<0)
+ /* Get the MPI rank */
+ if ((mpi_rank=H5F_mpi_get_rank(f))<0)
HGOTO_ERROR(H5E_INTERNAL, H5E_MPI, FAIL, "Can't retrieve MPI rank");
/* Set the MPI-capable file driver flag */
using_mpi=1;
} /* end if */
- else if(IS_H5FD_MPIPOSIX(f)) {
- /* Get the MPI communicator */
- if (MPI_COMM_NULL == (mpi_comm=H5FD_mpiposix_communicator(f->shared->lf)))
- HGOTO_ERROR(H5E_INTERNAL, H5E_MPI, FAIL, "Can't retrieve MPI communicator");
-
- /* Get the MPI rank & size */
- if ((mpi_rank=H5FD_mpiposix_mpi_rank(f->shared->lf))<0)
- HGOTO_ERROR(H5E_INTERNAL, H5E_MPI, FAIL, "Can't retrieve MPI rank");
-
- /* Set the MPI-capable file driver flag */
- using_mpi=1;
- } /* end else */
-#ifdef H5_HAVE_FPHDF5
- else if (IS_H5FD_FPHDF5(f)) {
- /* Get the FPHDF5 barrier communicator */
- if (MPI_COMM_NULL == (mpi_comm = H5FD_fphdf5_barrier_communicator(f->shared->lf)))
- HGOTO_ERROR(H5E_INTERNAL, H5E_MPI, FAIL, "Can't retrieve MPI communicator");
-
- /* Get the MPI rank & size */
- if ((mpi_rank = H5FD_fphdf5_mpi_rank(f->shared->lf)) < 0)
- HGOTO_ERROR(H5E_INTERNAL, H5E_MPI, FAIL, "Can't retrieve MPI rank");
-
- /* Set the MPI-capable file driver flag */
- using_mpi = 1;
- } /* end if */
-#endif /* H5_HAVE_FPHDF5 */
#endif /* H5_HAVE_PARALLEL */
/*
* Setup indice to go through all chunks. (Future improvement
* should allocate only chunks that have no file space assigned yet.
*/
- for (u=0; u<layout->u.chunk.ndims; u++)
+ for (u=0; u<dset->layout.u.chunk.ndims; u++)
chunk_offset[u] = 0;
- chunk_size = layout->u.chunk.size;
+ chunk_size = dset->layout.u.chunk.size;
/* Check the dataset's fill-value status */
if (H5P_is_fill_value_defined(&fill, &fill_status) < 0)
@@ -2292,7 +2266,7 @@ H5F_istore_allocate(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout,
if(should_fill) {
/* Allocate chunk buffer for processes to use when writing fill values */
H5_CHECK_OVERFLOW(chunk_size,hsize_t,size_t);
- if (NULL==(chunk = H5F_istore_chunk_alloc((size_t)chunk_size,&pline)))
+ if (NULL==(chunk = H5D_istore_chunk_alloc((size_t)chunk_size,&pline)))
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for chunk");
/* Fill the chunk with the proper values */
@@ -2329,41 +2303,36 @@ H5F_istore_allocate(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout,
while (carry==0) {
/* Check if the chunk exists yet on disk */
chunk_exists=1;
- if(H5F_istore_get_addr(f,dxpl_id,layout,chunk_offset, NULL)==HADDR_UNDEF) {
- H5F_rdcc_t *rdcc = &(f->shared->rdcc); /*raw data chunk cache */
- H5F_rdcc_ent_t *ent = NULL; /*cache entry */
+ if(H5D_istore_get_addr(f,dxpl_id,&(dset->layout),chunk_offset, NULL)==HADDR_UNDEF) {
+ const H5D_rdcc_t *rdcc = &(dset->cache.chunk); /*raw data chunk cache */
+ H5D_rdcc_ent_t *ent = NULL; /*cache entry */
/* Didn't find the chunk on disk */
chunk_exists = 0;
/* Look for chunk in cache */
for(ent = rdcc->head; ent && !chunk_exists; ent = ent->next) {
- /* Make certain we are dealing with the correct B-tree, etc */
- if (layout->u.chunk.ndims==ent->layout.u.chunk.ndims &&
- H5F_addr_eq(layout->u.chunk.addr, ent->layout.u.chunk.addr)) {
-
- /* Assume a match */
- chunk_exists = 1;
- for(u = 0; u < layout->u.chunk.ndims && chunk_exists; u++) {
- if(ent->offset[u] != chunk_offset[u])
- chunk_exists = 0; /* Reset if no match */
- } /* end for */
- } /* end if */
+ /* Assume a match */
+ chunk_exists = 1;
+ for(u = 0; u < dset->layout.u.chunk.ndims && chunk_exists; u++) {
+ if(ent->offset[u] != chunk_offset[u])
+ chunk_exists = 0; /* Reset if no match */
+ } /* end for */
} /* end for */
} /* end if */
if(!chunk_exists) {
/* Initialize the chunk information */
- udata.mesg = *layout;
+ udata.mesg = dset->layout;
udata.key.filter_mask = 0;
udata.addr = HADDR_UNDEF;
H5_CHECK_OVERFLOW(chunk_size,hsize_t,size_t);
udata.key.nbytes = (size_t)chunk_size;
- for (u=0; u<layout->u.chunk.ndims; u++)
+ for (u=0; u<dset->layout.u.chunk.ndims; u++)
udata.key.offset[u] = chunk_offset[u];
/* Allocate the chunk with all processes */
- if (H5B_insert(f, dxpl_id, H5B_ISTORE, layout->u.chunk.addr, &udata)<0)
+ if (H5B_insert(f, dxpl_id, H5B_ISTORE, dset->layout.u.chunk.addr, &udata)<0)
HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "unable to allocate chunk");
/* Check if fill values should be written to blocks */
@@ -2392,8 +2361,8 @@ H5F_istore_allocate(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout,
} /* end if */
/* Increment indices */
- for (i=layout->u.chunk.ndims-1, carry=1; i>=0 && carry; --i) {
- chunk_offset[i] += layout->u.chunk.dim[i];
+ for (i=dset->layout.u.chunk.ndims-1, carry=1; i>=0 && carry; --i) {
+ chunk_offset[i] += dset->layout.u.chunk.dim[i];
if (chunk_offset[i] >= (hssize_t)(space_dim[i]))
chunk_offset[i] = 0;
else
@@ -2417,14 +2386,14 @@ H5F_istore_allocate(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout,
done:
/* Free the chunk for fill values */
if(chunk!=NULL)
- H5F_istore_chunk_xfree(chunk,&pline);
+ H5D_istore_chunk_xfree(chunk,&pline);
FUNC_LEAVE_NOAPI(ret_value);
-}
+} /* end H5D_istore_allocate() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_prune_by_extent
+ * Function: H5D_istore_prune_by_extent
*
* Purpose: This function searches for chunks that are no longer necessary both in the
* raw data cache and in the B-tree.
@@ -2524,28 +2493,28 @@ done:
*-------------------------------------------------------------------------
*/
herr_t
-H5F_istore_prune_by_extent(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache,
- hid_t dxpl_id, const H5O_layout_t *layout, const H5S_t * space)
+H5D_istore_prune_by_extent(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache,
+ hid_t dxpl_id, H5D_t *dset)
{
- H5F_rdcc_t *rdcc = &(f->shared->rdcc); /*raw data chunk cache */
- H5F_rdcc_ent_t *ent = NULL, *next = NULL; /*cache entry */
+ H5D_rdcc_t *rdcc = &(dset->cache.chunk); /*raw data chunk cache */
+ H5D_rdcc_ent_t *ent = NULL, *next = NULL; /*cache entry */
unsigned u; /*counters */
int found; /*remove this entry */
- H5F_istore_ud1_t udata; /*B-tree pass-through */
+ H5D_istore_ud1_t udata; /*B-tree pass-through */
hsize_t curr_dims[H5O_LAYOUT_NDIMS]; /*current dataspace dimensions */
herr_t ret_value=SUCCEED; /* Return value */
- FUNC_ENTER_NOAPI(H5F_istore_prune_by_extent, FAIL);
+ FUNC_ENTER_NOAPI(H5D_istore_prune_by_extent, FAIL);
/* Check args */
assert(f);
- assert(layout && H5D_CHUNKED == layout->type);
- assert(layout->u.chunk.ndims > 0 && layout->u.chunk.ndims <= H5O_LAYOUT_NDIMS);
- assert(H5F_addr_defined(layout->u.chunk.addr));
- assert(space);
+ assert(dxpl_cache);
+ assert(dset && H5D_CHUNKED == dset->layout.type);
+ assert(dset->layout.u.chunk.ndims > 0 && dset->layout.u.chunk.ndims <= H5O_LAYOUT_NDIMS);
+ assert(H5F_addr_defined(dset->layout.u.chunk.addr));
/* Go get the rank & dimensions */
- if(H5S_get_simple_extent_dims(space, curr_dims, NULL) < 0)
+ if(H5S_get_simple_extent_dims(dset->space, curr_dims, NULL) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't get dataset dimensions");
/*-------------------------------------------------------------------------
@@ -2557,26 +2526,23 @@ H5F_istore_prune_by_extent(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache,
for(ent = rdcc->head; ent; ent = next) {
next = ent->next;
- /* Make certain we are dealing with the correct B-tree, etc */
- if (H5F_addr_eq(layout->u.chunk.addr, ent->layout.u.chunk.addr)) {
- for(u = 0; u < ent->layout.u.chunk.ndims - 1; u++) {
- if((hsize_t)ent->offset[u] > curr_dims[u]) {
- found = 1;
- break;
- }
- }
- } /* end if */
+ for(u = 0; u < dset->layout.u.chunk.ndims - 1; u++) {
+ if((hsize_t)ent->offset[u] > curr_dims[u]) {
+ found = 1;
+ break;
+ } /* end if */
+ } /* end for */
if(found) {
-#ifdef H5F_ISTORE_DEBUG
+#ifdef H5D_ISTORE_DEBUG
HDfputs("cache:remove:[", stderr);
- for(u = 0; u < ent->layout.u.chunk.ndims - 1; u++)
+ for(u = 0; u < dset->layout.u.chunk.ndims - 1; u++)
HDfprintf(stderr, "%s%Hd", u ? ", " : "", ent->offset[u]);
HDfputs("]\n", stderr);
#endif
/* Preempt the entry from the cache, but do not flush it to disk */
- if(H5F_istore_preempt(f, dxpl_cache, dxpl_id, ent, FALSE) < 0)
+ if(H5D_istore_preempt(f, dxpl_cache, dxpl_id, dset, ent, FALSE) < 0)
HGOTO_ERROR(H5E_IO, H5E_CANTINIT, 0, "unable to preempt chunk");
found=0;
@@ -2590,22 +2556,22 @@ H5F_istore_prune_by_extent(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache,
HDmemset(&udata, 0, sizeof udata);
udata.stream = stdout;
- udata.mesg.u.chunk.addr = layout->u.chunk.addr;
- udata.mesg.u.chunk.ndims = layout->u.chunk.ndims;
- for(u = 0; u < udata.mesg.u.chunk.ndims; u++)
- udata.mesg.u.chunk.dim[u] = layout->u.chunk.dim[u];
+ udata.mesg.u.chunk.addr = dset->layout.u.chunk.addr;
+ udata.mesg.u.chunk.ndims = dset->layout.u.chunk.ndims;
+ for(u = 0; u < dset->layout.u.chunk.ndims; u++)
+ udata.mesg.u.chunk.dim[u] = dset->layout.u.chunk.dim[u];
udata.dims = curr_dims;
- if(H5B_iterate(f, dxpl_id, H5B_ISTORE, H5F_istore_prune_extent, layout->u.chunk.addr, &udata) < 0)
+ if(H5B_iterate(f, dxpl_id, H5B_ISTORE, H5D_istore_prune_extent, dset->layout.u.chunk.addr, &udata) < 0)
HGOTO_ERROR(H5E_IO, H5E_CANTINIT, 0, "unable to iterate over B-tree");
done:
FUNC_LEAVE_NOAPI(ret_value);
-}
+} /* end H5D_istore_prune_by_extent() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_prune_extent
+ * Function: H5D_istore_prune_extent
*
* Purpose: Search for chunks that are no longer necessary in the B-tree.
*
@@ -2615,32 +2581,32 @@ done:
*
* Date: March 26, 2002
*
- * Comments: Called by H5B_prune_by_extent, part of H5B_ISTORE
+ * Comments: Called by H5D_prune_by_extent
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static int
-H5F_istore_prune_extent(H5F_t *f, hid_t dxpl_id, void *_lt_key, haddr_t UNUSED addr,
+H5D_istore_prune_extent(H5F_t *f, hid_t dxpl_id, void *_lt_key, haddr_t UNUSED addr,
void UNUSED *_rt_key, void *_udata)
{
- H5F_istore_ud1_t *bt_udata = (H5F_istore_ud1_t *)_udata;
- H5F_istore_key_t *lt_key = (H5F_istore_key_t *)_lt_key;
+ H5D_istore_ud1_t *bt_udata = (H5D_istore_ud1_t *)_udata;
+ H5D_istore_key_t *lt_key = (H5D_istore_key_t *)_lt_key;
unsigned u;
- H5F_istore_ud1_t udata;
+ H5D_istore_ud1_t udata;
int ret_value=H5B_ITER_CONT; /* Return value */
/* The LT_KEY is the left key (the one that describes the chunk). It points to a chunk of
* storage that contains the beginning of the logical address space represented by UDATA.
*/
- FUNC_ENTER_NOAPI_NOINIT(H5F_istore_prune_extent);
+ FUNC_ENTER_NOAPI_NOINIT(H5D_istore_prune_extent);
/* Figure out what chunks are no longer in use for the specified extent and release them */
for(u = 0; u < bt_udata->mesg.u.chunk.ndims - 1; u++)
if((hsize_t)lt_key->offset[u] > bt_udata->dims[u]) {
-#ifdef H5F_ISTORE_DEBUG
+#ifdef H5D_ISTORE_DEBUG
HDfputs("b-tree:remove:[", bt_udata->stream);
for(u = 0; u < bt_udata->mesg.u.chunk.ndims - 1; u++)
HDfprintf(bt_udata->stream, "%s%Hd", u ? ", " : "", lt_key->offset[u]);
@@ -2659,11 +2625,11 @@ H5F_istore_prune_extent(H5F_t *f, hid_t dxpl_id, void *_lt_key, haddr_t UNUSED a
done:
FUNC_LEAVE_NOAPI(ret_value);
-}
+} /* end H5D_istore_prune_extent() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_remove
+ * Function: H5D_istore_remove
*
* Purpose: Removes chunks that are no longer necessary in the B-tree.
*
@@ -2681,20 +2647,16 @@ done:
*-------------------------------------------------------------------------
*/
static H5B_ins_t
-H5F_istore_remove(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *_lt_key /*in,out */ ,
+H5D_istore_remove(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *_lt_key /*in,out */ ,
hbool_t *lt_key_changed /*out */ ,
void UNUSED * _udata /*in,out */ ,
void UNUSED * _rt_key /*in,out */ ,
hbool_t *rt_key_changed /*out */ )
{
- H5F_istore_key_t *lt_key = (H5F_istore_key_t *)_lt_key;
+ H5D_istore_key_t *lt_key = (H5D_istore_key_t *)_lt_key;
H5B_ins_t ret_value=H5B_INS_REMOVE; /* Return value */
- FUNC_ENTER_NOAPI(H5F_istore_remove,H5B_INS_ERROR);
-
- /* Check for overlap with the sieve buffer and reset it */
- if (H5F_sieve_overlap_clear(f, dxpl_id, addr, (hsize_t)lt_key->nbytes)<0)
- HGOTO_ERROR(H5E_OHDR, H5E_CANTFREE, H5B_INS_ERROR, "unable to clear sieve buffer");
+ FUNC_ENTER_NOAPI(H5D_istore_remove,H5B_INS_ERROR);
/* Remove raw data chunk from file */
H5MF_xfree(f, H5FD_MEM_DRAW, dxpl_id, addr, (hsize_t)lt_key->nbytes);
@@ -2705,11 +2667,11 @@ H5F_istore_remove(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *_lt_key /*in,out
done:
FUNC_LEAVE_NOAPI(ret_value);
-}
+} /* end H5D_istore_remove() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_initialize_by_extent
+ * Function: H5D_istore_initialize_by_extent
*
* Purpose: This function searches for chunks that have to be initialized with the fill
* value both in the raw data cache and in the B-tree.
@@ -2722,7 +2684,7 @@ done:
*
* Comments:
*
- * (See the example of H5F_istore_prune_by_extent)
+ * (See the example of H5D_istore_prune_by_extent)
* Next, there are seven chunks where the database extent boundary is
* within the chunk. We find those seven just like we did with the previous nine.
* Fot the ones that are allocated we initialize the part that lies outside the boundary
@@ -2733,9 +2695,8 @@ done:
*-------------------------------------------------------------------------
*/
herr_t
-H5F_istore_initialize_by_extent(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache,
- hid_t dxpl_id, const H5O_layout_t *layout,
- H5P_genplist_t *dc_plist, const H5S_t * space)
+H5D_istore_initialize_by_extent(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache,
+ hid_t dxpl_id, H5D_t *dset)
{
uint8_t *chunk = NULL; /*the file chunk */
unsigned idx_hint = 0; /*input value for H5F_istore_lock */
@@ -2758,20 +2719,25 @@ H5F_istore_initialize_by_extent(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_ca
int i, carry; /*counters */
unsigned u;
int found = 0; /*initialize this entry */
+ H5P_genplist_t *dc_plist; /* Property list */
H5O_pline_t pline; /* I/O pipeline information */
H5O_fill_t fill; /* Fill value information */
H5D_fill_time_t fill_time; /* Fill time information */
H5D_storage_t store; /* Dataset storage information */
herr_t ret_value=SUCCEED; /* Return value */
- FUNC_ENTER_NOAPI(H5F_istore_initialize_by_extent, FAIL);
+ FUNC_ENTER_NOAPI(H5D_istore_initialize_by_extent, FAIL);
/* Check args */
assert(f);
- assert(layout && H5D_CHUNKED == layout->type);
- assert(layout->u.chunk.ndims > 0 && layout->u.chunk.ndims <= H5O_LAYOUT_NDIMS);
- assert(H5F_addr_defined(layout->u.chunk.addr));
- assert(space);
+ assert(dxpl_cache);
+ assert(dset && H5D_CHUNKED == dset->layout.type);
+ assert(dset->layout.u.chunk.ndims > 0 && dset->layout.u.chunk.ndims <= H5O_LAYOUT_NDIMS);
+ assert(H5F_addr_defined(dset->layout.u.chunk.addr));
+
+ /* Get dataset's creation property list */
+ if (NULL == (dc_plist = H5I_object(dset->dcpl_id)))
+ HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataset creation property list")
/* Get necessary properties from property list */
if(H5P_get(dc_plist, H5D_CRT_FILL_VALUE_NAME, &fill) < 0)
@@ -2786,7 +2752,7 @@ H5F_istore_initialize_by_extent(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_ca
HDmemset(count, 0, sizeof(count));
/* Go get the rank & dimensions */
- if((srank = H5S_get_simple_extent_dims(space, curr_dims, NULL)) < 0)
+ if((srank = H5S_get_simple_extent_dims(dset->space, curr_dims, NULL)) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't get dataset dimensions");
H5_ASSIGN_OVERFLOW(rank,srank,int,unsigned);
@@ -2795,9 +2761,9 @@ H5F_istore_initialize_by_extent(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_ca
size[u] = curr_dims[u];
/* Round up to the next integer # of chunks, to accomodate partial chunks */
- chunks[u] = ((curr_dims[u]+layout->u.chunk.dim[u])-1) / layout->u.chunk.dim[u];
+ chunks[u] = ((curr_dims[u]+dset->layout.u.chunk.dim[u])-1) / dset->layout.u.chunk.dim[u];
} /* end for */
- size[u] = layout->u.chunk.dim[u];
+ size[u] = dset->layout.u.chunk.dim[u];
/* Get the "down" sizes for each dimension */
if(H5V_array_down(rank,chunks,down_chunks)<0)
@@ -2805,7 +2771,7 @@ H5F_istore_initialize_by_extent(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_ca
/* Create a data space for a chunk & set the extent */
for(u = 0; u < rank; u++)
- chunk_dims[u] = layout->u.chunk.dim[u];
+ chunk_dims[u] = dset->layout.u.chunk.dim[u];
if(NULL == (space_chunk = H5S_create_simple(rank,chunk_dims,NULL)))
HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCREATE, FAIL, "can't create simple dataspace");
@@ -2814,18 +2780,18 @@ H5F_istore_initialize_by_extent(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_ca
* loop through the chunks copying each chunk from the application to the
* chunk cache.
*/
- for(u = 0; u < layout->u.chunk.ndims; u++) {
- idx_max[u] = (size[u] - 1) / layout->u.chunk.dim[u] + 1;
+ for(u = 0; u < dset->layout.u.chunk.ndims; u++) {
+ idx_max[u] = (size[u] - 1) / dset->layout.u.chunk.dim[u] + 1;
idx_cur[u] = 0;
} /* end for */
/* Loop over all chunks */
carry=0;
while(carry==0) {
- for(u = 0, naccessed = 1; u < layout->u.chunk.ndims; u++) {
+ for(u = 0, naccessed = 1; u < dset->layout.u.chunk.ndims; u++) {
/* The location and size of the chunk being accessed */
- chunk_offset[u] = idx_cur[u] * (hssize_t)(layout->u.chunk.dim[u]);
- sub_size[u] = MIN((idx_cur[u] + 1) * layout->u.chunk.dim[u],
+ chunk_offset[u] = idx_cur[u] * (hssize_t)(dset->layout.u.chunk.dim[u]);
+ sub_size[u] = MIN((idx_cur[u] + 1) * dset->layout.u.chunk.dim[u],
size[u]) - chunk_offset[u];
naccessed *= sub_size[u];
} /* end for */
@@ -2834,8 +2800,8 @@ H5F_istore_initialize_by_extent(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_ca
* Figure out what chunks have to be initialized. These are the chunks where the dataspace
* extent boundary is within the chunk
*/
- for(u = 0, found = 0; u < layout->u.chunk.ndims - 1; u++) {
- end_chunk = chunk_offset[u] + layout->u.chunk.dim[u];
+ for(u = 0, found = 0; u < dset->layout.u.chunk.ndims - 1; u++) {
+ end_chunk = chunk_offset[u] + dset->layout.u.chunk.dim[u];
if(end_chunk > size[u]) {
found = 1;
break;
@@ -2845,27 +2811,27 @@ H5F_istore_initialize_by_extent(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_ca
if(found) {
/* Calculate the index of this chunk */
- if(H5V_chunk_index(rank,chunk_offset,layout->u.chunk.dim,down_chunks,&store.chunk.index)<0)
+ if(H5V_chunk_index(rank,chunk_offset,dset->layout.u.chunk.dim,down_chunks,&store.chunk.index)<0)
HGOTO_ERROR (H5E_DATASPACE, H5E_BADRANGE, FAIL, "can't get chunk index")
store.chunk.offset=chunk_offset;
- if(NULL == (chunk = H5F_istore_lock(f, dxpl_cache, dxpl_id, layout, &pline, &fill, fill_time,
- NULL, &store, FALSE, &idx_hint)))
+ if(NULL == (chunk = H5D_istore_lock(f, dxpl_cache, dxpl_id, dset,
+ &store, NULL, FALSE, &idx_hint)))
HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "unable to read raw data chunk");
if(H5S_select_all(space_chunk,1) < 0)
HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "unable to select space");
for(u = 0; u < rank; u++)
- count[u] = MIN((idx_cur[u] + 1) * layout->u.chunk.dim[u], size[u] - chunk_offset[u]);
+ count[u] = MIN((idx_cur[u] + 1) * dset->layout.u.chunk.dim[u], size[u] - chunk_offset[u]);
-#ifdef H5F_ISTORE_DEBUG
+#ifdef H5D_ISTORE_DEBUG
HDfputs("cache:initialize:offset:[", stdout);
- for(u = 0; u < layout->u.chunk.ndims - 1; u++)
+ for(u = 0; u < dset->layout.u.chunk.ndims - 1; u++)
HDfprintf(stdout, "%s%Hd", u ? ", " : "", chunk_offset[u]);
HDfputs("]", stdout);
HDfputs(":count:[", stdout);
- for(u = 0; u < layout->u.chunk.ndims - 1; u++)
+ for(u = 0; u < dset->layout.u.chunk.ndims - 1; u++)
HDfprintf(stdout, "%s%Hd", u ? ", " : "", count[u]);
HDfputs("]\n", stdout);
#endif
@@ -2882,13 +2848,13 @@ H5F_istore_initialize_by_extent(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_ca
if(H5S_select_fill(fill.buf, (size_t)size[rank], space_chunk, chunk) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_CANTENCODE, FAIL, "filling selection failed");
- if(H5F_istore_unlock(f, dxpl_cache, dxpl_id, layout, &pline, TRUE,
- &store, idx_hint, chunk, (size_t)naccessed) < 0)
+ if(H5D_istore_unlock(f, dxpl_cache, dxpl_id, dset, &store,
+ TRUE, idx_hint, chunk, (size_t)naccessed) < 0)
HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "unable to unlock raw data chunk");
} /*found */
/* Increment indices */
- for(i = layout->u.chunk.ndims - 1, carry = 1; i >= 0 && carry; --i) {
+ for(i = dset->layout.u.chunk.ndims - 1, carry = 1; i >= 0 && carry; --i) {
if(++idx_cur[i] >= idx_max[i])
idx_cur[i] = 0;
else
@@ -2901,11 +2867,11 @@ done:
H5S_close(space_chunk);
FUNC_LEAVE_NOAPI(ret_value);
-}
+} /* end H5D_istore_initialize_by_extent() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_delete
+ * Function: H5D_istore_delete
*
* Purpose: Delete raw data storage for entire dataset (i.e. all chunks)
*
@@ -2920,34 +2886,15 @@ done:
*-------------------------------------------------------------------------
*/
herr_t
-H5F_istore_delete(H5F_t *f, hid_t dxpl_id, const struct H5O_layout_t *layout)
+H5D_istore_delete(H5F_t *f, hid_t dxpl_id, const struct H5O_layout_t *layout)
{
- H5D_dxpl_cache_t dxpl_cache; /* Cached data transfer properties */
- H5F_istore_ud1_t udata; /* User data for B-tree iterator call */
- H5F_rdcc_t *rdcc = &(f->shared->rdcc); /* File's raw data chunk cache */
- H5F_rdcc_ent_t *ent, *next; /* Pointers to cache entries */
+ H5D_istore_ud1_t udata; /* User data for B-tree iterator call */
herr_t ret_value=SUCCEED; /* Return value */
- FUNC_ENTER_NOAPI(H5F_istore_delete, FAIL);
-
- /* Fill the DXPL cache values for later use */
- if (H5D_get_dxpl_cache(dxpl_id,&dxpl_cache)<0)
- HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't fill dxpl cache")
+ FUNC_ENTER_NOAPI(H5D_istore_delete, FAIL);
/* Check if the B-tree has been created in the file */
if(H5F_addr_defined(layout->u.chunk.addr)) {
- /* Iterate through the entries in the cache, checking for the chunks to be deleted */
- for (ent=rdcc->head; ent; ent=next) {
- /* Get pointer to next node, in case this one is deleted */
- next=ent->next;
-
- /* Is the chunk to be deleted this cache entry? */
- if(layout->u.chunk.addr==ent->layout.u.chunk.addr)
- /* Remove entry without flushing */
- if (H5F_istore_preempt(f, &dxpl_cache, dxpl_id, ent, FALSE )<0)
- HGOTO_ERROR (H5E_IO, H5E_CANTFLUSH, FAIL, "unable to flush one or more raw data chunks");
- } /* end for */
-
/* Set up user data for B-tree deletion */
HDmemset(&udata, 0, sizeof udata);
udata.mesg = *layout;
@@ -2959,11 +2906,11 @@ H5F_istore_delete(H5F_t *f, hid_t dxpl_id, const struct H5O_layout_t *layout)
done:
FUNC_LEAVE_NOAPI(ret_value);
-} /* end H5F_istore_delete() */
+} /* end H5D_istore_delete() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_update_cache
+ * Function: H5D_istore_update_cache
*
* Purpose: Update any cached chunks index values after the dataspace
* size has changed
@@ -2979,11 +2926,11 @@ done:
*-------------------------------------------------------------------------
*/
herr_t
-H5F_istore_update_cache(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout, const H5S_t * space)
+H5D_istore_update_cache(H5F_t *f, hid_t dxpl_id, H5D_t *dset)
{
- H5F_rdcc_t *rdcc = &(f->shared->rdcc); /*raw data chunk cache */
- H5F_rdcc_ent_t *ent, *next; /*cache entry */
- H5F_rdcc_ent_t *old_ent; /* Old cache entry */
+ H5D_rdcc_t *rdcc = &(dset->cache.chunk); /*raw data chunk cache */
+ H5D_rdcc_ent_t *ent, *next; /*cache entry */
+ H5D_rdcc_ent_t *old_ent; /* Old cache entry */
H5D_dxpl_cache_t dxpl_cache; /* Cached data transfer properties */
int srank; /*current # of dimensions (signed) */
unsigned rank; /*current # of dimensions */
@@ -2991,29 +2938,25 @@ H5F_istore_update_cache(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout, con
hsize_t chunks[H5O_LAYOUT_NDIMS]; /*current number of chunks in each dimension */
hsize_t down_chunks[H5O_LAYOUT_NDIMS]; /* "down" size of number of elements in each dimension */
hsize_t idx; /* Chunk index */
- hsize_t temp_idx; /* temporary index number */
unsigned old_idx; /* Previous index number */
unsigned u; /*counters */
herr_t ret_value=SUCCEED; /* Return value */
- FUNC_ENTER_NOAPI(H5F_istore_update_cache, FAIL);
+ FUNC_ENTER_NOAPI(H5D_istore_update_cache, FAIL);
/* Check args */
assert(f);
- assert(layout && H5D_CHUNKED == layout->type);
- assert(layout->u.chunk.ndims > 0 && layout->u.chunk.ndims <= H5O_LAYOUT_NDIMS);
- assert(space);
+ assert(dset && H5D_CHUNKED == dset->layout.type);
+ assert(dset->layout.u.chunk.ndims > 0 && dset->layout.u.chunk.ndims <= H5O_LAYOUT_NDIMS);
/* Go get the rank & dimensions */
- if((srank = H5S_get_simple_extent_dims(space, curr_dims, NULL)) < 0)
+ if((srank = H5S_get_simple_extent_dims(dset->space, curr_dims, NULL)) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't get dataset dimensions");
H5_ASSIGN_OVERFLOW(rank,srank,int,unsigned);
- /* Copy current dimensions */
- for(u = 0; u < rank; u++) {
- /* Round up to the next integer # of chunks, to accomodate partial chunks */
- chunks[u] = ((curr_dims[u]+layout->u.chunk.dim[u])-1) / layout->u.chunk.dim[u];
- } /* end for */
+ /* Round up to the next integer # of chunks, to accomodate partial chunks */
+ for(u = 0; u < rank; u++)
+ chunks[u] = ((curr_dims[u]+dset->layout.u.chunk.dim[u])-1) / dset->layout.u.chunk.dim[u];
/* Get the "down" sizes for each dimension */
if(H5V_array_down(rank,chunks,down_chunks)<0)
@@ -3027,38 +2970,34 @@ H5F_istore_update_cache(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout, con
for(ent = rdcc->head; ent; ent = next) {
next=ent->next;
- /* Make certain we are dealing with the correct B-tree, etc */
- if (H5F_addr_eq(layout->u.chunk.addr, ent->layout.u.chunk.addr)) {
- /* Calculate the index of this chunk */
- if(H5V_chunk_index(rank,ent->offset,layout->u.chunk.dim,down_chunks,&idx)<0)
- HGOTO_ERROR (H5E_DATASPACE, H5E_BADRANGE, FAIL, "can't get chunk index")
+ /* Calculate the index of this chunk */
+ if(H5V_chunk_index(rank,ent->offset,dset->layout.u.chunk.dim,down_chunks,&idx)<0)
+ HGOTO_ERROR (H5E_DATASPACE, H5E_BADRANGE, FAIL, "can't get chunk index")
- /* Compute the index for the chunk entry */
- temp_idx = idx + (hsize_t)(layout->u.chunk.addr);
- old_idx=ent->idx; /* Save for later */
- ent->idx=H5F_HASH(f,temp_idx);
+ /* Compute the index for the chunk entry */
+ old_idx=ent->idx; /* Save for later */
+ ent->idx=H5D_HASH(dset,idx);
- if(old_idx!=ent->idx) {
- /* Check if there is already a chunk at this chunk's new location */
- old_ent = rdcc->slot[ent->idx];
- if(old_ent!=NULL) {
- assert(old_ent->locked==0);
+ if(old_idx!=ent->idx) {
+ /* Check if there is already a chunk at this chunk's new location */
+ old_ent = rdcc->slot[ent->idx];
+ if(old_ent!=NULL) {
+ assert(old_ent->locked==0);
- /* Check if we are removing the entry we would walk to next */
- if(old_ent==next)
- next=old_ent->next;
+ /* Check if we are removing the entry we would walk to next */
+ if(old_ent==next)
+ next=old_ent->next;
- /* Remove the old entry from the cache */
- if (H5F_istore_preempt(f, &dxpl_cache, dxpl_id, old_ent, TRUE )<0)
- HGOTO_ERROR (H5E_IO, H5E_CANTFLUSH, FAIL, "unable to flush one or more raw data chunks");
- } /* end if */
+ /* Remove the old entry from the cache */
+ if (H5D_istore_preempt(f, &dxpl_cache, dxpl_id, dset, old_ent, TRUE )<0)
+ HGOTO_ERROR (H5E_IO, H5E_CANTFLUSH, FAIL, "unable to flush one or more raw data chunks");
+ } /* end if */
- /* Insert this chunk into correct location in hash table */
- rdcc->slot[ent->idx]=ent;
+ /* Insert this chunk into correct location in hash table */
+ rdcc->slot[ent->idx]=ent;
- /* Null out previous location */
- rdcc->slot[old_idx]=NULL;
- } /* end if */
+ /* Null out previous location */
+ rdcc->slot[old_idx]=NULL;
} /* end if */
} /* end for */
@@ -3068,7 +3007,7 @@ done:
/*-------------------------------------------------------------------------
- * Function: H5F_istore_dump_btree
+ * Function: H5D_istore_dump_btree
*
* Purpose: Prints information about the storage B-tree to the specified
* stream.
@@ -3086,29 +3025,29 @@ done:
*-------------------------------------------------------------------------
*/
herr_t
-H5F_istore_dump_btree(H5F_t *f, hid_t dxpl_id, FILE *stream, unsigned ndims, haddr_t addr)
+H5D_istore_dump_btree(H5F_t *f, hid_t dxpl_id, FILE *stream, unsigned ndims, haddr_t addr)
{
- H5F_istore_ud1_t udata;
+ H5D_istore_ud1_t udata;
herr_t ret_value=SUCCEED; /* Return value */
- FUNC_ENTER_NOAPI(H5F_istore_dump_btree, FAIL);
+ FUNC_ENTER_NOAPI(H5D_istore_dump_btree, FAIL);
HDmemset(&udata, 0, sizeof udata);
udata.mesg.u.chunk.ndims = ndims;
udata.stream = stream;
if(stream)
HDfprintf(stream, " Address: %a\n",addr);
- if(H5B_iterate(f, dxpl_id, H5B_ISTORE, H5F_istore_iter_dump, addr, &udata)<0)
+ if(H5B_iterate(f, dxpl_id, H5B_ISTORE, H5D_istore_iter_dump, addr, &udata)<0)
HGOTO_ERROR(H5E_IO, H5E_CANTINIT, 0, "unable to iterate over chunk B-tree");
done:
FUNC_LEAVE_NOAPI(ret_value);
-}
+} /* end H5D_istore_dump_btree() */
-#ifdef H5F_ISTORE_DEBUG
+#ifdef H5D_ISTORE_DEBUG
/*-------------------------------------------------------------------------
- * Function: H5F_istore_stats
+ * Function: H5D_istore_stats
*
* Purpose: Print raw data cache statistics to the debug stream. If
* HEADERS is non-zero then print table column headers,
@@ -3124,21 +3063,20 @@ done:
*-------------------------------------------------------------------------
*/
herr_t
-H5F_istore_stats (H5F_t *f, hbool_t headers)
+H5D_istore_stats (H5D_t *dset, hbool_t headers)
{
- H5F_rdcc_t *rdcc = &(f->shared->rdcc);
+ H5D_rdcc_t *rdcc = &(dset->cache.chunk);
double miss_rate;
char ascii[32];
herr_t ret_value=SUCCEED; /* Return value */
- FUNC_ENTER_NOAPI(H5F_istore_stats, FAIL);
+ FUNC_ENTER_NOAPI(H5D_istore_stats, FAIL);
if (!H5DEBUG(AC))
HGOTO_DONE(SUCCEED);
if (headers) {
- fprintf(H5DEBUG(AC), "H5F: raw data cache statistics for file %s\n",
- f->name);
+ fprintf(H5DEBUG(AC), "H5D: raw data cache statistics\n");
fprintf(H5DEBUG(AC), " %-18s %8s %8s %8s %8s+%-8s\n",
"Layer", "Hits", "Misses", "MissRate", "Inits", "Flushes");
fprintf(H5DEBUG(AC), " %-18s %8s %8s %8s %8s-%-8s\n",
@@ -3169,12 +3107,12 @@ H5F_istore_stats (H5F_t *f, hbool_t headers)
done:
FUNC_LEAVE_NOAPI(ret_value);
-}
-#endif /* H5F_ISTORE_DEBUG */
+} /* end H5D_istore_stats() */
+#endif /* H5D_ISTORE_DEBUG */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_debug
+ * Function: H5D_istore_debug
*
* Purpose: Debugs a B-tree node for indexed raw data storage.
*
@@ -3189,13 +3127,13 @@ done:
*-------------------------------------------------------------------------
*/
herr_t
-H5F_istore_debug(H5F_t *f, hid_t dxpl_id, haddr_t addr, FILE * stream, int indent,
+H5D_istore_debug(H5F_t *f, hid_t dxpl_id, haddr_t addr, FILE * stream, int indent,
int fwidth, int ndims)
{
- H5F_istore_ud1_t udata;
+ H5D_istore_ud1_t udata;
herr_t ret_value=SUCCEED; /* Return value */
- FUNC_ENTER_NOAPI(H5F_istore_debug, FAIL);
+ FUNC_ENTER_NOAPI(H5D_istore_debug, FAIL);
HDmemset (&udata, 0, sizeof udata);
udata.mesg.u.chunk.ndims = ndims;
@@ -3204,5 +3142,4 @@ H5F_istore_debug(H5F_t *f, hid_t dxpl_id, haddr_t addr, FILE * stream, int inden
done:
FUNC_LEAVE_NOAPI(ret_value);
-}
-
+} /* end H5D_istore_debug() */
diff --git a/src/H5Dpkg.h b/src/H5Dpkg.h
index 8a4abae..b72a13d 100644
--- a/src/H5Dpkg.h
+++ b/src/H5Dpkg.h
@@ -50,6 +50,29 @@
/* Package Private Typedefs */
/****************************/
+/* The raw data chunk cache */
+typedef struct H5D_rdcc_t {
+ unsigned ninits; /* Number of chunk creations */
+ unsigned nhits; /* Number of cache hits */
+ unsigned nmisses;/* Number of cache misses */
+ unsigned nflushes;/* Number of cache flushes */
+ size_t nbytes; /* Current cached raw data in bytes */
+ size_t nslots; /* Number of chunk slots allocated */
+ struct H5D_rdcc_ent_t *head; /* Head of doubly linked list */
+ struct H5D_rdcc_ent_t *tail; /* Tail of doubly linked list */
+ int nused; /* Number of chunk slots in use */
+ struct H5D_rdcc_ent_t **slot; /* Chunk slots, each points to a chunk*/
+} H5D_rdcc_t;
+
+/* The raw data contiguous data cache */
+typedef struct H5D_rdcdc_t {
+ unsigned char *sieve_buf; /* Buffer to hold data sieve buffer */
+ haddr_t sieve_loc; /* File location (offset) of the data sieve buffer */
+ size_t sieve_size; /* Size of the data sieve buffer used (in bytes) */
+ size_t sieve_buf_size; /* Size of the data sieve buffer allocated (in bytes) */
+ unsigned sieve_dirty; /* Flag to indicate that the data sieve buffer is dirty */
+} H5D_rdcdc_t;
+
/*
* A dataset is the following struct.
*/
@@ -60,11 +83,18 @@ struct H5D_t {
hid_t dcpl_id; /* dataset creation property id */
H5D_dcpl_cache_t dcpl_cache; /* Cached DCPL values */
H5O_layout_t layout; /* data layout */
+
/* Cache some frequently accessed values from the DCPL */
H5O_efl_t efl; /* External file list information */
H5D_alloc_time_t alloc_time; /* Dataset allocation time */
H5D_fill_time_t fill_time; /* Dataset fill value writing time */
H5O_fill_t fill; /* Dataset fill value information */
+
+ /* Buffered/cached information for types of raw data storage*/
+ union {
+ H5D_rdcdc_t contig; /* Information about contiguous data */
+ H5D_rdcc_t chunk; /* Information about chunked data */
+ }cache;
};
/* Enumerated type for allocating dataset's storage */
@@ -87,6 +117,30 @@ extern H5D_dxpl_cache_t H5D_def_dxpl_cache;
H5_DLL herr_t H5D_alloc_storage (H5F_t *f, hid_t dxpl_id, H5D_t *dset, H5D_time_alloc_t time_alloc,
hbool_t update_time, hbool_t full_overwrite);
+/* Functions that operate on contiguous storage */
+H5_DLL herr_t H5D_contig_create(H5F_t *f, hid_t dxpl_id, H5D_t *dset);
+H5_DLL herr_t H5D_contig_fill(H5F_t *f, hid_t dxpl_id, H5D_t *dset);
+
+/* Functions that operate on indexed storage */
+H5_DLL herr_t H5D_istore_init (H5F_t *f, H5D_t *dset);
+H5_DLL herr_t H5D_istore_flush (H5F_t *f, hid_t dxpl_id, H5D_t *dset, unsigned flags);
+H5_DLL herr_t H5D_istore_create(H5F_t *f, hid_t dxpl_id,
+ H5O_layout_t *layout/*in,out*/);
+H5_DLL herr_t H5D_istore_dest (H5F_t *f, hid_t dxpl_id, H5D_t *dset);
+H5_DLL herr_t H5D_istore_allocate (H5F_t *f, hid_t dxpl_id,
+ const H5D_t *dset, hbool_t full_overwrite);
+H5_DLL hsize_t H5D_istore_allocated(H5F_t *f, hid_t dxpl_id, H5D_t *dset);
+H5_DLL herr_t H5D_istore_prune_by_extent( H5F_t *f,
+ const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id, H5D_t *dset);
+H5_DLL herr_t H5D_istore_initialize_by_extent( H5F_t *f,
+ const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id, H5D_t *dset);
+H5_DLL herr_t H5D_istore_update_cache(H5F_t *f, hid_t dxpl_id, H5D_t *dset);
+H5_DLL herr_t H5D_istore_dump_btree(H5F_t *f, hid_t dxpl_id, FILE *stream, unsigned ndims,
+ haddr_t addr);
+#ifdef H5D_ISTORE_DEBUG
+H5_DLL herr_t H5D_istore_stats (H5D_t *dset, hbool_t headers);
+#endif /* H5D_ISTORE_DEBUG */
+
/* Testing functions */
#ifdef H5D_TESTING
H5_DLL herr_t H5D_layout_version_test(hid_t did, unsigned *version);
diff --git a/src/H5Dprivate.h b/src/H5Dprivate.h
index 193e524..803a03e 100644
--- a/src/H5Dprivate.h
+++ b/src/H5Dprivate.h
@@ -208,8 +208,61 @@ H5_DLL herr_t H5D_xfer_create(hid_t dxpl_id, void *create_data);
H5_DLL herr_t H5D_xfer_copy(hid_t new_plist_id, hid_t old_plist_id,
void *copy_data);
H5_DLL herr_t H5D_xfer_close(hid_t dxpl_id, void *close_data);
-H5_DLL herr_t H5D_flush(const H5F_t *f, hid_t dxpl_id);
+H5_DLL herr_t H5D_flush(H5F_t *f, hid_t dxpl_id, unsigned flags);
H5_DLL herr_t H5D_get_dxpl_cache(hid_t dxpl_id, H5D_dxpl_cache_t *cache);
H5_DLL herr_t H5D_get_dxpl_cache_real(hid_t dxpl_id, H5D_dxpl_cache_t *cache);
+/* Functions that operate on byte sequences in memory and on disk */
+H5_DLL ssize_t H5D_seq_readvv(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache,
+ hid_t dxpl_id, H5D_t *dset, const H5D_storage_t *store,
+ size_t dset_max_nseq, size_t *dset_curr_seq, size_t dset_len_arr[], hsize_t dset_offset_arr[],
+ size_t mem_max_nseq, size_t *mem_curr_seq, size_t mem_len_arr[], hsize_t mem_offset_arr[],
+ void *buf);
+H5_DLL ssize_t H5D_seq_writevv(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache,
+ hid_t dxpl_id, H5D_t *dset, const H5D_storage_t *store,
+ size_t dset_max_nseq, size_t *dset_curr_seq, size_t dset_len_arr[], hsize_t dset_offset_arr[],
+ size_t mem_max_nseq, size_t *mem_curr_seq, size_t mem_len_arr[], hsize_t mem_offset_arr[],
+ const void *buf);
+
+/* Functions that operate on contiguous storage */
+H5_DLL herr_t H5D_contig_delete(H5F_t *f, hid_t dxpl_id,
+ const H5O_layout_t *layout);
+H5_DLL haddr_t H5D_contig_get_addr(const H5D_t *dset);
+H5_DLL ssize_t H5D_contig_readvv(H5F_t *f, hid_t dxpl_id, H5D_t *dset,
+ haddr_t dset_addr, hsize_t dset_size,
+ size_t dset_max_nseq, size_t *dset_curr_seq, size_t dset_len_arr[], hsize_t dset_offset_arr[],
+ size_t mem_max_nseq, size_t *mem_curr_seq, size_t mem_len_arr[], hsize_t mem_offset_arr[],
+ void *buf);
+H5_DLL ssize_t H5D_contig_writevv(H5F_t *f, hid_t dxpl_id, H5D_t *dset,
+ haddr_t dset_addr, hsize_t dset_size,
+ size_t dset_max_nseq, size_t *dset_curr_seq, size_t dset_len_arr[], hsize_t dset_offset_arr[],
+ size_t mem_max_nseq, size_t *mem_curr_seq, size_t mem_len_arr[], hsize_t mem_offset_arr[],
+ const void *buf);
+
+/* Functions that operate on compact dataset storage */
+H5_DLL ssize_t H5D_compact_readvv(H5F_t *f, hid_t dxpl_id, const H5D_t *dset,
+ size_t dset_max_nseq, size_t *dset_curr_seq, size_t dset_size_arr[], hsize_t dset_offset_arr[],
+ size_t mem_max_nseq, size_t *mem_curr_seq, size_t mem_size_arr[], hsize_t mem_offset_arr[],
+ void *buf);
+H5_DLL ssize_t H5D_compact_writevv(H5F_t *f, hid_t dxpl_id, H5D_t *dset,
+ size_t dset_max_nseq, size_t *dset_curr_seq, size_t dset_size_arr[], hsize_t dset_offset_arr[],
+ size_t mem_max_nseq, size_t *mem_curr_seq, size_t mem_size_arr[], hsize_t mem_offset_arr[],
+ const void *buf);
+
+/* Functions that operate on indexed storage */
+H5_DLL herr_t H5D_istore_delete(H5F_t *f, hid_t dxpl_id,
+ const H5O_layout_t *layout);
+H5_DLL ssize_t H5D_istore_readvv(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache,
+ hid_t dxpl_id, H5D_t *dset, const H5D_storage_t *store,
+ size_t chunk_max_nseq, size_t *chunk_curr_seq, size_t chunk_len_arr[], hsize_t chunk_offset_arr[],
+ size_t mem_max_nseq, size_t *mem_curr_seq, size_t mem_len_arr[], hsize_t mem_offset_arr[],
+ void *buf);
+H5_DLL ssize_t H5D_istore_writevv(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache,
+ hid_t dxpl_id, H5D_t *dset, const H5D_storage_t *store,
+ size_t chunk_max_nseq, size_t *chunk_curr_seq, size_t chunk_len_arr[], hsize_t chunk_offset_arr[],
+ size_t mem_max_nseq, size_t *mem_curr_seq, size_t mem_len_arr[], hsize_t mem_offset_arr[],
+ const void *buf);
+H5_DLL herr_t H5D_istore_debug(H5F_t *f, hid_t dxpl_id, haddr_t addr, FILE * stream,
+ int indent, int fwidth, int ndims);
+
#endif
diff --git a/src/H5Dseq.c b/src/H5Dseq.c
index 9bd9f72..5585315 100644
--- a/src/H5Dseq.c
+++ b/src/H5Dseq.c
@@ -23,27 +23,23 @@
*
*/
-#define H5F_PACKAGE /*suppress error about including H5Fpkg */
+#define H5D_PACKAGE /*suppress error about including H5Dpkg */
/* Pablo information */
/* (Put before include files to avoid problems with inline functions) */
-#define PABLO_MASK H5Fseq_mask
+#define PABLO_MASK H5Dseq_mask
-#include "H5private.h"
-#include "H5Dprivate.h"
-#include "H5Eprivate.h"
-#include "H5Fpkg.h"
-#include "H5FDprivate.h" /*file driver */
-#include "H5Iprivate.h"
-#include "H5MFprivate.h"
-#include "H5MMprivate.h" /*memory management */
-#include "H5Oprivate.h"
-#include "H5Pprivate.h"
-#include "H5Vprivate.h"
-
-/* MPIO & MPIPOSIX driver functions are needed for some special checks */
-#include "H5FDmpio.h"
-#include "H5FDmpiposix.h"
+#include "H5private.h" /* Generic Functions */
+#include "H5Dpkg.h" /* Datasets */
+#include "H5Eprivate.h" /* Error handling */
+#include "H5Fprivate.h" /* Files */
+#include "H5FDprivate.h" /* File drivers */
+#include "H5Iprivate.h" /* IDs */
+#include "H5MFprivate.h" /* File space management */
+#include "H5MMprivate.h" /* Memory management */
+#include "H5Oprivate.h" /* Object headers */
+#include "H5Pprivate.h" /* Property lists */
+#include "H5Vprivate.h" /* Vector and array functions */
/* Interface initialization */
#define INTERFACE_INIT NULL
@@ -51,105 +47,7 @@ static int interface_initialize_g = 0;
/*-------------------------------------------------------------------------
- * Function: H5F_seq_read
- *
- * Purpose: Reads a sequence of bytes from a file dataset into a buffer in
- * in memory. The data is read from file F and the array's size and
- * storage information is in LAYOUT. External files are described
- * according to the external file list, EFL. The sequence offset is
- * DSET_OFFSET in the dataset (offsets are in terms of bytes) and the
- * size of the hyperslab is SEQ_LEN. The total size of the file array
- * is implied in the LAYOUT argument.
- *
- * Return: Non-negative on success/Negative on failure
- *
- * Programmer: Quincey Koziol
- * Thursday, September 28, 2000
- *
- * Modifications:
- * Re-written to use new vector I/O call - QAK, 7/7/01
- *
- *-------------------------------------------------------------------------
- */
-herr_t
-H5F_seq_read(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache,
- hid_t dxpl_id, const H5O_layout_t *layout,
- const struct H5D_dcpl_cache_t *dcpl_cache, const H5D_storage_t *store,
- size_t seq_len, hsize_t dset_offset, void *buf/*out*/)
-{
- hsize_t mem_off=0; /* Offset in memory */
- size_t mem_len=seq_len; /* Length in memory */
- size_t mem_curr_seq=0; /* "Current sequence" in memory */
- size_t dset_curr_seq=0; /* "Current sequence" in dataset */
- herr_t ret_value=SUCCEED; /* Return value */
-
- FUNC_ENTER_NOAPI(H5F_seq_read, FAIL);
-
- /* Check args */
- assert(f);
- assert(layout);
- assert(buf);
- assert(TRUE==H5P_isa_class(dxpl_id,H5P_DATASET_XFER));
-
- if (H5F_seq_readvv(f, dxpl_cache, dxpl_id, layout, dcpl_cache, store, 1, &dset_curr_seq, &seq_len, &dset_offset, 1, &mem_curr_seq, &mem_len, &mem_off, buf)<0)
- HGOTO_ERROR(H5E_IO, H5E_READERROR, FAIL, "vector read failed");
-
-done:
- FUNC_LEAVE_NOAPI(ret_value);
-} /* H5F_seq_read() */
-
-
-/*-------------------------------------------------------------------------
- * Function: H5F_seq_write
- *
- * Purpose: Writes a sequence of bytes to a file dataset from a buffer in
- * in memory. The data is written to file F and the array's size and
- * storage information is in LAYOUT. External files are described
- * according to the external file list, EFL. The sequence offset is
- * DSET_OFFSET in the dataset (offsets are in terms of bytes) and the
- * size of the hyperslab is SEQ_LEN. The total size of the file array
- * is implied in the LAYOUT argument.
- *
- * Return: Non-negative on success/Negative on failure
- *
- * Programmer: Quincey Koziol
- * Monday, October 9, 2000
- *
- * Modifications:
- * Re-written to use new vector I/O routine - QAK, 7/7/01
- *
- *-------------------------------------------------------------------------
- */
-herr_t
-H5F_seq_write(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache,
- hid_t dxpl_id, H5O_layout_t *layout,
- const struct H5D_dcpl_cache_t *dcpl_cache, const H5D_storage_t *store,
- size_t seq_len, hsize_t dset_offset, const void *buf)
-{
- hsize_t mem_off=0; /* Offset in memory */
- size_t mem_len=seq_len; /* Length in memory */
- size_t mem_curr_seq=0; /* "Current sequence" in memory */
- size_t dset_curr_seq=0; /* "Current sequence" in dataset */
- herr_t ret_value=SUCCEED; /* Return value */
-
- FUNC_ENTER_NOAPI(H5F_seq_write, FAIL);
-
- /* Check args */
- assert(f);
- assert(layout);
- assert(buf);
- assert(TRUE==H5P_isa_class(dxpl_id,H5P_DATASET_XFER));
-
- if (H5F_seq_writevv(f, dxpl_cache, dxpl_id, layout, dcpl_cache, store, 1, &dset_curr_seq, &seq_len, &dset_offset, 1, &mem_curr_seq, &mem_len, &mem_off, buf)<0)
- HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "vector write failed");
-
-done:
- FUNC_LEAVE_NOAPI(ret_value);
-} /* H5F_seq_write() */
-
-
-/*-------------------------------------------------------------------------
- * Function: H5F_seq_readvv
+ * Function: H5D_seq_readvv
*
* Purpose: Reads in a vector of byte sequences from a file dataset into a
* buffer in in memory. The data is read from file F and the array's size
@@ -189,22 +87,20 @@ done:
*-------------------------------------------------------------------------
*/
ssize_t
-H5F_seq_readvv(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id,
- const struct H5O_layout_t *layout,
- const struct H5D_dcpl_cache_t *dcpl_cache, const H5D_storage_t *store,
+H5D_seq_readvv(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id,
+ H5D_t *dset, const H5D_storage_t *store,
size_t dset_max_nseq, size_t *dset_curr_seq, size_t dset_len_arr[], hsize_t dset_offset_arr[],
size_t mem_max_nseq, size_t *mem_curr_seq, size_t mem_len_arr[], hsize_t mem_offset_arr[],
void *buf/*out*/)
{
ssize_t ret_value; /* Return value */
- FUNC_ENTER_NOAPI(H5F_seq_readvv, FAIL);
+ FUNC_ENTER_NOAPI(H5D_seq_readvv, FAIL);
/* Check args */
assert(f);
assert(TRUE==H5P_isa_class(dxpl_id,H5P_DATASET_XFER)); /* Make certain we have the correct type of property list */
- assert(layout);
- assert(dcpl_cache);
+ assert(dset);
assert(dset_curr_seq);
assert(*dset_curr_seq<dset_max_nseq);
assert(dset_len_arr);
@@ -215,7 +111,7 @@ H5F_seq_readvv(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_i
assert(mem_offset_arr);
assert(buf);
- switch (layout->type) {
+ switch (dset->layout.type) {
case H5D_CONTIGUOUS:
/* Read directly from file if the dataset is in an external file */
if (store && store->efl.nused>0) {
@@ -231,17 +127,18 @@ H5F_seq_readvv(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_i
HGOTO_ERROR(H5E_IO, H5E_READERROR, FAIL, "external data read failed");
} else {
/* Pass along the vector of sequences to read */
- if((ret_value=H5F_contig_readvv(f, layout->u.contig.size, layout->u.contig.addr,
+ if((ret_value=H5D_contig_readvv(f, dxpl_id, dset,
+ dset->layout.u.contig.addr, dset->layout.u.contig.size,
dset_max_nseq, dset_curr_seq, dset_len_arr, dset_offset_arr,
mem_max_nseq, mem_curr_seq, mem_len_arr, mem_offset_arr,
- dxpl_id, buf))<0)
+ buf))<0)
HGOTO_ERROR(H5E_IO, H5E_READERROR, FAIL, "block read failed");
} /* end else */
break;
case H5D_CHUNKED:
assert(store);
- if((ret_value=H5F_istore_readvv(f, dxpl_cache, dxpl_id, layout, dcpl_cache, store,
+ if((ret_value=H5D_istore_readvv(f, dxpl_cache, dxpl_id, dset, store,
dset_max_nseq, dset_curr_seq, dset_len_arr, dset_offset_arr,
mem_max_nseq, mem_curr_seq, mem_len_arr, mem_offset_arr,
buf))<0)
@@ -250,10 +147,10 @@ H5F_seq_readvv(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_i
case H5D_COMPACT:
/* Pass along the vector of sequences to read */
- if((ret_value=H5F_compact_readvv(f, layout,
+ if((ret_value=H5D_compact_readvv(f, dxpl_id, dset,
dset_max_nseq, dset_curr_seq, dset_len_arr, dset_offset_arr,
mem_max_nseq, mem_curr_seq, mem_len_arr, mem_offset_arr,
- dxpl_id, buf))<0)
+ buf))<0)
HGOTO_ERROR(H5E_IO, H5E_READERROR, FAIL, "compact read failed");
break;
@@ -264,11 +161,11 @@ H5F_seq_readvv(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_i
done:
FUNC_LEAVE_NOAPI(ret_value);
-} /* H5F_seq_readvv() */
+} /* H5D_seq_readvv() */
/*-------------------------------------------------------------------------
- * Function: H5F_seq_writevv
+ * Function: H5D_seq_writevv
*
* Purpose: Writes a vector of byte sequences from a buffer in memory into
* a vector of byte sequences in a file dataset. The data is written to
@@ -298,22 +195,20 @@ done:
*-------------------------------------------------------------------------
*/
ssize_t
-H5F_seq_writevv(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache,
- hid_t dxpl_id, struct H5O_layout_t *layout,
- const struct H5D_dcpl_cache_t *dcpl_cache, const H5D_storage_t *store,
+H5D_seq_writevv(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache,
+ hid_t dxpl_id, struct H5D_t *dset, const H5D_storage_t *store,
size_t dset_max_nseq, size_t *dset_curr_seq, size_t dset_len_arr[], hsize_t dset_offset_arr[],
size_t mem_max_nseq, size_t *mem_curr_seq, size_t mem_len_arr[], hsize_t mem_offset_arr[],
const void *buf)
{
ssize_t ret_value; /* Return value */
- FUNC_ENTER_NOAPI(H5F_seq_writevv, FAIL);
+ FUNC_ENTER_NOAPI(H5D_seq_writevv, FAIL);
/* Check args */
assert(f);
assert(TRUE==H5P_isa_class(dxpl_id,H5P_DATASET_XFER)); /* Make certain we have the correct type of property list */
- assert(layout);
- assert(dcpl_cache);
+ assert(dset);
assert(dset_curr_seq);
assert(*dset_curr_seq<dset_max_nseq);
assert(dset_len_arr);
@@ -324,7 +219,7 @@ H5F_seq_writevv(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache,
assert(mem_offset_arr);
assert(buf);
- switch (layout->type) {
+ switch (dset->layout.type) {
case H5D_CONTIGUOUS:
/* Write directly to file if the dataset is in an external file */
if (store && store->efl.nused>0) {
@@ -340,17 +235,18 @@ H5F_seq_writevv(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache,
HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "external data write failed");
} else {
/* Pass along the vector of sequences to write */
- if ((ret_value=H5F_contig_writevv(f, layout->u.contig.size, layout->u.contig.addr,
+ if ((ret_value=H5D_contig_writevv(f, dxpl_id, dset,
+ dset->layout.u.contig.addr, dset->layout.u.contig.size,
dset_max_nseq, dset_curr_seq, dset_len_arr, dset_offset_arr,
mem_max_nseq, mem_curr_seq, mem_len_arr, mem_offset_arr,
- dxpl_id, buf))<0)
+ buf))<0)
HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "block write failed");
} /* end else */
break;
case H5D_CHUNKED:
assert(store);
- if((ret_value=H5F_istore_writevv(f, dxpl_cache, dxpl_id, layout, dcpl_cache, store,
+ if((ret_value=H5D_istore_writevv(f, dxpl_cache, dxpl_id, dset, store,
dset_max_nseq, dset_curr_seq, dset_len_arr, dset_offset_arr,
mem_max_nseq, mem_curr_seq, mem_len_arr, mem_offset_arr,
buf))<0)
@@ -359,10 +255,10 @@ H5F_seq_writevv(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache,
case H5D_COMPACT:
/* Pass along the vector of sequences to write */
- if((ret_value=H5F_compact_writevv(f, layout,
+ if((ret_value=H5D_compact_writevv(f, dxpl_id, dset,
dset_max_nseq, dset_curr_seq, dset_len_arr, dset_offset_arr,
mem_max_nseq, mem_curr_seq, mem_len_arr, mem_offset_arr,
- dxpl_id, buf))<0)
+ buf))<0)
HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "compact write failed");
break;
@@ -373,4 +269,4 @@ H5F_seq_writevv(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache,
done:
FUNC_LEAVE_NOAPI(ret_value);
-} /* H5F_seq_writevv() */
+} /* H5D_seq_writevv() */
diff --git a/src/H5F.c b/src/H5F.c
index 36fcd73..493815b 100644
--- a/src/H5F.c
+++ b/src/H5F.c
@@ -22,6 +22,10 @@
#define H5F_PACKAGE /*suppress error about including H5Fpkg */
+/* Pablo information */
+/* (Put before include files to avoid problems with inline functions) */
+#define PABLO_MASK H5F_mask
+
/* Predefined file drivers */
#include "H5FDcore.h" /*temporary in-memory files */
#include "H5FDfamily.h" /*family of files */
@@ -52,8 +56,6 @@
#include "H5Pprivate.h" /* Property lists */
#include "H5Tprivate.h" /* Datatypes */
-#define PABLO_MASK H5F_mask
-
/* Interface initialization */
static int interface_initialize_g = 0;
#define INTERFACE_INIT H5F_init_interface
@@ -97,9 +99,6 @@ H5FL_DEFINE_STATIC(H5F_file_t);
/* Declare the external free list for the H5G_t struct */
H5FL_EXTERN(H5G_t);
-/* Declare the external PQ free list for the sieve buffer information */
-H5FL_BLK_EXTERN(sieve_buf);
-
/*-------------------------------------------------------------------------
* Function: H5F_init
@@ -1560,10 +1559,6 @@ H5F_new(H5F_file_t *shared, hid_t fcpl_id, hid_t fapl_id)
f->shared->mdc_nelmts = n;
- /* Create the chunk cache */
- if(H5F_istore_init(f)<0)
- HGOTO_ERROR(H5E_FILE, H5E_CANTINIT, NULL, "unable to initialize indexed storage routines")
-
/* Create the file's "open object" information */
if(H5FO_create(f)<0)
HGOTO_ERROR(H5E_FILE, H5E_CANTINIT, NULL, "unable to create open object TBBT")
@@ -1648,22 +1643,12 @@ H5F_dest(H5F_t *f, hid_t dxpl_id)
HERROR(H5E_FILE, H5E_CANTRELEASE, "problems closing file");
ret_value = FAIL; /*but keep going*/
}
- if (H5F_istore_dest (f, dxpl_id)<0) {
- HERROR(H5E_FILE, H5E_CANTRELEASE, "problems closing file");
- ret_value = FAIL; /*but keep going*/
- }
if (H5FO_dest(f)<0) {
HERROR(H5E_FILE, H5E_CANTRELEASE, "problems closing file");
ret_value = FAIL; /*but keep going*/
} /* end if */
f->shared->cwfs = H5MM_xfree (f->shared->cwfs);
- /* Free the data sieve buffer, if it's been allocated */
- if(f->shared->sieve_buf) {
- assert(f->shared->sieve_dirty==0); /* The buffer had better be flushed... */
- f->shared->sieve_buf = H5FL_BLK_FREE (sieve_buf,f->shared->sieve_buf);
- } /* end if */
-
/* Destroy file creation properties */
if(H5I_GENPROP_LST != H5I_get_type(f->shared->fcpl_id))
HGOTO_ERROR(H5E_PLIST, H5E_BADTYPE, FAIL, "not a property list")
@@ -1823,25 +1808,25 @@ H5F_open(const char *name, unsigned flags, hid_t fcpl_id, hid_t fapl_id, hid_t d
/*
* If the driver has a `cmp' method then the driver is capable of
* determining when two file handles refer to the same file and the
- * library can insure that when the application opens a file twice that
- * the two handles coordinate their operations appropriately. Otherwise
- * it is the application's responsibility to never open the same file
- * more than once at a time.
+ * library can insure that when the application opens a file twice
+ * that the two handles coordinate their operations appropriately.
+ * Otherwise it is the application's responsibility to never open the
+ * same file more than once at a time.
*/
if((drvr=H5FD_get_class(fapl_id))==NULL)
HGOTO_ERROR(H5E_FILE, H5E_CANTGET, NULL, "unable to retrieve VFL class")
driver_has_cmp = (NULL!=drvr->cmp);
/*
- * Opening a file is a two step process. First we try to open the file in
- * a way which doesn't affect its state (like not truncating or creating
- * it) so we can compare it with files that are already open. If that
- * fails then we try again with the full set of flags (only if they're
- * different than the original failed attempt). However, if the file
- * driver can't distinquish between files then there's no reason to open
- * the file tentatively because it's the application's responsibility to
- * prevent this situation (there's no way for us to detect it here
- * anyway).
+ * Opening a file is a two step process. First we try to open the
+ * file in a way which doesn't affect its state (like not truncating
+ * or creating it) so we can compare it with files that are already
+ * open. If that fails then we try again with the full set of flags
+ * (only if they're different than the original failed attempt).
+ * However, if the file driver can't distinquish between files then
+ * there's no reason to open the file tentatively because it's the
+ * application's responsibility to prevent this situation (there's no
+ * way for us to detect it here anyway).
*/
if (driver_has_cmp) {
tent_flags = flags & ~(H5F_ACC_CREAT|H5F_ACC_TRUNC|H5F_ACC_EXCL);
@@ -1945,7 +1930,7 @@ H5F_open(const char *name, unsigned flags, hid_t fcpl_id, hid_t fapl_id, hid_t d
if (0==H5FD_get_eof(lf) && (flags & H5F_ACC_RDWR)) {
/*
* We've just opened a fresh new file (or truncated one). We need
- * to write the superblock.
+ * to create & write the superblock.
*/
#ifdef H5_HAVE_FPHDF5
/*
@@ -2592,7 +2577,7 @@ H5F_flush(H5F_t *f, hid_t dxpl_id, H5F_scope_t scope, unsigned flags)
uint8_t sbuf[H5F_SUPERBLOCK_SIZE]; /* Superblock encoding buffer */
uint8_t dbuf[H5F_DRVINFOBLOCK_SIZE]; /* Driver info block encoding buffer */
uint8_t *p=NULL; /* Temporary pointer into encoding buffers */
- unsigned nerrors=0; /* Errors from nested flushes */
+ unsigned nerrors = 0; /* Errors from nested flushes */
unsigned i; /* Index variable */
unsigned chksum; /* Checksum temporary variable */
size_t superblock_size;/* Size of superblock, in bytes */
@@ -2637,8 +2622,8 @@ H5F_flush(H5F_t *f, hid_t dxpl_id, H5F_scope_t scope, unsigned flags)
/* Avoid flushing buffers & caches when alloc_only set */
if ((flags & H5F_FLUSH_ALLOC_ONLY) == 0) {
- /* flush any cached compact storage raw data */
- if (H5D_flush(f, dxpl_id) < 0)
+ /* flush any cached dataset storage raw data */
+ if (H5D_flush(f, dxpl_id, flags) < 0)
HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "unable to flush dataset cache");
/*
@@ -2700,22 +2685,6 @@ H5F_flush(H5F_t *f, hid_t dxpl_id, H5F_scope_t scope, unsigned flags)
#endif /* H5_HAVE_FPHDF5 */
} /* end if */
- /* flush the data sieve buffer, if we have a dirty one */
- if (f->shared->sieve_buf && f->shared->sieve_dirty) {
- /* Write dirty data sieve buffer to file */
- if (H5F_block_write(f, H5FD_MEM_DRAW, f->shared->sieve_loc,
- f->shared->sieve_size, dxpl_id,
- f->shared->sieve_buf) < 0)
- HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "block write failed");
-
- /* Reset sieve buffer dirty flag */
- f->shared->sieve_dirty=0;
- } /* end if */
-
- /* flush the entire raw data cache */
- if (H5F_istore_flush(f, dxpl_id, flags & (H5F_FLUSH_INVALIDATE|H5F_FLUSH_CLEAR_ONLY)) < 0)
- HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "unable to flush raw data cache");
-
/* flush (and invalidate) the entire meta data cache */
if (H5AC_flush(f, dxpl_id, NULL, HADDR_UNDEF, flags & (H5F_FLUSH_INVALIDATE|H5F_FLUSH_CLEAR_ONLY)) < 0)
HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "unable to flush meta data cache");
@@ -3117,9 +3086,6 @@ H5F_close(H5F_t *f)
#ifdef H5AC_DEBUG
H5AC_debug(f);
#endif /* H5AC_DEBUG */
-#ifdef H5F_ISTORE_DEBUG
- H5F_istore_stats(f, FALSE);
-#endif /* H5F_ISTORE_DEBUG */
/* Only try to flush the file if it was opened with write access */
if(f->intent&H5F_ACC_RDWR) {
@@ -3909,6 +3875,130 @@ H5F_Kvalue(const H5F_t *f, const H5B_class_t *type)
/*-------------------------------------------------------------------------
+ * Function: H5F_rdcc_nelmts
+ *
+ * Purpose: Replaced a macro to retrieve the raw data cache number of elments,
+ * now that the generic properties are being used to store
+ * the values.
+ *
+ * Return: Success: Non-negative, and the raw data cache number of
+ * of elemnts is returned.
+ *
+ * Failure: Negative (should not happen)
+ *
+ * Programmer: Quincey Koziol
+ * koziol@ncsa.uiuc.edu
+ * Jun 1 2004
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+size_t H5F_rdcc_nelmts(const H5F_t *f)
+{
+ /* Use FUNC_ENTER_NOAPI_NOINIT_NOFUNC here to avoid performance issues */
+ FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5F_rdcc_nelmts)
+
+ assert(f);
+ assert(f->shared);
+
+ FUNC_LEAVE_NOAPI(f->shared->rdcc_nelmts)
+} /* end H5F_rdcc_nelmts() */
+
+
+/*-------------------------------------------------------------------------
+ * Function: H5F_rdcc_nbytes
+ *
+ * Purpose: Replaced a macro to retrieve the raw data cache number of bytes,
+ * now that the generic properties are being used to store
+ * the values.
+ *
+ * Return: Success: Non-negative, and the raw data cache number of
+ * of bytes is returned.
+ *
+ * Failure: Negative (should not happen)
+ *
+ * Programmer: Quincey Koziol
+ * koziol@ncsa.uiuc.edu
+ * Jun 1 2004
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+size_t H5F_rdcc_nbytes(const H5F_t *f)
+{
+ /* Use FUNC_ENTER_NOAPI_NOINIT_NOFUNC here to avoid performance issues */
+ FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5F_rdcc_nbytes)
+
+ assert(f);
+ assert(f->shared);
+
+ FUNC_LEAVE_NOAPI(f->shared->rdcc_nbytes)
+} /* end H5F_rdcc_nbytes() */
+
+
+/*-------------------------------------------------------------------------
+ * Function: H5F_rdcc_w0
+ *
+ * Purpose: Replaced a macro to retrieve the raw data cache 'w0' value
+ * now that the generic properties are being used to store
+ * the values.
+ *
+ * Return: Success: Non-negative, and the raw data cache 'w0' value
+ * is returned.
+ *
+ * Failure: Negative (should not happen)
+ *
+ * Programmer: Quincey Koziol
+ * koziol@ncsa.uiuc.edu
+ * Jun 2 2004
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+double H5F_rdcc_w0(const H5F_t *f)
+{
+ /* Use FUNC_ENTER_NOAPI_NOINIT_NOFUNC here to avoid performance issues */
+ FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5F_rdcc_w0)
+
+ assert(f);
+ assert(f->shared);
+
+ FUNC_LEAVE_NOAPI(f->shared->rdcc_w0)
+} /* end H5F_rdcc_w0() */
+
+
+/*-------------------------------------------------------------------------
+ * Function: H5F_has_feature
+ *
+ * Purpose: Check if a file has a particular feature enabled
+ *
+ * Return: Success: Non-negative - TRUE or FALSE
+ * Failure: Negative (should not happen)
+ *
+ * Programmer: Quincey Koziol
+ * koziol@ncsa.uiuc.edu
+ * May 31 2004
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+hbool_t H5F_has_feature(const H5F_t *f, unsigned feature)
+{
+ /* Use FUNC_ENTER_NOAPI_NOINIT_NOFUNC here to avoid performance issues */
+ FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5F_has_feature)
+
+ assert(f);
+ assert(f->shared);
+
+ FUNC_LEAVE_NOAPI(f->shared->lf->feature_flags&feature);
+} /* end H5F_has_feature() */
+
+
+/*-------------------------------------------------------------------------
* Function: H5F_get_driver_id
*
* Purpose: Quick and dirty routine to retrieve the file's 'driver_id' value
@@ -3976,35 +4066,6 @@ done:
/*-------------------------------------------------------------------------
- * Function: H5F_get_base_addr
- *
- * Purpose: Quick and dirty routine to retrieve the file's 'base_addr' value
- * (Mainly added to stop non-file routines from poking about in the
- * H5F_t data structure)
- *
- * Return: Non-negative on success/Negative on failure
- *
- * Programmer: Raymond Lu <slu@ncsa.uiuc.edu>
- * December 20, 2002
- *
- * Modifications:
- *
- *-------------------------------------------------------------------------
- */
-haddr_t
-H5F_get_base_addr(const H5F_t *f)
-{
- /* Use FUNC_ENTER_NOAPI_NOINIT_NOFUNC here to avoid performance issues */
- FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5F_get_base_addr);
-
- assert(f);
- assert(f->shared);
-
- FUNC_LEAVE_NOAPI(f->shared->base_addr);
-} /* end H5F_get_base_addr() */
-
-
-/*-------------------------------------------------------------------------
* Function: H5F_block_read
*
* Purpose: Reads some data from a file/server/etc into a buffer.
@@ -4248,89 +4309,6 @@ H5F_addr_pack(H5F_t UNUSED *f, haddr_t *addr_p/*out*/,
/*-------------------------------------------------------------------------
- * Function: H5F_sieve_overlap_clear
- *
- * Purpose: Checks for an address range's overlap with the sieve buffer
- * and resets the sieve buffer if it overlaps.
- *
- * Return: Non-negative on success/Negative on failure
- *
- * Programmer: Quincey Koziol
- * Wednesday, March 19, 2003
- *
- * Modifications:
- *
- *-------------------------------------------------------------------------
- */
-herr_t
-H5F_sieve_overlap_clear(const H5F_t *f, hid_t dxpl_id, haddr_t addr, hsize_t size)
-{
- herr_t ret_value=SUCCEED; /* Return value */
-
- FUNC_ENTER_NOAPI(H5F_sieve_overlap_clear,FAIL);
-
- /* Sanity check arguments */
- assert(f);
-
- /* Check for the address range overlapping with the sieve buffer */
- if(H5F_addr_overlap(f->shared->sieve_loc,f->shared->sieve_size,addr,size)) {
- /* Check if only part of the sieve buffer is being invalidated */
- if(size<f->shared->sieve_size) {
- /* Check if the portion to invalidate is at the end */
- if((f->shared->sieve_loc+f->shared->sieve_size)==(addr+size)) {
- /* Just shorten the buffer */
- f->shared->sieve_size-=size;
- } /* end if */
- /* Check if the portion to invalidate is at the beginning */
- else if(f->shared->sieve_loc==addr) {
- /* Advance the start of the sieve buffer (on disk) and shorten the buffer */
- f->shared->sieve_loc+=size;
- f->shared->sieve_size-=size;
-
- /* Move the retained information in the buffer down */
- HDmemcpy(f->shared->sieve_buf,f->shared->sieve_buf+size,f->shared->sieve_size);
- } /* end elif */
- /* Portion to invalidate is in middle */
- else {
- size_t invalid_size; /* Portion of sieve buffer to invalidate */
-
- /* Write out portion at the beginning of the buffer, if buffer is dirty */
- if(f->shared->sieve_dirty) {
- size_t start_size; /* Portion of sieve buffer to write */
-
- /* Compute size of block at beginning of buffer */
- start_size=(addr-f->shared->sieve_loc);
-
- /* Write to file */
- if (H5F_block_write(f, H5FD_MEM_DRAW, f->shared->sieve_loc, start_size, dxpl_id, f->shared->sieve_buf)<0)
- HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "block write failed");
- } /* end if */
-
- /* Compute size of block to invalidate */
- invalid_size=((addr+size)-f->shared->sieve_loc);
-
- /* Advance the start of the sieve buffer (on disk) and shorten the buffer */
- f->shared->sieve_loc+=invalid_size;
- f->shared->sieve_size-=invalid_size;
-
- /* Move the retained information in the buffer down */
- HDmemcpy(f->shared->sieve_buf,f->shared->sieve_buf+invalid_size,f->shared->sieve_size);
- } /* end else */
- } /* end if */
- else {
- /* Reset sieve information */
- f->shared->sieve_loc=HADDR_UNDEF;
- f->shared->sieve_size=0;
- f->shared->sieve_dirty=0;
- } /* end else */
- } /* end if */
-
-done:
- FUNC_LEAVE_NOAPI(ret_value);
-} /* H5F_sieve_overlap_clear() */
-
-
-/*-------------------------------------------------------------------------
* Function: H5Fget_freespace
*
* Purpose: Retrieves the amount of free space (of a given type) in the
@@ -4529,3 +4507,165 @@ done:
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5F_get_id() */
+
+/*-------------------------------------------------------------------------
+ * Function: H5F_get_base_addr
+ *
+ * Purpose: Quick and dirty routine to retrieve the file's 'base_addr' value
+ * (Mainly added to stop non-file routines from poking about in the
+ * H5F_t data structure)
+ *
+ * Return: Non-negative on success/Negative on failure
+ *
+ * Programmer: Raymond Lu <slu@ncsa.uiuc.edu>
+ * December 20, 2002
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+haddr_t
+H5F_get_base_addr(const H5F_t *f)
+{
+ /* Use FUNC_ENTER_NOAPI_NOINIT_NOFUNC here to avoid performance issues */
+ FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5F_get_base_addr)
+
+ assert(f);
+ assert(f->shared);
+
+ FUNC_LEAVE_NOAPI(f->shared->base_addr)
+} /* end H5F_get_base_addr() */
+
+
+/*-------------------------------------------------------------------------
+ * Function: H5F_get_eoa
+ *
+ * Purpose: Quick and dirty routine to retrieve the file's 'eoa' value
+ *
+ * Return: Non-negative on success/Negative on failure
+ *
+ * Programmer: Quincey Koziol <koziol@ncsa.uiuc.edu>
+ * June 1, 2004
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+haddr_t
+H5F_get_eoa(const H5F_t *f)
+{
+ haddr_t ret_value;
+
+ /* Use FUNC_ENTER_NOAPI_NOINIT_NOFUNC here to avoid performance issues */
+ FUNC_ENTER_NOAPI(H5F_get_eoa, HADDR_UNDEF)
+
+ assert(f);
+ assert(f->shared);
+
+ /* Dispatch to driver */
+ if (HADDR_UNDEF==(ret_value=H5FD_get_eoa(f->shared->lf)))
+ HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, HADDR_UNDEF, "driver get_eoa request failed")
+
+done:
+ FUNC_LEAVE_NOAPI(ret_value)
+} /* end H5F_get_base_addr() */
+
+#ifdef H5_HAVE_PARALLEL
+
+/*-------------------------------------------------------------------------
+ * Function: H5F_mpi_get_rank
+ *
+ * Purpose: Retrieves the rank of an MPI process.
+ *
+ * Return: Success: The rank (non-negative)
+ *
+ * Failure: Negative
+ *
+ * Programmer: Quincey Koziol
+ * Friday, January 30, 2004
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+int
+H5F_mpi_get_rank(const H5F_t *f)
+{
+ int ret_value=FAIL;
+
+ FUNC_ENTER_NOAPI(H5F_mpi_get_rank, FAIL)
+
+ assert(f && f->shared);
+
+ /* Dispatch to driver */
+ if(IS_H5FD_MPIO(f)) {
+ /* Get the MPI rank & size */
+ if ((ret_value=H5FD_mpio_mpi_rank(f->shared->lf))<0)
+ HGOTO_ERROR(H5E_INTERNAL, H5E_MPI, FAIL, "Can't retrieve MPI rank");
+ } /* end if */
+ else if(IS_H5FD_MPIPOSIX(f)) {
+ /* Get the MPI rank & size */
+ if ((ret_value=H5FD_mpiposix_mpi_rank(f->shared->lf))<0)
+ HGOTO_ERROR(H5E_INTERNAL, H5E_MPI, FAIL, "Can't retrieve MPI rank");
+ } /* end else */
+#ifdef H5_HAVE_FPHDF5
+ else if (IS_H5FD_FPHDF5(f)) {
+ /* Get the MPI rank & size */
+ if ((ret_value = H5FD_fphdf5_mpi_rank(f->shared->lf)) < 0)
+ HGOTO_ERROR(H5E_INTERNAL, H5E_MPI, FAIL, "Can't retrieve MPI rank");
+ } /* end if */
+#endif /* H5_HAVE_FPHDF5 */
+
+done:
+ FUNC_LEAVE_NOAPI(ret_value)
+} /* end H5F_mpi_get_rank() */
+
+
+/*-------------------------------------------------------------------------
+ * Function: H5F_mpi_get_comm
+ *
+ * Purpose: Retrieves the file's communicator
+ *
+ * Return: Success: The communicator (non-negative)
+ *
+ * Failure: Negative
+ *
+ * Programmer: Quincey Koziol
+ * Friday, January 30, 2004
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+MPI_Comm
+H5F_mpi_get_comm(const H5F_t *f)
+{
+ MPI_Comm ret_value=MPI_COMM_NULL;
+
+ FUNC_ENTER_NOAPI(H5F_mpi_get_comm, MPI_COMM_NULL)
+
+ assert(f && f->shared);
+
+ /* Dispatch to driver */
+ if(IS_H5FD_MPIO(f)) {
+ /* Get the MPI communicator */
+ if (MPI_COMM_NULL == (ret_value=H5FD_mpio_communicator(f->shared->lf)))
+ HGOTO_ERROR(H5E_INTERNAL, H5E_MPI, FAIL, "Can't retrieve MPI communicator");
+ } /* end if */
+ else if(IS_H5FD_MPIPOSIX(f)) {
+ /* Get the MPI communicator */
+ if (MPI_COMM_NULL == (ret_value=H5FD_mpiposix_communicator(f->shared->lf)))
+ HGOTO_ERROR(H5E_INTERNAL, H5E_MPI, FAIL, "Can't retrieve MPI communicator");
+ } /* end else */
+#ifdef H5_HAVE_FPHDF5
+ else if (IS_H5FD_FPHDF5(f)) {
+ /* Get the FPHDF5 barrier communicator */
+ if (MPI_COMM_NULL == (ret_value = H5FD_fphdf5_barrier_communicator(f->shared->lf)))
+ HGOTO_ERROR(H5E_INTERNAL, H5E_MPI, FAIL, "Can't retrieve MPI communicator");
+ } /* end if */
+#endif /* H5_HAVE_FPHDF5 */
+
+done:
+ FUNC_LEAVE_NOAPI(ret_value)
+} /* end H5F_mpi_get_comm() */
+#endif /* H5_HAVE_PARALLEL */
diff --git a/src/H5FDprivate.h b/src/H5FDprivate.h
index eafb10d..f115be4 100644
--- a/src/H5FDprivate.h
+++ b/src/H5FDprivate.h
@@ -38,6 +38,10 @@
#define IS_H5FD_MPI(file) \
(IS_H5FD_MPIO(file) || IS_H5FD_MPIPOSIX(file) || IS_H5FD_FPHDF5(file))
+/* Forward declarations for prototype arguments */
+struct H5P_genplist_t;
+
+/* Prototypes */
H5_DLL int H5FD_term_interface(void);
H5_DLL H5FD_class_t *H5FD_get_class(hid_t id);
H5_DLL hsize_t H5FD_sb_size(H5FD_t *file);
diff --git a/src/H5Fcompact.c b/src/H5Fcompact.c
index 4f5b75e..3701221 100644
--- a/src/H5Fcompact.c
+++ b/src/H5Fcompact.c
@@ -17,21 +17,22 @@
* August 5, 2002
*
* Purpose: Compact dataset I/O functions. These routines are similar
- * H5F_contig_* and H5F_istore_*.
+ * H5D_contig_* and H5D_istore_*.
*/
-#define H5F_PACKAGE /*suppress error about including H5Fpkg */
+#define H5D_PACKAGE /*suppress error about including H5Dpkg */
/* Pablo information */
/* (Put before include files to avoid problems with inline functions) */
-#define PABLO_MASK H5Fcompact_mask
+#define PABLO_MASK H5Dcompact_mask
-#include "H5private.h"
-#include "H5Eprivate.h"
-#include "H5Fpkg.h"
-#include "H5Oprivate.h"
-#include "H5FDprivate.h" /*file driver */
-#include "H5FLprivate.h" /*Free Lists */
+#include "H5private.h" /* Generic Functions */
+#include "H5Dpkg.h" /* Dataset functions */
+#include "H5Eprivate.h" /* Error handling */
+#include "H5Fprivate.h" /* Files */
+#include "H5FDprivate.h" /* File drivers */
+#include "H5FLprivate.h" /* Free Lists */
+#include "H5Oprivate.h" /* Object headers */
#include "H5Vprivate.h" /* Vector and array functions */
/* Interface initialization */
@@ -40,7 +41,7 @@ static int interface_initialize_g = 0;
/*-------------------------------------------------------------------------
- * Function: H5F_compact_readvv
+ * Function: H5D_compact_readvv
*
* Purpose: Reads some data vectors from a dataset into a buffer.
* The data is in compact dataset. The address is relative
@@ -60,26 +61,28 @@ static int interface_initialize_g = 0;
*-------------------------------------------------------------------------
*/
ssize_t
-H5F_compact_readvv(H5F_t UNUSED *f, const H5O_layout_t *layout,
+H5D_compact_readvv(H5F_t UNUSED *f, hid_t UNUSED dxpl_id, const H5D_t *dset,
size_t dset_max_nseq, size_t *dset_curr_seq, size_t dset_size_arr[], hsize_t dset_offset_arr[],
size_t mem_max_nseq, size_t *mem_curr_seq, size_t mem_size_arr[], hsize_t mem_offset_arr[],
- hid_t UNUSED dxpl_id, void *buf)
+ void *buf)
{
ssize_t ret_value; /* Return value */
- FUNC_ENTER_NOAPI(H5F_compact_readvv, FAIL);
+ FUNC_ENTER_NOAPI(H5D_compact_readvv, FAIL);
+
+ assert(dset);
/* Use the vectorized memory copy routine to do actual work */
- if((ret_value=H5V_memcpyvv(buf,mem_max_nseq,mem_curr_seq,mem_size_arr,mem_offset_arr,layout->u.compact.buf,dset_max_nseq,dset_curr_seq,dset_size_arr,dset_offset_arr))<0)
+ if((ret_value=H5V_memcpyvv(buf,mem_max_nseq,mem_curr_seq,mem_size_arr,mem_offset_arr,dset->layout.u.compact.buf,dset_max_nseq,dset_curr_seq,dset_size_arr,dset_offset_arr))<0)
HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "vectorized memcpy failed");
done:
FUNC_LEAVE_NOAPI(ret_value);
-} /* end H5F_compact_readvv() */
+} /* end H5D_compact_readvv() */
/*-------------------------------------------------------------------------
- * Function: H5F_compact_writevv
+ * Function: H5D_compact_writevv
*
* Purpose: Writes some data vectors from a dataset into a buffer.
* The data is in compact dataset. The address is relative
@@ -102,22 +105,23 @@ done:
*-------------------------------------------------------------------------
*/
ssize_t
-H5F_compact_writevv(H5F_t UNUSED *f, H5O_layout_t *layout,
+H5D_compact_writevv(H5F_t UNUSED *f, hid_t UNUSED dxpl_id, H5D_t *dset,
size_t dset_max_nseq, size_t *dset_curr_seq, size_t dset_size_arr[], hsize_t dset_offset_arr[],
size_t mem_max_nseq, size_t *mem_curr_seq, size_t mem_size_arr[], hsize_t mem_offset_arr[],
- hid_t UNUSED dxpl_id, const void *buf)
+ const void *buf)
{
ssize_t ret_value; /* Return value */
- FUNC_ENTER_NOAPI(H5F_compact_writevv, FAIL);
+ FUNC_ENTER_NOAPI(H5D_compact_writevv, FAIL);
+
+ assert(dset);
/* Use the vectorized memory copy routine to do actual work */
- if((ret_value=H5V_memcpyvv(layout->u.compact.buf,dset_max_nseq,dset_curr_seq,dset_size_arr,dset_offset_arr,buf,mem_max_nseq,mem_curr_seq,mem_size_arr,mem_offset_arr))<0)
+ if((ret_value=H5V_memcpyvv(dset->layout.u.compact.buf,dset_max_nseq,dset_curr_seq,dset_size_arr,dset_offset_arr,buf,mem_max_nseq,mem_curr_seq,mem_size_arr,mem_offset_arr))<0)
HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "vectorized memcpy failed");
- layout->u.compact.dirty = TRUE;
+ dset->layout.u.compact.dirty = TRUE;
done:
FUNC_LEAVE_NOAPI(ret_value);
-} /* end H5F_compact_writevv() */
-
+} /* end H5D_compact_writevv() */
diff --git a/src/H5Fcontig.c b/src/H5Fcontig.c
index 35b9700..47fdace 100644
--- a/src/H5Fcontig.c
+++ b/src/H5Fcontig.c
@@ -18,20 +18,20 @@
*
* Purpose:
* Contiguous dataset I/O functions. These routines are similar to
- * the H5F_istore_* routines and really only an abstract way of dealing
- * with the data sieve buffer from H5F_seg_read/write.
+ * the H5D_istore_* routines and really only an abstract way of dealing
+ * with the data sieve buffer from H5F_seq_read/write.
*/
-#define H5F_PACKAGE /*suppress error about including H5Fpkg */
+#define H5D_PACKAGE /*suppress error about including H5Dpkg */
/* Pablo information */
/* (Put before include files to avoid problems with inline functions) */
-#define PABLO_MASK H5Fcontig_mask
+#define PABLO_MASK H5Dcontig_mask
#include "H5private.h" /* Generic Functions */
-#include "H5Dprivate.h" /* Dataset functions */
+#include "H5Dpkg.h" /* Dataset functions */
#include "H5Eprivate.h" /* Error handling */
-#include "H5Fpkg.h" /* Files */
+#include "H5Fprivate.h" /* Files */
#include "H5FDprivate.h" /* File drivers */
#include "H5FLprivate.h" /* Free Lists */
#include "H5MFprivate.h" /* File memory management */
@@ -46,8 +46,8 @@
#include "H5FDmpiposix.h"
/* Private prototypes */
-static herr_t H5F_contig_write(H5F_t *f, hsize_t max_data, haddr_t addr,
- const size_t size, hid_t dxpl_id, const void *buf);
+static herr_t H5D_contig_write(H5F_t *f, hid_t dxpl_id, H5D_t *dset,
+ hsize_t offset, size_t size, const void *buf);
/* Interface initialization */
static int interface_initialize_g = 0;
@@ -64,7 +64,7 @@ H5FL_BLK_DEFINE_STATIC(zero_fill);
/*-------------------------------------------------------------------------
- * Function: H5F_contig_create
+ * Function: H5D_contig_create
*
* Purpose: Allocate file space for a contiguously stored dataset
*
@@ -78,27 +78,27 @@ H5FL_BLK_DEFINE_STATIC(zero_fill);
*-------------------------------------------------------------------------
*/
herr_t
-H5F_contig_create(H5F_t *f, hid_t dxpl_id, struct H5O_layout_t *layout)
+H5D_contig_create(H5F_t *f, hid_t dxpl_id, H5D_t *dset)
{
herr_t ret_value=SUCCEED; /* Return value */
- FUNC_ENTER_NOAPI(H5F_contig_create, FAIL);
+ FUNC_ENTER_NOAPI(H5D_contig_create, FAIL);
/* check args */
assert(f);
- assert(layout);
+ assert(dset);
/* Allocate space for the contiguous data */
- if (HADDR_UNDEF==(layout->u.contig.addr=H5MF_alloc(f, H5FD_MEM_DRAW, dxpl_id, layout->u.contig.size)))
+ if (HADDR_UNDEF==(dset->layout.u.contig.addr=H5MF_alloc(f, H5FD_MEM_DRAW, dxpl_id, dset->layout.u.contig.size)))
HGOTO_ERROR (H5E_IO, H5E_NOSPACE, FAIL, "unable to reserve file space");
done:
FUNC_LEAVE_NOAPI(ret_value);
-} /* end H5F_contig_create */
+} /* end H5D_contig_create */
/*-------------------------------------------------------------------------
- * Function: H5F_contig_fill
+ * Function: H5D_contig_fill
*
* Purpose: Write fill values to a contiguously stored dataset.
*
@@ -115,16 +115,15 @@ done:
*-------------------------------------------------------------------------
*/
herr_t
-H5F_contig_fill(H5F_t *f, hid_t dxpl_id, struct H5O_layout_t *layout,
- const struct H5S_t *space,
- const struct H5O_fill_t *fill, size_t elmt_size)
+H5D_contig_fill(H5F_t *f, hid_t dxpl_id, H5D_t *dset)
{
hssize_t snpoints; /* Number of points in space (for error checking) */
size_t npoints; /* Number of points in space */
size_t ptsperbuf; /* Maximum # of points which fit in the buffer */
+ size_t elmt_size; /* Size of each element */
size_t bufsize=64*1024; /* Size of buffer to write */
size_t size; /* Current # of points to write */
- haddr_t addr; /* Offset of dataset */
+ hsize_t offset; /* Offset of dataset */
void *buf = NULL; /* Buffer for fill value writing */
#ifdef H5_HAVE_PARALLEL
MPI_Comm mpi_comm=MPI_COMM_NULL; /* MPI communicator for file */
@@ -136,67 +135,44 @@ H5F_contig_fill(H5F_t *f, hid_t dxpl_id, struct H5O_layout_t *layout,
int non_zero_fill_f=(-1); /* Indicate that a non-zero fill-value was used */
herr_t ret_value=SUCCEED; /* Return value */
- FUNC_ENTER_NOAPI(H5F_contig_fill, FAIL);
+ FUNC_ENTER_NOAPI(H5D_contig_fill, FAIL);
/* Check args */
assert(f);
assert(TRUE==H5P_isa_class(dxpl_id,H5P_DATASET_XFER));
- assert(layout && H5D_CONTIGUOUS==layout->type);
- assert(H5F_addr_defined(layout->u.contig.addr));
- assert(layout->u.contig.size>0);
- assert(space);
- assert(elmt_size>0);
+ assert(dset && H5D_CONTIGUOUS==dset->layout.type);
+ assert(H5F_addr_defined(dset->layout.u.contig.addr));
+ assert(dset->layout.u.contig.size>0);
+ assert(dset->space);
#ifdef H5_HAVE_PARALLEL
- /* Retrieve up MPI parameters */
- if(IS_H5FD_MPIO(f)) {
+ /* Retrieve MPI parameters */
+ if(IS_H5FD_MPI(f)) {
/* Get the MPI communicator */
- if (MPI_COMM_NULL == (mpi_comm=H5FD_mpio_communicator(f->shared->lf)))
+ if (MPI_COMM_NULL == (mpi_comm=H5F_mpi_get_comm(f)))
HGOTO_ERROR(H5E_INTERNAL, H5E_MPI, FAIL, "Can't retrieve MPI communicator");
- /* Get the MPI rank & size */
- if ((mpi_rank=H5FD_mpio_mpi_rank(f->shared->lf))<0)
+ /* Get the MPI rank */
+ if ((mpi_rank=H5F_mpi_get_rank(f))<0)
HGOTO_ERROR(H5E_INTERNAL, H5E_MPI, FAIL, "Can't retrieve MPI rank");
/* Set the MPI-capable file driver flag */
using_mpi=1;
} /* end if */
- else if(IS_H5FD_MPIPOSIX(f)) {
- /* Get the MPI communicator */
- if (MPI_COMM_NULL == (mpi_comm=H5FD_mpiposix_communicator(f->shared->lf)))
- HGOTO_ERROR(H5E_INTERNAL, H5E_MPI, FAIL, "Can't retrieve MPI communicator");
-
- /* Get the MPI rank & size */
- if ((mpi_rank=H5FD_mpiposix_mpi_rank(f->shared->lf))<0)
- HGOTO_ERROR(H5E_INTERNAL, H5E_MPI, FAIL, "Can't retrieve MPI rank");
-
- /* Set the MPI-capable file driver flag */
- using_mpi=1;
- } /* end if */
-#ifdef H5_HAVE_FPHDF5
- else if (IS_H5FD_FPHDF5(f)) {
- /* Get the FPHDF5 barrier communicator */
- if (MPI_COMM_NULL == (mpi_comm = H5FD_fphdf5_barrier_communicator(f->shared->lf)))
- HGOTO_ERROR(H5E_INTERNAL, H5E_MPI, FAIL, "Can't retrieve MPI communicator");
-
- /* Get the MPI rank & size */
- if ((mpi_rank = H5FD_fphdf5_mpi_rank(f->shared->lf)) < 0)
- HGOTO_ERROR(H5E_INTERNAL, H5E_MPI, FAIL, "Can't retrieve MPI rank");
-
- /* Set the MPI-capable file driver flag */
- using_mpi = 1;
- } /* end if */
-#endif /* H5_HAVE_FPHDF5 */
#endif /* H5_HAVE_PARALLEL */
+ /* Get size of elements */
+ elmt_size=H5T_get_size(dset->type);
+ assert(elmt_size>0);
+
/* Get the number of elements in the dataset's dataspace */
- snpoints = H5S_GET_SIMPLE_EXTENT_NPOINTS(space);
+ snpoints = H5S_GET_SIMPLE_EXTENT_NPOINTS(dset->space);
assert(snpoints>=0);
H5_ASSIGN_OVERFLOW(npoints,snpoints,hssize_t,size_t);
/* If fill value is not library default, use it to set the element size */
- if(fill->buf)
- elmt_size=fill->size;
+ if(dset->fill.buf)
+ elmt_size=dset->fill.size;
/*
* Fill the entire current extent with the fill value. We can do
@@ -207,12 +183,12 @@ H5F_contig_fill(H5F_t *f, hid_t dxpl_id, struct H5O_layout_t *layout,
bufsize = ptsperbuf*elmt_size;
/* Fill the buffer with the user's fill value */
- if(fill->buf) {
+ if(dset->fill.buf) {
/* Allocate temporary buffer */
if ((buf=H5FL_BLK_MALLOC(non_zero_fill,bufsize))==NULL)
HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for fill buffer");
- H5V_array_fill(buf, fill->buf, elmt_size, ptsperbuf);
+ H5V_array_fill(buf, dset->fill.buf, elmt_size, ptsperbuf);
/* Indicate that a non-zero fill buffer was used */
non_zero_fill_f=1;
@@ -237,7 +213,7 @@ H5F_contig_fill(H5F_t *f, hid_t dxpl_id, struct H5O_layout_t *layout,
} /* end else */
/* Start at the beginning of the dataset */
- addr = layout->u.contig.addr;
+ offset = 0;
/* Loop through writing the fill value to the dataset */
while (npoints>0) {
@@ -249,7 +225,7 @@ H5F_contig_fill(H5F_t *f, hid_t dxpl_id, struct H5O_layout_t *layout,
/* Write the chunks out from only one process */
/* !! Use the internal "independent" DXPL!! -QAK */
if(H5_PAR_META_WRITE==mpi_rank) {
- if (H5F_contig_write(f, (hsize_t)size, addr, size, H5AC_ind_dxpl_id, buf)<0)
+ if (H5D_contig_write(f, H5AC_ind_dxpl_id, dset, offset, size, buf)<0)
HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to write fill value to dataset");
} /* end if */
@@ -259,14 +235,14 @@ H5F_contig_fill(H5F_t *f, hid_t dxpl_id, struct H5O_layout_t *layout,
else {
#endif /* H5_HAVE_PARALLEL */
H5_CHECK_OVERFLOW(size,size_t,hsize_t);
- if (H5F_contig_write(f, (hsize_t)size, addr, size, dxpl_id, buf)<0)
+ if (H5D_contig_write(f, dxpl_id, dset, offset, size, buf)<0)
HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to write fill value to dataset");
#ifdef H5_HAVE_PARALLEL
} /* end else */
#endif /* H5_HAVE_PARALLEL */
npoints -= MIN(ptsperbuf, npoints);
- addr += size;
+ offset += size;
} /* end while */
#ifdef H5_HAVE_PARALLEL
@@ -293,11 +269,11 @@ done:
} /* end if */
FUNC_LEAVE_NOAPI(ret_value);
-}
+} /* end H5D_contig_fill() */
/*-------------------------------------------------------------------------
- * Function: H5F_contig_delete
+ * Function: H5D_contig_delete
*
* Purpose: Delete the file space for a contiguously stored dataset
*
@@ -311,31 +287,60 @@ done:
*-------------------------------------------------------------------------
*/
herr_t
-H5F_contig_delete(H5F_t *f, hid_t dxpl_id, const struct H5O_layout_t *layout)
+H5D_contig_delete(H5F_t *f, hid_t dxpl_id, const struct H5O_layout_t *layout)
{
herr_t ret_value=SUCCEED; /* Return value */
- FUNC_ENTER_NOAPI(H5F_contig_delete, FAIL);
+ FUNC_ENTER_NOAPI(H5D_contig_delete, FAIL);
/* check args */
assert(f);
assert(layout);
- /* Check for overlap with the sieve buffer and reset it */
- if (H5F_sieve_overlap_clear(f, dxpl_id, layout->u.contig.addr, layout->u.contig.size)<0)
- HGOTO_ERROR(H5E_OHDR, H5E_CANTFREE, FAIL, "unable to clear sieve buffer");
-
/* Free the file space for the chunk */
if (H5MF_xfree(f, H5FD_MEM_DRAW, dxpl_id, layout->u.contig.addr, layout->u.contig.size)<0)
HGOTO_ERROR(H5E_OHDR, H5E_CANTFREE, FAIL, "unable to free object header");
done:
FUNC_LEAVE_NOAPI(ret_value);
-} /* end H5F_contig_delete */
+} /* end H5D_contig_delete */
+
+
+/*-------------------------------------------------------------------------
+ * Function: H5D_contig_get_addr
+ *
+ * Purpose: Get the offset of the contiguous data on disk
+ *
+ * Return: Non-negative on success/Negative on failure
+ *
+ * Programmer: Quincey Koziol
+ * June 2, 2004
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+haddr_t
+H5D_contig_get_addr(const H5D_t *dset)
+{
+ haddr_t ret_value; /* Return value */
+
+ FUNC_ENTER_NOAPI(H5D_contig_get_addr, HADDR_UNDEF);
+
+ /* check args */
+ assert(dset);
+ assert(dset->layout.type==H5D_CONTIGUOUS);
+
+ /* Get the address */
+ ret_value=dset->layout.u.contig.addr;
+
+done:
+ FUNC_LEAVE_NOAPI(ret_value);
+} /* end H5D_contig_get_addr */
/*-------------------------------------------------------------------------
- * Function: H5F_contig_write
+ * Function: H5D_contig_write
*
* Purpose: Writes some data from a dataset into a buffer.
* The data is contiguous. The address is relative to the base
@@ -352,32 +357,34 @@ done:
*-------------------------------------------------------------------------
*/
static herr_t
-H5F_contig_write(H5F_t *f, hsize_t max_data, haddr_t addr,
- const size_t size, hid_t dxpl_id, const void *buf)
+H5D_contig_write(H5F_t *f, hid_t dxpl_id, H5D_t *dset,
+ hsize_t offset, size_t size, const void *buf)
{
- hsize_t dset_off=0; /* Offset in dataset */
- hsize_t mem_off=0; /* Offset in memory */
+ hsize_t dset_off=offset; /* Offset in dataset */
size_t dset_len=size; /* Length in dataset */
+ size_t dset_curr_seq=0; /* "Current sequence" in dataset */
+ hsize_t mem_off=0; /* Offset in memory */
size_t mem_len=size; /* Length in memory */
size_t mem_curr_seq=0; /* "Current sequence" in memory */
- size_t dset_curr_seq=0; /* "Current sequence" in dataset */
herr_t ret_value=SUCCEED; /* Return value */
- FUNC_ENTER_NOAPI(H5F_contig_write, FAIL);
+ FUNC_ENTER_NOAPI(H5D_contig_write, FAIL);
assert (f);
+ assert (dset);
assert (buf);
- if (H5F_contig_writevv(f, max_data, addr, 1, &dset_curr_seq, &dset_len, &dset_off, 1, &mem_curr_seq, &mem_len, &mem_off, dxpl_id, buf)<0)
+ if (H5D_contig_writevv(f, dxpl_id, dset, dset->layout.u.contig.addr, dset->layout.u.contig.size,
+ 1, &dset_curr_seq, &dset_len, &dset_off, 1, &mem_curr_seq, &mem_len, &mem_off, buf)<0)
HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "vector write failed");
done:
FUNC_LEAVE_NOAPI(ret_value);
-} /* end H5F_contig_write() */
+} /* end H5D_contig_write() */
/*-------------------------------------------------------------------------
- * Function: H5F_contig_readvv
+ * Function: H5D_contig_readvv
*
* Purpose: Reads some data vectors from a dataset into a buffer.
* The data is contiguous. The address is the start of the dataset,
@@ -397,10 +404,11 @@ done:
*-------------------------------------------------------------------------
*/
ssize_t
-H5F_contig_readvv(H5F_t *f, hsize_t _max_data, haddr_t _addr,
+H5D_contig_readvv(H5F_t *f, hid_t dxpl_id, H5D_t *dset,
+ haddr_t dset_addr, hsize_t dset_size,
size_t dset_max_nseq, size_t *dset_curr_seq, size_t dset_len_arr[], hsize_t dset_offset_arr[],
size_t mem_max_nseq, size_t *mem_curr_seq, size_t mem_len_arr[], hsize_t mem_offset_arr[],
- hid_t dxpl_id, void *_buf)
+ void *_buf)
{
unsigned char *buf=(unsigned char *)_buf; /* Pointer to buffer to fill */
haddr_t abs_eoa; /* Absolute end of file address */
@@ -412,14 +420,15 @@ H5F_contig_readvv(H5F_t *f, hsize_t _max_data, haddr_t _addr,
size_t v; /* Counting variable */
ssize_t ret_value=0; /* Return value */
- FUNC_ENTER_NOAPI(H5F_contig_readvv, FAIL);
+ FUNC_ENTER_NOAPI(H5D_contig_readvv, FAIL);
/* Check args */
assert(f);
+ assert(dset);
assert(buf);
/* Check if data sieving is enabled */
- if(f->shared->lf->feature_flags&H5FD_FEAT_DATA_SIEVE) {
+ if(H5F_HAS_FEATURE(f,H5FD_FEAT_DATA_SIEVE)) {
haddr_t sieve_start, sieve_end; /* Start & end locations of sieve buffer */
haddr_t contig_end; /* End locations of block to write */
size_t sieve_size; /* size of sieve buffer */
@@ -429,7 +438,7 @@ H5F_contig_readvv(H5F_t *f, hsize_t _max_data, haddr_t _addr,
v=*mem_curr_seq;
/* No data sieve buffer yet, go allocate one */
- if(f->shared->sieve_buf==NULL) {
+ if(dset->cache.contig.sieve_buf==NULL) {
/* Choose smallest buffer to write */
if(mem_len_arr[v]<dset_len_arr[u])
size=mem_len_arr[v];
@@ -437,46 +446,46 @@ H5F_contig_readvv(H5F_t *f, hsize_t _max_data, haddr_t _addr,
size=dset_len_arr[u];
/* Compute offset on disk */
- addr=_addr+dset_offset_arr[u];
+ addr=dset_addr+dset_offset_arr[u];
/* Compute offset in memory */
buf = (unsigned char *)_buf + mem_offset_arr[v];
/* Set up the buffer parameters */
- max_data=_max_data-dset_offset_arr[u];
+ max_data=dset_size-dset_offset_arr[u];
/* Check if we can actually hold the I/O request in the sieve buffer */
- if(size>f->shared->sieve_buf_size) {
+ if(size>dset->cache.contig.sieve_buf_size) {
if (H5F_block_read(f, H5FD_MEM_DRAW, addr, size, dxpl_id, buf)<0)
HGOTO_ERROR(H5E_IO, H5E_READERROR, FAIL, "block read failed");
} /* end if */
else {
/* Allocate room for the data sieve buffer */
- if (NULL==(f->shared->sieve_buf=H5FL_BLK_MALLOC(sieve_buf,f->shared->sieve_buf_size)))
+ if (NULL==(dset->cache.contig.sieve_buf=H5FL_BLK_MALLOC(sieve_buf,dset->cache.contig.sieve_buf_size)))
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed");
/* Determine the new sieve buffer size & location */
- f->shared->sieve_loc=addr;
+ dset->cache.contig.sieve_loc=addr;
/* Make certain we don't read off the end of the file */
- if (HADDR_UNDEF==(abs_eoa=H5FD_get_eoa(f->shared->lf)))
+ if (HADDR_UNDEF==(abs_eoa=H5F_get_eoa(f)))
HGOTO_ERROR(H5E_FILE, H5E_CANTOPENFILE, FAIL, "unable to determine file size");
/* Adjust absolute EOA address to relative EOA address */
- rel_eoa=abs_eoa-f->shared->base_addr;
+ rel_eoa=abs_eoa-H5F_get_base_addr(f);
/* Compute the size of the sieve buffer */
- H5_ASSIGN_OVERFLOW(f->shared->sieve_size,MIN(rel_eoa-f->shared->sieve_loc,MIN(max_data,f->shared->sieve_buf_size)),hsize_t,size_t);
+ H5_ASSIGN_OVERFLOW(dset->cache.contig.sieve_size,MIN3(rel_eoa-dset->cache.contig.sieve_loc,max_data,dset->cache.contig.sieve_buf_size),hsize_t,size_t);
/* Read the new sieve buffer */
- if (H5F_block_read(f, H5FD_MEM_DRAW, f->shared->sieve_loc, f->shared->sieve_size, dxpl_id, f->shared->sieve_buf)<0)
+ if (H5F_block_read(f, H5FD_MEM_DRAW, dset->cache.contig.sieve_loc, dset->cache.contig.sieve_size, dxpl_id, dset->cache.contig.sieve_buf)<0)
HGOTO_ERROR(H5E_IO, H5E_READERROR, FAIL, "block read failed");
/* Grab the data out of the buffer (must be first piece of data in buffer ) */
- HDmemcpy(buf,f->shared->sieve_buf,size);
+ HDmemcpy(buf,dset->cache.contig.sieve_buf,size);
/* Reset sieve buffer dirty flag */
- f->shared->sieve_dirty=0;
+ dset->cache.contig.sieve_dirty=0;
} /* end else */
/* Update memory information */
@@ -496,8 +505,8 @@ H5F_contig_readvv(H5F_t *f, hsize_t _max_data, haddr_t _addr,
} /* end if */
/* Stash local copies of these value */
- sieve_start=f->shared->sieve_loc;
- sieve_size=f->shared->sieve_size;
+ sieve_start=dset->cache.contig.sieve_loc;
+ sieve_size=dset->cache.contig.sieve_size;
sieve_end=sieve_start+sieve_size;
/* Works through sequences as fast as possible */
@@ -509,7 +518,7 @@ H5F_contig_readvv(H5F_t *f, hsize_t _max_data, haddr_t _addr,
size=dset_len_arr[u];
/* Compute offset on disk */
- addr=_addr+dset_offset_arr[u];
+ addr=dset_addr+dset_offset_arr[u];
/* Compute offset in memory */
buf = (unsigned char *)_buf + mem_offset_arr[v];
@@ -519,7 +528,7 @@ H5F_contig_readvv(H5F_t *f, hsize_t _max_data, haddr_t _addr,
/* If entire read is within the sieve buffer, read it from the buffer */
if(addr>=sieve_start && contig_end<sieve_end) {
- unsigned char *base_sieve_buf=f->shared->sieve_buf+(addr-sieve_start);
+ unsigned char *base_sieve_buf=dset->cache.contig.sieve_buf+(addr-sieve_start);
/* Grab the data out of the buffer */
HDmemcpy(buf,base_sieve_buf,size);
@@ -527,18 +536,18 @@ H5F_contig_readvv(H5F_t *f, hsize_t _max_data, haddr_t _addr,
/* Entire request is not within this data sieve buffer */
else {
/* Check if we can actually hold the I/O request in the sieve buffer */
- if(size>f->shared->sieve_buf_size) {
+ if(size>dset->cache.contig.sieve_buf_size) {
/* Check for any overlap with the current sieve buffer */
if((sieve_start>=addr && sieve_start<(contig_end+1))
|| ((sieve_end-1)>=addr && (sieve_end-1)<(contig_end+1))) {
/* Flush the sieve buffer, if it's dirty */
- if(f->shared->sieve_dirty) {
+ if(dset->cache.contig.sieve_dirty) {
/* Write to file */
- if (H5F_block_write(f, H5FD_MEM_DRAW, sieve_start, sieve_size, dxpl_id, f->shared->sieve_buf)<0)
+ if (H5F_block_write(f, H5FD_MEM_DRAW, sieve_start, sieve_size, dxpl_id, dset->cache.contig.sieve_buf)<0)
HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "block write failed");
/* Reset sieve buffer dirty flag */
- f->shared->sieve_dirty=0;
+ dset->cache.contig.sieve_dirty=0;
} /* end if */
} /* end if */
@@ -549,46 +558,46 @@ H5F_contig_readvv(H5F_t *f, hsize_t _max_data, haddr_t _addr,
/* Element size fits within the buffer size */
else {
/* Flush the sieve buffer if it's dirty */
- if(f->shared->sieve_dirty) {
+ if(dset->cache.contig.sieve_dirty) {
/* Write to file */
- if (H5F_block_write(f, H5FD_MEM_DRAW, sieve_start, sieve_size, dxpl_id, f->shared->sieve_buf)<0)
+ if (H5F_block_write(f, H5FD_MEM_DRAW, sieve_start, sieve_size, dxpl_id, dset->cache.contig.sieve_buf)<0)
HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "block write failed");
/* Reset sieve buffer dirty flag */
- f->shared->sieve_dirty=0;
+ dset->cache.contig.sieve_dirty=0;
} /* end if */
/* Determine the new sieve buffer size & location */
- f->shared->sieve_loc=addr;
+ dset->cache.contig.sieve_loc=addr;
/* Make certain we don't read off the end of the file */
- if (HADDR_UNDEF==(abs_eoa=H5FD_get_eoa(f->shared->lf)))
+ if (HADDR_UNDEF==(abs_eoa=H5F_get_eoa(f)))
HGOTO_ERROR(H5E_FILE, H5E_CANTOPENFILE, FAIL, "unable to determine file size");
/* Adjust absolute EOA address to relative EOA address */
- rel_eoa=abs_eoa-f->shared->base_addr;
+ rel_eoa=abs_eoa-H5F_get_base_addr(f);
/* Only need this when resizing sieve buffer */
- max_data=_max_data-dset_offset_arr[u];
+ max_data=dset_size-dset_offset_arr[u];
/* Compute the size of the sieve buffer */
/* Don't read off the end of the file, don't read past the end of the data element and don't read more than the buffer size */
- H5_ASSIGN_OVERFLOW(f->shared->sieve_size,MIN(rel_eoa-f->shared->sieve_loc,MIN(max_data,f->shared->sieve_buf_size)),hsize_t,size_t);
+ H5_ASSIGN_OVERFLOW(dset->cache.contig.sieve_size,MIN3(rel_eoa-dset->cache.contig.sieve_loc,max_data,dset->cache.contig.sieve_buf_size),hsize_t,size_t);
/* Update local copies of sieve information */
- sieve_start=f->shared->sieve_loc;
- sieve_size=f->shared->sieve_size;
+ sieve_start=dset->cache.contig.sieve_loc;
+ sieve_size=dset->cache.contig.sieve_size;
sieve_end=sieve_start+sieve_size;
/* Read the new sieve buffer */
- if (H5F_block_read(f, H5FD_MEM_DRAW, f->shared->sieve_loc, f->shared->sieve_size, dxpl_id, f->shared->sieve_buf)<0)
+ if (H5F_block_read(f, H5FD_MEM_DRAW, dset->cache.contig.sieve_loc, dset->cache.contig.sieve_size, dxpl_id, dset->cache.contig.sieve_buf)<0)
HGOTO_ERROR(H5E_IO, H5E_READERROR, FAIL, "block read failed");
/* Grab the data out of the buffer (must be first piece of data in buffer ) */
- HDmemcpy(buf,f->shared->sieve_buf,size);
+ HDmemcpy(buf,dset->cache.contig.sieve_buf,size);
/* Reset sieve buffer dirty flag */
- f->shared->sieve_dirty=0;
+ dset->cache.contig.sieve_dirty=0;
} /* end else */
} /* end else */
@@ -618,7 +627,7 @@ H5F_contig_readvv(H5F_t *f, hsize_t _max_data, haddr_t _addr,
size=dset_len_arr[u];
/* Compute offset on disk */
- addr=_addr+dset_offset_arr[u];
+ addr=dset_addr+dset_offset_arr[u];
/* Compute offset in memory */
buf = (unsigned char *)_buf + mem_offset_arr[v];
@@ -650,11 +659,11 @@ H5F_contig_readvv(H5F_t *f, hsize_t _max_data, haddr_t _addr,
done:
FUNC_LEAVE_NOAPI(ret_value);
-} /* end H5F_contig_readvv() */
+} /* end H5D_contig_readvv() */
/*-------------------------------------------------------------------------
- * Function: H5F_contig_writevv
+ * Function: H5D_contig_writevv
*
* Purpose: Writes some data vectors into a dataset from vectors into a
* buffer. The address is the start of the dataset,
@@ -674,10 +683,11 @@ done:
*-------------------------------------------------------------------------
*/
ssize_t
-H5F_contig_writevv(H5F_t *f, hsize_t _max_data, haddr_t _addr,
+H5D_contig_writevv(H5F_t *f, hid_t dxpl_id, H5D_t *dset,
+ haddr_t dset_addr, hsize_t dset_size,
size_t dset_max_nseq, size_t *dset_curr_seq, size_t dset_len_arr[], hsize_t dset_offset_arr[],
size_t mem_max_nseq, size_t *mem_curr_seq, size_t mem_len_arr[], hsize_t mem_offset_arr[],
- hid_t dxpl_id, const void *_buf)
+ const void *_buf)
{
const unsigned char *buf=_buf; /* Pointer to buffer to fill */
haddr_t abs_eoa; /* Absolute end of file address */
@@ -689,14 +699,15 @@ H5F_contig_writevv(H5F_t *f, hsize_t _max_data, haddr_t _addr,
size_t v; /* Counting variable */
ssize_t ret_value=0; /* Return value */
- FUNC_ENTER_NOAPI(H5F_contig_writevv, FAIL);
+ FUNC_ENTER_NOAPI(H5D_contig_writevv, FAIL);
/* Check args */
assert(f);
+ assert(dset);
assert(buf);
/* Check if data sieving is enabled */
- if(f->shared->lf->feature_flags&H5FD_FEAT_DATA_SIEVE) {
+ if(H5F_HAS_FEATURE(f,H5FD_FEAT_DATA_SIEVE)) {
haddr_t sieve_start, sieve_end; /* Start & end locations of sieve buffer */
haddr_t contig_end; /* End locations of block to write */
size_t sieve_size; /* size of sieve buffer */
@@ -706,7 +717,7 @@ H5F_contig_writevv(H5F_t *f, hsize_t _max_data, haddr_t _addr,
v=*mem_curr_seq;
/* No data sieve buffer yet, go allocate one */
- if(f->shared->sieve_buf==NULL) {
+ if(dset->cache.contig.sieve_buf==NULL) {
/* Choose smallest buffer to write */
if(mem_len_arr[v]<dset_len_arr[u])
size=mem_len_arr[v];
@@ -714,49 +725,49 @@ H5F_contig_writevv(H5F_t *f, hsize_t _max_data, haddr_t _addr,
size=dset_len_arr[u];
/* Compute offset on disk */
- addr=_addr+dset_offset_arr[u];
+ addr=dset_addr+dset_offset_arr[u];
/* Compute offset in memory */
buf = (const unsigned char *)_buf + mem_offset_arr[v];
/* Set up the buffer parameters */
- max_data=_max_data-dset_offset_arr[u];
+ max_data=dset_size-dset_offset_arr[u];
/* Check if we can actually hold the I/O request in the sieve buffer */
- if(size>f->shared->sieve_buf_size) {
+ if(size>dset->cache.contig.sieve_buf_size) {
if (H5F_block_write(f, H5FD_MEM_DRAW, addr, size, dxpl_id, buf)<0)
HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "block write failed");
} /* end if */
else {
/* Allocate room for the data sieve buffer */
- if (NULL==(f->shared->sieve_buf=H5FL_BLK_MALLOC(sieve_buf,f->shared->sieve_buf_size)))
+ if (NULL==(dset->cache.contig.sieve_buf=H5FL_BLK_MALLOC(sieve_buf,dset->cache.contig.sieve_buf_size)))
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed");
/* Determine the new sieve buffer size & location */
- f->shared->sieve_loc=addr;
+ dset->cache.contig.sieve_loc=addr;
/* Make certain we don't read off the end of the file */
- if (HADDR_UNDEF==(abs_eoa=H5FD_get_eoa(f->shared->lf)))
+ if (HADDR_UNDEF==(abs_eoa=H5F_get_eoa(f)))
HGOTO_ERROR(H5E_FILE, H5E_CANTOPENFILE, FAIL, "unable to determine file size");
/* Adjust absolute EOA address to relative EOA address */
- rel_eoa=abs_eoa-f->shared->base_addr;
+ rel_eoa=abs_eoa-H5F_get_base_addr(f);
/* Compute the size of the sieve buffer */
- H5_ASSIGN_OVERFLOW(f->shared->sieve_size,MIN(rel_eoa-f->shared->sieve_loc,MIN(max_data,f->shared->sieve_buf_size)),hsize_t,size_t);
+ H5_ASSIGN_OVERFLOW(dset->cache.contig.sieve_size,MIN3(rel_eoa-dset->cache.contig.sieve_loc,max_data,dset->cache.contig.sieve_buf_size),hsize_t,size_t);
/* Check if there is any point in reading the data from the file */
- if(f->shared->sieve_size>size) {
+ if(dset->cache.contig.sieve_size>size) {
/* Read the new sieve buffer */
- if (H5F_block_read(f, H5FD_MEM_DRAW, f->shared->sieve_loc, f->shared->sieve_size, dxpl_id, f->shared->sieve_buf)<0)
+ if (H5F_block_read(f, H5FD_MEM_DRAW, dset->cache.contig.sieve_loc, dset->cache.contig.sieve_size, dxpl_id, dset->cache.contig.sieve_buf)<0)
HGOTO_ERROR(H5E_IO, H5E_READERROR, FAIL, "block read failed");
} /* end if */
/* Grab the data out of the buffer (must be first piece of data in buffer ) */
- HDmemcpy(f->shared->sieve_buf,buf,size);
+ HDmemcpy(dset->cache.contig.sieve_buf,buf,size);
/* Set sieve buffer dirty flag */
- f->shared->sieve_dirty=1;
+ dset->cache.contig.sieve_dirty=1;
} /* end else */
/* Update memory information */
@@ -776,8 +787,8 @@ H5F_contig_writevv(H5F_t *f, hsize_t _max_data, haddr_t _addr,
} /* end if */
/* Stash local copies of these value */
- sieve_start=f->shared->sieve_loc;
- sieve_size=f->shared->sieve_size;
+ sieve_start=dset->cache.contig.sieve_loc;
+ sieve_size=dset->cache.contig.sieve_size;
sieve_end=sieve_start+sieve_size;
/* Works through sequences as fast as possible */
@@ -789,7 +800,7 @@ H5F_contig_writevv(H5F_t *f, hsize_t _max_data, haddr_t _addr,
size=dset_len_arr[u];
/* Compute offset on disk */
- addr=_addr+dset_offset_arr[u];
+ addr=dset_addr+dset_offset_arr[u];
/* Compute offset in memory */
buf = (const unsigned char *)_buf + mem_offset_arr[v];
@@ -799,35 +810,35 @@ H5F_contig_writevv(H5F_t *f, hsize_t _max_data, haddr_t _addr,
/* If entire write is within the sieve buffer, write it to the buffer */
if(addr>=sieve_start && contig_end<sieve_end) {
- unsigned char *base_sieve_buf=f->shared->sieve_buf+(addr-sieve_start);
+ unsigned char *base_sieve_buf=dset->cache.contig.sieve_buf+(addr-sieve_start);
/* Put the data into the sieve buffer */
HDmemcpy(base_sieve_buf,buf,size);
/* Set sieve buffer dirty flag */
- f->shared->sieve_dirty=1;
+ dset->cache.contig.sieve_dirty=1;
} /* end if */
/* Entire request is not within this data sieve buffer */
else {
/* Check if we can actually hold the I/O request in the sieve buffer */
- if(size>f->shared->sieve_buf_size) {
+ if(size>dset->cache.contig.sieve_buf_size) {
/* Check for any overlap with the current sieve buffer */
if((sieve_start>=addr && sieve_start<(contig_end+1))
|| ((sieve_end-1)>=addr && (sieve_end-1)<(contig_end+1))) {
/* Flush the sieve buffer, if it's dirty */
- if(f->shared->sieve_dirty) {
+ if(dset->cache.contig.sieve_dirty) {
/* Write to file */
- if (H5F_block_write(f, H5FD_MEM_DRAW, sieve_start, sieve_size, dxpl_id, f->shared->sieve_buf)<0)
+ if (H5F_block_write(f, H5FD_MEM_DRAW, sieve_start, sieve_size, dxpl_id, dset->cache.contig.sieve_buf)<0)
HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "block write failed");
/* Reset sieve buffer dirty flag */
- f->shared->sieve_dirty=0;
+ dset->cache.contig.sieve_dirty=0;
} /* end if */
/* Force the sieve buffer to be re-read the next time */
- f->shared->sieve_loc=HADDR_UNDEF;
- f->shared->sieve_size=0;
+ dset->cache.contig.sieve_loc=HADDR_UNDEF;
+ dset->cache.contig.sieve_size=0;
} /* end if */
/* Write directly from the user's buffer */
@@ -838,81 +849,81 @@ H5F_contig_writevv(H5F_t *f, hsize_t _max_data, haddr_t _addr,
else {
/* Check if it is possible to (exactly) prepend or append to existing (dirty) sieve buffer */
if(((addr+size)==sieve_start || addr==sieve_end) &&
- (size+sieve_size)<=f->shared->sieve_buf_size &&
- f->shared->sieve_dirty) {
+ (size+sieve_size)<=dset->cache.contig.sieve_buf_size &&
+ dset->cache.contig.sieve_dirty) {
/* Prepend to existing sieve buffer */
if((addr+size)==sieve_start) {
/* Move existing sieve information to correct location */
- HDmemmove(f->shared->sieve_buf+size,f->shared->sieve_buf,sieve_size);
+ HDmemmove(dset->cache.contig.sieve_buf+size,dset->cache.contig.sieve_buf,sieve_size);
/* Copy in new information (must be first in sieve buffer) */
- HDmemcpy(f->shared->sieve_buf,buf,size);
+ HDmemcpy(dset->cache.contig.sieve_buf,buf,size);
/* Adjust sieve location */
- f->shared->sieve_loc=addr;
+ dset->cache.contig.sieve_loc=addr;
} /* end if */
/* Append to existing sieve buffer */
else {
/* Copy in new information */
- HDmemcpy(f->shared->sieve_buf+sieve_size,buf,size);
+ HDmemcpy(dset->cache.contig.sieve_buf+sieve_size,buf,size);
} /* end else */
/* Adjust sieve size */
- f->shared->sieve_size += size;
+ dset->cache.contig.sieve_size += size;
/* Update local copies of sieve information */
- sieve_start=f->shared->sieve_loc;
- sieve_size=f->shared->sieve_size;
+ sieve_start=dset->cache.contig.sieve_loc;
+ sieve_size=dset->cache.contig.sieve_size;
sieve_end=sieve_start+sieve_size;
} /* end if */
/* Can't add the new data onto the existing sieve buffer */
else {
/* Flush the sieve buffer if it's dirty */
- if(f->shared->sieve_dirty) {
+ if(dset->cache.contig.sieve_dirty) {
/* Write to file */
- if (H5F_block_write(f, H5FD_MEM_DRAW, sieve_start, sieve_size, dxpl_id, f->shared->sieve_buf)<0)
+ if (H5F_block_write(f, H5FD_MEM_DRAW, sieve_start, sieve_size, dxpl_id, dset->cache.contig.sieve_buf)<0)
HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "block write failed");
/* Reset sieve buffer dirty flag */
- f->shared->sieve_dirty=0;
+ dset->cache.contig.sieve_dirty=0;
} /* end if */
/* Determine the new sieve buffer size & location */
- f->shared->sieve_loc=addr;
+ dset->cache.contig.sieve_loc=addr;
/* Make certain we don't read off the end of the file */
- if (HADDR_UNDEF==(abs_eoa=H5FD_get_eoa(f->shared->lf)))
+ if (HADDR_UNDEF==(abs_eoa=H5F_get_eoa(f)))
HGOTO_ERROR(H5E_FILE, H5E_CANTOPENFILE, FAIL, "unable to determine file size");
/* Adjust absolute EOA address to relative EOA address */
- rel_eoa=abs_eoa-f->shared->base_addr;
+ rel_eoa=abs_eoa-H5F_get_base_addr(f);
/* Only need this when resizing sieve buffer */
- max_data=_max_data-dset_offset_arr[u];
+ max_data=dset_size-dset_offset_arr[u];
/* Compute the size of the sieve buffer */
/* Don't read off the end of the file, don't read past the end of the data element and don't read more than the buffer size */
- H5_ASSIGN_OVERFLOW(f->shared->sieve_size,MIN(rel_eoa-f->shared->sieve_loc,MIN(max_data,f->shared->sieve_buf_size)),hsize_t,size_t);
+ H5_ASSIGN_OVERFLOW(dset->cache.contig.sieve_size,MIN3(rel_eoa-dset->cache.contig.sieve_loc,max_data,dset->cache.contig.sieve_buf_size),hsize_t,size_t);
/* Update local copies of sieve information */
- sieve_start=f->shared->sieve_loc;
- sieve_size=f->shared->sieve_size;
+ sieve_start=dset->cache.contig.sieve_loc;
+ sieve_size=dset->cache.contig.sieve_size;
sieve_end=sieve_start+sieve_size;
/* Check if there is any point in reading the data from the file */
- if(f->shared->sieve_size>size) {
+ if(dset->cache.contig.sieve_size>size) {
/* Read the new sieve buffer */
- if (H5F_block_read(f, H5FD_MEM_DRAW, f->shared->sieve_loc, f->shared->sieve_size, dxpl_id, f->shared->sieve_buf)<0)
+ if (H5F_block_read(f, H5FD_MEM_DRAW, dset->cache.contig.sieve_loc, dset->cache.contig.sieve_size, dxpl_id, dset->cache.contig.sieve_buf)<0)
HGOTO_ERROR(H5E_IO, H5E_READERROR, FAIL, "block read failed");
} /* end if */
/* Grab the data out of the buffer (must be first piece of data in buffer ) */
- HDmemcpy(f->shared->sieve_buf,buf,size);
+ HDmemcpy(dset->cache.contig.sieve_buf,buf,size);
/* Set sieve buffer dirty flag */
- f->shared->sieve_dirty=1;
+ dset->cache.contig.sieve_dirty=1;
} /* end else */
} /* end else */
@@ -944,7 +955,7 @@ H5F_contig_writevv(H5F_t *f, hsize_t _max_data, haddr_t _addr,
size=dset_len_arr[u];
/* Compute offset on disk */
- addr=_addr+dset_offset_arr[u];
+ addr=dset_addr+dset_offset_arr[u];
/* Compute offset in memory */
buf = (const unsigned char *)_buf + mem_offset_arr[v];
@@ -976,5 +987,5 @@ H5F_contig_writevv(H5F_t *f, hsize_t _max_data, haddr_t _addr,
done:
FUNC_LEAVE_NOAPI(ret_value);
-} /* end H5F_contig_writevv() */
+} /* end H5D_contig_writevv() */
diff --git a/src/H5Fistore.c b/src/H5Fistore.c
index bf4cc66..75433fd 100644
--- a/src/H5Fistore.c
+++ b/src/H5Fistore.c
@@ -41,17 +41,17 @@
*/
#define H5B_PACKAGE /*suppress error about including H5Bpkg */
-#define H5F_PACKAGE /*suppress error about including H5Fpkg */
+#define H5D_PACKAGE /*suppress error about including H5Dpkg */
/* Pablo information */
/* (Put before include files to avoid problems with inline functions) */
-#define PABLO_MASK H5Fistore_mask
+#define PABLO_MASK H5Distore_mask
#include "H5private.h" /* Generic Functions */
#include "H5Bpkg.h" /* B-link trees */
-#include "H5Dprivate.h" /* Datasets */
+#include "H5Dpkg.h" /* Datasets */
#include "H5Eprivate.h" /* Error handling */
-#include "H5Fpkg.h" /* Files */
+#include "H5Fprivate.h" /* Files */
#include "H5FLprivate.h" /* Free Lists */
#include "H5Iprivate.h" /* IDs */
#include "H5MFprivate.h" /* File space management */
@@ -90,7 +90,7 @@
* and the operating system can also eliminate a read operation.
*/
-/*#define H5F_ISTORE_DEBUG */
+/*#define H5D_ISTORE_DEBUG */
/* Interface initialization */
static int interface_initialize_g = 0;
@@ -100,14 +100,12 @@ static int interface_initialize_g = 0;
* Given a B-tree node return the dimensionality of the chunks pointed to by
* that node.
*/
-#define H5F_ISTORE_NDIMS(X) ((int)(((X)->sizeof_rkey-8)/8))
+#define H5D_ISTORE_NDIMS(X) ((int)(((X)->sizeof_rkey-8)/8))
/* Raw data chunks are cached. Each entry in the cache is: */
-typedef struct H5F_rdcc_ent_t {
+typedef struct H5D_rdcc_ent_t {
hbool_t locked; /*entry is locked in cache */
hbool_t dirty; /*needs to be written to disk? */
- H5O_layout_t layout; /*the layout message */
- H5O_pline_t pline; /*filter pipeline message */
hssize_t offset[H5O_LAYOUT_NDIMS]; /*chunk name */
size_t rd_count; /*bytes remaining to be read */
size_t wr_count; /*bytes remaining to be written */
@@ -115,10 +113,10 @@ typedef struct H5F_rdcc_ent_t {
size_t alloc_size; /*amount allocated for the chunk */
uint8_t *chunk; /*the unfiltered chunk data */
unsigned idx; /*index in hash table */
- struct H5F_rdcc_ent_t *next;/*next item in doubly-linked list */
- struct H5F_rdcc_ent_t *prev;/*previous item in doubly-linked list */
-} H5F_rdcc_ent_t;
-typedef H5F_rdcc_ent_t *H5F_rdcc_ent_ptr_t; /* For free lists */
+ struct H5D_rdcc_ent_t *next;/*next item in doubly-linked list */
+ struct H5D_rdcc_ent_t *prev;/*previous item in doubly-linked list */
+} H5D_rdcc_ent_t;
+typedef H5D_rdcc_ent_t *H5D_rdcc_ent_ptr_t; /* For free lists */
/*
* B-tree key. A key contains the minimum logical N-dimensional address and
@@ -134,97 +132,94 @@ typedef H5F_rdcc_ent_t *H5F_rdcc_ent_ptr_t; /* For free lists */
*
* The chunk's file address is part of the B-tree and not part of the key.
*/
-typedef struct H5F_istore_key_t {
+typedef struct H5D_istore_key_t {
size_t nbytes; /*size of stored data */
hssize_t offset[H5O_LAYOUT_NDIMS]; /*logical offset to start*/
unsigned filter_mask; /*excluded filters */
-} H5F_istore_key_t;
+} H5D_istore_key_t;
-typedef struct H5F_istore_ud1_t {
- H5F_istore_key_t key; /*key values */
+typedef struct H5D_istore_ud1_t {
+ H5D_istore_key_t key; /*key values */
haddr_t addr; /*file address of chunk */
H5O_layout_t mesg; /*layout message */
hsize_t total_storage; /*output from iterator */
FILE *stream; /*debug output stream */
hsize_t *dims; /*dataset dimensions */
-} H5F_istore_ud1_t;
+} H5D_istore_ud1_t;
-#define H5F_HASH_DIVISOR 1 /* Attempt to spread out the hashing */
- /* This should be the same size as the alignment of */
- /* of the smallest file format object written to the file. */
-#define H5F_HASH(F,ADDR) H5F_addr_hash((ADDR/H5F_HASH_DIVISOR),(F)->shared->rdcc.nslots)
+#define H5D_HASH(D,ADDR) H5F_addr_hash(ADDR,(D)->cache.chunk.nslots)
/* Private prototypes */
-static haddr_t H5F_istore_get_addr(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout,
- const hssize_t offset[], H5F_istore_ud1_t *_udata);
-static void *H5F_istore_chunk_alloc(size_t size, const H5O_pline_t *pline);
-static void *H5F_istore_chunk_xfree(void *chk, const H5O_pline_t *pline);
+static haddr_t H5D_istore_get_addr(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout,
+ const hssize_t offset[], H5D_istore_ud1_t *_udata);
+static void *H5D_istore_chunk_alloc(size_t size, const H5O_pline_t *pline);
+static void *H5D_istore_chunk_xfree(void *chk, const H5O_pline_t *pline);
/* B-tree iterator callbacks */
-static int H5F_istore_iter_allocated(H5F_t *f, hid_t dxpl_id, void *left_key, haddr_t addr,
+static int H5D_istore_iter_allocated(H5F_t *f, hid_t dxpl_id, void *left_key, haddr_t addr,
void *right_key, void *_udata);
-static int H5F_istore_iter_dump(H5F_t *f, hid_t dxpl_id, void *left_key, haddr_t addr,
+static int H5D_istore_iter_dump(H5F_t *f, hid_t dxpl_id, void *left_key, haddr_t addr,
void *right_key, void *_udata);
-static int H5F_istore_prune_extent(H5F_t *f, hid_t dxpl_id, void *_lt_key, haddr_t addr,
+static int H5D_istore_prune_extent(H5F_t *f, hid_t dxpl_id, void *_lt_key, haddr_t addr,
void *_rt_key, void *_udata);
/* B-tree callbacks */
-static size_t H5F_istore_sizeof_rkey(H5F_t *f, const void *_udata);
-static herr_t H5F_istore_new_node(H5F_t *f, hid_t dxpl_id, H5B_ins_t, void *_lt_key,
+static size_t H5D_istore_sizeof_rkey(H5F_t *f, const void *_udata);
+static herr_t H5D_istore_new_node(H5F_t *f, hid_t dxpl_id, H5B_ins_t, void *_lt_key,
void *_udata, void *_rt_key,
haddr_t *addr_p /*out*/);
-static int H5F_istore_cmp2(H5F_t *f, hid_t dxpl_id, void *_lt_key, void *_udata,
+static int H5D_istore_cmp2(H5F_t *f, hid_t dxpl_id, void *_lt_key, void *_udata,
void *_rt_key);
-static int H5F_istore_cmp3(H5F_t *f, hid_t dxpl_id, void *_lt_key, void *_udata,
+static int H5D_istore_cmp3(H5F_t *f, hid_t dxpl_id, void *_lt_key, void *_udata,
void *_rt_key);
-static herr_t H5F_istore_found(H5F_t *f, hid_t dxpl_id, haddr_t addr, const void *_lt_key,
+static herr_t H5D_istore_found(H5F_t *f, hid_t dxpl_id, haddr_t addr, const void *_lt_key,
void *_udata, const void *_rt_key);
-static H5B_ins_t H5F_istore_insert(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *_lt_key,
+static H5B_ins_t H5D_istore_insert(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *_lt_key,
hbool_t *lt_key_changed, void *_md_key,
void *_udata, void *_rt_key,
hbool_t *rt_key_changed,
haddr_t *new_node/*out*/);
-static H5B_ins_t H5F_istore_remove( H5F_t *f, hid_t dxpl_id, haddr_t addr, void *_lt_key,
+static H5B_ins_t H5D_istore_remove( H5F_t *f, hid_t dxpl_id, haddr_t addr, void *_lt_key,
hbool_t *lt_key_changed, void *_udata, void *_rt_key,
hbool_t *rt_key_changed);
-static herr_t H5F_istore_decode_key(H5F_t *f, H5B_t *bt, uint8_t *raw,
+static herr_t H5D_istore_decode_key(H5F_t *f, H5B_t *bt, uint8_t *raw,
void *_key);
-static herr_t H5F_istore_encode_key(H5F_t *f, H5B_t *bt, uint8_t *raw,
+static herr_t H5D_istore_encode_key(H5F_t *f, H5B_t *bt, uint8_t *raw,
void *_key);
-static herr_t H5F_istore_debug_key(FILE *stream, H5F_t *f, hid_t dxpl_id,
+static herr_t H5D_istore_debug_key(FILE *stream, H5F_t *f, hid_t dxpl_id,
int indent, int fwidth, const void *key,
const void *udata);
/* inherits B-tree like properties from H5B */
H5B_class_t H5B_ISTORE[1] = {{
H5B_ISTORE_ID, /*id */
- sizeof(H5F_istore_key_t), /*sizeof_nkey */
- H5F_istore_sizeof_rkey, /*get_sizeof_rkey */
- H5F_istore_new_node, /*new */
- H5F_istore_cmp2, /*cmp2 */
- H5F_istore_cmp3, /*cmp3 */
- H5F_istore_found, /*found */
- H5F_istore_insert, /*insert */
+ sizeof(H5D_istore_key_t), /*sizeof_nkey */
+ H5D_istore_sizeof_rkey, /*get_sizeof_rkey */
+ H5D_istore_new_node, /*new */
+ H5D_istore_cmp2, /*cmp2 */
+ H5D_istore_cmp3, /*cmp3 */
+ H5D_istore_found, /*found */
+ H5D_istore_insert, /*insert */
FALSE, /*follow min branch? */
FALSE, /*follow max branch? */
- H5F_istore_remove, /*remove */
- H5F_istore_decode_key, /*decode */
- H5F_istore_encode_key, /*encode */
- H5F_istore_debug_key, /*debug */
+ H5D_istore_remove, /*remove */
+ H5D_istore_decode_key, /*decode */
+ H5D_istore_encode_key, /*encode */
+ H5D_istore_debug_key, /*debug */
}};
/* Declare a free list to manage H5F_rdcc_ent_t objects */
-H5FL_DEFINE_STATIC(H5F_rdcc_ent_t);
+H5FL_DEFINE_STATIC(H5D_rdcc_ent_t);
/* Declare a free list to manage the H5F_rdcc_ent_ptr_t sequence information */
-H5FL_SEQ_DEFINE_STATIC(H5F_rdcc_ent_ptr_t);
+H5FL_SEQ_DEFINE_STATIC(H5D_rdcc_ent_ptr_t);
/* Declare a free list to manage the chunk sequence information */
H5FL_BLK_DEFINE_STATIC(chunk);
/*-------------------------------------------------------------------------
- * Function: H5F_istore_sizeof_rkey
+ * Function: H5D_istore_sizeof_rkey
*
* Purpose: Returns the size of a raw key for the specified UDATA. The
* size of the key is dependent on the number of dimensions for
@@ -243,13 +238,13 @@ H5FL_BLK_DEFINE_STATIC(chunk);
*-------------------------------------------------------------------------
*/
static size_t
-H5F_istore_sizeof_rkey(H5F_t UNUSED *f, const void *_udata)
+H5D_istore_sizeof_rkey(H5F_t UNUSED *f, const void *_udata)
{
- const H5F_istore_ud1_t *udata = (const H5F_istore_ud1_t *) _udata;
+ const H5D_istore_ud1_t *udata = (const H5D_istore_ud1_t *) _udata;
size_t nbytes;
/* Use FUNC_ENTER_NOAPI_NOINIT_NOFUNC here to avoid performance issues */
- FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5F_istore_sizeof_rkey);
+ FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5D_istore_sizeof_rkey);
assert(udata);
assert(udata->mesg.u.chunk.ndims > 0 && udata->mesg.u.chunk.ndims <= H5O_LAYOUT_NDIMS);
@@ -259,11 +254,11 @@ H5F_istore_sizeof_rkey(H5F_t UNUSED *f, const void *_udata)
udata->mesg.u.chunk.ndims*8; /*dimension indices */
FUNC_LEAVE_NOAPI(nbytes);
-}
+} /* end H5D_istore_sizeof_rkey() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_decode_key
+ * Function: H5D_istore_decode_key
*
* Purpose: Decodes a raw key into a native key for the B-tree
*
@@ -277,14 +272,14 @@ H5F_istore_sizeof_rkey(H5F_t UNUSED *f, const void *_udata)
*-------------------------------------------------------------------------
*/
static herr_t
-H5F_istore_decode_key(H5F_t UNUSED *f, H5B_t *bt, uint8_t *raw, void *_key)
+H5D_istore_decode_key(H5F_t UNUSED *f, H5B_t *bt, uint8_t *raw, void *_key)
{
- H5F_istore_key_t *key = (H5F_istore_key_t *) _key;
+ H5D_istore_key_t *key = (H5D_istore_key_t *) _key;
int i;
- int ndims = H5F_ISTORE_NDIMS(bt);
+ int ndims = H5D_ISTORE_NDIMS(bt);
herr_t ret_value=SUCCEED; /* Return value */
- FUNC_ENTER_NOAPI(H5F_istore_decode_key, FAIL);
+ FUNC_ENTER_NOAPI(H5D_istore_decode_key, FAIL);
/* check args */
assert(f);
@@ -301,11 +296,11 @@ H5F_istore_decode_key(H5F_t UNUSED *f, H5B_t *bt, uint8_t *raw, void *_key)
done:
FUNC_LEAVE_NOAPI(ret_value);
-}
+} /* end H5D_istore_decode_key() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_encode_key
+ * Function: H5D_istore_encode_key
*
* Purpose: Encode a key from native format to raw format.
*
@@ -319,14 +314,14 @@ done:
*-------------------------------------------------------------------------
*/
static herr_t
-H5F_istore_encode_key(H5F_t UNUSED *f, H5B_t *bt, uint8_t *raw, void *_key)
+H5D_istore_encode_key(H5F_t UNUSED *f, H5B_t *bt, uint8_t *raw, void *_key)
{
- H5F_istore_key_t *key = (H5F_istore_key_t *) _key;
- int ndims = H5F_ISTORE_NDIMS(bt);
+ H5D_istore_key_t *key = (H5D_istore_key_t *) _key;
+ int ndims = H5D_ISTORE_NDIMS(bt);
int i;
herr_t ret_value=SUCCEED; /* Return value */
- FUNC_ENTER_NOAPI(H5F_istore_encode_key, FAIL);
+ FUNC_ENTER_NOAPI(H5D_istore_encode_key, FAIL);
/* check args */
assert(f);
@@ -343,11 +338,11 @@ H5F_istore_encode_key(H5F_t UNUSED *f, H5B_t *bt, uint8_t *raw, void *_key)
done:
FUNC_LEAVE_NOAPI(ret_value);
-}
+} /* end H5D_istore_encode_key() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_debug_key
+ * Function: H5D_istore_debug_key
*
* Purpose: Prints a key.
*
@@ -361,15 +356,15 @@ done:
*-------------------------------------------------------------------------
*/
static herr_t
-H5F_istore_debug_key (FILE *stream, H5F_t UNUSED *f, hid_t UNUSED dxpl_id, int indent, int fwidth,
+H5D_istore_debug_key (FILE *stream, H5F_t UNUSED *f, hid_t UNUSED dxpl_id, int indent, int fwidth,
const void *_key, const void *_udata)
{
- const H5F_istore_key_t *key = (const H5F_istore_key_t *)_key;
- const H5F_istore_ud1_t *udata = (const H5F_istore_ud1_t *)_udata;
+ const H5D_istore_key_t *key = (const H5D_istore_key_t *)_key;
+ const H5D_istore_ud1_t *udata = (const H5D_istore_ud1_t *)_udata;
unsigned u;
herr_t ret_value=SUCCEED; /* Return value */
- FUNC_ENTER_NOAPI(H5F_istore_debug_key, FAIL);
+ FUNC_ENTER_NOAPI(H5D_istore_debug_key, FAIL);
assert (key);
@@ -385,11 +380,11 @@ H5F_istore_debug_key (FILE *stream, H5F_t UNUSED *f, hid_t UNUSED dxpl_id, int i
done:
FUNC_LEAVE_NOAPI(ret_value);
-}
+} /* end H5D_istore_debug_key() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_cmp2
+ * Function: H5D_istore_cmp2
*
* Purpose: Compares two keys sort of like strcmp(). The UDATA pointer
* is only to supply extra information not carried in the keys
@@ -410,15 +405,15 @@ done:
*-------------------------------------------------------------------------
*/
static int
-H5F_istore_cmp2(H5F_t UNUSED *f, hid_t UNUSED dxpl_id, void *_lt_key, void *_udata,
+H5D_istore_cmp2(H5F_t UNUSED *f, hid_t UNUSED dxpl_id, void *_lt_key, void *_udata,
void *_rt_key)
{
- H5F_istore_key_t *lt_key = (H5F_istore_key_t *) _lt_key;
- H5F_istore_key_t *rt_key = (H5F_istore_key_t *) _rt_key;
- H5F_istore_ud1_t *udata = (H5F_istore_ud1_t *) _udata;
+ H5D_istore_key_t *lt_key = (H5D_istore_key_t *) _lt_key;
+ H5D_istore_key_t *rt_key = (H5D_istore_key_t *) _rt_key;
+ H5D_istore_ud1_t *udata = (H5D_istore_ud1_t *) _udata;
int ret_value;
- FUNC_ENTER_NOAPI(H5F_istore_cmp2, FAIL);
+ FUNC_ENTER_NOAPI(H5D_istore_cmp2, FAIL);
assert(lt_key);
assert(rt_key);
@@ -430,11 +425,11 @@ H5F_istore_cmp2(H5F_t UNUSED *f, hid_t UNUSED dxpl_id, void *_lt_key, void *_uda
done:
FUNC_LEAVE_NOAPI(ret_value);
-}
+} /* end H5D_istore_cmp2() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_cmp3
+ * Function: H5D_istore_cmp3
*
* Purpose: Compare the requested datum UDATA with the left and right
* keys of the B-tree.
@@ -463,15 +458,15 @@ done:
*-------------------------------------------------------------------------
*/
static int
-H5F_istore_cmp3(H5F_t UNUSED *f, hid_t UNUSED dxpl_id, void *_lt_key, void *_udata,
+H5D_istore_cmp3(H5F_t UNUSED *f, hid_t UNUSED dxpl_id, void *_lt_key, void *_udata,
void *_rt_key)
{
- H5F_istore_key_t *lt_key = (H5F_istore_key_t *) _lt_key;
- H5F_istore_key_t *rt_key = (H5F_istore_key_t *) _rt_key;
- H5F_istore_ud1_t *udata = (H5F_istore_ud1_t *) _udata;
+ H5D_istore_key_t *lt_key = (H5D_istore_key_t *) _lt_key;
+ H5D_istore_key_t *rt_key = (H5D_istore_key_t *) _rt_key;
+ H5D_istore_ud1_t *udata = (H5D_istore_ud1_t *) _udata;
int ret_value = 0;
- FUNC_ENTER_NOAPI(H5F_istore_cmp3, FAIL);
+ FUNC_ENTER_NOAPI(H5D_istore_cmp3, FAIL);
assert(lt_key);
assert(rt_key);
@@ -488,11 +483,11 @@ H5F_istore_cmp3(H5F_t UNUSED *f, hid_t UNUSED dxpl_id, void *_lt_key, void *_uda
done:
FUNC_LEAVE_NOAPI(ret_value);
-}
+} /* end H5D_istore_cmp3() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_new_node
+ * Function: H5D_istore_new_node
*
* Purpose: Adds a new entry to an i-storage B-tree. We can assume that
* the domain represented by UDATA doesn't intersect the domain
@@ -512,17 +507,17 @@ done:
*-------------------------------------------------------------------------
*/
static herr_t
-H5F_istore_new_node(H5F_t *f, hid_t dxpl_id, H5B_ins_t op,
+H5D_istore_new_node(H5F_t *f, hid_t dxpl_id, H5B_ins_t op,
void *_lt_key, void *_udata, void *_rt_key,
haddr_t *addr_p/*out*/)
{
- H5F_istore_key_t *lt_key = (H5F_istore_key_t *) _lt_key;
- H5F_istore_key_t *rt_key = (H5F_istore_key_t *) _rt_key;
- H5F_istore_ud1_t *udata = (H5F_istore_ud1_t *) _udata;
+ H5D_istore_key_t *lt_key = (H5D_istore_key_t *) _lt_key;
+ H5D_istore_key_t *rt_key = (H5D_istore_key_t *) _rt_key;
+ H5D_istore_ud1_t *udata = (H5D_istore_ud1_t *) _udata;
unsigned u;
herr_t ret_value=SUCCEED; /* Return value */
- FUNC_ENTER_NOAPI(H5F_istore_new_node, FAIL);
+ FUNC_ENTER_NOAPI(H5D_istore_new_node, FAIL);
/* check args */
assert(f);
@@ -565,11 +560,11 @@ H5F_istore_new_node(H5F_t *f, hid_t dxpl_id, H5B_ins_t op,
done:
FUNC_LEAVE_NOAPI(ret_value);
-}
+} /* end H5D_istore_new_node() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_found
+ * Function: H5D_istore_found
*
* Purpose: This function is called when the B-tree search engine has
* found the leaf entry that points to a chunk of storage that
@@ -596,15 +591,15 @@ done:
*-------------------------------------------------------------------------
*/
static herr_t
-H5F_istore_found(H5F_t UNUSED *f, hid_t UNUSED dxpl_id, haddr_t addr, const void *_lt_key,
+H5D_istore_found(H5F_t UNUSED *f, hid_t UNUSED dxpl_id, haddr_t addr, const void *_lt_key,
void *_udata, const void UNUSED *_rt_key)
{
- H5F_istore_ud1_t *udata = (H5F_istore_ud1_t *) _udata;
- const H5F_istore_key_t *lt_key = (const H5F_istore_key_t *) _lt_key;
+ H5D_istore_ud1_t *udata = (H5D_istore_ud1_t *) _udata;
+ const H5D_istore_key_t *lt_key = (const H5D_istore_key_t *) _lt_key;
unsigned u;
herr_t ret_value=SUCCEED; /* Return value */
- FUNC_ENTER_NOAPI(H5F_istore_found, FAIL);
+ FUNC_ENTER_NOAPI(H5D_istore_found, FAIL);
/* Check arguments */
assert(f);
@@ -628,11 +623,11 @@ H5F_istore_found(H5F_t UNUSED *f, hid_t UNUSED dxpl_id, haddr_t addr, const void
done:
FUNC_LEAVE_NOAPI(ret_value);
-}
+} /* end H5D_istore_found() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_insert
+ * Function: H5D_istore_insert
*
* Purpose: This function is called when the B-tree insert engine finds
* the node to use to insert new data. The UDATA argument
@@ -664,21 +659,21 @@ done:
*-------------------------------------------------------------------------
*/
static H5B_ins_t
-H5F_istore_insert(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *_lt_key,
+H5D_istore_insert(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *_lt_key,
hbool_t UNUSED *lt_key_changed,
void *_md_key, void *_udata, void *_rt_key,
hbool_t UNUSED *rt_key_changed,
haddr_t *new_node_p/*out*/)
{
- H5F_istore_key_t *lt_key = (H5F_istore_key_t *) _lt_key;
- H5F_istore_key_t *md_key = (H5F_istore_key_t *) _md_key;
- H5F_istore_key_t *rt_key = (H5F_istore_key_t *) _rt_key;
- H5F_istore_ud1_t *udata = (H5F_istore_ud1_t *) _udata;
+ H5D_istore_key_t *lt_key = (H5D_istore_key_t *) _lt_key;
+ H5D_istore_key_t *md_key = (H5D_istore_key_t *) _md_key;
+ H5D_istore_key_t *rt_key = (H5D_istore_key_t *) _rt_key;
+ H5D_istore_ud1_t *udata = (H5D_istore_ud1_t *) _udata;
int cmp;
unsigned u;
H5B_ins_t ret_value;
- FUNC_ENTER_NOAPI(H5F_istore_insert, H5B_INS_ERROR);
+ FUNC_ENTER_NOAPI(H5D_istore_insert, H5B_INS_ERROR);
/* check args */
assert(f);
@@ -691,7 +686,7 @@ H5F_istore_insert(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *_lt_key,
assert(rt_key_changed);
assert(new_node_p);
- cmp = H5F_istore_cmp3(f, dxpl_id, lt_key, udata, rt_key);
+ cmp = H5D_istore_cmp3(f, dxpl_id, lt_key, udata, rt_key);
assert(cmp <= 0);
if (cmp < 0) {
@@ -771,11 +766,11 @@ H5F_istore_insert(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *_lt_key,
done:
FUNC_LEAVE_NOAPI(ret_value);
-}
+} /* end H5D_istore_insert() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_iter_allocated
+ * Function: H5D_istore_iter_allocated
*
* Purpose: Simply counts the number of chunks for a dataset.
*
@@ -795,22 +790,22 @@ done:
*-------------------------------------------------------------------------
*/
static int
-H5F_istore_iter_allocated (H5F_t UNUSED *f, hid_t UNUSED dxpl_id, void *_lt_key, haddr_t UNUSED addr,
+H5D_istore_iter_allocated (H5F_t UNUSED *f, hid_t UNUSED dxpl_id, void *_lt_key, haddr_t UNUSED addr,
void UNUSED *_rt_key, void *_udata)
{
- H5F_istore_ud1_t *bt_udata = (H5F_istore_ud1_t *)_udata;
- H5F_istore_key_t *lt_key = (H5F_istore_key_t *)_lt_key;
+ H5D_istore_ud1_t *bt_udata = (H5D_istore_ud1_t *)_udata;
+ H5D_istore_key_t *lt_key = (H5D_istore_key_t *)_lt_key;
- FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5F_istore_iter_allocated);
+ FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5D_istore_iter_allocated);
bt_udata->total_storage += lt_key->nbytes;
FUNC_LEAVE_NOAPI(H5B_ITER_CONT);
-} /* H5F_istore_iter_allocated() */
+} /* H5D_istore_iter_allocated() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_iter_dump
+ * Function: H5D_istore_iter_dump
*
* Purpose: If the UDATA.STREAM member is non-null then debugging
* information is written to that stream.
@@ -831,14 +826,14 @@ H5F_istore_iter_allocated (H5F_t UNUSED *f, hid_t UNUSED dxpl_id, void *_lt_key,
*-------------------------------------------------------------------------
*/
static int
-H5F_istore_iter_dump (H5F_t UNUSED *f, hid_t UNUSED dxpl_id, void *_lt_key, haddr_t UNUSED addr,
+H5D_istore_iter_dump (H5F_t UNUSED *f, hid_t UNUSED dxpl_id, void *_lt_key, haddr_t UNUSED addr,
void UNUSED *_rt_key, void *_udata)
{
- H5F_istore_ud1_t *bt_udata = (H5F_istore_ud1_t *)_udata;
- H5F_istore_key_t *lt_key = (H5F_istore_key_t *)_lt_key;
+ H5D_istore_ud1_t *bt_udata = (H5D_istore_ud1_t *)_udata;
+ H5D_istore_key_t *lt_key = (H5D_istore_key_t *)_lt_key;
unsigned u;
- FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5F_istore_iter_dump);
+ FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5D_istore_iter_dump);
if (bt_udata->stream) {
if (0==bt_udata->total_storage) {
@@ -859,14 +854,14 @@ H5F_istore_iter_dump (H5F_t UNUSED *f, hid_t UNUSED dxpl_id, void *_lt_key, hadd
}
FUNC_LEAVE_NOAPI(H5B_ITER_CONT);
-} /* H5F_istore_iter_dump() */
+} /* H5D_istore_iter_dump() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_init
+ * Function: H5D_istore_init
*
- * Purpose: Initialize the raw data chunk cache for a file. This is
- * called when the file handle is initialized.
+ * Purpose: Initialize the raw data chunk cache for a dataset. This is
+ * called when the dataset is initialized.
*
* Return: Non-negative on success/Negative on failure
*
@@ -878,28 +873,29 @@ H5F_istore_iter_dump (H5F_t UNUSED *f, hid_t UNUSED dxpl_id, void *_lt_key, hadd
*-------------------------------------------------------------------------
*/
herr_t
-H5F_istore_init (H5F_t *f)
+H5D_istore_init (H5F_t *f, H5D_t *dset)
{
- H5F_rdcc_t *rdcc = &(f->shared->rdcc);
+ H5D_rdcc_t *rdcc = &(dset->cache.chunk);
herr_t ret_value=SUCCEED; /* Return value */
- FUNC_ENTER_NOAPI(H5F_istore_init, FAIL);
+ FUNC_ENTER_NOAPI(H5D_istore_init, FAIL);
- HDmemset (rdcc, 0, sizeof(H5F_rdcc_t));
- if (f->shared->rdcc_nbytes>0 && f->shared->rdcc_nelmts>0) {
- rdcc->nslots = f->shared->rdcc_nelmts;
- rdcc->slot = H5FL_SEQ_CALLOC (H5F_rdcc_ent_ptr_t,rdcc->nslots);
+ HDmemset (rdcc, 0, sizeof(H5D_rdcc_t));
+ if (H5F_RDCC_NBYTES(f)>0 && H5F_RDCC_NELMTS(f)>0) {
+ rdcc->nbytes=H5F_RDCC_NBYTES(f);
+ rdcc->nslots = H5F_RDCC_NELMTS(f);
+ rdcc->slot = H5FL_SEQ_CALLOC (H5D_rdcc_ent_ptr_t,rdcc->nslots);
if (NULL==rdcc->slot)
HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed");
- }
+ } /* end if */
done:
FUNC_LEAVE_NOAPI(ret_value);
-}
+} /* end H5D_istore_init() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_flush_entry
+ * Function: H5D_istore_flush_entry
*
* Purpose: Writes a chunk to disk. If RESET is non-zero then the
* entry is cleared -- it's slightly faster to flush a chunk if
@@ -916,8 +912,8 @@ done:
*-------------------------------------------------------------------------
*/
static herr_t
-H5F_istore_flush_entry(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache,
- hid_t dxpl_id, H5F_rdcc_ent_t *ent, hbool_t reset)
+H5D_istore_flush_entry(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache,
+ hid_t dxpl_id, H5D_t *dset, H5D_rdcc_ent_t *ent, hbool_t reset)
{
herr_t ret_value=SUCCEED; /*return value */
unsigned u; /*counters */
@@ -925,7 +921,7 @@ H5F_istore_flush_entry(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache,
size_t alloc; /*bytes allocated for BUF */
hbool_t point_of_no_return = FALSE;
- FUNC_ENTER_NOAPI_NOINIT(H5F_istore_flush_entry);
+ FUNC_ENTER_NOAPI_NOINIT(H5D_istore_flush_entry);
assert(f);
assert(ent);
@@ -933,18 +929,18 @@ H5F_istore_flush_entry(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache,
buf = ent->chunk;
if (ent->dirty) {
- H5F_istore_ud1_t udata; /*pass through B-tree */
+ H5D_istore_ud1_t udata; /*pass through B-tree */
- udata.mesg = ent->layout;
+ udata.mesg = dset->layout;
udata.key.filter_mask = 0;
udata.addr = HADDR_UNDEF;
udata.key.nbytes = ent->chunk_size;
- for (u=0; u<ent->layout.u.chunk.ndims; u++)
+ for (u=0; u<dset->layout.u.chunk.ndims; u++)
udata.key.offset[u] = ent->offset[u];
alloc = ent->alloc_size;
/* Should the chunk be filtered before writing it to disk? */
- if (ent->pline.nused) {
+ if (dset->dcpl_cache.pline.nused) {
if (!reset) {
/*
* Copy the chunk to a new buffer before running it through
@@ -966,36 +962,33 @@ H5F_istore_flush_entry(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache,
point_of_no_return = TRUE;
ent->chunk = NULL;
}
- if (H5Z_pipeline(&ent->pline, 0, &(udata.key.filter_mask), dxpl_cache->err_detect,
- dxpl_cache->filter_cb, &(udata.key.nbytes), &alloc, &buf)<0) {
- HGOTO_ERROR(H5E_PLINE, H5E_WRITEERROR, FAIL,
- "output pipeline failed");
- }
+ if (H5Z_pipeline(&(dset->dcpl_cache.pline), 0, &(udata.key.filter_mask), dxpl_cache->err_detect,
+ dxpl_cache->filter_cb, &(udata.key.nbytes), &alloc, &buf)<0)
+ HGOTO_ERROR(H5E_PLINE, H5E_WRITEERROR, FAIL, "output pipeline failed")
}
/*
* Create the chunk it if it doesn't exist, or reallocate the chunk if
* its size changed. Then write the data into the file.
*/
- if (H5B_insert(f, dxpl_id, H5B_ISTORE, ent->layout.u.chunk.addr, &udata)<0)
+ if (H5B_insert(f, dxpl_id, H5B_ISTORE, dset->layout.u.chunk.addr, &udata)<0)
HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "unable to allocate chunk");
if (H5F_block_write(f, H5FD_MEM_DRAW, udata.addr, udata.key.nbytes, dxpl_id, buf)<0)
HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "unable to write raw data to file");
/* Mark cache entry as clean */
ent->dirty = FALSE;
- f->shared->rdcc.nflushes++;
- }
+ dset->cache.chunk.nflushes++;
+ } /* end if */
/* Reset, but do not free or removed from list */
if (reset) {
point_of_no_return = FALSE;
- H5O_reset(H5O_LAYOUT_ID, &ent->layout);
- if (buf==ent->chunk) buf = NULL;
+ if(buf==ent->chunk)
+ buf = NULL;
if(ent->chunk!=NULL)
- ent->chunk = H5F_istore_chunk_xfree(ent->chunk,&ent->pline);
- H5O_reset(H5O_PLINE_ID, &ent->pline);
- }
+ ent->chunk = H5D_istore_chunk_xfree(ent->chunk,&(dset->dcpl_cache.pline));
+ } /* end if */
done:
/* Free the temp buffer only if it's different than the entry chunk */
@@ -1009,17 +1002,16 @@ done:
* list.
*/
if (ret_value<0 && point_of_no_return) {
- H5O_reset(H5O_LAYOUT_ID, &ent->layout);
if(ent->chunk)
- ent->chunk = H5F_istore_chunk_xfree(ent->chunk,&ent->pline);
- H5O_reset(H5O_PLINE_ID, &ent->pline);
- }
+ ent->chunk = H5D_istore_chunk_xfree(ent->chunk,&(dset->dcpl_cache.pline));
+ } /* end if */
+
FUNC_LEAVE_NOAPI(ret_value);
-}
+} /* end H5D_istore_flush_entry() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_preempt
+ * Function: H5D_istore_preempt
*
* Purpose: Preempts the specified entry from the cache, flushing it to
* disk if necessary.
@@ -1037,12 +1029,13 @@ done:
*-------------------------------------------------------------------------
*/
static herr_t
-H5F_istore_preempt(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id, H5F_rdcc_ent_t * ent, hbool_t flush)
+H5D_istore_preempt(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id,
+ H5D_t *dset, H5D_rdcc_ent_t * ent, hbool_t flush)
{
- H5F_rdcc_t *rdcc = &(f->shared->rdcc);
+ H5D_rdcc_t *rdcc = &(dset->cache.chunk);
herr_t ret_value=SUCCEED; /* Return value */
- FUNC_ENTER_NOAPI_NOINIT(H5F_istore_preempt);
+ FUNC_ENTER_NOAPI_NOINIT(H5D_istore_preempt);
assert(f);
assert(ent);
@@ -1051,15 +1044,13 @@ H5F_istore_preempt(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id,
if(flush) {
/* Flush */
- if(H5F_istore_flush_entry(f, dxpl_cache, dxpl_id, ent, TRUE) < 0)
+ if(H5D_istore_flush_entry(f, dxpl_cache, dxpl_id, dset, ent, TRUE) < 0)
HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "cannot flush indexed storage buffer");
}
else {
/* Don't flush, just free chunk */
- H5O_reset(H5O_LAYOUT_ID, &ent->layout);
if(ent->chunk != NULL)
- ent->chunk = H5F_istore_chunk_xfree(ent->chunk,&ent->pline);
- H5O_reset(H5O_PLINE_ID, &ent->pline);
+ ent->chunk = H5D_istore_chunk_xfree(ent->chunk,&(dset->dcpl_cache.pline));
}
/* Unlink from list */
@@ -1080,15 +1071,15 @@ H5F_istore_preempt(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id,
--rdcc->nused;
/* Free */
- H5FL_FREE(H5F_rdcc_ent_t, ent);
+ H5FL_FREE(H5D_rdcc_ent_t, ent);
done:
FUNC_LEAVE_NOAPI(ret_value);
-}
+} /* end H5D_istore_preempt() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_flush
+ * Function: H5D_istore_flush
*
* Purpose: Writes all dirty chunks to disk and optionally preempts them
* from the cache.
@@ -1105,15 +1096,15 @@ done:
*-------------------------------------------------------------------------
*/
herr_t
-H5F_istore_flush (H5F_t *f, hid_t dxpl_id, unsigned flags)
+H5D_istore_flush (H5F_t *f, hid_t dxpl_id, H5D_t *dset, unsigned flags)
{
H5D_dxpl_cache_t dxpl_cache; /* Cached data transfer properties */
- H5F_rdcc_t *rdcc = &(f->shared->rdcc);
+ H5D_rdcc_t *rdcc = &(dset->cache.chunk);
int nerrors=0;
- H5F_rdcc_ent_t *ent=NULL, *next=NULL;
+ H5D_rdcc_ent_t *ent=NULL, *next=NULL;
herr_t ret_value=SUCCEED; /* Return value */
- FUNC_ENTER_NOAPI(H5F_istore_flush, FAIL);
+ FUNC_ENTER_NOAPI(H5D_istore_flush, FAIL);
/* Fill the DXPL cache values for later use */
if (H5D_get_dxpl_cache(dxpl_id,&dxpl_cache)<0)
@@ -1126,24 +1117,24 @@ H5F_istore_flush (H5F_t *f, hid_t dxpl_id, unsigned flags)
ent->dirty = FALSE;
} /* end if */
else if ((flags&H5F_FLUSH_INVALIDATE)) {
- if (H5F_istore_preempt(f, &dxpl_cache, dxpl_id, ent, TRUE )<0)
+ if (H5D_istore_preempt(f, &dxpl_cache, dxpl_id, dset, ent, TRUE )<0)
nerrors++;
} else {
- if (H5F_istore_flush_entry(f, &dxpl_cache, dxpl_id, ent, FALSE)<0)
+ if (H5D_istore_flush_entry(f, &dxpl_cache, dxpl_id, dset, ent, FALSE)<0)
nerrors++;
}
- }
+ } /* end for */
if (nerrors)
HGOTO_ERROR (H5E_IO, H5E_CANTFLUSH, FAIL, "unable to flush one or more raw data chunks");
done:
FUNC_LEAVE_NOAPI(ret_value);
-}
+} /* end H5D_istore_flush() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_dest
+ * Function: H5D_istore_dest
*
* Purpose: Destroy the entire chunk cache by flushing dirty entries,
* preempting all entries, and freeing the cache itself.
@@ -1160,42 +1151,42 @@ done:
*-------------------------------------------------------------------------
*/
herr_t
-H5F_istore_dest (H5F_t *f, hid_t dxpl_id)
+H5D_istore_dest (H5F_t *f, hid_t dxpl_id, H5D_t *dset)
{
H5D_dxpl_cache_t dxpl_cache; /* Cached data transfer properties */
- H5F_rdcc_t *rdcc = &(f->shared->rdcc);
+ H5D_rdcc_t *rdcc = &(dset->cache.chunk);
int nerrors=0;
- H5F_rdcc_ent_t *ent=NULL, *next=NULL;
+ H5D_rdcc_ent_t *ent=NULL, *next=NULL;
herr_t ret_value=SUCCEED; /* Return value */
- FUNC_ENTER_NOAPI(H5F_istore_dest, FAIL);
+ FUNC_ENTER_NOAPI(H5D_istore_dest, FAIL);
/* Fill the DXPL cache values for later use */
if (H5D_get_dxpl_cache(dxpl_id,&dxpl_cache)<0)
HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't fill dxpl cache")
for (ent=rdcc->head; ent; ent=next) {
-#ifdef H5F_ISTORE_DEBUG
+#ifdef H5D_ISTORE_DEBUG
HDfputc('c', stderr);
HDfflush(stderr);
#endif
next = ent->next;
- if (H5F_istore_preempt(f, &dxpl_cache, dxpl_id, ent, TRUE )<0)
+ if (H5D_istore_preempt(f, &dxpl_cache, dxpl_id, dset, ent, TRUE )<0)
nerrors++;
}
if (nerrors)
HGOTO_ERROR (H5E_IO, H5E_CANTFLUSH, FAIL, "unable to flush one or more raw data chunks");
- H5FL_SEQ_FREE (H5F_rdcc_ent_ptr_t,rdcc->slot);
- HDmemset (rdcc, 0, sizeof(H5F_rdcc_t));
+ H5FL_SEQ_FREE (H5D_rdcc_ent_ptr_t,rdcc->slot);
+ HDmemset (rdcc, 0, sizeof(H5D_rdcc_t));
done:
FUNC_LEAVE_NOAPI(ret_value);
-}
+} /* end H5D_istore_dest() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_prune
+ * Function: H5D_istore_prune
*
* Purpose: Prune the cache by preempting some things until the cache has
* room for something which is SIZE bytes. Only unlocked
@@ -1213,18 +1204,19 @@ done:
*-------------------------------------------------------------------------
*/
static herr_t
-H5F_istore_prune (H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id, size_t size)
+H5D_istore_prune (H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id, H5D_t *dset,
+ size_t size)
{
int i, j, nerrors=0;
- H5F_rdcc_t *rdcc = &(f->shared->rdcc);
- size_t total = f->shared->rdcc_nbytes;
+ H5D_rdcc_t *rdcc = &(dset->cache.chunk);
+ size_t total = rdcc->nbytes;
const int nmeth=2; /*number of methods */
int w[1]; /*weighting as an interval */
- H5F_rdcc_ent_t *p[2], *cur; /*list pointers */
- H5F_rdcc_ent_t *n[2]; /*list next pointers */
+ H5D_rdcc_ent_t *p[2], *cur; /*list pointers */
+ H5D_rdcc_ent_t *n[2]; /*list next pointers */
herr_t ret_value=SUCCEED; /* Return value */
- FUNC_ENTER_NOAPI_NOINIT(H5F_istore_prune);
+ FUNC_ENTER_NOAPI_NOINIT(H5D_istore_prune);
/*
* Preemption is accomplished by having multiple pointers (currently two)
@@ -1236,7 +1228,7 @@ H5F_istore_prune (H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id, s
* begins. The pointers participating in the list traversal are each
* given a chance at preemption before any of the pointers are advanced.
*/
- w[0] = (int)(rdcc->nused * f->shared->rdcc_w0);
+ w[0] = (int)(rdcc->nused * H5F_RDCC_W0(f));
p[0] = rdcc->head;
p[1] = NULL;
@@ -1263,7 +1255,7 @@ H5F_istore_prune (H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id, s
* written or partially read.
*/
cur = p[0];
-#ifdef H5F_ISTORE_DEBUG
+#ifdef H5D_ISTORE_DEBUG
HDputc('.', stderr);
HDfflush(stderr);
#endif
@@ -1275,7 +1267,7 @@ H5F_istore_prune (H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id, s
* resort preemption.
*/
cur = p[1];
-#ifdef H5F_ISTORE_DEBUG
+#ifdef H5D_ISTORE_DEBUG
HDputc(':', stderr);
HDfflush(stderr);
#endif
@@ -1292,7 +1284,7 @@ H5F_istore_prune (H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id, s
if (n[j]==cur)
n[j] = cur->next;
}
- if (H5F_istore_preempt(f, dxpl_cache, dxpl_id, cur, TRUE)<0)
+ if (H5D_istore_preempt(f, dxpl_cache, dxpl_id, dset, cur, TRUE)<0)
nerrors++;
}
}
@@ -1309,11 +1301,11 @@ H5F_istore_prune (H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id, s
done:
FUNC_LEAVE_NOAPI(ret_value);
-}
+} /* end H5D_istore_prune() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_lock
+ * Function: H5D_istore_lock
*
* Purpose: Return a pointer to a dataset chunk. The pointer points
* directly into the chunk cache and should not be freed
@@ -1347,24 +1339,29 @@ done:
*-------------------------------------------------------------------------
*/
static void *
-H5F_istore_lock(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id, const H5O_layout_t *layout,
- const H5O_pline_t *pline, const H5O_fill_t *fill, H5D_fill_time_t fill_time,
- H5F_istore_ud1_t *udata,
- const H5D_storage_t *store, hbool_t relax,
- unsigned *idx_hint/*in,out*/)
+H5D_istore_lock(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id,
+ H5D_t *dset, const H5D_storage_t *store,
+ H5D_istore_ud1_t *udata, hbool_t relax, unsigned *idx_hint/*in,out*/)
{
- int idx=0; /*hash index number */
- hsize_t temp_idx=0; /* temporary index number */
+ unsigned idx=0; /*hash index number */
hbool_t found = FALSE; /*already in cache? */
- H5F_rdcc_t *rdcc = &(f->shared->rdcc);/*raw data chunk cache*/
- H5F_rdcc_ent_t *ent = NULL; /*cache entry */
+ const H5O_pline_t *pline=&(dset->dcpl_cache.pline); /* I/O pipeline info */
+ const H5O_layout_t *layout=&(dset->layout); /* Dataset layout */
+ const H5O_fill_t *fill=&(dset->dcpl_cache.fill); /* Fill value info */
+ H5D_fill_time_t fill_time=dset->dcpl_cache.fill_time; /* Fill time */
+ H5D_rdcc_t *rdcc = &(dset->cache.chunk);/*raw data chunk cache*/
+ H5D_rdcc_ent_t *ent = NULL; /*cache entry */
unsigned u; /*counters */
size_t chunk_size=0; /*size of a chunk */
void *chunk=NULL; /*the file chunk */
void *ret_value; /*return value */
- FUNC_ENTER_NOAPI_NOINIT(H5F_istore_lock);
+ FUNC_ENTER_NOAPI_NOINIT(H5D_istore_lock);
+ assert(f);
+ assert(dset);
+ assert(store);
+ assert(dxpl_cache);
assert(TRUE==H5P_isa_class(dxpl_id,H5P_DATASET_XFER));
/* Get the chunk's size */
@@ -1373,20 +1370,18 @@ H5F_istore_lock(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id, con
/* Search for the chunk in the cache */
if (rdcc->nslots>0) {
- temp_idx = store->chunk.index + (hsize_t)(layout->u.chunk.addr);
- idx=H5F_HASH(f,temp_idx);
+ idx=H5D_HASH(dset,store->chunk.index);
ent = rdcc->slot[idx];
- if (ent && layout->u.chunk.ndims==ent->layout.u.chunk.ndims &&
- H5F_addr_eq(layout->u.chunk.addr, ent->layout.u.chunk.addr)) {
- for (u=0, found=TRUE; u<ent->layout.u.chunk.ndims; u++) {
+ if (ent) {
+ for (u=0, found=TRUE; u<dset->layout.u.chunk.ndims; u++) {
if (store->chunk.offset[u]!=ent->offset[u]) {
found = FALSE;
break;
- }
- }
- }
- }
+ } /* end if */
+ } /* end for */
+ } /* end if */
+ } /* end if */
if (found) {
/*
@@ -1401,16 +1396,16 @@ H5F_istore_lock(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id, con
* buffer with the file contents. Count this as a hit instead of a
* miss because we saved ourselves lots of work.
*/
-#ifdef H5F_ISTORE_DEBUG
+#ifdef H5D_ISTORE_DEBUG
HDputc('w', stderr);
HDfflush(stderr);
#endif
rdcc->nhits++;
- if (NULL==(chunk=H5F_istore_chunk_alloc (chunk_size,pline)))
+ if (NULL==(chunk=H5D_istore_chunk_alloc (chunk_size,pline)))
HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed for raw data chunk");
} else {
- H5F_istore_ud1_t tmp_udata; /*B-tree pass-through */
+ H5D_istore_ud1_t tmp_udata; /*B-tree pass-through */
haddr_t chunk_addr; /* Address of chunk on disk */
if(udata!=NULL)
@@ -1423,7 +1418,7 @@ H5F_istore_lock(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id, con
* Not in the cache. Read it from the file and count this as a miss
* if it's in the file or an init if it isn't.
*/
- chunk_addr = H5F_istore_get_addr(f, dxpl_id, layout, store->chunk.offset, udata);
+ chunk_addr = H5D_istore_get_addr(f, dxpl_id, layout, store->chunk.offset, udata);
} /* end else */
if (H5F_addr_defined(chunk_addr)) {
@@ -1435,7 +1430,7 @@ H5F_istore_lock(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id, con
/* Chunk size on disk isn't [likely] the same size as the final chunk
* size in memory, so allocate memory big enough. */
chunk_alloc = udata->key.nbytes;
- if (NULL==(chunk = H5F_istore_chunk_alloc (chunk_alloc,pline)))
+ if (NULL==(chunk = H5D_istore_chunk_alloc (chunk_alloc,pline)))
HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed for raw data chunk");
if (H5F_block_read(f, H5FD_MEM_DRAW, chunk_addr, udata->key.nbytes, dxpl_id, chunk)<0)
HGOTO_ERROR (H5E_IO, H5E_READERROR, NULL, "unable to read raw data chunk");
@@ -1454,7 +1449,7 @@ H5F_istore_lock(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id, con
/* Chunk size on disk isn't [likely] the same size as the final chunk
* size in memory, so allocate memory big enough. */
- if (NULL==(chunk = H5F_istore_chunk_alloc (chunk_size,pline)))
+ if (NULL==(chunk = H5D_istore_chunk_alloc (chunk_size,pline)))
HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed for raw data chunk");
if (H5P_is_fill_value_defined(fill, &fill_status) < 0)
@@ -1482,31 +1477,29 @@ H5F_istore_lock(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id, con
}
assert (found || chunk_size>0);
- if (!found && rdcc->nslots>0 && chunk_size<=f->shared->rdcc_nbytes &&
+ if (!found && rdcc->nslots>0 && chunk_size<=dset->cache.chunk.nbytes &&
(!ent || !ent->locked)) {
/*
* Add the chunk to the cache only if the slot is not already locked.
* Preempt enough things from the cache to make room.
*/
if (ent) {
-#ifdef H5F_ISTORE_DEBUG
+#ifdef H5D_ISTORE_DEBUG
HDputc('#', stderr);
HDfflush(stderr);
#endif
- if (H5F_istore_preempt(f, dxpl_cache, dxpl_id, ent, TRUE)<0)
+ if (H5D_istore_preempt(f, dxpl_cache, dxpl_id, dset, ent, TRUE)<0)
HGOTO_ERROR(H5E_IO, H5E_CANTINIT, NULL, "unable to preempt chunk from cache");
}
- if (H5F_istore_prune(f, dxpl_cache, dxpl_id, chunk_size)<0)
+ if (H5D_istore_prune(f, dxpl_cache, dxpl_id, dset, chunk_size)<0)
HGOTO_ERROR(H5E_IO, H5E_CANTINIT, NULL, "unable to preempt chunk(s) from cache");
/* Create a new entry */
- ent = H5FL_MALLOC(H5F_rdcc_ent_t);
+ ent = H5FL_MALLOC(H5D_rdcc_ent_t);
ent->locked = 0;
ent->dirty = FALSE;
ent->chunk_size = chunk_size;
ent->alloc_size = chunk_size;
- H5O_copy(H5O_LAYOUT_ID, layout, &ent->layout);
- H5O_copy(H5O_PLINE_ID, pline, &ent->pline);
for (u=0; u<layout->u.chunk.ndims; u++)
ent->offset[u] = store->chunk.offset[u];
ent->rd_count = chunk_size;
@@ -1578,13 +1571,13 @@ H5F_istore_lock(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id, con
done:
if (!ret_value)
if(chunk)
- H5F_istore_chunk_xfree (chunk,pline);
+ H5D_istore_chunk_xfree (chunk,pline);
FUNC_LEAVE_NOAPI(ret_value);
-}
+} /* end H5D_istore_lock() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_unlock
+ * Function: H5D_istore_unlock
*
* Purpose: Unlocks a previously locked chunk. The LAYOUT, COMP, and
* OFFSET arguments should be the same as for H5F_rdcc_lock().
@@ -1610,16 +1603,16 @@ done:
*-------------------------------------------------------------------------
*/
static herr_t
-H5F_istore_unlock(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id,
- const H5O_layout_t *layout, const H5O_pline_t *pline, hbool_t dirty,
- const H5D_storage_t *store, unsigned idx_hint, uint8_t *chunk, size_t naccessed)
+H5D_istore_unlock(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id,
+ H5D_t *dset, const H5D_storage_t *store,
+ hbool_t dirty, unsigned idx_hint, uint8_t *chunk, size_t naccessed)
{
- H5F_rdcc_t *rdcc = &(f->shared->rdcc);
- H5F_rdcc_ent_t *ent = NULL;
+ H5D_rdcc_t *rdcc = &(dset->cache.chunk);
+ H5D_rdcc_ent_t *ent = NULL;
int found = -1;
unsigned u;
- FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5F_istore_unlock);
+ FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5D_istore_unlock);
if (UINT_MAX==idx_hint) {
/*not in cache*/
@@ -1638,23 +1631,21 @@ H5F_istore_unlock(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id,
* don't discard the `const' qualifier.
*/
if (dirty) {
- H5F_rdcc_ent_t x;
+ H5D_rdcc_ent_t x;
HDmemset (&x, 0, sizeof x);
x.dirty = TRUE;
- H5O_copy (H5O_LAYOUT_ID, layout, &x.layout);
- H5O_copy (H5O_PLINE_ID, pline, &x.pline);
- for (u=0; u<layout->u.chunk.ndims; u++)
+ for (u=0; u<dset->layout.u.chunk.ndims; u++)
x.offset[u] = store->chunk.offset[u];
- assert(layout->u.chunk.size>0);
- H5_ASSIGN_OVERFLOW(x.chunk_size,layout->u.chunk.size,hsize_t,size_t);
+ assert(dset->layout.u.chunk.size>0);
+ H5_ASSIGN_OVERFLOW(x.chunk_size,dset->layout.u.chunk.size,hsize_t,size_t);
x.alloc_size = x.chunk_size;
x.chunk = chunk;
- H5F_istore_flush_entry (f, dxpl_cache, dxpl_id, &x, TRUE);
+ H5D_istore_flush_entry (f, dxpl_cache, dxpl_id, dset, &x, TRUE);
} else {
if(chunk)
- H5F_istore_chunk_xfree (chunk,pline);
+ H5D_istore_chunk_xfree (chunk,&(dset->dcpl_cache.pline));
}
} else {
/*
@@ -1672,11 +1663,11 @@ H5F_istore_unlock(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id,
}
FUNC_LEAVE_NOAPI(SUCCEED);
-}
+} /* end H5D_istore_unlock() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_readvv
+ * Function: H5D_istore_readvv
*
* Purpose: Reads a multi-dimensional buffer from (part of) an indexed raw
* storage array.
@@ -1691,25 +1682,25 @@ H5F_istore_unlock(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id,
*-------------------------------------------------------------------------
*/
ssize_t
-H5F_istore_readvv(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id,
- const H5O_layout_t *layout, const struct H5D_dcpl_cache_t *dcpl_cache, const H5D_storage_t *store,
+H5D_istore_readvv(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id,
+ H5D_t *dset, const H5D_storage_t *store,
size_t chunk_max_nseq, size_t *chunk_curr_seq, size_t chunk_len_arr[], hsize_t chunk_offset_arr[],
size_t mem_max_nseq, size_t *mem_curr_seq, size_t mem_len_arr[], hsize_t mem_offset_arr[],
void *buf)
{
- H5F_istore_ud1_t udata; /*B-tree pass-through */
+ H5D_istore_ud1_t udata; /*B-tree pass-through */
haddr_t chunk_addr; /* Chunk address on disk */
size_t u; /* Local index variables */
ssize_t ret_value; /* Return value */
- FUNC_ENTER_NOAPI(H5F_istore_readvv, FAIL);
+ FUNC_ENTER_NOAPI(H5D_istore_readvv, FAIL);
/* Check args */
assert(f);
assert(dxpl_cache);
- assert(layout && H5D_CHUNKED==layout->type);
- assert(layout->u.chunk.ndims>0 && layout->u.chunk.ndims<=H5O_LAYOUT_NDIMS);
- assert(dcpl_cache);
+ assert(dset && H5D_CHUNKED==dset->layout.type);
+ assert(dset->layout.u.chunk.ndims>0 && dset->layout.u.chunk.ndims<=H5O_LAYOUT_NDIMS);
+ assert(store);
assert(chunk_len_arr);
assert(chunk_offset_arr);
assert(mem_len_arr);
@@ -1717,19 +1708,19 @@ H5F_istore_readvv(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache, hid_t dxp
assert(buf);
#ifndef NDEBUG
- for (u=0; u<layout->u.chunk.ndims; u++)
+ for (u=0; u<dset->layout.u.chunk.ndims; u++)
assert(store->chunk.offset[u]>=0); /*negative coordinates not supported (yet) */
#endif
/* Get the address of this chunk on disk */
#ifdef QAK
HDfprintf(stderr,"%s: chunk_coords={",FUNC);
-for(u=0; u<layout->u.chunk.ndims; u++)
- HDfprintf(stderr,"%Hd%s",chunk_coords[u],(u<(layout->u.chunk.ndims-1) ? ", " : "}\n"));
+for(u=0; u<dset->layout.u.chunk.ndims; u++)
+ HDfprintf(stderr,"%Hd%s",chunk_coords[u],(u<(dset->layout.u.chunk.ndims-1) ? ", " : "}\n"));
#endif /* QAK */
- chunk_addr=H5F_istore_get_addr(f, dxpl_id, layout, store->chunk.offset, &udata);
+ chunk_addr=H5D_istore_get_addr(f, dxpl_id, &(dset->layout), store->chunk.offset, &udata);
#ifdef QAK
-HDfprintf(stderr,"%s: chunk_addr=%a, chunk_size=%Hu\n",FUNC,chunk_addr,layout->u.chunk.size);
+HDfprintf(stderr,"%s: chunk_addr=%a, chunk_size=%Hu\n",FUNC,chunk_addr,dset->layout.u.chunk.size);
HDfprintf(stderr,"%s: chunk_len_arr[%Zu]=%Zu\n",FUNC,*chunk_curr_seq,chunk_len_arr[*chunk_curr_seq]);
HDfprintf(stderr,"%s: chunk_offset_arr[%Zu]=%Hu\n",FUNC,*chunk_curr_seq,chunk_offset_arr[*chunk_curr_seq]);
HDfprintf(stderr,"%s: mem_len_arr[%Zu]=%Zu\n",FUNC,*mem_curr_seq,mem_len_arr[*mem_curr_seq]);
@@ -1742,9 +1733,9 @@ HDfprintf(stderr,"%s: mem_offset_arr[%Zu]=%Hu\n",FUNC,*mem_curr_seq,mem_offset_a
* for the chunk has been defined, then don't load the chunk into the
* cache, just write the data to it directly.
*/
- if (layout->u.chunk.size>f->shared->rdcc_nbytes && dcpl_cache->pline.nused==0 &&
+ if (dset->layout.u.chunk.size>dset->cache.chunk.nbytes && dset->dcpl_cache.pline.nused==0 &&
chunk_addr!=HADDR_UNDEF) {
- if ((ret_value=H5F_contig_readvv(f, (hsize_t)layout->u.chunk.size, chunk_addr, chunk_max_nseq, chunk_curr_seq, chunk_len_arr, chunk_offset_arr, mem_max_nseq, mem_curr_seq, mem_len_arr, mem_offset_arr, dxpl_id, buf))<0)
+ if ((ret_value=H5D_contig_readvv(f, dxpl_id, dset, chunk_addr, (hsize_t)dset->layout.u.chunk.size, chunk_max_nseq, chunk_curr_seq, chunk_len_arr, chunk_offset_arr, mem_max_nseq, mem_curr_seq, mem_len_arr, mem_offset_arr, buf))<0)
HGOTO_ERROR (H5E_IO, H5E_READERROR, FAIL, "unable to read raw data to file");
} /* end if */
else {
@@ -1756,8 +1747,8 @@ HDfprintf(stderr,"%s: mem_offset_arr[%Zu]=%Hu\n",FUNC,*mem_curr_seq,mem_offset_a
* Lock the chunk, copy from application to chunk, then unlock the
* chunk.
*/
- if (NULL==(chunk=H5F_istore_lock(f, dxpl_cache, dxpl_id, layout, &dcpl_cache->pline, &dcpl_cache->fill, dcpl_cache->fill_time,
- &udata, store, FALSE, &idx_hint)))
+ if (NULL==(chunk=H5D_istore_lock(f, dxpl_cache, dxpl_id, dset, store,
+ &udata, FALSE, &idx_hint)))
HGOTO_ERROR(H5E_IO, H5E_READERROR, FAIL, "unable to read raw data chunk");
/* Use the vectorized memory copy routine to do actual work */
@@ -1765,8 +1756,8 @@ HDfprintf(stderr,"%s: mem_offset_arr[%Zu]=%Hu\n",FUNC,*mem_curr_seq,mem_offset_a
HGOTO_ERROR(H5E_IO, H5E_READERROR, FAIL, "vectorized memcpy failed");
H5_CHECK_OVERFLOW(naccessed,ssize_t,size_t);
- if (H5F_istore_unlock(f, dxpl_cache, dxpl_id, layout, &dcpl_cache->pline, FALSE,
- store, idx_hint, chunk, (size_t)naccessed)<0)
+ if (H5D_istore_unlock(f, dxpl_cache, dxpl_id, dset, store,
+ FALSE, idx_hint, chunk, (size_t)naccessed)<0)
HGOTO_ERROR(H5E_IO, H5E_READERROR, FAIL, "unable to unlock raw data chunk");
/* Set return value */
@@ -1775,11 +1766,11 @@ HDfprintf(stderr,"%s: mem_offset_arr[%Zu]=%Hu\n",FUNC,*mem_curr_seq,mem_offset_a
done:
FUNC_LEAVE_NOAPI(ret_value);
-} /* H5F_istore_readvv() */
+} /* H5D_istore_readvv() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_writevv
+ * Function: H5D_istore_writevv
*
* Purpose: Writes a multi-dimensional buffer to (part of) an indexed raw
* storage array.
@@ -1794,26 +1785,25 @@ done:
*-------------------------------------------------------------------------
*/
ssize_t
-H5F_istore_writevv(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache,
- hid_t dxpl_id, const H5O_layout_t *layout,
- const struct H5D_dcpl_cache_t *dcpl_cache, const H5D_storage_t *store,
+H5D_istore_writevv(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache,
+ hid_t dxpl_id, H5D_t *dset, const H5D_storage_t *store,
size_t chunk_max_nseq, size_t *chunk_curr_seq, size_t chunk_len_arr[], hsize_t chunk_offset_arr[],
size_t mem_max_nseq, size_t *mem_curr_seq, size_t mem_len_arr[], hsize_t mem_offset_arr[],
const void *buf)
{
- H5F_istore_ud1_t udata; /*B-tree pass-through */
+ H5D_istore_ud1_t udata; /*B-tree pass-through */
haddr_t chunk_addr; /* Chunk address on disk */
size_t u; /* Local index variables */
ssize_t ret_value; /* Return value */
- FUNC_ENTER_NOAPI(H5F_istore_writevv, FAIL);
+ FUNC_ENTER_NOAPI(H5D_istore_writevv, FAIL);
/* Check args */
assert(f);
assert(dxpl_cache);
- assert(layout && H5D_CHUNKED==layout->type);
- assert(layout->u.chunk.ndims>0 && layout->u.chunk.ndims<=H5O_LAYOUT_NDIMS);
- assert(dcpl_cache);
+ assert(dset && H5D_CHUNKED==dset->layout.type);
+ assert(dset->layout.u.chunk.ndims>0 && dset->layout.u.chunk.ndims<=H5O_LAYOUT_NDIMS);
+ assert(store);
assert(chunk_len_arr);
assert(chunk_offset_arr);
assert(mem_len_arr);
@@ -1821,19 +1811,19 @@ H5F_istore_writevv(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache,
assert(buf);
#ifndef NDEBUG
- for (u=0; u<layout->u.chunk.ndims; u++)
+ for (u=0; u<dset->layout.u.chunk.ndims; u++)
assert(store->chunk.offset[u]>=0); /*negative coordinates not supported (yet) */
#endif
/* Get the address of this chunk on disk */
#ifdef QAK
HDfprintf(stderr,"%s: chunk_coords={",FUNC);
-for(u=0; u<layout->u.chunk.ndims; u++)
- HDfprintf(stderr,"%Hd%s",chunk_coords[u],(u<(layout->u.chunk.ndims-1) ? ", " : "}\n"));
+for(u=0; u<dset->layout.u.chunk.ndims; u++)
+ HDfprintf(stderr,"%Hd%s",chunk_coords[u],(u<(dset->layout.u.chunk.ndims-1) ? ", " : "}\n"));
#endif /* QAK */
- chunk_addr=H5F_istore_get_addr(f, dxpl_id, layout, store->chunk.offset, &udata);
+ chunk_addr=H5D_istore_get_addr(f, dxpl_id, &(dset->layout), store->chunk.offset, &udata);
#ifdef QAK
-HDfprintf(stderr,"%s: chunk_addr=%a, chunk_size=%Hu\n",FUNC,chunk_addr,layout->u.chunk.size);
+HDfprintf(stderr,"%s: chunk_addr=%a, chunk_size=%Hu\n",FUNC,chunk_addr,dset->layout.u.chunk.size);
HDfprintf(stderr,"%s: chunk_len_arr[%Zu]=%Zu\n",FUNC,*chunk_curr_seq,chunk_len_arr[*chunk_curr_seq]);
HDfprintf(stderr,"%s: chunk_offset_arr[%Zu]=%Hu\n",FUNC,*chunk_curr_seq,chunk_offset_arr[*chunk_curr_seq]);
HDfprintf(stderr,"%s: mem_len_arr[%Zu]=%Zu\n",FUNC,*mem_curr_seq,mem_len_arr[*mem_curr_seq]);
@@ -1851,14 +1841,14 @@ HDfprintf(stderr,"%s: mem_offset_arr[%Zu]=%Hu\n",FUNC,*mem_curr_seq,mem_offset_a
* writing to other elements in the same chunk. Do a direct
* write-through of only the elements requested.
*/
- if ((layout->u.chunk.size>f->shared->rdcc_nbytes && dcpl_cache->pline.nused==0 && chunk_addr!=HADDR_UNDEF)
- || (IS_H5FD_MPI(f) && (H5F_ACC_RDWR & f->shared->flags))) {
+ if ((dset->layout.u.chunk.size>dset->cache.chunk.nbytes && dset->dcpl_cache.pline.nused==0 && chunk_addr!=HADDR_UNDEF)
+ || (IS_H5FD_MPI(f) && (H5F_ACC_RDWR & H5F_get_intent(f)))) {
#ifdef H5_HAVE_PARALLEL
/* Additional sanity check when operating in parallel */
- if (chunk_addr==HADDR_UNDEF || dcpl_cache->pline.nused>0)
+ if (chunk_addr==HADDR_UNDEF || dset->dcpl_cache.pline.nused>0)
HGOTO_ERROR (H5E_IO, H5E_WRITEERROR, FAIL, "unable to locate raw data chunk");
#endif /* H5_HAVE_PARALLEL */
- if ((ret_value=H5F_contig_writevv(f, (hsize_t)layout->u.chunk.size, chunk_addr, chunk_max_nseq, chunk_curr_seq, chunk_len_arr, chunk_offset_arr, mem_max_nseq, mem_curr_seq, mem_len_arr, mem_offset_arr, dxpl_id, buf))<0)
+ if ((ret_value=H5D_contig_writevv(f, dxpl_id, dset, chunk_addr, (hsize_t)dset->layout.u.chunk.size, chunk_max_nseq, chunk_curr_seq, chunk_len_arr, chunk_offset_arr, mem_max_nseq, mem_curr_seq, mem_len_arr, mem_offset_arr, buf))<0)
HGOTO_ERROR (H5E_IO, H5E_WRITEERROR, FAIL, "unable to write raw data to file");
} /* end if */
else {
@@ -1871,13 +1861,13 @@ HDfprintf(stderr,"%s: mem_offset_arr[%Zu]=%Hu\n",FUNC,*mem_curr_seq,mem_offset_a
* Lock the chunk, copy from application to chunk, then unlock the
* chunk.
*/
- if(chunk_max_nseq==1 && chunk_len_arr[0] == layout->u.chunk.size)
+ if(chunk_max_nseq==1 && chunk_len_arr[0] == dset->layout.u.chunk.size)
relax = TRUE;
else
relax = FALSE;
- if (NULL==(chunk=H5F_istore_lock(f, dxpl_cache, dxpl_id, layout, &dcpl_cache->pline, &dcpl_cache->fill, dcpl_cache->fill_time,
- &udata, store, relax, &idx_hint)))
+ if (NULL==(chunk=H5D_istore_lock(f, dxpl_cache, dxpl_id, dset, store,
+ &udata, relax, &idx_hint)))
HGOTO_ERROR (H5E_IO, H5E_WRITEERROR, FAIL, "unable to read raw data chunk");
/* Use the vectorized memory copy routine to do actual work */
@@ -1885,8 +1875,8 @@ HDfprintf(stderr,"%s: mem_offset_arr[%Zu]=%Hu\n",FUNC,*mem_curr_seq,mem_offset_a
HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "vectorized memcpy failed");
H5_CHECK_OVERFLOW(naccessed,ssize_t,size_t);
- if (H5F_istore_unlock(f, dxpl_cache, dxpl_id, layout, &dcpl_cache->pline, TRUE,
- store, idx_hint, chunk, (size_t)naccessed)<0)
+ if (H5D_istore_unlock(f, dxpl_cache, dxpl_id, dset, store,
+ TRUE, idx_hint, chunk, (size_t)naccessed)<0)
HGOTO_ERROR (H5E_IO, H5E_WRITEERROR, FAIL, "uanble to unlock raw data chunk");
/* Set return value */
@@ -1895,11 +1885,11 @@ HDfprintf(stderr,"%s: mem_offset_arr[%Zu]=%Hu\n",FUNC,*mem_curr_seq,mem_offset_a
done:
FUNC_LEAVE_NOAPI(ret_value);
-} /* H5F_istore_writevv() */
+} /* H5D_istore_writevv() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_create
+ * Function: H5D_istore_create
*
* Purpose: Creates a new indexed-storage B-tree and initializes the
* istore struct with information about the storage. The
@@ -1919,15 +1909,15 @@ done:
*-------------------------------------------------------------------------
*/
herr_t
-H5F_istore_create(H5F_t *f, hid_t dxpl_id, H5O_layout_t *layout /*out */ )
+H5D_istore_create(H5F_t *f, hid_t dxpl_id, H5O_layout_t *layout /*out */ )
{
- H5F_istore_ud1_t udata;
+ H5D_istore_ud1_t udata;
#ifndef NDEBUG
unsigned u;
#endif
herr_t ret_value=SUCCEED; /* Return value */
- FUNC_ENTER_NOAPI(H5F_istore_create, FAIL);
+ FUNC_ENTER_NOAPI(H5D_istore_create, FAIL);
/* Check args */
assert(f);
@@ -1944,11 +1934,11 @@ H5F_istore_create(H5F_t *f, hid_t dxpl_id, H5O_layout_t *layout /*out */ )
done:
FUNC_LEAVE_NOAPI(ret_value);
-}
+} /* end H5D_istore_create() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_allocated
+ * Function: H5D_istore_allocated
*
* Purpose: Return the number of bytes allocated in the file for storage
* of raw data under the specified B-tree (ADDR is the address
@@ -1967,15 +1957,15 @@ done:
*-------------------------------------------------------------------------
*/
hsize_t
-H5F_istore_allocated(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout)
+H5D_istore_allocated(H5F_t *f, hid_t dxpl_id, H5D_t *dset)
{
- H5F_rdcc_t *rdcc = &(f->shared->rdcc); /*raw data chunk cache */
- H5F_rdcc_ent_t *ent; /*cache entry */
+ H5D_rdcc_t *rdcc = &(dset->cache.chunk); /*raw data chunk cache */
+ H5D_rdcc_ent_t *ent; /*cache entry */
H5D_dxpl_cache_t dxpl_cache; /* Cached data transfer properties */
- H5F_istore_ud1_t udata;
+ H5D_istore_ud1_t udata;
hsize_t ret_value; /* Return value */
- FUNC_ENTER_NOAPI(H5F_istore_allocated, 0);
+ FUNC_ENTER_NOAPI(H5D_istore_allocated, 0);
/* Fill the DXPL cache values for later use */
if (H5D_get_dxpl_cache(dxpl_id,&dxpl_cache)<0)
@@ -1983,17 +1973,14 @@ H5F_istore_allocated(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout)
/* Search for cached chunks that haven't been written out */
for(ent = rdcc->head; ent; ent = ent->next) {
- /* Make certain we are dealing with the correct B-tree, etc */
- if (H5F_addr_eq(layout->u.chunk.addr, ent->layout.u.chunk.addr)) {
- /* Flush the chunk out to disk, to make certain the size is correct later */
- if (H5F_istore_flush_entry(f, &dxpl_cache, dxpl_id, ent, FALSE)<0)
- HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, 0, "cannot flush indexed storage buffer");
- } /* end if */
+ /* Flush the chunk out to disk, to make certain the size is correct later */
+ if (H5D_istore_flush_entry(f, &dxpl_cache, dxpl_id, dset, ent, FALSE)<0)
+ HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, 0, "cannot flush indexed storage buffer");
} /* end for */
HDmemset(&udata, 0, sizeof udata);
- udata.mesg.u.chunk.ndims = layout->u.chunk.ndims;
- if (H5B_iterate(f, dxpl_id, H5B_ISTORE, H5F_istore_iter_allocated, layout->u.chunk.addr, &udata)<0)
+ udata.mesg.u.chunk.ndims = dset->layout.u.chunk.ndims;
+ if (H5B_iterate(f, dxpl_id, H5B_ISTORE, H5D_istore_iter_allocated, dset->layout.u.chunk.addr, &udata)<0)
HGOTO_ERROR(H5E_IO, H5E_CANTINIT, 0, "unable to iterate over chunk B-tree");
/* Set return value */
@@ -2001,11 +1988,11 @@ H5F_istore_allocated(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout)
done:
FUNC_LEAVE_NOAPI(ret_value);
-} /* end H5F_istore_allocated() */
+} /* end H5D_istore_allocated() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_get_addr
+ * Function: H5D_istore_get_addr
*
* Purpose: Get the file address of a chunk if file space has been
* assigned. Save the retrieved information in the udata
@@ -2023,15 +2010,15 @@ done:
*-------------------------------------------------------------------------
*/
static haddr_t
-H5F_istore_get_addr(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout,
- const hssize_t offset[], H5F_istore_ud1_t *_udata)
+H5D_istore_get_addr(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout,
+ const hssize_t offset[], H5D_istore_ud1_t *_udata)
{
- H5F_istore_ud1_t tmp_udata; /* Information about a chunk */
- H5F_istore_ud1_t *udata; /* Pointer to information about a chunk */
+ H5D_istore_ud1_t tmp_udata; /* Information about a chunk */
+ H5D_istore_ud1_t *udata; /* Pointer to information about a chunk */
unsigned u;
haddr_t ret_value; /* Return value */
- FUNC_ENTER_NOAPI_NOINIT(H5F_istore_get_addr);
+ FUNC_ENTER_NOAPI_NOINIT(H5D_istore_get_addr);
assert(f);
assert(layout && (layout->u.chunk.ndims > 0));
@@ -2058,11 +2045,11 @@ H5F_istore_get_addr(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout,
done:
FUNC_LEAVE_NOAPI(ret_value);
-} /* H5F_istore_get_addr() */
+} /* H5D_istore_get_addr() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_chunk_alloc
+ * Function: H5D_istore_chunk_alloc
*
* Purpose: Allocate space for a chunk in memory. This routine allocates
* memory space for non-filtered chunks from a block free list
@@ -2078,11 +2065,11 @@ done:
*-------------------------------------------------------------------------
*/
static void *
-H5F_istore_chunk_alloc(size_t size, const H5O_pline_t *pline)
+H5D_istore_chunk_alloc(size_t size, const H5O_pline_t *pline)
{
void *ret_value=NULL; /* Return value */
- FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5F_istore_chunk_alloc);
+ FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5D_istore_chunk_alloc);
assert(size);
assert(pline);
@@ -2093,11 +2080,11 @@ H5F_istore_chunk_alloc(size_t size, const H5O_pline_t *pline)
ret_value=H5FL_BLK_MALLOC(chunk,size);
FUNC_LEAVE_NOAPI(ret_value);
-} /* H5F_istore_chunk_alloc() */
+} /* H5D_istore_chunk_alloc() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_chunk_xfree
+ * Function: H5D_istore_chunk_xfree
*
* Purpose: Free space for a chunk in memory. This routine allocates
* memory space for non-filtered chunks from a block free list
@@ -2113,9 +2100,9 @@ H5F_istore_chunk_alloc(size_t size, const H5O_pline_t *pline)
*-------------------------------------------------------------------------
*/
static void *
-H5F_istore_chunk_xfree(void *chk, const H5O_pline_t *pline)
+H5D_istore_chunk_xfree(void *chk, const H5O_pline_t *pline)
{
- FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5F_istore_chunk_xfree);
+ FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5D_istore_chunk_xfree);
assert(pline);
@@ -2127,11 +2114,11 @@ H5F_istore_chunk_xfree(void *chk, const H5O_pline_t *pline)
} /* end if */
FUNC_LEAVE_NOAPI(NULL);
-} /* H5F_istore_chunk_xfree() */
+} /* H5D_istore_chunk_xfree() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_allocate
+ * Function: H5D_istore_allocate
*
* Purpose: Allocate file space for all chunks that are not allocated yet.
* Return SUCCEED if all needed allocation succeed, otherwise
@@ -2145,6 +2132,9 @@ H5F_istore_chunk_xfree(void *chk, const H5O_pline_t *pline)
* This should be changed to do a direct flush independent
* of the cache value.
*
+ * This routine might be called before the dcpl_cache is set up
+ * correctly, so don't use those values.
+ *
* Programmer: Albert Cheng
* June 26, 1998
*
@@ -2171,8 +2161,8 @@ H5F_istore_chunk_xfree(void *chk, const H5O_pline_t *pline)
*-------------------------------------------------------------------------
*/
herr_t
-H5F_istore_allocate(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout,
- const hsize_t *space_dim, H5P_genplist_t *dc_plist, hbool_t full_overwrite)
+H5D_istore_allocate(H5F_t *f, hid_t dxpl_id, const H5D_t *dset,
+ hbool_t full_overwrite)
{
hssize_t chunk_offset[H5O_LAYOUT_NDIMS]; /* Offset of current chunk */
hsize_t chunk_size; /* Size of chunk in bytes */
@@ -2181,7 +2171,7 @@ H5F_istore_allocate(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout,
H5D_fill_time_t fill_time; /* When to write fill values */
H5D_fill_value_t fill_status; /* The fill value status */
unsigned should_fill=0; /* Whether fill values should be written */
- H5F_istore_ud1_t udata; /* B-tree pass-through for creating chunk */
+ H5D_istore_ud1_t udata; /* B-tree pass-through for creating chunk */
void *chunk=NULL; /* Chunk buffer for writing fill values */
H5P_genplist_t *dx_plist; /* Data xfer property list */
#ifdef H5_HAVE_PARALLEL
@@ -2197,18 +2187,28 @@ H5F_istore_allocate(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout,
unsigned u; /* Local index variable */
H5Z_EDC_t edc; /* Decide whether to enable EDC for read */
H5Z_cb_t cb_struct;
+ H5P_genplist_t *dc_plist; /* Property list */
+ int space_ndims; /* Dataset's space rank */
+ hsize_t space_dim[H5O_LAYOUT_NDIMS]; /* Dataset's dataspace dimensions */
herr_t ret_value=SUCCEED; /* Return value */
- FUNC_ENTER_NOAPI(H5F_istore_allocate, FAIL);
+ FUNC_ENTER_NOAPI(H5D_istore_allocate, FAIL);
/* Check args */
assert(f);
- assert(space_dim);
- assert(layout && H5D_CHUNKED==layout->type);
- assert(layout->u.chunk.ndims>0 && layout->u.chunk.ndims<=H5O_LAYOUT_NDIMS);
- assert(H5F_addr_defined(layout->u.chunk.addr));
assert(TRUE==H5P_isa_class(dxpl_id,H5P_DATASET_XFER));
- assert(dc_plist);
+ assert(dset && H5D_CHUNKED==dset->layout.type);
+ assert(dset->layout.u.chunk.ndims>0 && dset->layout.u.chunk.ndims<=H5O_LAYOUT_NDIMS);
+ assert(H5F_addr_defined(dset->layout.u.chunk.addr));
+
+ /* Get dataset's creation property list */
+ if (NULL == (dc_plist = H5I_object(dset->dcpl_id)))
+ HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataset creation property list")
+
+ /* We only handle simple data spaces so far */
+ if ((space_ndims=H5S_get_simple_extent_dims(dset->space, space_dim, NULL))<0)
+ HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to get simple data space info")
+ space_dim[space_ndims] = dset->layout.u.chunk.dim[space_ndims];
/* Get necessary properties from dataset creation property list */
if(H5P_get(dc_plist, H5D_CRT_FILL_VALUE_NAME, &fill) < 0)
@@ -2227,54 +2227,28 @@ H5F_istore_allocate(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout,
HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't get filter callback struct");
#ifdef H5_HAVE_PARALLEL
- /* Retrieve up MPI parameters */
- if(IS_H5FD_MPIO(f)) {
+ /* Retrieve MPI parameters */
+ if(IS_H5FD_MPI(f)) {
/* Get the MPI communicator */
- if (MPI_COMM_NULL == (mpi_comm=H5FD_mpio_communicator(f->shared->lf)))
+ if (MPI_COMM_NULL == (mpi_comm=H5F_mpi_get_comm(f)))
HGOTO_ERROR(H5E_INTERNAL, H5E_MPI, FAIL, "Can't retrieve MPI communicator");
- /* Get the MPI rank & size */
- if ((mpi_rank=H5FD_mpio_mpi_rank(f->shared->lf))<0)
+ /* Get the MPI rank */
+ if ((mpi_rank=H5F_mpi_get_rank(f))<0)
HGOTO_ERROR(H5E_INTERNAL, H5E_MPI, FAIL, "Can't retrieve MPI rank");
/* Set the MPI-capable file driver flag */
using_mpi=1;
} /* end if */
- else if(IS_H5FD_MPIPOSIX(f)) {
- /* Get the MPI communicator */
- if (MPI_COMM_NULL == (mpi_comm=H5FD_mpiposix_communicator(f->shared->lf)))
- HGOTO_ERROR(H5E_INTERNAL, H5E_MPI, FAIL, "Can't retrieve MPI communicator");
-
- /* Get the MPI rank & size */
- if ((mpi_rank=H5FD_mpiposix_mpi_rank(f->shared->lf))<0)
- HGOTO_ERROR(H5E_INTERNAL, H5E_MPI, FAIL, "Can't retrieve MPI rank");
-
- /* Set the MPI-capable file driver flag */
- using_mpi=1;
- } /* end else */
-#ifdef H5_HAVE_FPHDF5
- else if (IS_H5FD_FPHDF5(f)) {
- /* Get the FPHDF5 barrier communicator */
- if (MPI_COMM_NULL == (mpi_comm = H5FD_fphdf5_barrier_communicator(f->shared->lf)))
- HGOTO_ERROR(H5E_INTERNAL, H5E_MPI, FAIL, "Can't retrieve MPI communicator");
-
- /* Get the MPI rank & size */
- if ((mpi_rank = H5FD_fphdf5_mpi_rank(f->shared->lf)) < 0)
- HGOTO_ERROR(H5E_INTERNAL, H5E_MPI, FAIL, "Can't retrieve MPI rank");
-
- /* Set the MPI-capable file driver flag */
- using_mpi = 1;
- } /* end if */
-#endif /* H5_HAVE_FPHDF5 */
#endif /* H5_HAVE_PARALLEL */
/*
* Setup indice to go through all chunks. (Future improvement
* should allocate only chunks that have no file space assigned yet.
*/
- for (u=0; u<layout->u.chunk.ndims; u++)
+ for (u=0; u<dset->layout.u.chunk.ndims; u++)
chunk_offset[u] = 0;
- chunk_size = layout->u.chunk.size;
+ chunk_size = dset->layout.u.chunk.size;
/* Check the dataset's fill-value status */
if (H5P_is_fill_value_defined(&fill, &fill_status) < 0)
@@ -2292,7 +2266,7 @@ H5F_istore_allocate(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout,
if(should_fill) {
/* Allocate chunk buffer for processes to use when writing fill values */
H5_CHECK_OVERFLOW(chunk_size,hsize_t,size_t);
- if (NULL==(chunk = H5F_istore_chunk_alloc((size_t)chunk_size,&pline)))
+ if (NULL==(chunk = H5D_istore_chunk_alloc((size_t)chunk_size,&pline)))
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for chunk");
/* Fill the chunk with the proper values */
@@ -2329,41 +2303,36 @@ H5F_istore_allocate(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout,
while (carry==0) {
/* Check if the chunk exists yet on disk */
chunk_exists=1;
- if(H5F_istore_get_addr(f,dxpl_id,layout,chunk_offset, NULL)==HADDR_UNDEF) {
- H5F_rdcc_t *rdcc = &(f->shared->rdcc); /*raw data chunk cache */
- H5F_rdcc_ent_t *ent = NULL; /*cache entry */
+ if(H5D_istore_get_addr(f,dxpl_id,&(dset->layout),chunk_offset, NULL)==HADDR_UNDEF) {
+ const H5D_rdcc_t *rdcc = &(dset->cache.chunk); /*raw data chunk cache */
+ H5D_rdcc_ent_t *ent = NULL; /*cache entry */
/* Didn't find the chunk on disk */
chunk_exists = 0;
/* Look for chunk in cache */
for(ent = rdcc->head; ent && !chunk_exists; ent = ent->next) {
- /* Make certain we are dealing with the correct B-tree, etc */
- if (layout->u.chunk.ndims==ent->layout.u.chunk.ndims &&
- H5F_addr_eq(layout->u.chunk.addr, ent->layout.u.chunk.addr)) {
-
- /* Assume a match */
- chunk_exists = 1;
- for(u = 0; u < layout->u.chunk.ndims && chunk_exists; u++) {
- if(ent->offset[u] != chunk_offset[u])
- chunk_exists = 0; /* Reset if no match */
- } /* end for */
- } /* end if */
+ /* Assume a match */
+ chunk_exists = 1;
+ for(u = 0; u < dset->layout.u.chunk.ndims && chunk_exists; u++) {
+ if(ent->offset[u] != chunk_offset[u])
+ chunk_exists = 0; /* Reset if no match */
+ } /* end for */
} /* end for */
} /* end if */
if(!chunk_exists) {
/* Initialize the chunk information */
- udata.mesg = *layout;
+ udata.mesg = dset->layout;
udata.key.filter_mask = 0;
udata.addr = HADDR_UNDEF;
H5_CHECK_OVERFLOW(chunk_size,hsize_t,size_t);
udata.key.nbytes = (size_t)chunk_size;
- for (u=0; u<layout->u.chunk.ndims; u++)
+ for (u=0; u<dset->layout.u.chunk.ndims; u++)
udata.key.offset[u] = chunk_offset[u];
/* Allocate the chunk with all processes */
- if (H5B_insert(f, dxpl_id, H5B_ISTORE, layout->u.chunk.addr, &udata)<0)
+ if (H5B_insert(f, dxpl_id, H5B_ISTORE, dset->layout.u.chunk.addr, &udata)<0)
HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "unable to allocate chunk");
/* Check if fill values should be written to blocks */
@@ -2392,8 +2361,8 @@ H5F_istore_allocate(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout,
} /* end if */
/* Increment indices */
- for (i=layout->u.chunk.ndims-1, carry=1; i>=0 && carry; --i) {
- chunk_offset[i] += layout->u.chunk.dim[i];
+ for (i=dset->layout.u.chunk.ndims-1, carry=1; i>=0 && carry; --i) {
+ chunk_offset[i] += dset->layout.u.chunk.dim[i];
if (chunk_offset[i] >= (hssize_t)(space_dim[i]))
chunk_offset[i] = 0;
else
@@ -2417,14 +2386,14 @@ H5F_istore_allocate(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout,
done:
/* Free the chunk for fill values */
if(chunk!=NULL)
- H5F_istore_chunk_xfree(chunk,&pline);
+ H5D_istore_chunk_xfree(chunk,&pline);
FUNC_LEAVE_NOAPI(ret_value);
-}
+} /* end H5D_istore_allocate() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_prune_by_extent
+ * Function: H5D_istore_prune_by_extent
*
* Purpose: This function searches for chunks that are no longer necessary both in the
* raw data cache and in the B-tree.
@@ -2524,28 +2493,28 @@ done:
*-------------------------------------------------------------------------
*/
herr_t
-H5F_istore_prune_by_extent(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache,
- hid_t dxpl_id, const H5O_layout_t *layout, const H5S_t * space)
+H5D_istore_prune_by_extent(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache,
+ hid_t dxpl_id, H5D_t *dset)
{
- H5F_rdcc_t *rdcc = &(f->shared->rdcc); /*raw data chunk cache */
- H5F_rdcc_ent_t *ent = NULL, *next = NULL; /*cache entry */
+ H5D_rdcc_t *rdcc = &(dset->cache.chunk); /*raw data chunk cache */
+ H5D_rdcc_ent_t *ent = NULL, *next = NULL; /*cache entry */
unsigned u; /*counters */
int found; /*remove this entry */
- H5F_istore_ud1_t udata; /*B-tree pass-through */
+ H5D_istore_ud1_t udata; /*B-tree pass-through */
hsize_t curr_dims[H5O_LAYOUT_NDIMS]; /*current dataspace dimensions */
herr_t ret_value=SUCCEED; /* Return value */
- FUNC_ENTER_NOAPI(H5F_istore_prune_by_extent, FAIL);
+ FUNC_ENTER_NOAPI(H5D_istore_prune_by_extent, FAIL);
/* Check args */
assert(f);
- assert(layout && H5D_CHUNKED == layout->type);
- assert(layout->u.chunk.ndims > 0 && layout->u.chunk.ndims <= H5O_LAYOUT_NDIMS);
- assert(H5F_addr_defined(layout->u.chunk.addr));
- assert(space);
+ assert(dxpl_cache);
+ assert(dset && H5D_CHUNKED == dset->layout.type);
+ assert(dset->layout.u.chunk.ndims > 0 && dset->layout.u.chunk.ndims <= H5O_LAYOUT_NDIMS);
+ assert(H5F_addr_defined(dset->layout.u.chunk.addr));
/* Go get the rank & dimensions */
- if(H5S_get_simple_extent_dims(space, curr_dims, NULL) < 0)
+ if(H5S_get_simple_extent_dims(dset->space, curr_dims, NULL) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't get dataset dimensions");
/*-------------------------------------------------------------------------
@@ -2557,26 +2526,23 @@ H5F_istore_prune_by_extent(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache,
for(ent = rdcc->head; ent; ent = next) {
next = ent->next;
- /* Make certain we are dealing with the correct B-tree, etc */
- if (H5F_addr_eq(layout->u.chunk.addr, ent->layout.u.chunk.addr)) {
- for(u = 0; u < ent->layout.u.chunk.ndims - 1; u++) {
- if((hsize_t)ent->offset[u] > curr_dims[u]) {
- found = 1;
- break;
- }
- }
- } /* end if */
+ for(u = 0; u < dset->layout.u.chunk.ndims - 1; u++) {
+ if((hsize_t)ent->offset[u] > curr_dims[u]) {
+ found = 1;
+ break;
+ } /* end if */
+ } /* end for */
if(found) {
-#ifdef H5F_ISTORE_DEBUG
+#ifdef H5D_ISTORE_DEBUG
HDfputs("cache:remove:[", stderr);
- for(u = 0; u < ent->layout.u.chunk.ndims - 1; u++)
+ for(u = 0; u < dset->layout.u.chunk.ndims - 1; u++)
HDfprintf(stderr, "%s%Hd", u ? ", " : "", ent->offset[u]);
HDfputs("]\n", stderr);
#endif
/* Preempt the entry from the cache, but do not flush it to disk */
- if(H5F_istore_preempt(f, dxpl_cache, dxpl_id, ent, FALSE) < 0)
+ if(H5D_istore_preempt(f, dxpl_cache, dxpl_id, dset, ent, FALSE) < 0)
HGOTO_ERROR(H5E_IO, H5E_CANTINIT, 0, "unable to preempt chunk");
found=0;
@@ -2590,22 +2556,22 @@ H5F_istore_prune_by_extent(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache,
HDmemset(&udata, 0, sizeof udata);
udata.stream = stdout;
- udata.mesg.u.chunk.addr = layout->u.chunk.addr;
- udata.mesg.u.chunk.ndims = layout->u.chunk.ndims;
- for(u = 0; u < udata.mesg.u.chunk.ndims; u++)
- udata.mesg.u.chunk.dim[u] = layout->u.chunk.dim[u];
+ udata.mesg.u.chunk.addr = dset->layout.u.chunk.addr;
+ udata.mesg.u.chunk.ndims = dset->layout.u.chunk.ndims;
+ for(u = 0; u < dset->layout.u.chunk.ndims; u++)
+ udata.mesg.u.chunk.dim[u] = dset->layout.u.chunk.dim[u];
udata.dims = curr_dims;
- if(H5B_iterate(f, dxpl_id, H5B_ISTORE, H5F_istore_prune_extent, layout->u.chunk.addr, &udata) < 0)
+ if(H5B_iterate(f, dxpl_id, H5B_ISTORE, H5D_istore_prune_extent, dset->layout.u.chunk.addr, &udata) < 0)
HGOTO_ERROR(H5E_IO, H5E_CANTINIT, 0, "unable to iterate over B-tree");
done:
FUNC_LEAVE_NOAPI(ret_value);
-}
+} /* end H5D_istore_prune_by_extent() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_prune_extent
+ * Function: H5D_istore_prune_extent
*
* Purpose: Search for chunks that are no longer necessary in the B-tree.
*
@@ -2615,32 +2581,32 @@ done:
*
* Date: March 26, 2002
*
- * Comments: Called by H5B_prune_by_extent, part of H5B_ISTORE
+ * Comments: Called by H5D_prune_by_extent
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static int
-H5F_istore_prune_extent(H5F_t *f, hid_t dxpl_id, void *_lt_key, haddr_t UNUSED addr,
+H5D_istore_prune_extent(H5F_t *f, hid_t dxpl_id, void *_lt_key, haddr_t UNUSED addr,
void UNUSED *_rt_key, void *_udata)
{
- H5F_istore_ud1_t *bt_udata = (H5F_istore_ud1_t *)_udata;
- H5F_istore_key_t *lt_key = (H5F_istore_key_t *)_lt_key;
+ H5D_istore_ud1_t *bt_udata = (H5D_istore_ud1_t *)_udata;
+ H5D_istore_key_t *lt_key = (H5D_istore_key_t *)_lt_key;
unsigned u;
- H5F_istore_ud1_t udata;
+ H5D_istore_ud1_t udata;
int ret_value=H5B_ITER_CONT; /* Return value */
/* The LT_KEY is the left key (the one that describes the chunk). It points to a chunk of
* storage that contains the beginning of the logical address space represented by UDATA.
*/
- FUNC_ENTER_NOAPI_NOINIT(H5F_istore_prune_extent);
+ FUNC_ENTER_NOAPI_NOINIT(H5D_istore_prune_extent);
/* Figure out what chunks are no longer in use for the specified extent and release them */
for(u = 0; u < bt_udata->mesg.u.chunk.ndims - 1; u++)
if((hsize_t)lt_key->offset[u] > bt_udata->dims[u]) {
-#ifdef H5F_ISTORE_DEBUG
+#ifdef H5D_ISTORE_DEBUG
HDfputs("b-tree:remove:[", bt_udata->stream);
for(u = 0; u < bt_udata->mesg.u.chunk.ndims - 1; u++)
HDfprintf(bt_udata->stream, "%s%Hd", u ? ", " : "", lt_key->offset[u]);
@@ -2659,11 +2625,11 @@ H5F_istore_prune_extent(H5F_t *f, hid_t dxpl_id, void *_lt_key, haddr_t UNUSED a
done:
FUNC_LEAVE_NOAPI(ret_value);
-}
+} /* end H5D_istore_prune_extent() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_remove
+ * Function: H5D_istore_remove
*
* Purpose: Removes chunks that are no longer necessary in the B-tree.
*
@@ -2681,20 +2647,16 @@ done:
*-------------------------------------------------------------------------
*/
static H5B_ins_t
-H5F_istore_remove(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *_lt_key /*in,out */ ,
+H5D_istore_remove(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *_lt_key /*in,out */ ,
hbool_t *lt_key_changed /*out */ ,
void UNUSED * _udata /*in,out */ ,
void UNUSED * _rt_key /*in,out */ ,
hbool_t *rt_key_changed /*out */ )
{
- H5F_istore_key_t *lt_key = (H5F_istore_key_t *)_lt_key;
+ H5D_istore_key_t *lt_key = (H5D_istore_key_t *)_lt_key;
H5B_ins_t ret_value=H5B_INS_REMOVE; /* Return value */
- FUNC_ENTER_NOAPI(H5F_istore_remove,H5B_INS_ERROR);
-
- /* Check for overlap with the sieve buffer and reset it */
- if (H5F_sieve_overlap_clear(f, dxpl_id, addr, (hsize_t)lt_key->nbytes)<0)
- HGOTO_ERROR(H5E_OHDR, H5E_CANTFREE, H5B_INS_ERROR, "unable to clear sieve buffer");
+ FUNC_ENTER_NOAPI(H5D_istore_remove,H5B_INS_ERROR);
/* Remove raw data chunk from file */
H5MF_xfree(f, H5FD_MEM_DRAW, dxpl_id, addr, (hsize_t)lt_key->nbytes);
@@ -2705,11 +2667,11 @@ H5F_istore_remove(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *_lt_key /*in,out
done:
FUNC_LEAVE_NOAPI(ret_value);
-}
+} /* end H5D_istore_remove() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_initialize_by_extent
+ * Function: H5D_istore_initialize_by_extent
*
* Purpose: This function searches for chunks that have to be initialized with the fill
* value both in the raw data cache and in the B-tree.
@@ -2722,7 +2684,7 @@ done:
*
* Comments:
*
- * (See the example of H5F_istore_prune_by_extent)
+ * (See the example of H5D_istore_prune_by_extent)
* Next, there are seven chunks where the database extent boundary is
* within the chunk. We find those seven just like we did with the previous nine.
* Fot the ones that are allocated we initialize the part that lies outside the boundary
@@ -2733,9 +2695,8 @@ done:
*-------------------------------------------------------------------------
*/
herr_t
-H5F_istore_initialize_by_extent(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache,
- hid_t dxpl_id, const H5O_layout_t *layout,
- H5P_genplist_t *dc_plist, const H5S_t * space)
+H5D_istore_initialize_by_extent(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache,
+ hid_t dxpl_id, H5D_t *dset)
{
uint8_t *chunk = NULL; /*the file chunk */
unsigned idx_hint = 0; /*input value for H5F_istore_lock */
@@ -2758,20 +2719,25 @@ H5F_istore_initialize_by_extent(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_ca
int i, carry; /*counters */
unsigned u;
int found = 0; /*initialize this entry */
+ H5P_genplist_t *dc_plist; /* Property list */
H5O_pline_t pline; /* I/O pipeline information */
H5O_fill_t fill; /* Fill value information */
H5D_fill_time_t fill_time; /* Fill time information */
H5D_storage_t store; /* Dataset storage information */
herr_t ret_value=SUCCEED; /* Return value */
- FUNC_ENTER_NOAPI(H5F_istore_initialize_by_extent, FAIL);
+ FUNC_ENTER_NOAPI(H5D_istore_initialize_by_extent, FAIL);
/* Check args */
assert(f);
- assert(layout && H5D_CHUNKED == layout->type);
- assert(layout->u.chunk.ndims > 0 && layout->u.chunk.ndims <= H5O_LAYOUT_NDIMS);
- assert(H5F_addr_defined(layout->u.chunk.addr));
- assert(space);
+ assert(dxpl_cache);
+ assert(dset && H5D_CHUNKED == dset->layout.type);
+ assert(dset->layout.u.chunk.ndims > 0 && dset->layout.u.chunk.ndims <= H5O_LAYOUT_NDIMS);
+ assert(H5F_addr_defined(dset->layout.u.chunk.addr));
+
+ /* Get dataset's creation property list */
+ if (NULL == (dc_plist = H5I_object(dset->dcpl_id)))
+ HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataset creation property list")
/* Get necessary properties from property list */
if(H5P_get(dc_plist, H5D_CRT_FILL_VALUE_NAME, &fill) < 0)
@@ -2786,7 +2752,7 @@ H5F_istore_initialize_by_extent(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_ca
HDmemset(count, 0, sizeof(count));
/* Go get the rank & dimensions */
- if((srank = H5S_get_simple_extent_dims(space, curr_dims, NULL)) < 0)
+ if((srank = H5S_get_simple_extent_dims(dset->space, curr_dims, NULL)) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't get dataset dimensions");
H5_ASSIGN_OVERFLOW(rank,srank,int,unsigned);
@@ -2795,9 +2761,9 @@ H5F_istore_initialize_by_extent(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_ca
size[u] = curr_dims[u];
/* Round up to the next integer # of chunks, to accomodate partial chunks */
- chunks[u] = ((curr_dims[u]+layout->u.chunk.dim[u])-1) / layout->u.chunk.dim[u];
+ chunks[u] = ((curr_dims[u]+dset->layout.u.chunk.dim[u])-1) / dset->layout.u.chunk.dim[u];
} /* end for */
- size[u] = layout->u.chunk.dim[u];
+ size[u] = dset->layout.u.chunk.dim[u];
/* Get the "down" sizes for each dimension */
if(H5V_array_down(rank,chunks,down_chunks)<0)
@@ -2805,7 +2771,7 @@ H5F_istore_initialize_by_extent(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_ca
/* Create a data space for a chunk & set the extent */
for(u = 0; u < rank; u++)
- chunk_dims[u] = layout->u.chunk.dim[u];
+ chunk_dims[u] = dset->layout.u.chunk.dim[u];
if(NULL == (space_chunk = H5S_create_simple(rank,chunk_dims,NULL)))
HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCREATE, FAIL, "can't create simple dataspace");
@@ -2814,18 +2780,18 @@ H5F_istore_initialize_by_extent(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_ca
* loop through the chunks copying each chunk from the application to the
* chunk cache.
*/
- for(u = 0; u < layout->u.chunk.ndims; u++) {
- idx_max[u] = (size[u] - 1) / layout->u.chunk.dim[u] + 1;
+ for(u = 0; u < dset->layout.u.chunk.ndims; u++) {
+ idx_max[u] = (size[u] - 1) / dset->layout.u.chunk.dim[u] + 1;
idx_cur[u] = 0;
} /* end for */
/* Loop over all chunks */
carry=0;
while(carry==0) {
- for(u = 0, naccessed = 1; u < layout->u.chunk.ndims; u++) {
+ for(u = 0, naccessed = 1; u < dset->layout.u.chunk.ndims; u++) {
/* The location and size of the chunk being accessed */
- chunk_offset[u] = idx_cur[u] * (hssize_t)(layout->u.chunk.dim[u]);
- sub_size[u] = MIN((idx_cur[u] + 1) * layout->u.chunk.dim[u],
+ chunk_offset[u] = idx_cur[u] * (hssize_t)(dset->layout.u.chunk.dim[u]);
+ sub_size[u] = MIN((idx_cur[u] + 1) * dset->layout.u.chunk.dim[u],
size[u]) - chunk_offset[u];
naccessed *= sub_size[u];
} /* end for */
@@ -2834,8 +2800,8 @@ H5F_istore_initialize_by_extent(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_ca
* Figure out what chunks have to be initialized. These are the chunks where the dataspace
* extent boundary is within the chunk
*/
- for(u = 0, found = 0; u < layout->u.chunk.ndims - 1; u++) {
- end_chunk = chunk_offset[u] + layout->u.chunk.dim[u];
+ for(u = 0, found = 0; u < dset->layout.u.chunk.ndims - 1; u++) {
+ end_chunk = chunk_offset[u] + dset->layout.u.chunk.dim[u];
if(end_chunk > size[u]) {
found = 1;
break;
@@ -2845,27 +2811,27 @@ H5F_istore_initialize_by_extent(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_ca
if(found) {
/* Calculate the index of this chunk */
- if(H5V_chunk_index(rank,chunk_offset,layout->u.chunk.dim,down_chunks,&store.chunk.index)<0)
+ if(H5V_chunk_index(rank,chunk_offset,dset->layout.u.chunk.dim,down_chunks,&store.chunk.index)<0)
HGOTO_ERROR (H5E_DATASPACE, H5E_BADRANGE, FAIL, "can't get chunk index")
store.chunk.offset=chunk_offset;
- if(NULL == (chunk = H5F_istore_lock(f, dxpl_cache, dxpl_id, layout, &pline, &fill, fill_time,
- NULL, &store, FALSE, &idx_hint)))
+ if(NULL == (chunk = H5D_istore_lock(f, dxpl_cache, dxpl_id, dset,
+ &store, NULL, FALSE, &idx_hint)))
HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "unable to read raw data chunk");
if(H5S_select_all(space_chunk,1) < 0)
HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "unable to select space");
for(u = 0; u < rank; u++)
- count[u] = MIN((idx_cur[u] + 1) * layout->u.chunk.dim[u], size[u] - chunk_offset[u]);
+ count[u] = MIN((idx_cur[u] + 1) * dset->layout.u.chunk.dim[u], size[u] - chunk_offset[u]);
-#ifdef H5F_ISTORE_DEBUG
+#ifdef H5D_ISTORE_DEBUG
HDfputs("cache:initialize:offset:[", stdout);
- for(u = 0; u < layout->u.chunk.ndims - 1; u++)
+ for(u = 0; u < dset->layout.u.chunk.ndims - 1; u++)
HDfprintf(stdout, "%s%Hd", u ? ", " : "", chunk_offset[u]);
HDfputs("]", stdout);
HDfputs(":count:[", stdout);
- for(u = 0; u < layout->u.chunk.ndims - 1; u++)
+ for(u = 0; u < dset->layout.u.chunk.ndims - 1; u++)
HDfprintf(stdout, "%s%Hd", u ? ", " : "", count[u]);
HDfputs("]\n", stdout);
#endif
@@ -2882,13 +2848,13 @@ H5F_istore_initialize_by_extent(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_ca
if(H5S_select_fill(fill.buf, (size_t)size[rank], space_chunk, chunk) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_CANTENCODE, FAIL, "filling selection failed");
- if(H5F_istore_unlock(f, dxpl_cache, dxpl_id, layout, &pline, TRUE,
- &store, idx_hint, chunk, (size_t)naccessed) < 0)
+ if(H5D_istore_unlock(f, dxpl_cache, dxpl_id, dset, &store,
+ TRUE, idx_hint, chunk, (size_t)naccessed) < 0)
HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "unable to unlock raw data chunk");
} /*found */
/* Increment indices */
- for(i = layout->u.chunk.ndims - 1, carry = 1; i >= 0 && carry; --i) {
+ for(i = dset->layout.u.chunk.ndims - 1, carry = 1; i >= 0 && carry; --i) {
if(++idx_cur[i] >= idx_max[i])
idx_cur[i] = 0;
else
@@ -2901,11 +2867,11 @@ done:
H5S_close(space_chunk);
FUNC_LEAVE_NOAPI(ret_value);
-}
+} /* end H5D_istore_initialize_by_extent() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_delete
+ * Function: H5D_istore_delete
*
* Purpose: Delete raw data storage for entire dataset (i.e. all chunks)
*
@@ -2920,34 +2886,15 @@ done:
*-------------------------------------------------------------------------
*/
herr_t
-H5F_istore_delete(H5F_t *f, hid_t dxpl_id, const struct H5O_layout_t *layout)
+H5D_istore_delete(H5F_t *f, hid_t dxpl_id, const struct H5O_layout_t *layout)
{
- H5D_dxpl_cache_t dxpl_cache; /* Cached data transfer properties */
- H5F_istore_ud1_t udata; /* User data for B-tree iterator call */
- H5F_rdcc_t *rdcc = &(f->shared->rdcc); /* File's raw data chunk cache */
- H5F_rdcc_ent_t *ent, *next; /* Pointers to cache entries */
+ H5D_istore_ud1_t udata; /* User data for B-tree iterator call */
herr_t ret_value=SUCCEED; /* Return value */
- FUNC_ENTER_NOAPI(H5F_istore_delete, FAIL);
-
- /* Fill the DXPL cache values for later use */
- if (H5D_get_dxpl_cache(dxpl_id,&dxpl_cache)<0)
- HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't fill dxpl cache")
+ FUNC_ENTER_NOAPI(H5D_istore_delete, FAIL);
/* Check if the B-tree has been created in the file */
if(H5F_addr_defined(layout->u.chunk.addr)) {
- /* Iterate through the entries in the cache, checking for the chunks to be deleted */
- for (ent=rdcc->head; ent; ent=next) {
- /* Get pointer to next node, in case this one is deleted */
- next=ent->next;
-
- /* Is the chunk to be deleted this cache entry? */
- if(layout->u.chunk.addr==ent->layout.u.chunk.addr)
- /* Remove entry without flushing */
- if (H5F_istore_preempt(f, &dxpl_cache, dxpl_id, ent, FALSE )<0)
- HGOTO_ERROR (H5E_IO, H5E_CANTFLUSH, FAIL, "unable to flush one or more raw data chunks");
- } /* end for */
-
/* Set up user data for B-tree deletion */
HDmemset(&udata, 0, sizeof udata);
udata.mesg = *layout;
@@ -2959,11 +2906,11 @@ H5F_istore_delete(H5F_t *f, hid_t dxpl_id, const struct H5O_layout_t *layout)
done:
FUNC_LEAVE_NOAPI(ret_value);
-} /* end H5F_istore_delete() */
+} /* end H5D_istore_delete() */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_update_cache
+ * Function: H5D_istore_update_cache
*
* Purpose: Update any cached chunks index values after the dataspace
* size has changed
@@ -2979,11 +2926,11 @@ done:
*-------------------------------------------------------------------------
*/
herr_t
-H5F_istore_update_cache(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout, const H5S_t * space)
+H5D_istore_update_cache(H5F_t *f, hid_t dxpl_id, H5D_t *dset)
{
- H5F_rdcc_t *rdcc = &(f->shared->rdcc); /*raw data chunk cache */
- H5F_rdcc_ent_t *ent, *next; /*cache entry */
- H5F_rdcc_ent_t *old_ent; /* Old cache entry */
+ H5D_rdcc_t *rdcc = &(dset->cache.chunk); /*raw data chunk cache */
+ H5D_rdcc_ent_t *ent, *next; /*cache entry */
+ H5D_rdcc_ent_t *old_ent; /* Old cache entry */
H5D_dxpl_cache_t dxpl_cache; /* Cached data transfer properties */
int srank; /*current # of dimensions (signed) */
unsigned rank; /*current # of dimensions */
@@ -2991,29 +2938,25 @@ H5F_istore_update_cache(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout, con
hsize_t chunks[H5O_LAYOUT_NDIMS]; /*current number of chunks in each dimension */
hsize_t down_chunks[H5O_LAYOUT_NDIMS]; /* "down" size of number of elements in each dimension */
hsize_t idx; /* Chunk index */
- hsize_t temp_idx; /* temporary index number */
unsigned old_idx; /* Previous index number */
unsigned u; /*counters */
herr_t ret_value=SUCCEED; /* Return value */
- FUNC_ENTER_NOAPI(H5F_istore_update_cache, FAIL);
+ FUNC_ENTER_NOAPI(H5D_istore_update_cache, FAIL);
/* Check args */
assert(f);
- assert(layout && H5D_CHUNKED == layout->type);
- assert(layout->u.chunk.ndims > 0 && layout->u.chunk.ndims <= H5O_LAYOUT_NDIMS);
- assert(space);
+ assert(dset && H5D_CHUNKED == dset->layout.type);
+ assert(dset->layout.u.chunk.ndims > 0 && dset->layout.u.chunk.ndims <= H5O_LAYOUT_NDIMS);
/* Go get the rank & dimensions */
- if((srank = H5S_get_simple_extent_dims(space, curr_dims, NULL)) < 0)
+ if((srank = H5S_get_simple_extent_dims(dset->space, curr_dims, NULL)) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't get dataset dimensions");
H5_ASSIGN_OVERFLOW(rank,srank,int,unsigned);
- /* Copy current dimensions */
- for(u = 0; u < rank; u++) {
- /* Round up to the next integer # of chunks, to accomodate partial chunks */
- chunks[u] = ((curr_dims[u]+layout->u.chunk.dim[u])-1) / layout->u.chunk.dim[u];
- } /* end for */
+ /* Round up to the next integer # of chunks, to accomodate partial chunks */
+ for(u = 0; u < rank; u++)
+ chunks[u] = ((curr_dims[u]+dset->layout.u.chunk.dim[u])-1) / dset->layout.u.chunk.dim[u];
/* Get the "down" sizes for each dimension */
if(H5V_array_down(rank,chunks,down_chunks)<0)
@@ -3027,38 +2970,34 @@ H5F_istore_update_cache(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout, con
for(ent = rdcc->head; ent; ent = next) {
next=ent->next;
- /* Make certain we are dealing with the correct B-tree, etc */
- if (H5F_addr_eq(layout->u.chunk.addr, ent->layout.u.chunk.addr)) {
- /* Calculate the index of this chunk */
- if(H5V_chunk_index(rank,ent->offset,layout->u.chunk.dim,down_chunks,&idx)<0)
- HGOTO_ERROR (H5E_DATASPACE, H5E_BADRANGE, FAIL, "can't get chunk index")
+ /* Calculate the index of this chunk */
+ if(H5V_chunk_index(rank,ent->offset,dset->layout.u.chunk.dim,down_chunks,&idx)<0)
+ HGOTO_ERROR (H5E_DATASPACE, H5E_BADRANGE, FAIL, "can't get chunk index")
- /* Compute the index for the chunk entry */
- temp_idx = idx + (hsize_t)(layout->u.chunk.addr);
- old_idx=ent->idx; /* Save for later */
- ent->idx=H5F_HASH(f,temp_idx);
+ /* Compute the index for the chunk entry */
+ old_idx=ent->idx; /* Save for later */
+ ent->idx=H5D_HASH(dset,idx);
- if(old_idx!=ent->idx) {
- /* Check if there is already a chunk at this chunk's new location */
- old_ent = rdcc->slot[ent->idx];
- if(old_ent!=NULL) {
- assert(old_ent->locked==0);
+ if(old_idx!=ent->idx) {
+ /* Check if there is already a chunk at this chunk's new location */
+ old_ent = rdcc->slot[ent->idx];
+ if(old_ent!=NULL) {
+ assert(old_ent->locked==0);
- /* Check if we are removing the entry we would walk to next */
- if(old_ent==next)
- next=old_ent->next;
+ /* Check if we are removing the entry we would walk to next */
+ if(old_ent==next)
+ next=old_ent->next;
- /* Remove the old entry from the cache */
- if (H5F_istore_preempt(f, &dxpl_cache, dxpl_id, old_ent, TRUE )<0)
- HGOTO_ERROR (H5E_IO, H5E_CANTFLUSH, FAIL, "unable to flush one or more raw data chunks");
- } /* end if */
+ /* Remove the old entry from the cache */
+ if (H5D_istore_preempt(f, &dxpl_cache, dxpl_id, dset, old_ent, TRUE )<0)
+ HGOTO_ERROR (H5E_IO, H5E_CANTFLUSH, FAIL, "unable to flush one or more raw data chunks");
+ } /* end if */
- /* Insert this chunk into correct location in hash table */
- rdcc->slot[ent->idx]=ent;
+ /* Insert this chunk into correct location in hash table */
+ rdcc->slot[ent->idx]=ent;
- /* Null out previous location */
- rdcc->slot[old_idx]=NULL;
- } /* end if */
+ /* Null out previous location */
+ rdcc->slot[old_idx]=NULL;
} /* end if */
} /* end for */
@@ -3068,7 +3007,7 @@ done:
/*-------------------------------------------------------------------------
- * Function: H5F_istore_dump_btree
+ * Function: H5D_istore_dump_btree
*
* Purpose: Prints information about the storage B-tree to the specified
* stream.
@@ -3086,29 +3025,29 @@ done:
*-------------------------------------------------------------------------
*/
herr_t
-H5F_istore_dump_btree(H5F_t *f, hid_t dxpl_id, FILE *stream, unsigned ndims, haddr_t addr)
+H5D_istore_dump_btree(H5F_t *f, hid_t dxpl_id, FILE *stream, unsigned ndims, haddr_t addr)
{
- H5F_istore_ud1_t udata;
+ H5D_istore_ud1_t udata;
herr_t ret_value=SUCCEED; /* Return value */
- FUNC_ENTER_NOAPI(H5F_istore_dump_btree, FAIL);
+ FUNC_ENTER_NOAPI(H5D_istore_dump_btree, FAIL);
HDmemset(&udata, 0, sizeof udata);
udata.mesg.u.chunk.ndims = ndims;
udata.stream = stream;
if(stream)
HDfprintf(stream, " Address: %a\n",addr);
- if(H5B_iterate(f, dxpl_id, H5B_ISTORE, H5F_istore_iter_dump, addr, &udata)<0)
+ if(H5B_iterate(f, dxpl_id, H5B_ISTORE, H5D_istore_iter_dump, addr, &udata)<0)
HGOTO_ERROR(H5E_IO, H5E_CANTINIT, 0, "unable to iterate over chunk B-tree");
done:
FUNC_LEAVE_NOAPI(ret_value);
-}
+} /* end H5D_istore_dump_btree() */
-#ifdef H5F_ISTORE_DEBUG
+#ifdef H5D_ISTORE_DEBUG
/*-------------------------------------------------------------------------
- * Function: H5F_istore_stats
+ * Function: H5D_istore_stats
*
* Purpose: Print raw data cache statistics to the debug stream. If
* HEADERS is non-zero then print table column headers,
@@ -3124,21 +3063,20 @@ done:
*-------------------------------------------------------------------------
*/
herr_t
-H5F_istore_stats (H5F_t *f, hbool_t headers)
+H5D_istore_stats (H5D_t *dset, hbool_t headers)
{
- H5F_rdcc_t *rdcc = &(f->shared->rdcc);
+ H5D_rdcc_t *rdcc = &(dset->cache.chunk);
double miss_rate;
char ascii[32];
herr_t ret_value=SUCCEED; /* Return value */
- FUNC_ENTER_NOAPI(H5F_istore_stats, FAIL);
+ FUNC_ENTER_NOAPI(H5D_istore_stats, FAIL);
if (!H5DEBUG(AC))
HGOTO_DONE(SUCCEED);
if (headers) {
- fprintf(H5DEBUG(AC), "H5F: raw data cache statistics for file %s\n",
- f->name);
+ fprintf(H5DEBUG(AC), "H5D: raw data cache statistics\n");
fprintf(H5DEBUG(AC), " %-18s %8s %8s %8s %8s+%-8s\n",
"Layer", "Hits", "Misses", "MissRate", "Inits", "Flushes");
fprintf(H5DEBUG(AC), " %-18s %8s %8s %8s %8s-%-8s\n",
@@ -3169,12 +3107,12 @@ H5F_istore_stats (H5F_t *f, hbool_t headers)
done:
FUNC_LEAVE_NOAPI(ret_value);
-}
-#endif /* H5F_ISTORE_DEBUG */
+} /* end H5D_istore_stats() */
+#endif /* H5D_ISTORE_DEBUG */
/*-------------------------------------------------------------------------
- * Function: H5F_istore_debug
+ * Function: H5D_istore_debug
*
* Purpose: Debugs a B-tree node for indexed raw data storage.
*
@@ -3189,13 +3127,13 @@ done:
*-------------------------------------------------------------------------
*/
herr_t
-H5F_istore_debug(H5F_t *f, hid_t dxpl_id, haddr_t addr, FILE * stream, int indent,
+H5D_istore_debug(H5F_t *f, hid_t dxpl_id, haddr_t addr, FILE * stream, int indent,
int fwidth, int ndims)
{
- H5F_istore_ud1_t udata;
+ H5D_istore_ud1_t udata;
herr_t ret_value=SUCCEED; /* Return value */
- FUNC_ENTER_NOAPI(H5F_istore_debug, FAIL);
+ FUNC_ENTER_NOAPI(H5D_istore_debug, FAIL);
HDmemset (&udata, 0, sizeof udata);
udata.mesg.u.chunk.ndims = ndims;
@@ -3204,5 +3142,4 @@ H5F_istore_debug(H5F_t *f, hid_t dxpl_id, haddr_t addr, FILE * stream, int inden
done:
FUNC_LEAVE_NOAPI(ret_value);
-}
-
+} /* end H5D_istore_debug() */
diff --git a/src/H5Fpkg.h b/src/H5Fpkg.h
index c3169cd..63d562d 100644
--- a/src/H5Fpkg.h
+++ b/src/H5Fpkg.h
@@ -86,20 +86,6 @@
# define H5F_OVERFLOW_HSIZET2OFFT(X) 0
#endif
-/* The raw data chunk cache */
-typedef struct H5F_rdcc_t {
- unsigned ninits; /* Number of chunk creations */
- unsigned nhits; /* Number of cache hits */
- unsigned nmisses;/* Number of cache misses */
- unsigned nflushes;/* Number of cache flushes */
- size_t nbytes; /* Current cached raw data in bytes */
- size_t nslots; /* Number of chunk slots allocated */
- struct H5F_rdcc_ent_t *head; /* Head of doubly linked list */
- struct H5F_rdcc_ent_t *tail; /* Tail of doubly linked list */
- int nused; /* Number of chunk slots in use */
- struct H5F_rdcc_ent_t **slot; /* Chunk slots, each points to a chunk*/
-} H5F_rdcc_t;
-
/*
* Define the structure to store the file information for HDF5 files. One of
* these structures is allocated per file, not per H5Fopen(). That is, set of
@@ -118,19 +104,20 @@ typedef struct H5F_file_t {
size_t sizeof_size; /* Size of offsets in file */
unsigned sym_leaf_k; /* Size of leaves in symbol tables */
unsigned btree_k[H5B_NUM_BTREE_ID]; /* B-tree key values for each type */
-
haddr_t super_addr; /* Absolute address of super block */
haddr_t base_addr; /* Absolute base address for rel.addrs. */
haddr_t freespace_addr; /* Relative address of free-space info */
haddr_t driver_addr; /* File driver information block address*/
+
unsigned super_chksum; /* Superblock checksum */
unsigned drvr_chksum; /* Driver info block checksum */
struct H5AC_t *cache; /* The object cache */
hid_t fcpl_id; /* File creation property list ID */
- int mdc_nelmts; /* Size of meta data cache (elements) */
+ int mdc_nelmts; /* Size of meta data cache (elements) */
size_t rdcc_nelmts; /* Size of raw data chunk cache (elmts) */
size_t rdcc_nbytes; /* Size of raw data chunk cache (bytes) */
double rdcc_w0; /* Preempt read chunks first? [0.0..1.0]*/
+ size_t sieve_buf_size; /* Size of the data sieve buffer allocated (in bytes) */
hsize_t threshold; /* Threshold for alignment */
hsize_t alignment; /* Alignment */
unsigned gc_ref; /* Garbage-collect references? */
@@ -138,15 +125,6 @@ typedef struct H5F_file_t {
int ncwfs; /* Num entries on cwfs list */
struct H5HG_heap_t **cwfs; /* Global heap cache */
H5FO_t *open_objs; /* Open objects in file */
-
- /* Data Sieve Buffering fields */
- unsigned char *sieve_buf; /* Buffer to hold data sieve buffer */
- haddr_t sieve_loc; /* File location (offset) of the data sieve buffer */
- size_t sieve_size; /* Size of the data sieve buffer used (in bytes) */
- size_t sieve_buf_size; /* Size of the data sieve buffer allocated (in bytes) */
- unsigned sieve_dirty; /* Flag to indicate that the data sieve buffer is dirty */
-
- H5F_rdcc_t rdcc; /* Raw data chunk cache */
H5F_close_degree_t fc_degree; /* File close behavior degree */
} H5F_file_t;
@@ -198,50 +176,6 @@ H5_DLL void H5F_encode_length_unusual(const H5F_t *f, uint8_t **p, uint8_t *l);
H5_DLL herr_t H5F_mountpoint(struct H5G_entry_t *find/*in,out*/);
H5_DLL herr_t H5F_debug(H5F_t *f, hid_t dxpl_id, haddr_t addr, FILE * stream,
int indent, int fwidth);
-H5_DLL herr_t H5F_sieve_overlap_clear(const H5F_t *f, hid_t dxpl_id, haddr_t addr, hsize_t size);
-
-/* Functions that operate on indexed storage */
-H5_DLL herr_t H5F_istore_init (H5F_t *f);
-H5_DLL herr_t H5F_istore_flush (H5F_t *f, hid_t dxpl_id, unsigned flags);
-H5_DLL herr_t H5F_istore_dest (H5F_t *f, hid_t dxpl_id);
-H5_DLL ssize_t H5F_istore_readvv(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache,
- hid_t dxpl_id,
- const struct H5O_layout_t *layout, const struct H5D_dcpl_cache_t *dcpl_cache,
- const union H5D_storage_t *store,
- size_t chunk_max_nseq, size_t *chunk_curr_seq, size_t chunk_len_arr[], hsize_t chunk_offset_arr[],
- size_t mem_max_nseq, size_t *mem_curr_seq, size_t mem_len_arr[], hsize_t mem_offset_arr[],
- void *buf);
-H5_DLL ssize_t H5F_istore_writevv(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache,
- hid_t dxpl_id,
- const struct H5O_layout_t *layout, const struct H5D_dcpl_cache_t *dcpl_cache,
- const union H5D_storage_t *store,
- size_t chunk_max_nseq, size_t *chunk_curr_seq, size_t chunk_len_arr[], hsize_t chunk_offset_arr[],
- size_t mem_max_nseq, size_t *mem_curr_seq, size_t mem_len_arr[], hsize_t mem_offset_arr[],
- const void *buf);
-#ifdef H5F_ISTORE_DEBUG
-H5_DLL herr_t H5F_istore_stats (H5F_t *f, hbool_t headers);
-#endif /* H5F_ISTORE_DEBUG */
-H5_DLL herr_t H5F_istore_debug(H5F_t *f, hid_t dxpl_id, haddr_t addr, FILE * stream,
- int indent, int fwidth, int ndims);
-
-/* Functions that operate on contiguous storage wrt superblock */
-H5_DLL ssize_t H5F_contig_readvv(H5F_t *f, hsize_t _max_data, haddr_t _addr,
- size_t dset_max_nseq, size_t *dset_curr_seq, size_t dset_len_arr[], hsize_t dset_offset_arr[],
- size_t mem_max_nseq, size_t *mem_curr_seq, size_t mem_len_arr[], hsize_t mem_offset_arr[],
- hid_t dxpl_id, void *buf);
-H5_DLL ssize_t H5F_contig_writevv(H5F_t *f, hsize_t _max_data, haddr_t _addr,
- size_t dset_max_nseq, size_t *dset_curr_seq, size_t dset_len_arr[], hsize_t dset_offset_arr[],
- size_t mem_max_nseq, size_t *mem_curr_seq, size_t mem_len_arr[], hsize_t mem_offset_arr[],
- hid_t dxpl_id, const void *buf);
-
-/* Functions that operate on compact dataset storage */
-H5_DLL ssize_t H5F_compact_readvv(H5F_t *f, const struct H5O_layout_t *layout,
- size_t dset_max_nseq, size_t *dset_curr_seq, size_t dset_size_arr[], hsize_t dset_offset_arr[],
- size_t mem_max_nseq, size_t *mem_curr_seq, size_t mem_size_arr[], hsize_t mem_offset_arr[],
- hid_t dxpl_id, void *buf);
-H5_DLL ssize_t H5F_compact_writevv(H5F_t *f, struct H5O_layout_t *layout,
- size_t dset_max_nseq, size_t *dset_curr_seq, size_t dset_size_arr[], hsize_t dset_offset_arr[],
- size_t mem_max_nseq, size_t *mem_curr_seq, size_t mem_size_arr[], hsize_t mem_offset_arr[],
- hid_t dxpl_id, const void *buf);
+
#endif
diff --git a/src/H5Fprivate.h b/src/H5Fprivate.h
index b8c7e2b..988f5e3 100644
--- a/src/H5Fprivate.h
+++ b/src/H5Fprivate.h
@@ -205,11 +205,21 @@ typedef struct H5F_t H5F_t;
#define H5F_SYM_LEAF_K(F) ((F)->shared->sym_leaf_k)
/* B-tree key value size */
#define H5F_KVALUE(F,T) ((F)->shared->btree_k[(T)->id])
+/* Raw data cache values */
+#define H5F_RDCC_NELMTS(F) ((F)->shared->rdcc_nelmts)
+#define H5F_RDCC_NBYTES(F) ((F)->shared->rdcc_nbytes)
+#define H5F_RDCC_W0(F) ((F)->shared->rdcc_w0)
+/* Check for file driver feature enabled */
+#define H5F_HAS_FEATURE(F,FL) ((F)->shared->lf->feature_flags&(FL))
#else /* H5F_PACKAGE */
#define H5F_SIZEOF_ADDR(F) (H5F_sizeof_addr(F))
#define H5F_SIZEOF_SIZE(F) (H5F_sizeof_size(F))
#define H5F_SYM_LEAF_K(F) (H5F_sym_leaf_k(F))
#define H5F_KVALUE(F,T) (H5F_Kvalue(F,T))
+#define H5F_RDCC_NELMTS(F) (H5F_rdcc_nelmts(F))
+#define H5F_RDCC_NBYTES(F) (H5F_rdcc_nbytes(F))
+#define H5F_RDCC_W0(F) (H5F_rdcc_w0(F))
+#define H5F_HAS_FEATURE(F,FL) (H5F_has_feature(F,FL))
#endif /* H5F_PACKAGE */
@@ -375,13 +385,6 @@ typedef struct H5F_t H5F_t;
/* Forward declarations for prototype arguments */
struct H5B_class_t;
-union H5D_storage_t;
-struct H5O_fill_t;
-struct H5O_layout_t;
-struct H5P_genplist_t;
-struct H5S_t;
-struct H5D_dxpl_cache_t;
-struct H5D_dcpl_cache_t;
/* Private functions, not part of the publicly documented API */
H5_DLL herr_t H5F_init(void);
@@ -392,6 +395,11 @@ H5_DLL hid_t H5F_get_id(H5F_t *file);
H5_DLL int H5F_get_obj_count(const H5F_t *f, unsigned types);
H5_DLL int H5F_get_obj_ids(const H5F_t *f, unsigned types, int max_objs, hid_t *obj_id_list);
H5_DLL haddr_t H5F_get_base_addr(const H5F_t *f);
+H5_DLL haddr_t H5F_get_eoa(const H5F_t *f);
+#ifdef H5_HAVE_PARALLEL
+H5_DLL int H5F_mpi_get_rank(const H5F_t *f);
+H5_DLL MPI_Comm H5F_mpi_get_comm(const H5F_t *f);
+#endif /* H5_HAVE_PARALLEL */
/* Functions than check file mounting information */
H5_DLL htri_t H5F_is_mount(const H5F_t *file);
@@ -402,6 +410,10 @@ H5_DLL size_t H5F_sizeof_addr(const H5F_t *f);
H5_DLL size_t H5F_sizeof_size(const H5F_t *f);
H5_DLL unsigned H5F_sym_leaf_k(const H5F_t *f);
H5_DLL unsigned H5F_Kvalue(const H5F_t *f, const struct H5B_class_t *type);
+H5_DLL hbool_t H5F_has_feature(const H5F_t *f, unsigned feature);
+H5_DLL size_t H5F_rdcc_nbytes(const H5F_t *f);
+H5_DLL size_t H5F_rdcc_nelmts(const H5F_t *f);
+H5_DLL double H5F_rdcc_w0(const H5F_t *f);
/* Functions that operate on blocks of bytes wrt super block */
H5_DLL herr_t H5F_block_read(const H5F_t *f, H5FD_mem_t type, haddr_t addr,
@@ -409,60 +421,6 @@ H5_DLL herr_t H5F_block_read(const H5F_t *f, H5FD_mem_t type, haddr_t addr,
H5_DLL herr_t H5F_block_write(const H5F_t *f, H5FD_mem_t type, haddr_t addr,
size_t size, hid_t dxpl_id, const void *buf);
-/* Functions that operate on byte sequences */
-H5_DLL herr_t H5F_seq_read(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache,
- hid_t dxpl_id, const struct H5O_layout_t *layout,
- const struct H5D_dcpl_cache_t *dcpl_cache, const union H5D_storage_t *store,
- size_t seq_len, hsize_t file_offset, void *_buf/*out*/);
-H5_DLL herr_t H5F_seq_write (H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache,
- hid_t dxpl_id, struct H5O_layout_t *layout,
- const struct H5D_dcpl_cache_t *dcpl_cache, const union H5D_storage_t *store,
- size_t seq_len, hsize_t file_offset, const void *_buf);
-
-/* Functions that operate on byte sequences in memory and on disk */
-H5_DLL ssize_t H5F_seq_readvv(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache,
- hid_t dxpl_id, const struct H5O_layout_t *layout,
- const struct H5D_dcpl_cache_t *dcpl_cache, const union H5D_storage_t *store,
- size_t dset_max_nseq, size_t *dset_curr_seq, size_t dset_len_arr[], hsize_t dset_offset_arr[],
- size_t mem_max_nseq, size_t *mem_curr_seq, size_t mem_len_arr[], hsize_t mem_offset_arr[],
- void *buf);
-H5_DLL ssize_t H5F_seq_writevv(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache,
- hid_t dxpl_id, struct H5O_layout_t *layout,
- const struct H5D_dcpl_cache_t *dcpl_cache, const union H5D_storage_t *store,
- size_t dset_max_nseq, size_t *dset_curr_seq, size_t dset_len_arr[], hsize_t dset_offset_arr[],
- size_t mem_max_nseq, size_t *mem_curr_seq, size_t mem_len_arr[], hsize_t mem_offset_arr[],
- const void *buf);
-
-/* Functions that operate on contiguous storage */
-H5_DLL herr_t H5F_contig_create(H5F_t *f, hid_t dxpl_id,
- struct H5O_layout_t *layout);
-H5_DLL herr_t H5F_contig_fill(H5F_t *f, hid_t dxpl_id,
- struct H5O_layout_t *layout, const struct H5S_t *space,
- const struct H5O_fill_t *fill, size_t elmt_size);
-H5_DLL herr_t H5F_contig_delete(H5F_t *f, hid_t dxpl_id,
- const struct H5O_layout_t *layout);
-
-/* Functions that operate on indexed storage */
-H5_DLL herr_t H5F_istore_create(H5F_t *f, hid_t dxpl_id,
- struct H5O_layout_t *layout/*in,out*/);
-H5_DLL herr_t H5F_istore_allocate (H5F_t *f, hid_t dxpl_id,
- const struct H5O_layout_t *layout, const hsize_t *space_dim,
- struct H5P_genplist_t *dc_plist, hbool_t full_overwrite);
-H5_DLL hsize_t H5F_istore_allocated(H5F_t *f, hid_t dxpl_id, const struct H5O_layout_t *layout);
-H5_DLL herr_t H5F_istore_dump_btree(H5F_t *f, hid_t dxpl_id, FILE *stream, unsigned ndims,
- haddr_t addr);
-H5_DLL herr_t H5F_istore_prune_by_extent( H5F_t *f,
- const struct H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id,
- const struct H5O_layout_t *layout, const struct H5S_t *space);
-H5_DLL herr_t H5F_istore_initialize_by_extent( H5F_t *f,
- const struct H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id,
- const struct H5O_layout_t *layout, struct H5P_genplist_t *dc_plist,
- const struct H5S_t *space );
-H5_DLL herr_t H5F_istore_delete(H5F_t *f, hid_t dxpl_id,
- const struct H5O_layout_t *layout);
-H5_DLL herr_t H5F_istore_update_cache(H5F_t *f, hid_t dxpl_id, const struct H5O_layout_t *layout,
- const struct H5S_t * space);
-
/* Address-related functions */
H5_DLL void H5F_addr_encode(H5F_t *, uint8_t** /*in,out*/, haddr_t);
H5_DLL void H5F_addr_decode(H5F_t *, const uint8_t** /*in,out*/,
diff --git a/src/H5Fseq.c b/src/H5Fseq.c
index 9bd9f72..5585315 100644
--- a/src/H5Fseq.c
+++ b/src/H5Fseq.c
@@ -23,27 +23,23 @@
*
*/
-#define H5F_PACKAGE /*suppress error about including H5Fpkg */
+#define H5D_PACKAGE /*suppress error about including H5Dpkg */
/* Pablo information */
/* (Put before include files to avoid problems with inline functions) */
-#define PABLO_MASK H5Fseq_mask
+#define PABLO_MASK H5Dseq_mask
-#include "H5private.h"
-#include "H5Dprivate.h"
-#include "H5Eprivate.h"
-#include "H5Fpkg.h"
-#include "H5FDprivate.h" /*file driver */
-#include "H5Iprivate.h"
-#include "H5MFprivate.h"
-#include "H5MMprivate.h" /*memory management */
-#include "H5Oprivate.h"
-#include "H5Pprivate.h"
-#include "H5Vprivate.h"
-
-/* MPIO & MPIPOSIX driver functions are needed for some special checks */
-#include "H5FDmpio.h"
-#include "H5FDmpiposix.h"
+#include "H5private.h" /* Generic Functions */
+#include "H5Dpkg.h" /* Datasets */
+#include "H5Eprivate.h" /* Error handling */
+#include "H5Fprivate.h" /* Files */
+#include "H5FDprivate.h" /* File drivers */
+#include "H5Iprivate.h" /* IDs */
+#include "H5MFprivate.h" /* File space management */
+#include "H5MMprivate.h" /* Memory management */
+#include "H5Oprivate.h" /* Object headers */
+#include "H5Pprivate.h" /* Property lists */
+#include "H5Vprivate.h" /* Vector and array functions */
/* Interface initialization */
#define INTERFACE_INIT NULL
@@ -51,105 +47,7 @@ static int interface_initialize_g = 0;
/*-------------------------------------------------------------------------
- * Function: H5F_seq_read
- *
- * Purpose: Reads a sequence of bytes from a file dataset into a buffer in
- * in memory. The data is read from file F and the array's size and
- * storage information is in LAYOUT. External files are described
- * according to the external file list, EFL. The sequence offset is
- * DSET_OFFSET in the dataset (offsets are in terms of bytes) and the
- * size of the hyperslab is SEQ_LEN. The total size of the file array
- * is implied in the LAYOUT argument.
- *
- * Return: Non-negative on success/Negative on failure
- *
- * Programmer: Quincey Koziol
- * Thursday, September 28, 2000
- *
- * Modifications:
- * Re-written to use new vector I/O call - QAK, 7/7/01
- *
- *-------------------------------------------------------------------------
- */
-herr_t
-H5F_seq_read(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache,
- hid_t dxpl_id, const H5O_layout_t *layout,
- const struct H5D_dcpl_cache_t *dcpl_cache, const H5D_storage_t *store,
- size_t seq_len, hsize_t dset_offset, void *buf/*out*/)
-{
- hsize_t mem_off=0; /* Offset in memory */
- size_t mem_len=seq_len; /* Length in memory */
- size_t mem_curr_seq=0; /* "Current sequence" in memory */
- size_t dset_curr_seq=0; /* "Current sequence" in dataset */
- herr_t ret_value=SUCCEED; /* Return value */
-
- FUNC_ENTER_NOAPI(H5F_seq_read, FAIL);
-
- /* Check args */
- assert(f);
- assert(layout);
- assert(buf);
- assert(TRUE==H5P_isa_class(dxpl_id,H5P_DATASET_XFER));
-
- if (H5F_seq_readvv(f, dxpl_cache, dxpl_id, layout, dcpl_cache, store, 1, &dset_curr_seq, &seq_len, &dset_offset, 1, &mem_curr_seq, &mem_len, &mem_off, buf)<0)
- HGOTO_ERROR(H5E_IO, H5E_READERROR, FAIL, "vector read failed");
-
-done:
- FUNC_LEAVE_NOAPI(ret_value);
-} /* H5F_seq_read() */
-
-
-/*-------------------------------------------------------------------------
- * Function: H5F_seq_write
- *
- * Purpose: Writes a sequence of bytes to a file dataset from a buffer in
- * in memory. The data is written to file F and the array's size and
- * storage information is in LAYOUT. External files are described
- * according to the external file list, EFL. The sequence offset is
- * DSET_OFFSET in the dataset (offsets are in terms of bytes) and the
- * size of the hyperslab is SEQ_LEN. The total size of the file array
- * is implied in the LAYOUT argument.
- *
- * Return: Non-negative on success/Negative on failure
- *
- * Programmer: Quincey Koziol
- * Monday, October 9, 2000
- *
- * Modifications:
- * Re-written to use new vector I/O routine - QAK, 7/7/01
- *
- *-------------------------------------------------------------------------
- */
-herr_t
-H5F_seq_write(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache,
- hid_t dxpl_id, H5O_layout_t *layout,
- const struct H5D_dcpl_cache_t *dcpl_cache, const H5D_storage_t *store,
- size_t seq_len, hsize_t dset_offset, const void *buf)
-{
- hsize_t mem_off=0; /* Offset in memory */
- size_t mem_len=seq_len; /* Length in memory */
- size_t mem_curr_seq=0; /* "Current sequence" in memory */
- size_t dset_curr_seq=0; /* "Current sequence" in dataset */
- herr_t ret_value=SUCCEED; /* Return value */
-
- FUNC_ENTER_NOAPI(H5F_seq_write, FAIL);
-
- /* Check args */
- assert(f);
- assert(layout);
- assert(buf);
- assert(TRUE==H5P_isa_class(dxpl_id,H5P_DATASET_XFER));
-
- if (H5F_seq_writevv(f, dxpl_cache, dxpl_id, layout, dcpl_cache, store, 1, &dset_curr_seq, &seq_len, &dset_offset, 1, &mem_curr_seq, &mem_len, &mem_off, buf)<0)
- HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "vector write failed");
-
-done:
- FUNC_LEAVE_NOAPI(ret_value);
-} /* H5F_seq_write() */
-
-
-/*-------------------------------------------------------------------------
- * Function: H5F_seq_readvv
+ * Function: H5D_seq_readvv
*
* Purpose: Reads in a vector of byte sequences from a file dataset into a
* buffer in in memory. The data is read from file F and the array's size
@@ -189,22 +87,20 @@ done:
*-------------------------------------------------------------------------
*/
ssize_t
-H5F_seq_readvv(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id,
- const struct H5O_layout_t *layout,
- const struct H5D_dcpl_cache_t *dcpl_cache, const H5D_storage_t *store,
+H5D_seq_readvv(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id,
+ H5D_t *dset, const H5D_storage_t *store,
size_t dset_max_nseq, size_t *dset_curr_seq, size_t dset_len_arr[], hsize_t dset_offset_arr[],
size_t mem_max_nseq, size_t *mem_curr_seq, size_t mem_len_arr[], hsize_t mem_offset_arr[],
void *buf/*out*/)
{
ssize_t ret_value; /* Return value */
- FUNC_ENTER_NOAPI(H5F_seq_readvv, FAIL);
+ FUNC_ENTER_NOAPI(H5D_seq_readvv, FAIL);
/* Check args */
assert(f);
assert(TRUE==H5P_isa_class(dxpl_id,H5P_DATASET_XFER)); /* Make certain we have the correct type of property list */
- assert(layout);
- assert(dcpl_cache);
+ assert(dset);
assert(dset_curr_seq);
assert(*dset_curr_seq<dset_max_nseq);
assert(dset_len_arr);
@@ -215,7 +111,7 @@ H5F_seq_readvv(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_i
assert(mem_offset_arr);
assert(buf);
- switch (layout->type) {
+ switch (dset->layout.type) {
case H5D_CONTIGUOUS:
/* Read directly from file if the dataset is in an external file */
if (store && store->efl.nused>0) {
@@ -231,17 +127,18 @@ H5F_seq_readvv(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_i
HGOTO_ERROR(H5E_IO, H5E_READERROR, FAIL, "external data read failed");
} else {
/* Pass along the vector of sequences to read */
- if((ret_value=H5F_contig_readvv(f, layout->u.contig.size, layout->u.contig.addr,
+ if((ret_value=H5D_contig_readvv(f, dxpl_id, dset,
+ dset->layout.u.contig.addr, dset->layout.u.contig.size,
dset_max_nseq, dset_curr_seq, dset_len_arr, dset_offset_arr,
mem_max_nseq, mem_curr_seq, mem_len_arr, mem_offset_arr,
- dxpl_id, buf))<0)
+ buf))<0)
HGOTO_ERROR(H5E_IO, H5E_READERROR, FAIL, "block read failed");
} /* end else */
break;
case H5D_CHUNKED:
assert(store);
- if((ret_value=H5F_istore_readvv(f, dxpl_cache, dxpl_id, layout, dcpl_cache, store,
+ if((ret_value=H5D_istore_readvv(f, dxpl_cache, dxpl_id, dset, store,
dset_max_nseq, dset_curr_seq, dset_len_arr, dset_offset_arr,
mem_max_nseq, mem_curr_seq, mem_len_arr, mem_offset_arr,
buf))<0)
@@ -250,10 +147,10 @@ H5F_seq_readvv(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_i
case H5D_COMPACT:
/* Pass along the vector of sequences to read */
- if((ret_value=H5F_compact_readvv(f, layout,
+ if((ret_value=H5D_compact_readvv(f, dxpl_id, dset,
dset_max_nseq, dset_curr_seq, dset_len_arr, dset_offset_arr,
mem_max_nseq, mem_curr_seq, mem_len_arr, mem_offset_arr,
- dxpl_id, buf))<0)
+ buf))<0)
HGOTO_ERROR(H5E_IO, H5E_READERROR, FAIL, "compact read failed");
break;
@@ -264,11 +161,11 @@ H5F_seq_readvv(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_i
done:
FUNC_LEAVE_NOAPI(ret_value);
-} /* H5F_seq_readvv() */
+} /* H5D_seq_readvv() */
/*-------------------------------------------------------------------------
- * Function: H5F_seq_writevv
+ * Function: H5D_seq_writevv
*
* Purpose: Writes a vector of byte sequences from a buffer in memory into
* a vector of byte sequences in a file dataset. The data is written to
@@ -298,22 +195,20 @@ done:
*-------------------------------------------------------------------------
*/
ssize_t
-H5F_seq_writevv(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache,
- hid_t dxpl_id, struct H5O_layout_t *layout,
- const struct H5D_dcpl_cache_t *dcpl_cache, const H5D_storage_t *store,
+H5D_seq_writevv(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache,
+ hid_t dxpl_id, struct H5D_t *dset, const H5D_storage_t *store,
size_t dset_max_nseq, size_t *dset_curr_seq, size_t dset_len_arr[], hsize_t dset_offset_arr[],
size_t mem_max_nseq, size_t *mem_curr_seq, size_t mem_len_arr[], hsize_t mem_offset_arr[],
const void *buf)
{
ssize_t ret_value; /* Return value */
- FUNC_ENTER_NOAPI(H5F_seq_writevv, FAIL);
+ FUNC_ENTER_NOAPI(H5D_seq_writevv, FAIL);
/* Check args */
assert(f);
assert(TRUE==H5P_isa_class(dxpl_id,H5P_DATASET_XFER)); /* Make certain we have the correct type of property list */
- assert(layout);
- assert(dcpl_cache);
+ assert(dset);
assert(dset_curr_seq);
assert(*dset_curr_seq<dset_max_nseq);
assert(dset_len_arr);
@@ -324,7 +219,7 @@ H5F_seq_writevv(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache,
assert(mem_offset_arr);
assert(buf);
- switch (layout->type) {
+ switch (dset->layout.type) {
case H5D_CONTIGUOUS:
/* Write directly to file if the dataset is in an external file */
if (store && store->efl.nused>0) {
@@ -340,17 +235,18 @@ H5F_seq_writevv(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache,
HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "external data write failed");
} else {
/* Pass along the vector of sequences to write */
- if ((ret_value=H5F_contig_writevv(f, layout->u.contig.size, layout->u.contig.addr,
+ if ((ret_value=H5D_contig_writevv(f, dxpl_id, dset,
+ dset->layout.u.contig.addr, dset->layout.u.contig.size,
dset_max_nseq, dset_curr_seq, dset_len_arr, dset_offset_arr,
mem_max_nseq, mem_curr_seq, mem_len_arr, mem_offset_arr,
- dxpl_id, buf))<0)
+ buf))<0)
HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "block write failed");
} /* end else */
break;
case H5D_CHUNKED:
assert(store);
- if((ret_value=H5F_istore_writevv(f, dxpl_cache, dxpl_id, layout, dcpl_cache, store,
+ if((ret_value=H5D_istore_writevv(f, dxpl_cache, dxpl_id, dset, store,
dset_max_nseq, dset_curr_seq, dset_len_arr, dset_offset_arr,
mem_max_nseq, mem_curr_seq, mem_len_arr, mem_offset_arr,
buf))<0)
@@ -359,10 +255,10 @@ H5F_seq_writevv(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache,
case H5D_COMPACT:
/* Pass along the vector of sequences to write */
- if((ret_value=H5F_compact_writevv(f, layout,
+ if((ret_value=H5D_compact_writevv(f, dxpl_id, dset,
dset_max_nseq, dset_curr_seq, dset_len_arr, dset_offset_arr,
mem_max_nseq, mem_curr_seq, mem_len_arr, mem_offset_arr,
- dxpl_id, buf))<0)
+ buf))<0)
HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "compact write failed");
break;
@@ -373,4 +269,4 @@ H5F_seq_writevv(H5F_t *f, const struct H5D_dxpl_cache_t *dxpl_cache,
done:
FUNC_LEAVE_NOAPI(ret_value);
-} /* H5F_seq_writevv() */
+} /* H5D_seq_writevv() */
diff --git a/src/H5Olayout.c b/src/H5Olayout.c
index 15013ee..0b6b4a8 100644
--- a/src/H5Olayout.c
+++ b/src/H5Olayout.c
@@ -656,13 +656,13 @@ H5O_layout_delete(H5F_t *f, hid_t dxpl_id, const void *_mesg)
case H5D_CONTIGUOUS: /* Contiguous block on disk */
/* Free the file space for the raw data */
- if (H5F_contig_delete(f, dxpl_id, mesg)<0)
+ if (H5D_contig_delete(f, dxpl_id, mesg)<0)
HGOTO_ERROR(H5E_OHDR, H5E_CANTFREE, FAIL, "unable to free raw data");
break;
case H5D_CHUNKED: /* Chunked blocks on disk */
/* Free the file space for the raw data */
- if (H5F_istore_delete(f, dxpl_id, mesg)<0)
+ if (H5D_istore_delete(f, dxpl_id, mesg)<0)
HGOTO_ERROR(H5E_OHDR, H5E_CANTFREE, FAIL, "unable to free raw data");
break;
diff --git a/src/H5Smpio.c b/src/H5Smpio.c
index 0158d14..6b8ce28 100644
--- a/src/H5Smpio.c
+++ b/src/H5Smpio.c
@@ -69,7 +69,7 @@ H5S_mpio_space_type( const H5S_t *space, size_t elmt_size,
hsize_t *extra_offset,
hbool_t *is_derived_type );
static herr_t
-H5S_mpio_spaces_xfer(H5F_t *f, const H5O_layout_t *layout, size_t elmt_size,
+H5S_mpio_spaces_xfer(H5F_t *f, const H5D_t *dset, size_t elmt_size,
const H5S_t *file_space, const H5S_t *mem_space,
hid_t dxpl_id, void *buf/*out*/, hbool_t do_write);
@@ -627,7 +627,7 @@ done:
*-------------------------------------------------------------------------
*/
static herr_t
-H5S_mpio_spaces_xfer(H5F_t *f, const H5O_layout_t *layout, size_t elmt_size,
+H5S_mpio_spaces_xfer(H5F_t *f, const H5D_t *dset, size_t elmt_size,
const H5S_t *file_space, const H5S_t *mem_space,
hid_t dxpl_id, void *_buf /*out*/,
hbool_t do_write )
@@ -647,7 +647,7 @@ H5S_mpio_spaces_xfer(H5F_t *f, const H5O_layout_t *layout, size_t elmt_size,
/* Check args */
assert (f);
- assert (layout);
+ assert (dset);
assert (file_space);
assert (mem_space);
assert (buf);
@@ -673,14 +673,9 @@ H5S_mpio_spaces_xfer(H5F_t *f, const H5O_layout_t *layout, size_t elmt_size,
&mft_is_derived )<0)
HGOTO_ERROR(H5E_DATASPACE, H5E_BADTYPE, FAIL,"couldn't create MPI file type");
- /* Use the absolute base address of the dataset (or chunk, eventually) as
- * the address to read from. This should be used as the diplacement for
- * a call to MPI_File_set_view() in the read or write call.
- */
- assert(layout->type==H5D_CONTIGUOUS);
- addr = f->shared->base_addr + layout->u.contig.addr + mpi_file_offset;
+ addr = H5D_contig_get_addr(dset) + mpi_file_offset;
#ifdef H5Smpi_DEBUG
- HDfprintf(stderr, "spaces_xfer: addr=%a\n", addr );
+ HDfprintf(stderr, "spaces_xfer: relative addr=%a\n", addr );
#endif
/*
@@ -696,10 +691,10 @@ H5S_mpio_spaces_xfer(H5F_t *f, const H5O_layout_t *layout, size_t elmt_size,
/* transfer the data */
if (do_write) {
- if (H5FD_write(f->shared->lf, H5FD_MEM_DRAW, dxpl_id, addr, mpi_buf_count, buf) <0)
+ if (H5F_block_write(f, H5FD_MEM_DRAW, addr, mpi_buf_count, dxpl_id, buf) <0)
HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL,"MPI write failed");
} else {
- if ( H5FD_read (f->shared->lf, H5FD_MEM_DRAW, dxpl_id, addr, mpi_buf_count, buf) <0)
+ if (H5F_block_read (f, H5FD_MEM_DRAW, addr, mpi_buf_count, dxpl_id, buf) <0)
HGOTO_ERROR(H5E_IO, H5E_READERROR, FAIL,"MPI read failed");
}
@@ -721,7 +716,7 @@ done:
}
FUNC_LEAVE_NOAPI(ret_value);
-}
+} /* end H5S_mpio_spaces_xfer() */
/*-------------------------------------------------------------------------
@@ -745,22 +740,22 @@ done:
*-------------------------------------------------------------------------
*/
herr_t
-H5S_mpio_spaces_read(H5F_t *f, const H5O_layout_t *layout,
- const H5D_dcpl_cache_t UNUSED *dcpl_cache, const H5D_storage_t UNUSED *store,
+H5S_mpio_spaces_read(H5F_t *f, const H5D_dxpl_cache_t UNUSED *dxpl_cache, hid_t dxpl_id,
+ H5D_t *dset, const H5D_storage_t UNUSED *store,
size_t UNUSED nelmts, size_t elmt_size,
- const H5S_t *file_space, const H5S_t *mem_space, const H5D_dxpl_cache_t UNUSED *dxpl_cache,
- hid_t dxpl_id, void *buf/*out*/)
+ const H5S_t *file_space, const H5S_t *mem_space,
+ void *buf/*out*/)
{
herr_t ret_value;
FUNC_ENTER_NOAPI(H5S_mpio_spaces_read, FAIL);
- ret_value = H5S_mpio_spaces_xfer(f, layout, elmt_size, file_space,
+ ret_value = H5S_mpio_spaces_xfer(f, dset, elmt_size, file_space,
mem_space, dxpl_id, buf, 0/*read*/);
done:
FUNC_LEAVE_NOAPI(ret_value);
-}
+} /* end H5S_mpio_spaces_read() */
/*-------------------------------------------------------------------------
@@ -784,23 +779,23 @@ done:
*-------------------------------------------------------------------------
*/
herr_t
-H5S_mpio_spaces_write(H5F_t *f, H5O_layout_t *layout,
- const H5D_dcpl_cache_t UNUSED *dcpl_cache, const H5D_storage_t UNUSED *store,
+H5S_mpio_spaces_write(H5F_t *f, const H5D_dxpl_cache_t UNUSED *dxpl_cache, hid_t dxpl_id,
+ H5D_t *dset, const H5D_storage_t UNUSED *store,
size_t UNUSED nelmts, size_t elmt_size,
- const H5S_t *file_space, const H5S_t *mem_space, const H5D_dxpl_cache_t UNUSED *dxpl_cache,
- hid_t dxpl_id, const void *buf)
+ const H5S_t *file_space, const H5S_t *mem_space,
+ const void *buf)
{
herr_t ret_value;
FUNC_ENTER_NOAPI(H5S_mpio_spaces_write, FAIL);
/*OKAY: CAST DISCARDS CONST QUALIFIER*/
- ret_value = H5S_mpio_spaces_xfer(f, layout, elmt_size, file_space,
+ ret_value = H5S_mpio_spaces_xfer(f, dset, elmt_size, file_space,
mem_space, dxpl_id, (void*)buf, 1/*write*/);
done:
FUNC_LEAVE_NOAPI(ret_value);
-}
+} /* end H5S_mpio_spaces_write() */
/*-------------------------------------------------------------------------
diff --git a/src/H5Spkg.h b/src/H5Spkg.h
index d93ec1e..89243ff 100644
--- a/src/H5Spkg.h
+++ b/src/H5Spkg.h
@@ -245,17 +245,17 @@ H5_DLL herr_t H5S_none_get_seq_list(const H5S_t *space, unsigned flags,
#ifdef H5_HAVE_PARALLEL
/* MPI-IO function to read directly from app buffer to file rky980813 */
-H5_DLL herr_t H5S_mpio_spaces_read(H5F_t *f, const struct H5O_layout_t *layout,
- const H5D_dcpl_cache_t *dcpl_cache, const H5D_storage_t *store,
- size_t nelmts, size_t elmt_size, const H5S_t *file_space,
- const H5S_t *mem_space, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id,
+H5_DLL herr_t H5S_mpio_spaces_read(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id,
+ H5D_t *dset, const H5D_storage_t *store,
+ size_t nelmts, size_t elmt_size,
+ const H5S_t *file_space, const H5S_t *mem_space,
void *buf/*out*/);
/* MPI-IO function to write directly from app buffer to file rky980813 */
-H5_DLL herr_t H5S_mpio_spaces_write(H5F_t *f, struct H5O_layout_t *layout,
- const H5D_dcpl_cache_t *dcpl_cache, const H5D_storage_t *store,
- size_t nelmts, size_t elmt_size, const H5S_t *file_space,
- const H5S_t *mem_space, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id,
+H5_DLL herr_t H5S_mpio_spaces_write(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id,
+ H5D_t *dset, const H5D_storage_t *store,
+ size_t nelmts, size_t elmt_size,
+ const H5S_t *file_space, const H5S_t *mem_space,
const void *buf);
/* MPI-IO function to check if a direct I/O transfer is possible between
diff --git a/src/H5Sprivate.h b/src/H5Sprivate.h
index 59174fc..11fd2f6 100644
--- a/src/H5Sprivate.h
+++ b/src/H5Sprivate.h
@@ -137,19 +137,19 @@ typedef struct H5S_conv_t {
*/
/* Read from file to application w/o intermediate scratch buffer */
- herr_t (*read)(H5F_t *f, const struct H5O_layout_t *layout,
- const H5D_dcpl_cache_t *dcpl_cache, const union H5D_storage_t *store,
- size_t nelmts, size_t elmt_size, const H5S_t *file_space,
- const H5S_t *mem_space, const H5D_dxpl_cache_t *dxpl_cache,
- hid_t dxpl_id, void *buf/*out*/);
+ herr_t (*read)(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id,
+ H5D_t *dset, const H5D_storage_t *store,
+ size_t nelmts, size_t elmt_size,
+ const H5S_t *file_space, const H5S_t *mem_space,
+ void *buf/*out*/);
/* Write directly from app buffer to file */
- herr_t (*write)(H5F_t *f, struct H5O_layout_t *layout,
- const H5D_dcpl_cache_t *dcpl_cache, const union H5D_storage_t *store,
- size_t nelmts, size_t elmt_size, const H5S_t *file_space,
- const H5S_t *mem_space, const H5D_dxpl_cache_t *dxpl_cache,
- hid_t dxpl_id, const void *buf);
+ herr_t (*write)(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id,
+ H5D_t *dset, const H5D_storage_t *store,
+ size_t nelmts, size_t elmt_size,
+ const H5S_t *file_space, const H5S_t *mem_space,
+ const void *buf);
#ifdef H5S_DEBUG
struct {
@@ -250,28 +250,30 @@ H5_DLL herr_t H5S_select_iterate(void *buf, hid_t type_id, const H5S_t *space,
H5D_operator_t op, void *operator_data);
H5_DLL herr_t H5S_select_fill(void *fill, size_t fill_size,
const H5S_t *space, void *buf);
-H5_DLL herr_t H5S_select_fscat (H5F_t *f, struct H5O_layout_t *layout,
- const H5D_dcpl_cache_t *dcpl_cache, const union H5D_storage_t *store,
- const H5S_t *file_space, H5S_sel_iter_t *file_iter, hsize_t nelmts,
- const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id, const void *_buf);
-H5_DLL hsize_t H5S_select_fgath (H5F_t *f, const struct H5O_layout_t *layout,
- const H5D_dcpl_cache_t *dcpl_cache, const union H5D_storage_t *store,
- const H5S_t *file_space, H5S_sel_iter_t *file_iter, hsize_t nelmts,
- const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id, void *buf);
+H5_DLL herr_t H5S_select_fscat (H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id,
+ H5D_t *dset, const H5D_storage_t *store,
+ const H5S_t *file_space, H5S_sel_iter_t *file_iter, hsize_t nelmts,
+ const void *_buf);
+H5_DLL hsize_t H5S_select_fgath (H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id,
+ H5D_t *dset, const H5D_storage_t *store,
+ const H5S_t *file_space, H5S_sel_iter_t *file_iter, hsize_t nelmts,
+ void *buf);
H5_DLL herr_t H5S_select_mscat (const void *_tscat_buf,
const H5S_t *space, H5S_sel_iter_t *iter, hsize_t nelmts,
const H5D_dxpl_cache_t *dxpl_cache, void *_buf/*out*/);
H5_DLL hsize_t H5S_select_mgath (const void *_buf,
const H5S_t *space, H5S_sel_iter_t *iter, hsize_t nelmts,
const H5D_dxpl_cache_t *dxpl_cache, void *_tgath_buf/*out*/);
-H5_DLL herr_t H5S_select_read(H5F_t *f, const struct H5O_layout_t *layout,
- const H5D_dcpl_cache_t *dcpl_cache, const union H5D_storage_t *store, size_t nelmts, size_t elmt_size,
- const H5S_t *file_space, const H5S_t *mem_space, const H5D_dxpl_cache_t *dxpl_cache,
- hid_t dxpl_id, void *buf/*out*/);
-H5_DLL herr_t H5S_select_write(H5F_t *f, struct H5O_layout_t *layout,
- const H5D_dcpl_cache_t *dcpl_cache, const union H5D_storage_t *store, size_t nelmts, size_t elmt_size,
- const H5S_t *file_space, const H5S_t *mem_space, const H5D_dxpl_cache_t *dxpl_cache,
- hid_t dxpl_id, const void *buf/*out*/);
+H5_DLL herr_t H5S_select_read(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id,
+ H5D_t *dset, const H5D_storage_t *store,
+ size_t nelmts, size_t elmt_size,
+ const H5S_t *file_space, const H5S_t *mem_space,
+ void *buf/*out*/);
+H5_DLL herr_t H5S_select_write(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id,
+ H5D_t *dset, const H5D_storage_t *store,
+ size_t nelmts, size_t elmt_size,
+ const H5S_t *file_space, const H5S_t *mem_space,
+ const void *buf/*out*/);
H5_DLL htri_t H5S_select_valid(const H5S_t *space);
H5_DLL hssize_t H5S_get_select_npoints(const H5S_t *space);
H5_DLL herr_t H5S_get_select_bounds(const H5S_t *space, hssize_t *start, hssize_t *end);
diff --git a/src/H5Sselect.c b/src/H5Sselect.c
index 5f281c5..f2a4cb9 100644
--- a/src/H5Sselect.c
+++ b/src/H5Sselect.c
@@ -1676,10 +1676,9 @@ done:
*-------------------------------------------------------------------------
*/
herr_t
-H5S_select_fscat (H5F_t *f, struct H5O_layout_t *layout,
- const H5D_dcpl_cache_t *dcpl_cache, const H5D_storage_t *store,
- const H5S_t *space, H5S_sel_iter_t *iter,
- hsize_t nelmts, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id,
+H5S_select_fscat (H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id,
+ H5D_t *dset, const H5D_storage_t *store,
+ const H5S_t *space, H5S_sel_iter_t *iter, hsize_t nelmts,
const void *_buf)
{
const uint8_t *buf=_buf; /* Alias for pointer arithmetic */
@@ -1700,7 +1699,7 @@ H5S_select_fscat (H5F_t *f, struct H5O_layout_t *layout,
/* Check args */
assert (f);
- assert (layout);
+ assert (dset);
assert (store);
assert (space);
assert (iter);
@@ -1735,7 +1734,7 @@ H5S_select_fscat (H5F_t *f, struct H5O_layout_t *layout,
mem_off=0;
/* Write sequence list out */
- if (H5F_seq_writevv(f, dxpl_cache, dxpl_id, layout, dcpl_cache, store, nseq, &dset_curr_seq, len, off, 1, &mem_curr_seq, &mem_len, &mem_off, buf)<0)
+ if (H5D_seq_writevv(f, dxpl_cache, dxpl_id, dset, store, nseq, &dset_curr_seq, len, off, 1, &mem_curr_seq, &mem_len, &mem_off, buf)<0)
HGOTO_ERROR(H5E_DATASPACE, H5E_WRITEERROR, FAIL, "write error");
/* Update buffer */
@@ -1780,11 +1779,10 @@ done:
*-------------------------------------------------------------------------
*/
hsize_t
-H5S_select_fgath (H5F_t *f, const struct H5O_layout_t *layout,
- const H5D_dcpl_cache_t *dcpl_cache, const H5D_storage_t *store,
- const H5S_t *space, H5S_sel_iter_t *iter,
- hsize_t nelmts, const H5D_dxpl_cache_t *dxpl_cache,
- hid_t dxpl_id, void *_buf/*out*/)
+H5S_select_fgath (H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id,
+ H5D_t *dset, const H5D_storage_t *store,
+ const H5S_t *space, H5S_sel_iter_t *iter, hsize_t nelmts,
+ void *_buf/*out*/)
{
uint8_t *buf=_buf; /* Alias for pointer arithmetic */
hsize_t _off[H5D_XFER_HYPER_VECTOR_SIZE_DEF]; /* Array to store sequence offsets */
@@ -1804,7 +1802,7 @@ H5S_select_fgath (H5F_t *f, const struct H5O_layout_t *layout,
/* Check args */
assert (f);
- assert (layout);
+ assert (dset);
assert (store);
assert (space);
assert (iter);
@@ -1838,7 +1836,7 @@ H5S_select_fgath (H5F_t *f, const struct H5O_layout_t *layout,
mem_off=0;
/* Read sequence list in */
- if (H5F_seq_readvv(f, dxpl_cache, dxpl_id, layout, dcpl_cache, store, nseq, &dset_curr_seq, len, off, 1, &mem_curr_seq, &mem_len, &mem_off, buf)<0)
+ if (H5D_seq_readvv(f, dxpl_cache, dxpl_id, dset, store, nseq, &dset_curr_seq, len, off, 1, &mem_curr_seq, &mem_len, &mem_off, buf)<0)
HGOTO_ERROR(H5E_DATASPACE, H5E_READERROR, 0, "read error");
/* Update buffer */
@@ -2058,10 +2056,10 @@ done:
*-------------------------------------------------------------------------
*/
herr_t
-H5S_select_read(H5F_t *f, const H5O_layout_t *layout, const H5D_dcpl_cache_t *dcpl_cache,
- const H5D_storage_t *store, size_t nelmts, size_t elmt_size,
+H5S_select_read(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id,
+ H5D_t *dset, const H5D_storage_t *store,
+ size_t nelmts, size_t elmt_size,
const H5S_t *file_space, const H5S_t *mem_space,
- const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id,
void *buf/*out*/)
{
H5S_sel_iter_t mem_iter; /* Memory selection iteration info */
@@ -2154,7 +2152,7 @@ HDfprintf(stderr,"%s: file_off[%Zu]=%Hu, file_len[%Zu]=%Zu\n",FUNC,curr_file_seq
HDfprintf(stderr,"%s: mem_off[%Zu]=%Hu, mem_len[%Zu]=%Zu\n",FUNC,curr_mem_seq,mem_off[curr_mem_seq],curr_mem_seq,mem_len[curr_mem_seq]);
#endif /* QAK */
/* Read file sequences into current memory sequence */
- if ((tmp_file_len=H5F_seq_readvv(f, dxpl_cache, dxpl_id, layout, dcpl_cache, store,
+ if ((tmp_file_len=H5D_seq_readvv(f, dxpl_cache, dxpl_id, dset, store,
file_nseq, &curr_file_seq, file_len, file_off,
mem_nseq, &curr_mem_seq, mem_len, mem_off,
buf))<0)
@@ -2208,10 +2206,10 @@ done:
*-------------------------------------------------------------------------
*/
herr_t
-H5S_select_write(H5F_t *f, H5O_layout_t *layout, const H5D_dcpl_cache_t *dcpl_cache,
- const H5D_storage_t *store, size_t nelmts, size_t elmt_size,
+H5S_select_write(H5F_t *f, const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id,
+ H5D_t *dset, const H5D_storage_t *store,
+ size_t nelmts, size_t elmt_size,
const H5S_t *file_space, const H5S_t *mem_space,
- const H5D_dxpl_cache_t *dxpl_cache, hid_t dxpl_id,
const void *buf/*out*/)
{
H5S_sel_iter_t mem_iter; /* Memory selection iteration info */
@@ -2346,7 +2344,7 @@ for(u=curr_mem_seq; u<mem_nseq; u++)
}
#endif /* QAK */
/* Write memory sequences into file sequences */
- if ((tmp_file_len=H5F_seq_writevv(f, dxpl_cache, dxpl_id, layout, dcpl_cache, store,
+ if ((tmp_file_len=H5D_seq_writevv(f, dxpl_cache, dxpl_id, dset, store,
file_nseq, &curr_file_seq, file_len, file_off,
mem_nseq, &curr_mem_seq, mem_len, mem_off,
buf))<0)
generated by cgit v0.12 at 2024-12-11 19:46:00 (GMT)