[svn-r26993] Description:

    Align w/incoming chunk performance changes, including some small performance
improvements here, as well as a few minor general code cleanups.

Tested on:
    Mac OSX/64 10.10.3 (amazon) w/serial & parallel
    (Too minor to require h5committest)

5 files changed, 100 insertions, 45 deletions

diff --git a/src/H5Dchunk.c b/src/H5Dchunk.c
index 6c7c5d5..033a97c 100644
--- a/src/H5Dchunk.c
+++ b/src/H5Dchunk.c
@@ -337,9 +337,7 @@ H5D__chunk_direct_write(const H5D_t *dset, hid_t dxpl_id, uint32_t filters, hsiz
             HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to initialize storage")
 
     /* Calculate the index of this chunk */
-    if(H5VM_chunk_index(dset->shared->ndims, offset,
-            layout->u.chunk.dim, layout->u.chunk.down_chunks, &chunk_idx) < 0)
-        HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "can't get chunk index")
+    chunk_idx = H5VM_chunk_index(dset->shared->ndims, offset, layout->u.chunk.dim, layout->u.chunk.down_chunks);
 
     /* Find out the file address of the chunk (if any) */
     if(H5D__chunk_lookup(dset, dxpl_id, offset, chunk_idx, &udata) < 0)
@@ -1156,8 +1154,7 @@ H5D__create_chunk_map_single(H5D_chunk_map_t *fm, const H5D_io_info_t
     chunk_info->coords[fm->f_ndims] = 0;
 
     /* Calculate the index of this chunk */
-    if(H5VM_chunk_index(fm->f_ndims, chunk_info->coords, fm->layout->u.chunk.dim, fm->layout->u.chunk.down_chunks, &chunk_info->index) < 0)
-        HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "can't get chunk index")
+    chunk_info->index = H5VM_chunk_index(fm->f_ndims, chunk_info->coords, fm->layout->u.chunk.dim, fm->layout->u.chunk.down_chunks);
 
     /* Copy selection for file's dataspace into chunk dataspace */
     if(H5S_select_copy(fm->single_space, fm->file_space, FALSE) < 0)
@@ -1215,7 +1212,7 @@ H5D__create_chunk_file_map_hyper(H5D_chunk_map_t *fm, const H5D_io_info_t
     hsize_t     sel_points;                 /* Number of elements in file selection */
     hsize_t     start_coords[H5O_LAYOUT_NDIMS];   /* Starting coordinates of selection */
     hsize_t     coords[H5O_LAYOUT_NDIMS];   /* Current coordinates of chunk */
-    hsize_t     end[H5O_LAYOUT_NDIMS];      /* Current coordinates of chunk */
+    hsize_t     end[H5O_LAYOUT_NDIMS];      /* Final coordinates of chunk */
     hsize_t     chunk_index;                /* Index of chunk */
     int         curr_dim;                   /* Current dimension to increment */
     unsigned    u;                          /* Local index variable */
@@ -1241,8 +1238,7 @@ H5D__create_chunk_file_map_hyper(H5D_chunk_map_t *fm, const H5D_io_info_t
     } /* end for */
 
     /* Calculate the index of this chunk */
-    if(H5VM_chunk_index(fm->f_ndims, coords, fm->layout->u.chunk.dim, fm->layout->u.chunk.down_chunks, &chunk_index) < 0)
-        HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "can't get chunk index")
+    chunk_index = H5VM_chunk_index(fm->f_ndims, coords, fm->layout->u.chunk.dim, fm->layout->u.chunk.down_chunks);
 
     /* Iterate through each chunk in the dataset */
     while(sel_points) {
@@ -1358,8 +1354,7 @@ H5D__create_chunk_file_map_hyper(H5D_chunk_map_t *fm, const H5D_io_info_t
             } while(coords[curr_dim] > sel_end[curr_dim]);
 
             /* Re-calculate the index of this chunk */
-            if(H5VM_chunk_index(fm->f_ndims, coords, fm->layout->u.chunk.dim, fm->layout->u.chunk.down_chunks, &chunk_index) < 0)
-                HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "can't get chunk index")
+            chunk_index = H5VM_chunk_index(fm->f_ndims, coords, fm->layout->u.chunk.dim, fm->layout->u.chunk.down_chunks);
         } /* end if */
     } /* end while */
 
@@ -1501,14 +1496,14 @@ H5D__chunk_file_cb(void UNUSED *elem, hid_t UNUSED type_id, unsigned ndims, cons
     H5D_chunk_info_t *chunk_info;               /* Chunk information for current chunk */
     hsize_t     coords_in_chunk[H5O_LAYOUT_NDIMS];        /* Coordinates of element in chunk */
     hsize_t     chunk_index;                    /* Chunk index */
+    hsize_t     scaled[H5S_MAX_RANK];	        /* Scaled coordinates for this chunk */
     unsigned    u;                              /* Local index variable */
     herr_t	ret_value = SUCCEED;            /* Return value		*/
 
     FUNC_ENTER_STATIC
 
     /* Calculate the index of this chunk */
-    if(H5VM_chunk_index(ndims, coords, fm->layout->u.chunk.dim, fm->layout->u.chunk.down_chunks, &chunk_index) < 0)
-        HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "can't get chunk index")
+    chunk_index = H5VM_chunk_index_scaled(ndims, coords, fm->layout->u.chunk.dim, fm->layout->u.chunk.down_chunks, scaled);
 
     /* Find correct chunk in file & memory skip list */
     if(chunk_index==fm->last_index) {
@@ -1561,7 +1556,7 @@ H5D__chunk_file_cb(void UNUSED *elem, hid_t UNUSED type_id, unsigned ndims, cons
             /* Compute the chunk's coordinates */
             for(u = 0; u < fm->f_ndims; u++) {
                 H5_CHECK_OVERFLOW(fm->layout->u.chunk.dim[u], hsize_t, hssize_t);
-                chunk_info->coords[u] = (coords[u] / (hssize_t)fm->layout->u.chunk.dim[u]) * (hssize_t)fm->layout->u.chunk.dim[u];
+                chunk_info->coords[u] = scaled[u] * (hssize_t)fm->layout->u.chunk.dim[u];
             } /* end for */
             chunk_info->coords[fm->f_ndims] = 0;
 
@@ -1625,8 +1620,7 @@ H5D__chunk_mem_cb(void UNUSED *elem, hid_t UNUSED type_id, unsigned ndims, const
     FUNC_ENTER_STATIC
 
     /* Calculate the index of this chunk */
-    if(H5VM_chunk_index(ndims, coords, fm->layout->u.chunk.dim, fm->layout->u.chunk.down_chunks, &chunk_index) < 0)
-        HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "can't get chunk index")
+    chunk_index = H5VM_chunk_index(ndims, coords, fm->layout->u.chunk.dim, fm->layout->u.chunk.down_chunks);
 
     /* Find correct chunk in file & memory skip list */
     if(chunk_index == fm->last_index) {
@@ -1968,8 +1962,7 @@ H5D__chunk_write(H5D_io_info_t *io_info, const H5D_type_info_t *type_info,
         /* Get the actual chunk information from the skip list node */
         chunk_info = H5D_CHUNK_GET_NODE_INFO(fm, chunk_node);
 
-        /* Load the chunk into cache.  But if the whole chunk is written,
-         * simply allocate space instead of load the chunk. */
+        /* Look up the chunk */
         if(H5D__chunk_lookup(io_info->dset, io_info->dxpl_id, chunk_info->coords, chunk_info->index, &udata) < 0)
             HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "error looking up chunk address")
 
@@ -1977,9 +1970,12 @@ H5D__chunk_write(H5D_io_info_t *io_info, const H5D_type_info_t *type_info,
         HDassert((H5F_addr_defined(udata.chunk_block.offset) && udata.chunk_block.length > 0) || 
                 (!H5F_addr_defined(udata.chunk_block.offset) && udata.chunk_block.length == 0));
 
+        /* Determine if we should use the chunk cache */
         if((cacheable = H5D__chunk_cacheable(io_info, udata.chunk_block.offset, TRUE)) < 0)
             HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't tell if chunk is cacheable")
         if(cacheable) {
+            /* Load the chunk into cache.  But if the whole chunk is written,
+             * simply allocate space instead of load the chunk. */
             hbool_t entire_chunk = TRUE;       /* Whether whole chunk is selected */
 
             /* Pass in chunk's coordinates in a union. */
@@ -2409,7 +2405,7 @@ H5D__chunk_lookup(const H5D_t *dset, hid_t dxpl_id, const hsize_t *chunk_offset,
         ent = dset->shared->cache.chunk.slot[udata->idx_hint];
 
         if(ent)
-            for(u = 0, found = TRUE; u < dset->shared->layout.u.chunk.ndims - 1; u++)
+            for(u = 0, found = TRUE; u < dset->shared->ndims; u++)
                 if(chunk_offset[u] != ent->offset[u]) {
                     found = FALSE;
                     break;
@@ -3432,12 +3428,8 @@ H5D__chunk_allocate(const H5D_t *dset, hid_t dxpl_id, hbool_t full_overwrite,
             {
                 hsize_t chunk_idx;
 
-                /* Calculate the index of this chunk */
-                if(H5VM_chunk_index(space_ndims, chunk_offset,
-                        layout->u.chunk.dim, layout->u.chunk.down_chunks,
-                        &chunk_idx) < 0)
-                    HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "can't get chunk index")
-
+                /* Look up this chunk */
+                chunk_idx = H5VM_chunk_index(space_ndims, chunk_offset, layout->u.chunk.dim, layout->u.chunk.down_chunks);
                 if(H5D__chunk_lookup(dset, dxpl_id, chunk_offset, chunk_idx, &udata) < 0)
                     HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "error looking up chunk address")
 
@@ -4170,10 +4162,7 @@ H5D__chunk_prune_by_extent(H5D_t *dset, hid_t dxpl_id, const hsize_t *old_dim)
             int i;	                        /* Local index variable */
 
             /* Calculate the index of this chunk */
-            if(H5VM_chunk_index(space_ndims, chunk_offset,
-                    layout->u.chunk.dim, layout->u.chunk.down_chunks,
-                    &(chk_io_info.store->chunk.index)) < 0)
-                HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "can't get chunk index")
+            chk_io_info.store->chunk.index = H5VM_chunk_index(space_ndims, chunk_offset, layout->u.chunk.dim, layout->u.chunk.down_chunks);
 
             if(0 == ndims_outside_fill) {
                 HDassert(fill_dim[op_dim]);
@@ -4306,8 +4295,7 @@ H5D__chunk_addrmap_cb(const H5D_chunk_rec_t *chunk_rec, void *_udata)
     FUNC_ENTER_STATIC
 
     /* Compute the index for this chunk */
-    if(H5VM_chunk_index(rank, chunk_rec->offset, udata->common.layout->dim, udata->common.layout->down_chunks, &chunk_index) < 0)
-       HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, H5_ITER_ERROR, "can't get chunk index")
+    chunk_index = H5VM_chunk_index(rank, chunk_rec->offset, udata->common.layout->dim, udata->common.layout->down_chunks);
 
     /* Set it in the userdata to return */
     udata->chunk_addr[chunk_index] = chunk_rec->chunk_addr;
@@ -4497,8 +4485,7 @@ H5D__chunk_update_cache(H5D_t *dset, hid_t dxpl_id)
         next = ent->next;
 
         /* Calculate the index of this chunk */
-        if(H5VM_chunk_index(rank, ent->offset, dset->shared->layout.u.chunk.dim, dset->shared->layout.u.chunk.down_chunks, &idx) < 0)
-            HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "can't get chunk index")
+        idx = H5VM_chunk_index(rank, ent->offset, dset->shared->layout.u.chunk.dim, dset->shared->layout.u.chunk.down_chunks);
 
         /* Compute the index for the chunk entry */
         old_idx = ent->idx;   /* Save for later */
diff --git a/src/H5Dint.c b/src/H5Dint.c
index c626475..23824e3 100644
--- a/src/H5Dint.c
+++ b/src/H5Dint.c
@@ -682,7 +682,6 @@ static herr_t
 H5D__cache_dataspace_info(const H5D_t *dset)
 {
     int sndims;                         /* Signed number of dimensions of dataspace rank */
-    unsigned u;                         /* Local index value */
     herr_t ret_value = SUCCEED;         /* Return value */
 
     FUNC_ENTER_STATIC
@@ -2261,7 +2260,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->shared->layout.type) {
-            /* Update the cached chunk info */
+            /* Set the cached chunk info */
             if(H5D__chunk_set_info(dset) < 0)
                 HGOTO_ERROR(H5E_DATASET, H5E_CANTSET, FAIL, "unable to update # of chunks")
             if(H5D__chunk_update_cache(dset, dxpl_id) < 0)
diff --git a/src/H5Dpkg.h b/src/H5Dpkg.h
index 769fec1..53c9780 100644
--- a/src/H5Dpkg.h
+++ b/src/H5Dpkg.h
@@ -388,7 +388,7 @@ typedef struct H5D_rdcc_t {
     struct H5D_rdcc_ent_t **slot; /* Chunk slots, each points to a chunk*/
     H5SL_t		*sel_chunks; /* Skip list containing information for each chunk selected */
     H5S_t		*single_space; /* Dataspace for single element I/O on chunks */
-    H5D_chunk_info_t *single_chunk_info;  /* Pointer to single chunk's info */
+    H5D_chunk_info_t    *single_chunk_info;  /* Pointer to single chunk's info */
 } H5D_rdcc_t;
 
 /* The raw data contiguous data cache */
diff --git a/src/H5VM.c b/src/H5VM.c
index 2fa49ba..ffc657d 100644
--- a/src/H5VM.c
+++ b/src/H5VM.c
@@ -1258,18 +1258,83 @@ done:
  *              The chunk index is placed in the CHUNK_IDX location for return
  *              from this function
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:	Chunk index on success (can't fail)
  *
  * Programmer:	Quincey Koziol
  *		Monday, April 21, 2003
  *
  *-------------------------------------------------------------------------
  */
-herr_t
+hsize_t
 H5VM_chunk_index(unsigned ndims, const hsize_t *coord, const uint32_t *chunk,
-    const hsize_t *down_nchunks, hsize_t *chunk_idx)
+    const hsize_t *down_nchunks)
 {
     hsize_t scaled_coord[H5VM_HYPER_NDIMS];	/* Scaled, coordinates, in terms of chunks */
+    hsize_t chunk_idx;          /* Chunk index computed */
+
+    FUNC_ENTER_NOAPI_NOINIT_NOERR
+
+    /* Sanity check */
+    HDassert(ndims <= H5VM_HYPER_NDIMS);
+    HDassert(coord);
+    HDassert(chunk);
+    HDassert(down_nchunks);
+
+    /* Defer to H5VM_chunk_index_scaled */
+    chunk_idx = H5VM_chunk_index_scaled(ndims, coord, chunk, down_nchunks, scaled_coord);
+    
+    FUNC_LEAVE_NOAPI(chunk_idx)
+} /* end H5VM_chunk_index() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5VM_chunk_index_scaled
+ *
+ * Purpose:	Given a coordinate offset (COORD), the size of each chunk
+ *              (CHUNK), the number of chunks in each dimension (NCHUNKS)
+ *              and the number of dimensions of all of these (NDIMS), calculate
+ *              a "chunk index" for the chunk that the coordinate offset is
+ *              located in.
+ *
+ *              The chunk index starts at 0 and increases according to the
+ *              fastest changing dimension, then the next fastest, etc.
+ *
+ *              For example, with a 3x5 chunk size and 6 chunks in the fastest
+ *              changing dimension and 3 chunks in the slowest changing
+ *              dimension, the chunk indices are as follows:
+ *
+ *              +-----+-----+-----+-----+-----+-----+
+ *              |     |     |     |     |     |     |
+ *              |  0  |  1  |  2  |  3  |  4  |  5  |
+ *              |     |     |     |     |     |     |
+ *              +-----+-----+-----+-----+-----+-----+
+ *              |     |     |     |     |     |     |
+ *              |  6  |  7  |  8  |  9  | 10  | 11  |
+ *              |     |     |     |     |     |     |
+ *              +-----+-----+-----+-----+-----+-----+
+ *              |     |     |     |     |     |     |
+ *              | 12  | 13  | 14  | 15  | 16  | 17  |
+ *              |     |     |     |     |     |     |
+ *              +-----+-----+-----+-----+-----+-----+
+ *
+ *              The chunk index is placed in the CHUNK_IDX location for return
+ *              from this function
+ *
+ * Note:	This routine is identical to H5VM_chunk_index(), except for
+ *		caching the scaled information.  Make changes in both places.
+ *
+ * Return:	Chunk index on success (can't fail)
+ *
+ * Programmer:	Vailin Choi
+ *		Monday, February 9, 2015
+ *
+ *-------------------------------------------------------------------------
+ */
+hsize_t
+H5VM_chunk_index_scaled(unsigned ndims, const hsize_t *coord, const uint32_t *chunk,
+    const hsize_t *down_nchunks, hsize_t *scaled)
+{
+    hsize_t chunk_idx;          /* Computed chunk index */
     unsigned u;                 /* Local index variable */
 
     FUNC_ENTER_NOAPI_NOINIT_NOERR
@@ -1278,17 +1343,19 @@ H5VM_chunk_index(unsigned ndims, const hsize_t *coord, const uint32_t *chunk,
     HDassert(ndims <= H5VM_HYPER_NDIMS);
     HDassert(coord);
     HDassert(chunk);
-    HDassert(chunk_idx);
+    HDassert(down_nchunks);
+    HDassert(scaled);
 
     /* Compute the scaled coordinates for actual coordinates */
+    /* (Note that the 'scaled' array is an 'OUT' parameter) */
     for(u = 0; u < ndims; u++)
-        scaled_coord[u] = coord[u] / chunk[u];
+        scaled[u] = coord[u] / chunk[u];
 
     /* Compute the chunk index */
-    *chunk_idx = H5VM_array_offset_pre(ndims,down_nchunks,scaled_coord); /*lint !e772 scaled_coord will always be initialized */
+    chunk_idx = H5VM_array_offset_pre(ndims, down_nchunks, scaled); /*lint !e772 scaled_coord will always be initialized */
 
-    FUNC_LEAVE_NOAPI(SUCCEED)
-} /* end H5VM_chunk_index() */
+    FUNC_LEAVE_NOAPI(chunk_idx)
+} /* end H5VM_chunk_index_scaled() */
 
 
 /*-------------------------------------------------------------------------
diff --git a/src/H5VMprivate.h b/src/H5VMprivate.h
index dbe39ca..8ddb5ee 100644
--- a/src/H5VMprivate.h
+++ b/src/H5VMprivate.h
@@ -89,8 +89,10 @@ H5_DLL hsize_t H5VM_array_offset(unsigned n, const hsize_t *total_size,
     const hsize_t *offset);
 H5_DLL herr_t H5VM_array_calc(hsize_t offset, unsigned n,
     const hsize_t *total_size, hsize_t *coords);
-H5_DLL herr_t H5VM_chunk_index(unsigned ndims, const hsize_t *coord,
-    const uint32_t *chunk, const hsize_t *down_nchunks, hsize_t *chunk_idx);
+H5_DLL hsize_t H5VM_chunk_index(unsigned ndims, const hsize_t *coord,
+    const uint32_t *chunk, const hsize_t *down_nchunks);
+H5_DLL hsize_t H5VM_chunk_index_scaled(unsigned ndims, const hsize_t *coord,
+    const uint32_t *chunk, const hsize_t *down_nchunks, hsize_t *scaled);
 H5_DLL ssize_t H5VM_opvv(size_t dst_max_nseq, size_t *dst_curr_seq, size_t dst_len_arr[],
     hsize_t dst_off_arr[],
     size_t src_max_nseq, size_t *src_curr_seq, size_t src_len_arr[],