Merge pull request #2033 in HDFFV/hdf5 from ~NFORTNE2/hdf5_naf:public_spi to develop

* commit 'db6eab893e5f027f0b535316e0e7a9abe9ff8619':
  Implement public H5Sselect_project_intersection().  Updated internal algorithm to (optionally) avoid sharing selection data structures. Tested internal code (including with valgrind) by setting VDS code to avoid sharing selection, has since been changed to share selection for performance, so this code is not yet tested in regression tests.  API has not been tested.

7 files changed, 308 insertions, 122 deletions

diff --git a/src/H5Dvirtual.c b/src/H5Dvirtual.c
index 53640e7..877aadb 100644
--- a/src/H5Dvirtual.c
+++ b/src/H5Dvirtual.c
@@ -2406,7 +2406,7 @@ H5D__virtual_pre_io(H5D_io_info_t *io_info,
                         /* Project intersection of virtual space and clipped
                          * virtual space onto source space (create
                          * clipped_source_select) */
-                        if(H5S_select_project_intersection(storage->list[i].sub_dset[j].virtual_select, storage->list[i].source_select, storage->list[i].sub_dset[j].clipped_virtual_select, &storage->list[i].sub_dset[j].clipped_source_select) < 0)
+                        if(H5S_select_project_intersection(storage->list[i].sub_dset[j].virtual_select, storage->list[i].source_select, storage->list[i].sub_dset[j].clipped_virtual_select, &storage->list[i].sub_dset[j].clipped_source_select, TRUE) < 0)
                             HGOTO_ERROR(H5E_DATASET, H5E_CANTCLIP, FAIL, "can't project virtual intersection onto memory space")
 
                         /* Set extents of virtual_select and
@@ -2423,7 +2423,7 @@ H5D__virtual_pre_io(H5D_io_info_t *io_info,
                 if(storage->list[i].sub_dset[j].clipped_virtual_select) {
                     /* Project intersection of file space and mapping virtual space
                      * onto memory space */
-                    if(H5S_select_project_intersection(file_space, mem_space, storage->list[i].sub_dset[j].clipped_virtual_select, &storage->list[i].sub_dset[j].projected_mem_space) < 0)
+                    if(H5S_select_project_intersection(file_space, mem_space, storage->list[i].sub_dset[j].clipped_virtual_select, &storage->list[i].sub_dset[j].projected_mem_space, TRUE) < 0)
                         HGOTO_ERROR(H5E_DATASET, H5E_CANTCLIP, FAIL, "can't project virtual intersection onto memory space")
 
                     /* Check number of elements selected */
@@ -2460,7 +2460,7 @@ H5D__virtual_pre_io(H5D_io_info_t *io_info,
             if(storage->list[i].source_dset.clipped_virtual_select) {
                 /* Project intersection of file space and mapping virtual space onto
                  * memory space */
-                if(H5S_select_project_intersection(file_space, mem_space, storage->list[i].source_dset.clipped_virtual_select, &storage->list[i].source_dset.projected_mem_space) < 0)
+                if(H5S_select_project_intersection(file_space, mem_space, storage->list[i].source_dset.clipped_virtual_select, &storage->list[i].source_dset.projected_mem_space, TRUE) < 0)
                     HGOTO_ERROR(H5E_DATASET, H5E_CANTCLIP, FAIL, "can't project virtual intersection onto memory space")
 
                 /* Check number of elements selected, add to tot_nelmts */
@@ -2590,7 +2590,7 @@ H5D__virtual_read_one(H5D_io_info_t *io_info, const H5D_type_info_t *type_info,
 
         /* Project intersection of file space and mapping virtual space onto
          * mapping source space */
-        if(H5S_select_project_intersection(source_dset->clipped_virtual_select, source_dset->clipped_source_select, file_space, &projected_src_space) < 0)
+        if(H5S_select_project_intersection(source_dset->clipped_virtual_select, source_dset->clipped_source_select, file_space, &projected_src_space, TRUE) < 0)
             HGOTO_ERROR(H5E_DATASET, H5E_CANTCLIP, FAIL, "can't project virtual intersection onto source space")
 
         /* Perform read on source dataset */
@@ -2781,7 +2781,7 @@ H5D__virtual_write_one(H5D_io_info_t *io_info, const H5D_type_info_t *type_info,
          * extent in the unlimited dimension.  -NAF */
         /* Project intersection of file space and mapping virtual space onto
          * mapping source space */
-        if(H5S_select_project_intersection(source_dset->virtual_select, source_dset->clipped_source_select, file_space, &projected_src_space) < 0)
+        if(H5S_select_project_intersection(source_dset->virtual_select, source_dset->clipped_source_select, file_space, &projected_src_space, TRUE) < 0)
             HGOTO_ERROR(H5E_DATASET, H5E_CANTCLIP, FAIL, "can't project virtual intersection onto source space")
 
         /* Perform write on source dataset */
diff --git a/src/H5Shyper.c b/src/H5Shyper.c
index 9feb8de..2c7502a 100644
--- a/src/H5Shyper.c
+++ b/src/H5Shyper.c
@@ -96,6 +96,7 @@ typedef struct {
     hsize_t skip;           /* Number of elements to skip in projected space */
     hsize_t nelem;          /* Number of elements to add to projected space (after skip) */
     uint64_t op_gen;        /* Operation generation for counting elements */
+    hbool_t share_selection; /* Whether span trees in dst_space can be shared with proj_space */
 } H5S_hyper_project_intersect_ud_t;
 
 /* Assert that H5S_MAX_RANK is <= 32 so our trick with using a 32 bit bitmap
@@ -112,6 +113,9 @@ typedef struct {
 static H5S_hyper_span_t *H5S__hyper_new_span(hsize_t low, hsize_t high,
     H5S_hyper_span_info_t *down, H5S_hyper_span_t *next);
 static H5S_hyper_span_info_t *H5S__hyper_new_span_info(unsigned rank);
+static H5S_hyper_span_info_t *H5S__hyper_copy_span_helper(
+    H5S_hyper_span_info_t *spans, unsigned rank, unsigned op_info_i,
+    uint64_t op_gen);
 static H5S_hyper_span_info_t *H5S__hyper_copy_span(H5S_hyper_span_info_t *spans,
     unsigned rank);
 static hbool_t H5S__hyper_cmp_spans(const H5S_hyper_span_info_t *span_info1,
@@ -132,7 +136,7 @@ static herr_t H5S__hyper_clip_spans(H5S_hyper_span_info_t *a_spans,
     H5S_hyper_span_info_t **a_and_b, H5S_hyper_span_info_t **b_not_a);
 static herr_t H5S__hyper_merge_spans(H5S_t *space, H5S_hyper_span_info_t *new_spans);
 static hsize_t H5S__hyper_spans_nelem_helper(H5S_hyper_span_info_t *spans,
-    uint64_t op_gen);
+    unsigned op_info_i, uint64_t op_gen);
 static hsize_t H5S__hyper_spans_nelem(H5S_hyper_span_info_t *spans);
 static herr_t H5S__hyper_add_disjoint_spans(H5S_t *space, H5S_hyper_span_info_t *new_spans);
 static H5S_hyper_span_info_t *H5S__hyper_make_spans(unsigned rank,
@@ -2852,9 +2856,10 @@ done:
  PURPOSE
     Helper routine to copy a hyperslab span tree
  USAGE
-    H5S_hyper_span_info_t * H5S__hyper_copy_span_helper(spans, rank)
+    H5S_hyper_span_info_t * H5S__hyper_copy_span_helper(spans, rank, op_info_i, op_gen)
         H5S_hyper_span_info_t *spans;   IN: Span tree to copy
         unsigned rank;                  IN: Rank of span tree
+        unsigned op_info_i;             IN: Index of op info to use
         uint64_t op_gen;                IN: Operation generation
  RETURNS
     Pointer to the copied span tree on success, NULL on failure
@@ -2867,7 +2872,7 @@ done:
 --------------------------------------------------------------------------*/
 static H5S_hyper_span_info_t *
 H5S__hyper_copy_span_helper(H5S_hyper_span_info_t *spans, unsigned rank,
-    uint64_t op_gen)
+    unsigned op_info_i, uint64_t op_gen)
 {
     H5S_hyper_span_t *span;         /* Hyperslab span */
     H5S_hyper_span_t *new_span;     /* Temporary hyperslab span */
@@ -2881,9 +2886,9 @@ H5S__hyper_copy_span_helper(H5S_hyper_span_info_t *spans, unsigned rank,
     HDassert(spans);
 
     /* Check if the span tree was already copied */
-    if(spans->op_gen == op_gen) {
+    if(spans->op_info[op_info_i].op_gen == op_gen) {
         /* Just return the value of the already copied span tree */
-        ret_value = spans->u.copied;
+        ret_value = spans->op_info[op_info_i].u.copied;
 
         /* Increment the reference count of the span tree */
         ret_value->count++;
@@ -2899,10 +2904,10 @@ H5S__hyper_copy_span_helper(H5S_hyper_span_info_t *spans, unsigned rank,
         ret_value->count = 1;
 
         /* Set the operation generation for the span info, to avoid future copies */
-        spans->op_gen = op_gen;
+        spans->op_info[op_info_i].op_gen = op_gen;
 
         /* Set the 'copied' pointer in the node being copied to the newly allocated node */
-        spans->u.copied = ret_value;
+        spans->op_info[op_info_i].u.copied = ret_value;
 
         /* Copy over the nodes in the span list */
         span = spans->head;
@@ -2920,7 +2925,7 @@ H5S__hyper_copy_span_helper(H5S_hyper_span_info_t *spans, unsigned rank,
 
             /* Recurse to copy the 'down' spans, if there are any */
             if(span->down != NULL) {
-                if(NULL == (new_down = H5S__hyper_copy_span_helper(span->down, rank - 1, op_gen)))
+                if(NULL == (new_down = H5S__hyper_copy_span_helper(span->down, rank - 1, op_info_i, op_gen)))
                     HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOPY, NULL, "can't copy hyperslab spans")
                 new_span->down = new_down;
             } /* end if */
@@ -2976,7 +2981,9 @@ H5S__hyper_copy_span(H5S_hyper_span_info_t *spans, unsigned rank)
     op_gen = H5S__hyper_get_op_gen();
 
     /* Copy the hyperslab span tree */
-    if(NULL == (ret_value = H5S__hyper_copy_span_helper(spans, rank, op_gen)))
+    /* Always use op_info[0] since we own this op_info, so there can be no
+     * simultaneous operations */
+    if(NULL == (ret_value = H5S__hyper_copy_span_helper(spans, rank, 0, op_gen)))
         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOPY, NULL, "can't copy hyperslab span tree")
 
 done:
@@ -3315,8 +3322,9 @@ done:
  PURPOSE
     Helper routine to count the number of blocks in a span tree
  USAGE
-    hsize_t H5S__hyper_span_nblocks_helper(spans)
+    hsize_t H5S__hyper_span_nblocks_helper(spans, op_info_i, op_gen)
         H5S_hyper_span_info_t *spans; IN: Hyperslab span tree to count blocks of
+        unsigned op_info_i; IN: Index of op info to use
         uint64_t op_gen;   IN: Operation generation
  RETURNS
     Number of blocks in span tree on success; negative on failure
@@ -3328,7 +3336,8 @@ done:
  REVISION LOG
 --------------------------------------------------------------------------*/
 static hsize_t
-H5S__hyper_span_nblocks_helper(H5S_hyper_span_info_t *spans, uint64_t op_gen)
+H5S__hyper_span_nblocks_helper(H5S_hyper_span_info_t *spans, unsigned op_info_i,
+    uint64_t op_gen)
 {
     hsize_t ret_value = 0;      /* Return value */
 
@@ -3338,9 +3347,9 @@ H5S__hyper_span_nblocks_helper(H5S_hyper_span_info_t *spans, uint64_t op_gen)
     HDassert(spans);
 
     /* Check if the span tree was already counted */
-    if(spans->op_gen == op_gen)
+    if(spans->op_info[op_info_i].op_gen == op_gen)
         /* Just return the # of blocks in the already counted span tree */
-        ret_value = spans->u.nblocks;
+        ret_value = spans->op_info[op_info_i].u.nblocks;
     else {      /* Count the number of elements in the span tree */
         H5S_hyper_span_t *span;     /* Hyperslab span */
 
@@ -3348,7 +3357,7 @@ H5S__hyper_span_nblocks_helper(H5S_hyper_span_info_t *spans, uint64_t op_gen)
         if(span->down) {
             while(span) {
                 /* If there are down spans, add the total down span blocks */
-                ret_value += H5S__hyper_span_nblocks_helper(span->down, op_gen);
+                ret_value += H5S__hyper_span_nblocks_helper(span->down, op_info_i, op_gen);
 
                 /* Advance to next span */
                 span = span->next;
@@ -3365,10 +3374,10 @@ H5S__hyper_span_nblocks_helper(H5S_hyper_span_info_t *spans, uint64_t op_gen)
         } /* end else */
 
         /* Set the operation generation for this span tree, to avoid re-computing */
-        spans->op_gen = op_gen;
+        spans->op_info[op_info_i].op_gen = op_gen;
 
         /* Hold a copy of the # of blocks */
-        spans->u.nblocks = ret_value;
+        spans->op_info[op_info_i].u.nblocks = ret_value;
     } /* end else */
 
     FUNC_LEAVE_NOAPI(ret_value)
@@ -3406,7 +3415,10 @@ H5S__hyper_span_nblocks(H5S_hyper_span_info_t *spans)
         /* Acquire an operation generation value for this operation */
         op_gen = H5S__hyper_get_op_gen();
 
-        ret_value = H5S__hyper_span_nblocks_helper(spans, op_gen);
+        /* Count the blocks */
+        /* Always use op_info[0] since we own this op_info, so there can be no
+         * simultaneous operations */
+        ret_value = H5S__hyper_span_nblocks_helper(spans, 0, op_gen);
     } /* end if */
 
     FUNC_LEAVE_NOAPI(ret_value)
@@ -5946,7 +5958,7 @@ H5S__hyper_add_span_element_helper(H5S_hyper_span_info_t *span_tree,
                     /* Check if we've compared the 'stop' span's "down tree" to
                      *      this span's "down tree" already.
                      */
-                    if(tmp_span->down->op_gen != op_gen) {
+                    if(tmp_span->down->op_info[0].op_gen != op_gen) {
                         if(H5S__hyper_cmp_spans(tmp_span->down, stop_span->down))
                             attempt_merge_spans = TRUE;
 
@@ -5954,7 +5966,7 @@ H5S__hyper_add_span_element_helper(H5S_hyper_span_info_t *span_tree,
                         /* (Because it wasn't the same as the 'stop' span's down tree
                          *      and we don't need to compare it again)
                          */
-                        tmp_span->down->op_gen = op_gen;
+                        tmp_span->down->op_info[0].op_gen = op_gen;
                     } /* end if */
                 } /* end else */
 
@@ -6159,11 +6171,12 @@ done:
  PURPOSE
     Helper routine to detect intersections in span trees
  USAGE
-    hbool_t H5S__hyper_intersect_block_helper(spans, start, end)
+    hbool_t H5S__hyper_intersect_block_helper(spans, rank, start, end, op_info_i, op_gen)
         H5S_hyper_span_info_t *spans;     IN: First span tree to operate with
         unsigned rank;     IN: Number of dimensions for span tree
         hsize_t *start;    IN: Starting coordinate for block
         hsize_t *end;      IN: Ending coordinate for block
+        unsigned op_info_i;             IN: Index of op info to use
         uint64_t op_gen;   IN: Operation generation
  RETURN
     Non-negative (TRUE/FALSE) on success, can't fail
@@ -6176,7 +6189,8 @@ done:
 --------------------------------------------------------------------------*/
 static hbool_t
 H5S__hyper_intersect_block_helper(H5S_hyper_span_info_t *spans,
-    unsigned rank, const hsize_t *start, const hsize_t *end, uint64_t op_gen)
+    unsigned rank, const hsize_t *start, const hsize_t *end, unsigned op_info_i,
+    uint64_t op_gen)
 {
     hbool_t ret_value = FALSE;      /* Return value */
 
@@ -6188,7 +6202,7 @@ H5S__hyper_intersect_block_helper(H5S_hyper_span_info_t *spans,
     HDassert(end);
 
     /* Check if we've already visited this span tree */
-    if(spans->op_gen != op_gen) {
+    if(spans->op_info[op_info_i].op_gen != op_gen) {
         H5S_hyper_span_t *curr;         /* Pointer to current span in 1st span tree */
         unsigned u;                     /* Local index variable */
 
@@ -6221,7 +6235,7 @@ H5S__hyper_intersect_block_helper(H5S_hyper_span_info_t *spans,
                     /* If there is an intersection in the "down" dimensions,
                      * the span trees overlap.
                      */
-                    if(H5S__hyper_intersect_block_helper(curr->down, rank - 1, start + 1, end + 1, op_gen))
+                    if(H5S__hyper_intersect_block_helper(curr->down, rank - 1, start + 1, end + 1, op_info_i, op_gen))
                         HGOTO_DONE(TRUE)
 
                     /* No intersection in down dimensions, advance to next span */
@@ -6231,7 +6245,7 @@ H5S__hyper_intersect_block_helper(H5S_hyper_span_info_t *spans,
         } /* end while */
 
         /* Set the tree's operation generation */
-        spans->op_gen = op_gen;
+        spans->op_info[op_info_i].op_gen = op_gen;
     } /* end if */
 
     /* Fall through with 'FALSE' return value */
@@ -6267,7 +6281,7 @@ H5S__hyper_intersect_block(const H5S_t *space, const hsize_t *start, const hsize
 {
     htri_t ret_value = FAIL;    /* Return value */
 
-    FUNC_ENTER_STATIC
+    FUNC_ENTER_STATIC_NOERR
 
     /* Sanity check */
     HDassert(space);
@@ -6363,7 +6377,9 @@ H5S__hyper_intersect_block(const H5S_t *space, const hsize_t *start, const hsize
         op_gen = H5S__hyper_get_op_gen();
 
         /* Perform the span-by-span intersection check */
-        ret_value = H5S__hyper_intersect_block_helper(space->select.sel_info.hslab->span_lst, space->extent.rank, start, end, op_gen);
+        /* Always use op_info[0] since we own this op_info, so there can be no
+         * simultaneous operations */
+        ret_value = H5S__hyper_intersect_block_helper(space->select.sel_info.hslab->span_lst, space->extent.rank, start, end, 0, op_gen);
     } /* end else */
 
 done:
@@ -6377,10 +6393,11 @@ done:
  PURPOSE
     Helper routine to adjust offsets in span trees
  USAGE
-    void H5S__hyper_adjust_u_helper(spans, offset)
+    void H5S__hyper_adjust_u_helper(spans, rank, offset, op_info_i, op_gen)
         H5S_hyper_span_info_t *spans;   IN: Span tree to operate with
         unsigned rank;                  IN: Number of dimensions for span tree
         const hsize_t *offset;          IN: Offset to subtract
+        unsigned op_info_i;             IN: Index of op info to use
         uint64_t op_gen;                IN: Operation generation
  RETURNS
     None
@@ -6393,7 +6410,7 @@ done:
 --------------------------------------------------------------------------*/
 static void
 H5S__hyper_adjust_u_helper(H5S_hyper_span_info_t *spans, unsigned rank,
-    const hsize_t *offset, uint64_t op_gen)
+    const hsize_t *offset, unsigned op_info_i, uint64_t op_gen)
 {
     FUNC_ENTER_STATIC_NOERR
 
@@ -6402,7 +6419,7 @@ H5S__hyper_adjust_u_helper(H5S_hyper_span_info_t *spans, unsigned rank,
     HDassert(offset);
 
     /* Check if we've already set this span tree */
-    if(spans->op_gen != op_gen) {
+    if(spans->op_info[op_info_i].op_gen != op_gen) {
         H5S_hyper_span_t *span;     /* Pointer to current span in span tree */
         unsigned u;                 /* Local index variable */
 
@@ -6423,14 +6440,14 @@ H5S__hyper_adjust_u_helper(H5S_hyper_span_info_t *spans, unsigned rank,
 
             /* Recursively adjust spans in next dimension down */
             if(span->down != NULL)
-                H5S__hyper_adjust_u_helper(span->down, rank - 1, offset + 1, op_gen);
+                H5S__hyper_adjust_u_helper(span->down, rank - 1, offset + 1, op_info_i, op_gen);
 
             /* Advance to next span in this dimension */
             span = span->next;
         } /* end while */
 
         /* Set the tree's operation generation */
-        spans->op_gen = op_gen;
+        spans->op_info[op_info_i].op_gen = op_gen;
     } /* end if */
 
     FUNC_LEAVE_NOAPI_VOID
@@ -6487,7 +6504,10 @@ H5S__hyper_adjust_u(H5S_t *space, const hsize_t *offset)
         /* Acquire an operation generation value for this operation */
         op_gen = H5S__hyper_get_op_gen();
 
-        H5S__hyper_adjust_u_helper(space->select.sel_info.hslab->span_lst, space->extent.rank, offset, op_gen);
+        /* Perform adjustment */
+        /* Always use op_info[0] since we own this op_info, so there can be no
+         * simultaneous operations */
+        H5S__hyper_adjust_u_helper(space->select.sel_info.hslab->span_lst, space->extent.rank, offset, 0, op_gen);
     } /* end if */
 
     FUNC_LEAVE_NOAPI(SUCCEED)
@@ -6897,10 +6917,11 @@ done:
  PURPOSE
     Helper routine to adjust offsets in span trees
  USAGE
-    void H5S__hyper_adjust_s_helper(spans, offset)
+    void H5S__hyper_adjust_s_helper(spans, rank, offset, op_info_i, op_gen)
         H5S_hyper_span_info_t *spans;   IN: Span tree to operate with
         unsigned rank;                  IN: Number of dimensions for span tree
         const hssize_t *offset;         IN: Offset to subtract
+        unsigned op_info_i;             IN: Index of op info to use
         uint64_t op_gen;                IN: Operation generation
  RETURNS
     None
@@ -6913,7 +6934,7 @@ done:
 --------------------------------------------------------------------------*/
 static void
 H5S__hyper_adjust_s_helper(H5S_hyper_span_info_t *spans, unsigned rank,
-    const hssize_t *offset, uint64_t op_gen)
+    const hssize_t *offset, unsigned op_info_i, uint64_t op_gen)
 {
     FUNC_ENTER_STATIC_NOERR
 
@@ -6922,7 +6943,7 @@ H5S__hyper_adjust_s_helper(H5S_hyper_span_info_t *spans, unsigned rank,
     HDassert(offset);
 
     /* Check if we've already set this span tree */
-    if(spans->op_gen != op_gen) {
+    if(spans->op_info[op_info_i].op_gen != op_gen) {
         H5S_hyper_span_t *span;     /* Pointer to current span in span tree */
         unsigned u;                 /* Local index variable */
 
@@ -6943,14 +6964,14 @@ H5S__hyper_adjust_s_helper(H5S_hyper_span_info_t *spans, unsigned rank,
 
             /* Recursively adjust spans in next dimension down */
             if(span->down != NULL)
-                H5S__hyper_adjust_s_helper(span->down, rank - 1, offset + 1, op_gen);
+                H5S__hyper_adjust_s_helper(span->down, rank - 1, offset + 1, op_info_i, op_gen);
 
             /* Advance to next span in this dimension */
             span = span->next;
         } /* end while */
 
         /* Set the tree's operation generation */
-        spans->op_gen = op_gen;
+        spans->op_info[op_info_i].op_gen = op_gen;
     } /* end if */
 
     FUNC_LEAVE_NOAPI_VOID
@@ -7018,7 +7039,10 @@ H5S_hyper_adjust_s(H5S_t *space, const hssize_t *offset)
             /* Acquire an operation generation value for this operation */
             op_gen = H5S__hyper_get_op_gen();
 
-            H5S__hyper_adjust_s_helper(space->select.sel_info.hslab->span_lst, space->extent.rank, offset, op_gen);
+            /* Perform the adjustment */
+            /* Always use op_info[0] since we own this op_info, so there can be no
+             * simultaneous operations */
+            H5S__hyper_adjust_s_helper(space->select.sel_info.hslab->span_lst, space->extent.rank, offset, 0, op_gen);
         } /* end if */
     } /* end if */
 
@@ -8281,8 +8305,9 @@ done:
  PURPOSE
     Count the number of elements in a span tree
  USAGE
-    hsize_t H5S__hyper_spans_nelem_helper(spans, op_gen)
+    hsize_t H5S__hyper_spans_nelem_helper(spans, op_info_i, op_gen)
         const H5S_hyper_span_info_t *spans; IN: Hyperslan span tree to count elements of
+        unsigned op_info_i;             IN: Index of op info to use
         uint64_t op_gen;                IN: Operation generation
  RETURNS
     Number of elements in span tree on success; negative on failure
@@ -8294,7 +8319,8 @@ done:
  REVISION LOG
 --------------------------------------------------------------------------*/
 static hsize_t
-H5S__hyper_spans_nelem_helper(H5S_hyper_span_info_t *spans, uint64_t op_gen)
+H5S__hyper_spans_nelem_helper(H5S_hyper_span_info_t *spans, unsigned op_info_i,
+    uint64_t op_gen)
 {
     hsize_t ret_value = 0;          /* Return value */
 
@@ -8304,9 +8330,9 @@ H5S__hyper_spans_nelem_helper(H5S_hyper_span_info_t *spans, uint64_t op_gen)
     HDassert(spans);
 
     /* Check if the span tree was already counted */
-    if(spans->op_gen == op_gen)
+    if(spans->op_info[op_info_i].op_gen == op_gen)
         /* Just return the # of elements in the already counted span tree */
-        ret_value = spans->u.nelmts;
+        ret_value = spans->op_info[op_info_i].u.nelmts;
     else {      /* Count the number of elements in the span tree */
         const H5S_hyper_span_t *span;     /* Hyperslab span */
 
@@ -8328,7 +8354,7 @@ H5S__hyper_spans_nelem_helper(H5S_hyper_span_info_t *spans, uint64_t op_gen)
                 nelmts = (span->high - span->low) + 1;
 
                 /* Multiply the size of this span by the total down span elements */
-                ret_value += nelmts * H5S__hyper_spans_nelem_helper(span->down, op_gen);
+                ret_value += nelmts * H5S__hyper_spans_nelem_helper(span->down, op_info_i, op_gen);
 
                 /* Advance to next span */
                 span = span->next;
@@ -8336,10 +8362,10 @@ H5S__hyper_spans_nelem_helper(H5S_hyper_span_info_t *spans, uint64_t op_gen)
         } /* end else */
 
         /* Set the operation generation for this span tree, to avoid re-computing */
-        spans->op_gen = op_gen;
+        spans->op_info[op_info_i].op_gen = op_gen;
 
         /* Hold a copy of the # of elements */
-        spans->u.nelmts = ret_value;
+        spans->op_info[op_info_i].u.nelmts = ret_value;
     } /* end else */
 
     FUNC_LEAVE_NOAPI(ret_value)
@@ -8378,7 +8404,9 @@ H5S__hyper_spans_nelem(H5S_hyper_span_info_t *spans)
     op_gen = H5S__hyper_get_op_gen();
 
     /* Count the number of elements in the span tree */
-    ret_value = H5S__hyper_spans_nelem_helper(spans, op_gen);
+    /* Always use op_info[0] since we own this op_info, so there can be no
+     * simultaneous operations */
+    ret_value = H5S__hyper_spans_nelem_helper(spans, 0, op_gen);
 
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__hyper_spans_nelem() */
@@ -8808,10 +8836,8 @@ H5S__hyper_update_diminfo(H5S_t *space, H5S_seloper_t op,
     (It can be recovered with regular selection)
  USAGE
     herr_t H5S__hyper_rebuild_helper(space)
-        const H5S_hyper_span_t *span;   IN: Portion of span tree to check
-        H5S_hyper_dim_t span_slab[];    OUT: Rebuilt section of hyperslab description
-        unsigned rank;                  IN: Current dimension to work on
-        uint64_t op_gen;                IN: Operation generation
+        const H5S_hyper_span_t *spans;  IN: Portion of span tree to check
+        H5S_hyper_dim_t span_slab_info[]; OUT: Rebuilt section of hyperslab description
  RETURNS
     TRUE/FALSE for hyperslab selection rebuilt
  DESCRIPTION
@@ -10833,6 +10859,7 @@ done:
 --------------------------------------------------------------------------*/
 static herr_t
 H5S__hyper_proj_int_build_proj(H5S_hyper_project_intersect_ud_t *udata) {
+    H5S_hyper_span_info_t *copied_span_info = NULL; /* Temporary span info pointer */
     herr_t ret_value = SUCCEED; /* Return value */
 
     FUNC_ENTER_STATIC
@@ -10852,15 +10879,15 @@ H5S__hyper_proj_int_build_proj(H5S_hyper_project_intersect_ud_t *udata) {
                     /* If we will run out of elements to skip in this span,
                      * advance to the first not fully skipped span and break
                      * out of this loop (start moving downwards) */
-                    if(udata->skip < H5S__hyper_spans_nelem_helper(udata->ds_span[udata->depth]->down, udata->op_gen)
+                    if(udata->skip < H5S__hyper_spans_nelem_helper(udata->ds_span[udata->depth]->down, 0, udata->op_gen)
                             * (udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1)) {
-                        udata->ds_low[udata->depth] += udata->skip / udata->ds_span[udata->depth]->down->u.nelmts;
-                        udata->skip %= udata->ds_span[udata->depth]->down->u.nelmts;
+                        udata->ds_low[udata->depth] += udata->skip / udata->ds_span[udata->depth]->down->op_info[0].u.nelmts;
+                        udata->skip %= udata->ds_span[udata->depth]->down->op_info[0].u.nelmts;
                         break;
                     } /* end if */
 
                     /* Skip over this entire span */
-                    udata->skip -= udata->ds_span[udata->depth]->down->u.nelmts
+                    udata->skip -= udata->ds_span[udata->depth]->down->op_info[0].u.nelmts
                             * (udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1);
                 } /* end if */
             } /* end if */
@@ -10919,15 +10946,15 @@ H5S__hyper_proj_int_build_proj(H5S_hyper_project_intersect_ud_t *udata) {
                     /* If we will run out of elements to skip in this span,
                      * advance to the first not fully skipped span and
                      * continue down */
-                    if(udata->skip < H5S__hyper_spans_nelem_helper(udata->ds_span[udata->depth]->down, udata->op_gen)
+                    if(udata->skip < H5S__hyper_spans_nelem_helper(udata->ds_span[udata->depth]->down, 0, udata->op_gen)
                             * (udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1)) {
-                        udata->ds_low[udata->depth] += udata->skip / udata->ds_span[udata->depth]->down->u.nelmts;
-                        udata->skip %= udata->ds_span[udata->depth]->down->u.nelmts;
+                        udata->ds_low[udata->depth] += udata->skip / udata->ds_span[udata->depth]->down->op_info[0].u.nelmts;
+                        udata->skip %= udata->ds_span[udata->depth]->down->op_info[0].u.nelmts;
                         break;
                     } /* end if */
 
                     /* Skip over this entire span */
-                    udata->skip -= udata->ds_span[udata->depth]->down->u.nelmts
+                    udata->skip -= udata->ds_span[udata->depth]->down->op_info[0].u.nelmts
                             * (udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1);
 
                     /* Advance to next span */
@@ -10972,27 +10999,59 @@ H5S__hyper_proj_int_build_proj(H5S_hyper_project_intersect_ud_t *udata) {
                  * any complete spans, advance to the first not fully added
                  * span, and break out of this loop (start moving downwards)
                  */
-                if(udata->nelem < H5S__hyper_spans_nelem_helper(udata->ds_span[udata->depth]->down, udata->op_gen)
+                if(udata->nelem < H5S__hyper_spans_nelem_helper(udata->ds_span[udata->depth]->down, 0, udata->op_gen)
                         * (udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1)) {
-                    if(udata->nelem >= udata->ds_span[udata->depth]->down->u.nelmts) {
-                        if(H5S__hyper_append_span(&udata->ps_span_info[udata->depth],
-                                udata->ds_rank - udata->depth, udata->ds_low[udata->depth],
-                                udata->ds_low[udata->depth] + (udata->nelem / udata->ds_span[udata->depth]->down->u.nelmts) - 1,
-                                udata->ds_span[udata->depth]->down) < 0)
-                            HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span")
-                        udata->ds_low[udata->depth] += udata->nelem / udata->ds_span[udata->depth]->down->u.nelmts;
-                        udata->nelem %= udata->ds_span[udata->depth]->down->u.nelmts;
+                    if(udata->nelem >= udata->ds_span[udata->depth]->down->op_info[0].u.nelmts) {
+                        if(udata->share_selection) {
+                            if(H5S__hyper_append_span(&udata->ps_span_info[udata->depth],
+                                    udata->ds_rank - udata->depth, udata->ds_low[udata->depth],
+                                    udata->ds_low[udata->depth] + (udata->nelem / udata->ds_span[udata->depth]->down->op_info[0].u.nelmts) - 1,
+                                    udata->ds_span[udata->depth]->down) < 0)
+                                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span")
+                        } /* end if */
+                        else {
+                            /* If we're not sharing the destination space's
+                             * spans, we must copy it first (then release it
+                             * afterwards) */
+                            if(NULL == (copied_span_info = H5S__hyper_copy_span_helper(udata->ds_span[udata->depth]->down, udata->ds_rank - udata->depth, 1, udata->op_gen)))
+                                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOPY, FAIL, "can't copy destination spans")
+                            if(H5S__hyper_append_span(&udata->ps_span_info[udata->depth],
+                                    udata->ds_rank - udata->depth, udata->ds_low[udata->depth],
+                                    udata->ds_low[udata->depth] + (udata->nelem / udata->ds_span[udata->depth]->down->op_info[0].u.nelmts) - 1,
+                                    copied_span_info) < 0)
+                                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span")
+                            H5S__hyper_free_span_info(copied_span_info);
+                            copied_span_info = NULL;
+                        } /* end else */
+                        udata->ds_low[udata->depth] += udata->nelem / udata->ds_span[udata->depth]->down->op_info[0].u.nelmts;
+                        udata->nelem %= udata->ds_span[udata->depth]->down->op_info[0].u.nelmts;
                     } /* end if */
                     break;
                 } /* end if */
 
                 /* Append span tree for entire span */
-                if(H5S__hyper_append_span(&udata->ps_span_info[udata->depth],
+                if(udata->share_selection) {
+                    if(H5S__hyper_append_span(&udata->ps_span_info[udata->depth],
                             udata->ds_rank - udata->depth, udata->ds_low[udata->depth],
                             udata->ds_span[udata->depth]->high,
                             udata->ds_span[udata->depth]->down) < 0)
                         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span")
-                udata->nelem -= udata->ds_span[udata->depth]->down->u.nelmts
+                } /* end if */
+                else {
+                    /* If we're not sharing the destination space's
+                     * spans, we must copy it first (then release it
+                     * afterwards) */
+                    if(NULL == (copied_span_info = H5S__hyper_copy_span_helper(udata->ds_span[udata->depth]->down, udata->ds_rank - udata->depth, 1, udata->op_gen)))
+                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOPY, FAIL, "can't copy destination spans")
+                    if(H5S__hyper_append_span(&udata->ps_span_info[udata->depth],
+                            udata->ds_rank - udata->depth, udata->ds_low[udata->depth],
+                            udata->ds_span[udata->depth]->high,
+                            copied_span_info) < 0)
+                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span")
+                    H5S__hyper_free_span_info(copied_span_info);
+                    copied_span_info = NULL;
+                } /* end else */
+                udata->nelem -= udata->ds_span[udata->depth]->down->op_info[0].u.nelmts
                         * (udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1);
             } /* end if */
         } /* end if */
@@ -11063,27 +11122,59 @@ H5S__hyper_proj_int_build_proj(H5S_hyper_project_intersect_ud_t *udata) {
                  * span and continue down
                  */
                 HDassert(udata->ds_low[udata->depth] <= udata->ds_span[udata->depth]->high);
-                if(udata->nelem < H5S__hyper_spans_nelem_helper(udata->ds_span[udata->depth]->down, udata->op_gen)
+                if(udata->nelem < H5S__hyper_spans_nelem_helper(udata->ds_span[udata->depth]->down, 0, udata->op_gen)
                         * (udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1)) {
-                    if(udata->nelem >= udata->ds_span[udata->depth]->down->u.nelmts) {
-                        if(H5S__hyper_append_span(&udata->ps_span_info[udata->depth],
-                                udata->ds_rank - udata->depth, udata->ds_low[udata->depth],
-                                udata->ds_low[udata->depth] + (udata->nelem / udata->ds_span[udata->depth]->down->u.nelmts) - 1,
-                                udata->ds_span[udata->depth]->down) < 0)
-                            HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span")
-                        udata->ds_low[udata->depth] += udata->nelem / udata->ds_span[udata->depth]->down->u.nelmts;
-                        udata->nelem %= udata->ds_span[udata->depth]->down->u.nelmts;
+                    if(udata->nelem >= udata->ds_span[udata->depth]->down->op_info[0].u.nelmts) {
+                        if(udata->share_selection) {
+                            if(H5S__hyper_append_span(&udata->ps_span_info[udata->depth],
+                                    udata->ds_rank - udata->depth, udata->ds_low[udata->depth],
+                                    udata->ds_low[udata->depth] + (udata->nelem / udata->ds_span[udata->depth]->down->op_info[0].u.nelmts) - 1,
+                                    udata->ds_span[udata->depth]->down) < 0)
+                                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span")
+                        } /* end if */
+                        else {
+                            /* If we're not sharing the destination space's
+                             * spans, we must copy it first (then release it
+                             * afterwards) */
+                            if(NULL == (copied_span_info = H5S__hyper_copy_span_helper(udata->ds_span[udata->depth]->down, udata->ds_rank - udata->depth, 1, udata->op_gen)))
+                                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOPY, FAIL, "can't copy destination spans")
+                            if(H5S__hyper_append_span(&udata->ps_span_info[udata->depth],
+                                    udata->ds_rank - udata->depth, udata->ds_low[udata->depth],
+                                    udata->ds_low[udata->depth] + (udata->nelem / udata->ds_span[udata->depth]->down->op_info[0].u.nelmts) - 1,
+                                    copied_span_info) < 0)
+                                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span")
+                            H5S__hyper_free_span_info(copied_span_info);
+                            copied_span_info = NULL;
+                        } /* end else */
+                        udata->ds_low[udata->depth] += udata->nelem / udata->ds_span[udata->depth]->down->op_info[0].u.nelmts;
+                        udata->nelem %= udata->ds_span[udata->depth]->down->op_info[0].u.nelmts;
                     } /* end if */
                     break;
                 } /* end if */
 
                 /* Append span tree for entire span */
-                if(H5S__hyper_append_span(&udata->ps_span_info[udata->depth],
+                if(udata->share_selection) {
+                    if(H5S__hyper_append_span(&udata->ps_span_info[udata->depth],
                             udata->ds_rank - udata->depth, udata->ds_low[udata->depth],
                             udata->ds_span[udata->depth]->high,
                             udata->ds_span[udata->depth]->down) < 0)
                         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span")
-                udata->nelem -= udata->ds_span[udata->depth]->down->u.nelmts
+                } /* end if */
+                else {
+                    /* If we're not sharing the destination space's
+                     * spans, we must copy it first (then release it
+                     * afterwards) */
+                    if(NULL == (copied_span_info = H5S__hyper_copy_span_helper(udata->ds_span[udata->depth]->down, udata->ds_rank - udata->depth, 1, udata->op_gen)))
+                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOPY, FAIL, "can't copy destination spans")
+                    if(H5S__hyper_append_span(&udata->ps_span_info[udata->depth],
+                            udata->ds_rank - udata->depth, udata->ds_low[udata->depth],
+                            udata->ds_span[udata->depth]->high,
+                            copied_span_info) < 0)
+                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTAPPEND, FAIL, "can't allocate hyperslab span")
+                    H5S__hyper_free_span_info(copied_span_info);
+                    copied_span_info = NULL;
+                } /* end else */
+                udata->nelem -= udata->ds_span[udata->depth]->down->op_info[0].u.nelmts
                         * (udata->ds_span[udata->depth]->high - udata->ds_low[udata->depth] + 1);
 
                 /* Advance to next span */
@@ -11128,6 +11219,13 @@ H5S__hyper_proj_int_build_proj(H5S_hyper_project_intersect_ud_t *udata) {
     udata->ps_clean_bitmap = 0;
 
 done:
+    /* Cleanup on failure */
+    if(copied_span_info) {
+        HDassert(ret_value < 0);
+        H5S__hyper_free_span_info(copied_span_info);
+        copied_span_info = NULL;
+    } /* end if */
+
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__hyper_proj_int_build_proj() */
 
@@ -11217,7 +11315,7 @@ H5S__hyper_proj_int_iterate(const H5S_hyper_span_info_t *ss_span_info,
                         /* Add skipped elements if there's a pre-gap */
                         if(ss_low < sis_low) {
                             low = sis_low;
-                            H5S_HYPER_PROJ_INT_ADD_SKIP(udata, H5S__hyper_spans_nelem_helper(ss_span->down, udata->op_gen) * (sis_low - ss_low), FAIL);
+                            H5S_HYPER_PROJ_INT_ADD_SKIP(udata, H5S__hyper_spans_nelem_helper(ss_span->down, 0, udata->op_gen) * (sis_low - ss_low), FAIL);
                         } /* end if */
                         else
                             low = ss_low;
@@ -11273,7 +11371,7 @@ H5S__hyper_proj_int_iterate(const H5S_hyper_span_info_t *ss_span_info,
                     if(ss_span->high < sis_low) {
                         /* Add skipped elements */
                         if(ss_span->down)
-                            H5S_HYPER_PROJ_INT_ADD_SKIP(udata, H5S__hyper_spans_nelem_helper(ss_span->down, udata->op_gen) * (ss_span->high - ss_low + 1), FAIL);
+                            H5S_HYPER_PROJ_INT_ADD_SKIP(udata, H5S__hyper_spans_nelem_helper(ss_span->down, 0, udata->op_gen) * (ss_span->high - ss_low + 1), FAIL);
                         else
                             H5S_HYPER_PROJ_INT_ADD_SKIP(udata, ss_span->high - ss_low + 1, FAIL);
 
@@ -11295,10 +11393,10 @@ H5S__hyper_proj_int_iterate(const H5S_hyper_span_info_t *ss_span_info,
             if(ss_span && !((depth == 0) && (u == count - 1))) {
                 /* Count remaining elements in ss_span_info */
                 if(ss_span->down) {
-                    H5S_HYPER_PROJ_INT_ADD_SKIP(udata, H5S__hyper_spans_nelem_helper(ss_span->down, udata->op_gen) * (ss_span->high - ss_low + 1), FAIL);
+                    H5S_HYPER_PROJ_INT_ADD_SKIP(udata, H5S__hyper_spans_nelem_helper(ss_span->down, 0, udata->op_gen) * (ss_span->high - ss_low + 1), FAIL);
                     ss_span = ss_span->next;
                     while(ss_span) {
-                        H5S_HYPER_PROJ_INT_ADD_SKIP(udata, H5S__hyper_spans_nelem_helper(ss_span->down, udata->op_gen) * (ss_span->high - ss_span->low + 1), FAIL);
+                        H5S_HYPER_PROJ_INT_ADD_SKIP(udata, H5S__hyper_spans_nelem_helper(ss_span->down, 0, udata->op_gen) * (ss_span->high - ss_span->low + 1), FAIL);
                         ss_span = ss_span->next;
                     } /* end while */
                 } /* end if */
@@ -11356,7 +11454,7 @@ H5S__hyper_proj_int_iterate(const H5S_hyper_span_info_t *ss_span_info,
     } /* end if */
     else if(depth > 0)
         /* Just count skipped elements */
-        H5S_HYPER_PROJ_INT_ADD_SKIP(udata, H5S__hyper_spans_nelem_helper((H5S_hyper_span_info_t *)ss_span_info, udata->op_gen) * count, FAIL); /* Casting away const OK -NAF */
+        H5S_HYPER_PROJ_INT_ADD_SKIP(udata, H5S__hyper_spans_nelem_helper((H5S_hyper_span_info_t *)ss_span_info, 0, udata->op_gen) * count, FAIL); /* Casting away const OK -NAF */
 
     /* Clean up if we are done */
     if(depth == 0) {
@@ -11391,11 +11489,12 @@ done:
     src_intersect_space within the selection of src_space as a selection
     within the selection of dst_space
  USAGE
-    herr_t H5S__hyper_project_intersection(src_space,dst_space,src_intersect_space,proj_space)
+    herr_t H5S__hyper_project_intersection(src_space,dst_space,src_intersect_space,proj_space,share_selection)
         H5S_t *src_space;       IN: Selection that is mapped to dst_space, and intersected with src_intersect_space
         H5S_t *dst_space;       IN: Selection that is mapped to src_space, and which contains the result
         H5S_t *src_intersect_space; IN: Selection whose intersection with src_space is projected to dst_space to obtain the result
         H5S_t *proj_space;      OUT: Will contain the result (intersection of src_intersect_space and src_space projected from src_space to dst_space) after the operation
+        hbool_t share_selection; IN: Whether we are allowed to share structures inside dst_space with proj_space
  RETURNS
     Non-negative on success/Negative on failure.
  DESCRIPTION
@@ -11414,7 +11513,8 @@ done:
 --------------------------------------------------------------------------*/
 herr_t
 H5S__hyper_project_intersection(const H5S_t *src_space, const H5S_t *dst_space,
-    const H5S_t *src_intersect_space, H5S_t *proj_space)
+    const H5S_t *src_intersect_space, H5S_t *proj_space,
+    hbool_t share_selection)
 {
     H5S_hyper_project_intersect_ud_t  udata; /* User data for subroutines */
     const H5S_hyper_span_info_t *ss_span_info;
@@ -11485,12 +11585,14 @@ H5S__hyper_project_intersection(const H5S_t *src_space, const H5S_t *dst_space,
             HGOTO_ERROR(H5E_DATASPACE, H5E_UNINITIALIZED, FAIL, "can't construct span tree for source intersect hyperslab selection")
 
     /* Initialize udata */
+    /* We will use op_info[0] for nelem and op_info[1] for copied spans */
     HDmemset(&udata, 0, sizeof(udata));
     udata.ds_span[0] = ds_span_info->head;
     udata.ds_low[0] = udata.ds_span[0]->low;
     udata.ss_rank = H5S_GET_EXTENT_NDIMS(src_space);
     udata.ds_rank = H5S_GET_EXTENT_NDIMS(dst_space);
     udata.op_gen = H5S__hyper_get_op_gen();
+    udata.share_selection = share_selection;
 
     /* Iterate over selections and build projected span tree */
     if(H5S__hyper_proj_int_iterate(ss_span_info, src_intersect_space->select.sel_info.hslab->span_lst, 1, 0, &udata) < 0)
diff --git a/src/H5Smpio.c b/src/H5Smpio.c
index f605a8a..800913f 100644
--- a/src/H5Smpio.c
+++ b/src/H5Smpio.c
@@ -86,7 +86,7 @@ static herr_t H5S__mpio_span_hyper_type(const H5S_t *space, size_t elmt_size,
 static herr_t H5S__release_datatype(H5S_mpio_mpitype_list_t *type_list);
 static herr_t H5S__obtain_datatype(H5S_hyper_span_info_t *spans, const hsize_t *down,
     size_t elmt_size, const MPI_Datatype *elmt_type, MPI_Datatype *span_type,
-    H5S_mpio_mpitype_list_t *type_list, uint64_t op_gen);
+    H5S_mpio_mpitype_list_t *type_list, unsigned op_info_i, uint64_t op_gen);
 
 
 /*****************************/
@@ -1007,8 +1007,10 @@ H5S__mpio_span_hyper_type(const H5S_t *space, size_t elmt_size,
     op_gen = H5S__hyper_get_op_gen();
 
     /* Obtain derived MPI data type */
+    /* Always use op_info[0] since we own this op_info, so there can be no
+     * simultaneous operations */
     type_list.head = type_list.tail = NULL;
-    if(H5S__obtain_datatype(space->select.sel_info.hslab->span_lst, down, elmt_size, &elmt_type, &span_type, &type_list, op_gen) < 0)
+    if(H5S__obtain_datatype(space->select.sel_info.hslab->span_lst, down, elmt_size, &elmt_type, &span_type, &type_list, 0, op_gen) < 0)
         HGOTO_ERROR(H5E_DATASPACE, H5E_BADTYPE, FAIL, "couldn't obtain MPI derived data type")
     if(MPI_SUCCESS != (mpi_code = MPI_Type_dup(span_type, new_type)))
         HMPI_GOTO_ERROR(FAIL, "MPI_Type_commit failed", mpi_code)
@@ -1096,7 +1098,7 @@ done:
 static herr_t
 H5S__obtain_datatype(H5S_hyper_span_info_t *spans, const hsize_t *down,
     size_t elmt_size, const MPI_Datatype *elmt_type, MPI_Datatype *span_type,
-    H5S_mpio_mpitype_list_t *type_list, uint64_t op_gen)
+    H5S_mpio_mpitype_list_t *type_list, unsigned op_info_i, uint64_t op_gen)
 {
     H5S_hyper_span_t      *span;                /* Hyperslab span to iterate with */
     hsize_t               bigio_count;          /* Transition point to create derived type */
@@ -1119,7 +1121,7 @@ H5S__obtain_datatype(H5S_hyper_span_info_t *spans, const hsize_t *down,
 
     bigio_count = H5_mpi_get_bigio_count();
     /* Check if we've visited this span tree before */
-    if(spans->op_gen != op_gen) {
+    if(spans->op_info[op_info_i].op_gen != op_gen) {
         H5S_mpio_mpitype_node_t *type_node;     /* Pointer to new node in MPI data type list */
 
         /* Allocate the initial displacement & block length buffers */
@@ -1172,7 +1174,7 @@ H5S__obtain_datatype(H5S_hyper_span_info_t *spans, const hsize_t *down,
 
             /* Everything fits into integers, so cast them and use hindexed */
             if(bigio_count >= outercount && large_block == FALSE) {
-                if(MPI_SUCCESS != (mpi_code = MPI_Type_create_hindexed((int)outercount, blocklen, disp, *elmt_type, &spans->u.down_type)))
+                if(MPI_SUCCESS != (mpi_code = MPI_Type_create_hindexed((int)outercount, blocklen, disp, *elmt_type, &spans->op_info[op_info_i].u.down_type)))
                    HMPI_GOTO_ERROR(FAIL, "MPI_Type_create_hindexed failed", mpi_code)
             } /* end if */
             else {      /* LARGE_DATATYPE:: Something doesn't fit into a 32 bit integer */
@@ -1190,17 +1192,17 @@ H5S__obtain_datatype(H5S_hyper_span_info_t *spans, const hsize_t *down,
 
                     /* Combine the current datatype that is created with this current block type */
                     if(0 == u)      /* first iteration, there is no combined datatype yet */
-                        spans->u.down_type = temp_type;
+                        spans->op_info[op_info_i].u.down_type = temp_type;
                     else {
                         int bl[2] = {1, 1};
                         MPI_Aint ds[2] = {disp[u - 1], disp[u]};
-                        MPI_Datatype dt[2] = {spans->u.down_type, temp_type};
+                        MPI_Datatype dt[2] = {spans->op_info[op_info_i].u.down_type, temp_type};
 
                         if(MPI_SUCCESS != (mpi_code = MPI_Type_create_struct(2,              /* count */
                                                                              bl,             /* blocklength */
                                                                              ds,             /* stride in bytes*/
                                                                              dt,             /* old type */
-                                                                             &spans->u.down_type)))  /* new type */
+                                                                             &spans->op_info[op_info_i].u.down_type)))  /* new type */
                             HMPI_GOTO_ERROR(FAIL, "MPI_Type_create_struct failed", mpi_code)
 
                         /* Release previous temporary datatype */
@@ -1253,7 +1255,7 @@ H5S__obtain_datatype(H5S_hyper_span_info_t *spans, const hsize_t *down,
                 blocklen[outercount]  = 1;
 
                 /* Generate MPI datatype for next dimension down */
-                if(H5S__obtain_datatype(span->down, down + 1, elmt_size, elmt_type, &down_type, type_list, op_gen) < 0)
+                if(H5S__obtain_datatype(span->down, down + 1, elmt_size, elmt_type, &down_type, type_list, op_info_i, op_gen) < 0)
                     HGOTO_ERROR(H5E_DATASPACE, H5E_BADTYPE, FAIL, "couldn't obtain MPI derived data type")
 
                 /* Compute the number of elements to attempt in this span */
@@ -1270,7 +1272,7 @@ H5S__obtain_datatype(H5S_hyper_span_info_t *spans, const hsize_t *down,
 
             /* Building the whole vector datatype */
             H5_CHECK_OVERFLOW(outercount, size_t, int)
-            if(MPI_SUCCESS != (mpi_code = MPI_Type_create_struct((int)outercount, blocklen, disp, inner_type, &spans->u.down_type)))
+            if(MPI_SUCCESS != (mpi_code = MPI_Type_create_struct((int)outercount, blocklen, disp, inner_type, &spans->op_info[op_info_i].u.down_type)))
                 HMPI_GOTO_ERROR(FAIL, "MPI_Type_create_struct failed", mpi_code)
 
             /* Release inner node types */
@@ -1285,7 +1287,7 @@ H5S__obtain_datatype(H5S_hyper_span_info_t *spans, const hsize_t *down,
             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, FAIL, "can't allocate MPI data type list node")
 
         /* Set up MPI type node */
-        type_node->type = spans->u.down_type;
+        type_node->type = spans->op_info[op_info_i].u.down_type;
         type_node->next = NULL;
 
         /* Add MPI type node to list */
@@ -1297,11 +1299,11 @@ H5S__obtain_datatype(H5S_hyper_span_info_t *spans, const hsize_t *down,
         } /* end else */
 
         /* Remember that we've visited this span tree */
-        spans->op_gen = op_gen;
+        spans->op_info[op_info_i].op_gen = op_gen;
     } /* end else */
 
     /* Return MPI data type for span tree */
-    *span_type = spans->u.down_type;
+    *span_type = spans->op_info[op_info_i].u.down_type;
 
 done:
     /* General cleanup */
diff --git a/src/H5Spkg.h b/src/H5Spkg.h
index 278f08d..6809643 100644
--- a/src/H5Spkg.h
+++ b/src/H5Spkg.h
@@ -147,6 +147,21 @@ struct H5S_hyper_span_t {
     struct H5S_hyper_span_t *next;      /* Pointer to next span in list */
 };
 
+/* "Operation info" struct.  Used to hold temporary information during  copies,
+ * 'adjust', 'nelem', and 'rebuild' operations, and higher level algorithms that
+ * generate this information. */
+typedef struct H5S_hyper_op_info_t {
+    uint64_t op_gen;            /* Generation of the scratch info */
+    union {
+        struct H5S_hyper_span_info_t *copied;  /* Pointer to already copied span tree */
+        hsize_t nelmts;         /* # of elements */
+        hsize_t nblocks;        /* # of blocks */
+#ifdef H5_HAVE_PARALLEL
+        MPI_Datatype down_type; /* MPI datatype for span tree */
+#endif  /* H5_HAVE_PARALLEL */
+    }u;
+} H5S_hyper_op_info_t;
+
 /* Information about a list of hyperslab spans in one dimension (typedef'd in H5Sprivate.h) */
 struct H5S_hyper_span_info_t {
     unsigned count;     /* Ref. count of number of spans which share this span */
@@ -165,17 +180,10 @@ struct H5S_hyper_span_info_t {
     hsize_t *low_bounds;        /* The smallest element selected in each dimension */
     hsize_t *high_bounds;       /* The largest element selected in each dimension */
 
-    /* "Operation generation" fields */
+    /* "Operation info" fields */
     /* (Used during copies, 'adjust', 'nelem', and 'rebuild' operations) */
-    uint64_t op_gen;            /* Generation of the scratch info */
-    union {
-        struct H5S_hyper_span_info_t *copied;  /* Pointer to already copied span tree */
-        hsize_t nelmts;         /* # of elements */
-        hsize_t nblocks;        /* # of blocks */
-#ifdef H5_HAVE_PARALLEL
-        MPI_Datatype down_type; /* MPI datatype for span tree */
-#endif  /* H5_HAVE_PARALLEL */
-    }u;
+    /* Currently the maximum number of simultaneous operations is 2 */
+    H5S_hyper_op_info_t op_info[2];
 
     struct H5S_hyper_span_t *head;  /* Pointer to the first span of list of spans in the current dimension */
     struct H5S_hyper_span_t *tail;  /* Pointer to the last span of list of spans in the current dimension */
@@ -377,7 +385,8 @@ H5_DLL uint64_t H5S__hyper_get_op_gen(void);
 H5_DLL void H5S__hyper_rebuild(H5S_t *space);
 H5_DLL herr_t H5S__modify_select(H5S_t *space1, H5S_seloper_t op, H5S_t *space2);
 H5_DLL herr_t H5S__hyper_project_intersection(const H5S_t *src_space,
-    const H5S_t *dst_space, const H5S_t *src_intersect_space, H5S_t *proj_space);
+    const H5S_t *dst_space, const H5S_t *src_intersect_space, H5S_t *proj_space,
+    hbool_t share_space);
 
 /* Testing functions */
 #ifdef H5S_TESTING
diff --git a/src/H5Sprivate.h b/src/H5Sprivate.h
index 3d68de0..41c8b95 100644
--- a/src/H5Sprivate.h
+++ b/src/H5Sprivate.h
@@ -261,7 +261,7 @@ H5_DLL herr_t H5S_select_project_scalar(const H5S_t *space, hsize_t *offset);
 H5_DLL herr_t H5S_select_project_simple(const H5S_t *space, H5S_t *new_space, hsize_t *offset);
 H5_DLL herr_t H5S_select_project_intersection(const H5S_t *src_space,
     const H5S_t *dst_space, const H5S_t *src_intersect_space,
-    H5S_t **new_space_ptr);
+    H5S_t **new_space_ptr, hbool_t share_space);
 H5_DLL herr_t H5S_select_subtract(H5S_t *space, H5S_t *subtract_space);
 
 /* Operations on all selections */
diff --git a/src/H5Spublic.h b/src/H5Spublic.h
index a04f3c1..263a880 100644
--- a/src/H5Spublic.h
+++ b/src/H5Spublic.h
@@ -172,6 +172,8 @@ H5_DLL hssize_t H5Sget_select_hyper_nblocks(hid_t spaceid);
 H5_DLL herr_t H5Sget_select_hyper_blocklist(hid_t spaceid, hsize_t startblock,
     hsize_t numblocks, hsize_t buf[/*numblocks*/]);
 H5_DLL herr_t H5Shyper_adjust_s(hid_t space_id, const hssize_t *offset);
+H5_DLL hid_t H5Sselect_project_intersection(hid_t src_space_id,
+    hid_t dst_space_id, hid_t src_intersect_space_id);
 
 /* Operations on dataspace selection iterators */
 H5_DLL hid_t H5Ssel_iter_create(hid_t spaceid, size_t elmt_size, unsigned flags);
diff --git a/src/H5Sselect.c b/src/H5Sselect.c
index 1a13f2c..65a66cb 100644
--- a/src/H5Sselect.c
+++ b/src/H5Sselect.c
@@ -2533,11 +2533,12 @@ done:
     within the selection of dst_space
 
  USAGE
-    herr_t H5S_select_project_intersection(src_space,dst_space,src_intersect_space,proj_space)
+    herr_t H5S_select_project_intersection(src_space,dst_space,src_intersect_space,proj_space,share_selection)
         H5S_t *src_space;       IN: Selection that is mapped to dst_space, and intersected with src_intersect_space
-        H5S_t *dst_space;       IN: Selection that is mapped to src_space, and which contains the result
+        H5S_t *dst_space;       IN: Selection that is mapped to src_space
         H5S_t *src_intersect_space; IN: Selection whose intersection with src_space is projected to dst_space to obtain the result
         H5S_t **new_space_ptr;  OUT: Will contain the result (intersection of src_intersect_space and src_space projected from src_space to dst_space) after the operation
+        hbool_t share_selection; IN: Whether we are allowed to share structures inside dst_space with proj_space
 
  RETURNS
     Non-negative on success/Negative on failure.
@@ -2555,7 +2556,8 @@ done:
 --------------------------------------------------------------------------*/
 herr_t
 H5S_select_project_intersection(const H5S_t *src_space, const H5S_t *dst_space,
-    const H5S_t *src_intersect_space, H5S_t **new_space_ptr)
+    const H5S_t *src_intersect_space, H5S_t **new_space_ptr,
+    hbool_t share_selection)
 {
     H5S_t *new_space = NULL;           /* New dataspace constructed */
     herr_t ret_value = SUCCEED;         /* Return value */
@@ -2602,8 +2604,8 @@ H5S_select_project_intersection(const H5S_t *src_space, const H5S_t *dst_space,
 
         /* Intersecting space is hyperslab selection.  Call the hyperslab
          * routine to project to another hyperslab selection. */
-        if(H5S__hyper_project_intersection(src_space, dst_space, src_intersect_space, new_space) < 0)
-            HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCLIP, FAIL, "can't project hyperslab ondot destination selection")
+        if(H5S__hyper_project_intersection(src_space, dst_space, src_intersect_space, new_space, share_selection) < 0)
+            HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCLIP, FAIL, "can't project hyperslab onto destination selection")
     } /* end else */
 
     /* load the address of the new space into *new_space_ptr */
@@ -2621,6 +2623,75 @@ done:
 
 /*--------------------------------------------------------------------------
  NAME
+    H5Sselect_project_intersection
+
+ PURPOSE
+    Projects the intersection of of the selections of src_space_id and
+    src_intersect_space_id within the selection of src_space_id as a
+    selection within the selection of dst_space_id.  Currently does not
+    support point selections.
+
+ USAGE
+    hid_t H5Sselect_project_intersection(src_space_id,dst_space_d,src_intersect_space_id)
+        hid_t src_space_id;         IN: Selection that is mapped to dst_space_id, and intersected with src_intersect_space_id
+        hid_t dst_space_id;         IN: Selection that is mapped to src_space_id
+        hid_t src_intersect_space_id; IN: Selection whose intersection with src_space_id is projected to dst_space_id to obtain the result
+
+ RETURNS
+    A dataspace with a selection equal to the intersection of
+    src_intersect_space_id and src_space_id projected from src_space to
+    dst_space on success, negative on failure.
+
+ DESCRIPTION
+    Projects the intersection of of the selections of src_space and
+    src_intersect_space within the selection of src_space as a selection
+    within the selection of dst_space.  The result is placed in the
+    selection of new_space_ptr.
+
+ GLOBAL VARIABLES
+ COMMENTS, BUGS, ASSUMPTIONS
+ EXAMPLES
+ REVISION LOG
+--------------------------------------------------------------------------*/
+hid_t
+H5Sselect_project_intersection(hid_t src_space_id, hid_t dst_space_id,
+    hid_t src_intersect_space_id)
+{
+    H5S_t *src_space, *dst_space, *src_intersect_space; /* Input dataspaces */
+    H5S_t *proj_space = NULL;  /* Output dataspace */
+    hid_t ret_value;           /* Return value */
+
+    FUNC_ENTER_API(FAIL)
+    H5TRACE3("i", "iii", src_space_id, dst_space_id, src_intersect_space_id);
+
+    /* Check args */
+    if(NULL == (src_space = (H5S_t *)H5I_object_verify(src_space_id, H5I_DATASPACE)))
+        HGOTO_ERROR(H5E_DATASPACE, H5E_BADTYPE, FAIL, "not a dataspace")
+    if(NULL == (dst_space = (H5S_t *)H5I_object_verify(dst_space_id, H5I_DATASPACE)))
+        HGOTO_ERROR(H5E_DATASPACE, H5E_BADTYPE, FAIL, "not a dataspace")
+    if(NULL == (src_intersect_space = (H5S_t *)H5I_object_verify(src_intersect_space_id, H5I_DATASPACE)))
+        HGOTO_ERROR(H5E_DATASPACE, H5E_BADTYPE, FAIL, "not a dataspace")
+
+    /* Perform operation */
+    if(H5S_select_project_intersection(src_space, dst_space,
+            src_intersect_space, &proj_space, FALSE) < 0)
+        HGOTO_ERROR(H5E_DATASET, H5E_CANTCLIP, FAIL, "can't project dataspace intersection")
+
+    /* Atomize */
+    if((ret_value = H5I_register(H5I_DATASPACE, proj_space, TRUE)) < 0)
+        HGOTO_ERROR(H5E_ATOM, H5E_CANTREGISTER, FAIL, "unable to register dataspace atom")
+
+done:
+    if(ret_value < 0)
+        if(proj_space && H5S_close(proj_space) < 0)
+            HDONE_ERROR(H5E_DATASPACE, H5E_CANTRELEASE, FAIL, "unable to release dataspace")
+
+    FUNC_LEAVE_API(ret_value)
+} /* end H5Sselect_project_intersection() */
+
+
+/*--------------------------------------------------------------------------
+ NAME
     H5S_select_subtract
 
  PURPOSE