[svn-r17236] Description:

	Add full support for any [single] dimension being unlimited when using
extensible arrays as a chunk index.

Tested on:
        FreeBSD/32 6.3 (duty) in debug mode
        FreeBSD/64 6.3 (liberty) w/C++ & FORTRAN, in debug mode
        Linux/32 2.6 (jam) w/PGI compilers, w/C++ & FORTRAN, w/threadsafe,
                                in debug mode
        Linux/64-amd64 2.6 (smirom) w/Intel compilers w/default API=1.6.x,
                                w/C++ & FORTRAN, in production mode
        Solaris/32 2.10 (linew) w/deprecated symbols disabled, w/C++ & FORTRAN,
                                w/szip filter, in production mode
        Linux/64-ia64 2.6 (cobalt) w/Intel compilers, w/C++ & FORTRAN,
                                in production mode
        Linux/64-ia64 2.4 (tg-login3) w/parallel, w/FORTRAN, in debug mode
        Linux/64-amd64 2.6 (abe) w/parallel, w/FORTRAN, in production mode
        Mac OS X/32 10.5.7 (amazon) in debug mode
        Mac OS X/32 10.5.7 (amazon) w/C++ & FORTRAN, w/threadsafe,
                                in production mode

6 files changed, 244 insertions, 25 deletions

diff --git a/src/H5Dchunk.c b/src/H5Dchunk.c
index 794d678..f0c720e 100644
--- a/src/H5Dchunk.c
+++ b/src/H5Dchunk.c
@@ -513,7 +513,7 @@ H5D_chunk_init(H5F_t *f, hid_t dxpl_id, const H5D_t *dset, hid_t dapl_id)
     if(dset->shared->layout.u.chunk.ops->init && (dset->shared->layout.u.chunk.ops->init)(&idx_info, dset->shared->space, dset->oloc.addr) < 0)
 	HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "can't initialize indexing information")
 
-    /* Set the number of chunks in dataset */
+    /* Set the number of chunks in dataset, etc. */
     if(H5D_chunk_set_info(dset) < 0)
         HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to set # of chunks for dataset")
 
diff --git a/src/H5Dearray.c b/src/H5Dearray.c
index f859c1c..76e0775 100644
--- a/src/H5Dearray.c
+++ b/src/H5Dearray.c
@@ -122,6 +122,7 @@ static herr_t H5D_earray_idx_insert(const H5D_chk_idx_info_t *idx_info,
     H5D_chunk_ud_t *udata);
 static herr_t H5D_earray_idx_get_addr(const H5D_chk_idx_info_t *idx_info,
     H5D_chunk_ud_t *udata);
+static herr_t H5D_earray_idx_resize(H5O_layout_t *layout);
 static int H5D_earray_idx_iterate(const H5D_chk_idx_info_t *idx_info,
     H5D_chunk_cb_func_t chunk_cb, void *chunk_udata);
 static herr_t H5D_earray_idx_remove(const H5D_chk_idx_info_t *idx_info,
@@ -155,7 +156,7 @@ const H5D_chunk_ops_t H5D_COPS_EARRAY[1] = {{
     H5D_earray_idx_is_space_alloc,
     H5D_earray_idx_insert,
     H5D_earray_idx_get_addr,
-    NULL,
+    H5D_earray_idx_resize,
     H5D_earray_idx_iterate,
     H5D_earray_idx_remove,
     H5D_earray_idx_delete,
@@ -780,7 +781,14 @@ static herr_t
 H5D_earray_idx_init(const H5D_chk_idx_info_t *idx_info, const H5S_t *space,
     haddr_t dset_ohdr_addr)
 {
-    FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5D_earray_idx_init)
+    hsize_t max_dims[H5O_LAYOUT_NDIMS];    /* Max. size of dataset dimensions */
+    int unlim_dim;              /* Rank of the dataset's unlimited dimension */
+    int sndims;                 /* Rank of dataspace */
+    unsigned ndims;             /* Rank of dataspace */
+    unsigned u;                 /* Local index variable */
+    herr_t ret_value = SUCCEED; /* Return value */
+
+    FUNC_ENTER_NOAPI_NOINIT(H5D_earray_idx_init)
 
     /* Check args */
     HDassert(idx_info);
@@ -790,10 +798,37 @@ H5D_earray_idx_init(const H5D_chk_idx_info_t *idx_info, const H5S_t *space,
     HDassert(space);
     HDassert(H5F_addr_defined(dset_ohdr_addr));
 
+    /* Get the dim info for dataset */
+    if((sndims = H5S_get_simple_extent_dims(space, NULL, max_dims)) < 0)
+	HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't get dataspace dimensions")
+    H5_ASSIGN_OVERFLOW(ndims, sndims, int, unsigned);
+
+    /* Find the rank of the unlimited dimension */
+    unlim_dim = (-1);
+    for(u = 0; u < ndims; u++) {
+        /* Check for unlimited dimension */
+        if(H5S_UNLIMITED == max_dims[u]) {
+            /* Check if we've already found an unlimited dimension */
+            if(unlim_dim >= 0)
+                HGOTO_ERROR(H5E_DATASET, H5E_ALREADYINIT, FAIL, "already found unlimited dimension")
+
+            /* Set the unlimited dimension */
+            unlim_dim = (int)u;
+        } /* end if */
+    } /* end for */
+
+    /* Check if we didn't find an unlimited dimension */
+    if(unlim_dim < 0)
+        HGOTO_ERROR(H5E_DATASET, H5E_UNINITIALIZED, FAIL, "didn't find unlimited dimension")
+
+    /* Set the unlimited dimension for the layout's future use */
+    idx_info->layout->u.chunk.u.earray.unlim_dim = (unsigned)unlim_dim;
+
     /* Store the dataset's object header address for later */
     idx_info->layout->u.chunk.u.earray.dset_ohdr_addr = dset_ohdr_addr;
 
-    FUNC_LEAVE_NOAPI(SUCCEED)
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5D_earray_idx_init() */
 
 
@@ -947,9 +982,24 @@ H5D_earray_idx_insert(const H5D_chk_idx_info_t *idx_info, H5D_chunk_ud_t *udata)
     /* Set convenience pointer to extensible array structure */
     ea = idx_info->layout->u.chunk.u.earray.ea;
 
-    /* Calculate the index of this chunk */
-    if(H5V_chunk_index((idx_info->layout->u.chunk.ndims - 1), udata->common.offset, idx_info->layout->u.chunk.dim, idx_info->layout->u.chunk.down_chunks, &idx) < 0)
-	HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "can't get chunk index")
+    /* Check for unlimited dim. not being the slowest-changing dim. */
+    if(idx_info->layout->u.chunk.u.earray.unlim_dim > 0) {
+        hsize_t swizzled_coords[H5O_LAYOUT_NDIMS];	/* swizzled chunk coordinates */
+        unsigned ndims = (idx_info->layout->u.chunk.ndims - 1); /* Number of dimensions */
+
+        /* Set up the swizzled chunk coordinates */
+        HDmemcpy(swizzled_coords, udata->common.offset, ndims * sizeof(udata->common.offset[0]));
+        H5V_swizzle_coords(swizzled_coords, idx_info->layout->u.chunk.u.earray.unlim_dim);
+
+        /* Calculate the index of this chunk */
+        if(H5V_chunk_index(ndims, swizzled_coords, idx_info->layout->u.chunk.dim, idx_info->layout->u.chunk.u.earray.swizzled_down_chunks, &idx) < 0)
+            HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "can't get chunk index")
+    } /* end if */
+    else {
+        /* Calculate the index of this chunk */
+        if(H5V_chunk_index((idx_info->layout->u.chunk.ndims - 1), udata->common.offset, idx_info->layout->u.chunk.dim, idx_info->layout->u.chunk.down_chunks, &idx) < 0)
+            HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "can't get chunk index")
+    } /* end else */
 
     /* Check for filters on chunks */
     if(idx_info->pline->nused > 0) {
@@ -1092,9 +1142,24 @@ H5D_earray_idx_get_addr(const H5D_chk_idx_info_t *idx_info, H5D_chunk_ud_t *udat
     /* Set convenience pointer to extensible array structure */
     ea = idx_info->layout->u.chunk.u.earray.ea;
 
-    /* Calculate the index of this chunk */
-    if(H5V_chunk_index((idx_info->layout->u.chunk.ndims - 1), udata->common.offset, idx_info->layout->u.chunk.dim, idx_info->layout->u.chunk.down_chunks, &idx) < 0)
-	HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "can't get chunk index")
+    /* Check for unlimited dim. not being the slowest-changing dim. */
+    if(idx_info->layout->u.chunk.u.earray.unlim_dim > 0) {
+        hsize_t swizzled_coords[H5O_LAYOUT_NDIMS];	/* swizzled chunk coordinates */
+        unsigned ndims = (idx_info->layout->u.chunk.ndims - 1); /* Number of dimensions */
+
+        /* Set up the swizzled chunk coordinates */
+        HDmemcpy(swizzled_coords, udata->common.offset, ndims * sizeof(udata->common.offset[0]));
+        H5V_swizzle_coords(swizzled_coords, idx_info->layout->u.chunk.u.earray.unlim_dim);
+
+        /* Calculate the index of this chunk */
+        if(H5V_chunk_index(ndims, swizzled_coords, idx_info->layout->u.chunk.dim, idx_info->layout->u.chunk.u.earray.swizzled_down_chunks, &idx) < 0)
+            HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "can't get chunk index")
+    } /* end if */
+    else {
+        /* Calculate the index of this chunk */
+        if(H5V_chunk_index((idx_info->layout->u.chunk.ndims - 1), udata->common.offset, idx_info->layout->u.chunk.dim, idx_info->layout->u.chunk.down_chunks, &idx) < 0)
+            HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "can't get chunk index")
+    } /* end else */
 
     /* Check for filters on chunks */
     if(idx_info->pline->nused > 0) {
@@ -1125,6 +1190,46 @@ done:
 
 
 /*-------------------------------------------------------------------------
+ * Function:	H5D_earray_idx_resize
+ *
+ * Purpose:	Calculate/setup the swizzled down chunk array, used for chunk
+ *              index calculations.
+ *
+ * Return:	Non-negative on success/Negative on failure
+ *
+ * Programmer:	Quincey Koziol
+ *              Thursday, July 23, 2009
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5D_earray_idx_resize(H5O_layout_t *layout)
+{
+    herr_t ret_value = SUCCEED; /* Return value */
+
+    FUNC_ENTER_NOAPI_NOINIT(H5D_earray_idx_resize)
+
+    /* Check args */
+    HDassert(layout);
+
+    /* Set up the swizzled "down" chunk information */
+    if(layout->u.chunk.u.earray.unlim_dim > 0) {
+        hsize_t swizzled_chunks[H5O_LAYOUT_NDIMS];    /* Swizzled form of # of chunks in each dimension */
+
+        HDmemcpy(swizzled_chunks, layout->u.chunk.chunks, (layout->u.chunk.ndims - 1) * sizeof(swizzled_chunks[0]));
+        H5V_swizzle_coords(swizzled_chunks, layout->u.chunk.u.earray.unlim_dim);
+
+        /* Get the swizzled "down" sizes for each dimension */
+        if(H5V_array_down((layout->u.chunk.ndims - 1), swizzled_chunks, layout->u.chunk.u.earray.swizzled_down_chunks) < 0)
+            HGOTO_ERROR(H5E_DATASET, H5E_CANTSET, FAIL, "can't compute swizzled 'down' chunk size value")
+    } /* end if */
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* end H5D_earray_idx_resize() */
+
+
+/*-------------------------------------------------------------------------
  * Function:	H5D_earray_idx_iterate
  *
  * Purpose:	Iterate over the chunks in an index, making a callback
@@ -1276,9 +1381,24 @@ H5D_earray_idx_remove(const H5D_chk_idx_info_t *idx_info, H5D_chunk_common_ud_t
     /* Set convenience pointer to extensible array structure */
     ea = idx_info->layout->u.chunk.u.earray.ea;
 
-    /* Calculate the index of this chunk */
-    if(H5V_chunk_index((idx_info->layout->u.chunk.ndims - 1), udata->offset, idx_info->layout->u.chunk.dim, idx_info->layout->u.chunk.down_chunks, &idx) < 0)
-	HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "can't get chunk index")
+    /* Check for unlimited dim. not being the slowest-changing dim. */
+    if(idx_info->layout->u.chunk.u.earray.unlim_dim > 0) {
+        hsize_t swizzled_coords[H5O_LAYOUT_NDIMS];	/* swizzled chunk coordinates */
+        unsigned ndims = (idx_info->layout->u.chunk.ndims - 1); /* Number of dimensions */
+
+        /* Set up the swizzled chunk coordinates */
+        HDmemcpy(swizzled_coords, udata->offset, ndims * sizeof(udata->offset[0]));
+        H5V_swizzle_coords(swizzled_coords, idx_info->layout->u.chunk.u.earray.unlim_dim);
+
+        /* Calculate the index of this chunk */
+        if(H5V_chunk_index(ndims, swizzled_coords, idx_info->layout->u.chunk.dim, idx_info->layout->u.chunk.u.earray.swizzled_down_chunks, &idx) < 0)
+            HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "can't get chunk index")
+    } /* end if */
+    else {
+        /* Calculate the index of this chunk */
+        if(H5V_chunk_index((idx_info->layout->u.chunk.ndims - 1), udata->offset, idx_info->layout->u.chunk.dim, idx_info->layout->u.chunk.down_chunks, &idx) < 0)
+            HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "can't get chunk index")
+    } /* end else */
 
     /* Check for filters on chunks */
     if(idx_info->pline->nused > 0) {
@@ -1640,9 +1760,24 @@ H5D_earray_idx_support(const H5D_chk_idx_info_t *idx_info,
     /* Set convenience pointer to extensible array structure */
     ea = idx_info->layout->u.chunk.u.earray.ea;
 
-    /* Calculate the index of this chunk */
-    if(H5V_chunk_index((idx_info->layout->u.chunk.ndims - 1), udata->offset, idx_info->layout->u.chunk.dim, idx_info->layout->u.chunk.down_chunks, &idx) < 0)
-	HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "can't get chunk index")
+    /* Check for unlimited dim. not being the slowest-changing dim. */
+    if(idx_info->layout->u.chunk.u.earray.unlim_dim > 0) {
+        hsize_t swizzled_coords[H5O_LAYOUT_NDIMS];	/* swizzled chunk coordinates */
+        unsigned ndims = (idx_info->layout->u.chunk.ndims - 1); /* Number of dimensions */
+
+        /* Set up the swizzled chunk coordinates */
+        HDmemcpy(swizzled_coords, udata->offset, ndims * sizeof(udata->offset[0]));
+        H5V_swizzle_coords(swizzled_coords, idx_info->layout->u.chunk.u.earray.unlim_dim);
+
+        /* Calculate the index of this chunk */
+        if(H5V_chunk_index(ndims, swizzled_coords, idx_info->layout->u.chunk.dim, idx_info->layout->u.chunk.u.earray.swizzled_down_chunks, &idx) < 0)
+            HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "can't get chunk index")
+    } /* end if */
+    else {
+        /* Calculate the index of this chunk */
+        if(H5V_chunk_index((idx_info->layout->u.chunk.ndims - 1), udata->offset, idx_info->layout->u.chunk.dim, idx_info->layout->u.chunk.down_chunks, &idx) < 0)
+            HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "can't get chunk index")
+    } /* end else */
 
     /* Create flush dependency between the child_entry and the piece of metadata
      *  in the extensible array that contains the entry for this chunk.
@@ -1693,9 +1828,24 @@ H5D_earray_idx_unsupport(const H5D_chk_idx_info_t *idx_info,
     /* Set convenience pointer to extensible array structure */
     ea = idx_info->layout->u.chunk.u.earray.ea;
 
-    /* Calculate the index of this chunk */
-    if(H5V_chunk_index((idx_info->layout->u.chunk.ndims - 1), udata->offset, idx_info->layout->u.chunk.dim, idx_info->layout->u.chunk.down_chunks, &idx) < 0)
-	HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "can't get chunk index")
+    /* Check for unlimited dim. not being the slowest-changing dim. */
+    if(idx_info->layout->u.chunk.u.earray.unlim_dim > 0) {
+        hsize_t swizzled_coords[H5O_LAYOUT_NDIMS];	/* swizzled chunk coordinates */
+        unsigned ndims = (idx_info->layout->u.chunk.ndims - 1); /* Number of dimensions */
+
+        /* Set up the swizzled chunk coordinates */
+        HDmemcpy(swizzled_coords, udata->offset, ndims * sizeof(udata->offset[0]));
+        H5V_swizzle_coords(swizzled_coords, idx_info->layout->u.chunk.u.earray.unlim_dim);
+
+        /* Calculate the index of this chunk */
+        if(H5V_chunk_index(ndims, swizzled_coords, idx_info->layout->u.chunk.dim, idx_info->layout->u.chunk.u.earray.swizzled_down_chunks, &idx) < 0)
+            HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "can't get chunk index")
+    } /* end if */
+    else {
+        /* Calculate the index of this chunk */
+        if(H5V_chunk_index((idx_info->layout->u.chunk.ndims - 1), udata->offset, idx_info->layout->u.chunk.dim, idx_info->layout->u.chunk.down_chunks, &idx) < 0)
+            HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "can't get chunk index")
+    } /* end else */
 
     /* Remove flush dependency between the child_entry and the piece of metadata
      *  in the extensible array that contains the entry for this chunk.
diff --git a/src/H5Olayout.c b/src/H5Olayout.c
index 1c7f3f7..96cb9b9 100644
--- a/src/H5Olayout.c
+++ b/src/H5Olayout.c
@@ -1027,12 +1027,8 @@ H5O_layout_set_latest_version(H5O_layout_t *layout, const H5S_t *space)
 
         /* If we have only 1 unlimited dimension, we can use extensible array index */
         if(1 == unlim_count) {
-            /* Check for slowest changing dimension being unlimited */
-            /* (non-slowest-changing dim. not supported yet) */
-            if(max_dims[0] == H5S_UNLIMITED) {
-                /* Set the chunk index type */
-                layout->u.chunk.idx_type = H5D_CHUNK_IDX_EARRAY;
-            } /* end if */
+            /* Set the chunk index type */
+            layout->u.chunk.idx_type = H5D_CHUNK_IDX_EARRAY;
         } /* end if */
         /* Chunked datasets with fixed dimensions */
         else if(layout->type == H5D_CHUNKED && fixed) {
diff --git a/src/H5Oprivate.h b/src/H5Oprivate.h
index c2b7cca..408a490 100644
--- a/src/H5Oprivate.h
+++ b/src/H5Oprivate.h
@@ -368,6 +368,8 @@ struct H5EA_t;                          /* Defined in H5EAprivate.h          */
 typedef struct H5O_layout_chunk_earray_t {
     haddr_t	addr;			/* File address of extensible array  */
     haddr_t	dset_ohdr_addr;		/* File address dataset's object header */
+    unsigned    unlim_dim;              /* Rank of unlimited dimension for dataset */
+    hsize_t    	swizzled_down_chunks[H5O_LAYOUT_NDIMS];	/* swizzled "down" size of number of chunks in each dimension */
     struct H5EA_t *ea;                  /* Pointer to extensible array struct */
 } H5O_layout_chunk_earray_t;
 
diff --git a/src/H5V.c b/src/H5V.c
index 48fa9ab..1efe497 100644
--- a/src/H5V.c
+++ b/src/H5V.c
@@ -1287,6 +1287,75 @@ H5V_chunk_index(unsigned ndims, const hsize_t *coord, const uint32_t *chunk,
 
 
 /*-------------------------------------------------------------------------
+ * Function:	H5V_swizzle_coords
+ *
+ * Purpose:	Given a coordinate offset array (COORDS), move the unlimited
+ *		dimension (UNLIM_DIM) value to offset 0, sliding any
+ *		intermediate values down one position.
+ *
+ * Return:	None
+ *
+ * Programmer:	Quincey Koziol
+ *		Tuesday, July 21, 2009
+ *
+ *-------------------------------------------------------------------------
+ */
+void
+H5V_swizzle_coords(hsize_t *coords, unsigned unlim_dim)
+{
+    FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5V_swizzle_coords)
+
+    /* Sanity check */
+    HDassert(coords);
+
+    /* Nothing to do when unlimited dimension is at position 0 */
+    if(0 != unlim_dim) {
+        hsize_t tmp = coords[unlim_dim];
+
+        HDmemmove(&coords[1], &coords[0], sizeof(coords[0]) * unlim_dim);
+        coords[0] = tmp;
+    } /* end if */
+
+    FUNC_LEAVE_NOAPI_VOID
+} /* end H5V_swizzle_coords() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5V_unswizzle_coords
+ *
+ * Purpose:	Given a coordinate offset array (COORDS), move the value at
+ *		offset 0 to offset of the unlimied dimension (UNLIM_DIM),
+ *		sliding any intermediate values up one position.  Undoes the
+ *		"swizzle_coords" operation.
+ *
+ * Return:	None
+ *
+ * Programmer:	Quincey Koziol
+ *		Tuesday, July 21, 2009
+ *
+ *-------------------------------------------------------------------------
+ */
+void
+H5V_unswizzle_coords(hsize_t *coords, unsigned unlim_dim)
+{
+    FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5V_unswizzle_coords)
+
+    /* Sanity check */
+    HDassert(coords);
+
+    /* Nothing to do when unlimited dimension is at position 0 */
+    if(0 != unlim_dim) {
+        hsize_t tmp = coords[0];
+
+        HDmemmove(&coords[0], &coords[1], sizeof(coords[0]) * unlim_dim);
+        coords[unlim_dim] = tmp;
+    } /* end if */
+
+    FUNC_LEAVE_NOAPI_VOID
+} /* end H5V_unswizzle_coords() */
+
+
+/*-------------------------------------------------------------------------
  * Function:	H5V_memcpyvv
  *
  * Purpose:	Given source and destination buffers in memory (SRC & DST)
diff --git a/src/H5Vprivate.h b/src/H5Vprivate.h
index e351f86..faa2505 100644
--- a/src/H5Vprivate.h
+++ b/src/H5Vprivate.h
@@ -89,6 +89,8 @@ H5_DLL herr_t H5V_array_calc(hsize_t offset, unsigned n,
     const hsize_t *total_size, hsize_t *coords);
 H5_DLL herr_t H5V_chunk_index(unsigned ndims, const hsize_t *coord,
     const uint32_t *chunk, const hsize_t *down_nchunks, hsize_t *chunk_idx);
+H5_DLL void H5V_swizzle_coords(hsize_t *coords, unsigned unlim_dim);
+H5_DLL void H5V_unswizzle_coords(hsize_t *coords, unsigned unlim_dim);
 H5_DLL ssize_t H5V_memcpyvv(void *_dst,
     size_t dst_max_nseq, size_t *dst_curr_seq, size_t dst_len_arr[], hsize_t dst_off_arr[],
     const void *_src,