diff options
Diffstat (limited to 'src/H5Shyper.c')
| -rw-r--r-- | src/H5Shyper.c | 7777 |
1 files changed, 5168 insertions, 2609 deletions
diff --git a/src/H5Shyper.c b/src/H5Shyper.c index 175d0c6..c0a51e4 100644 --- a/src/H5Shyper.c +++ b/src/H5Shyper.c @@ -27,25 +27,6 @@ static int interface_initialize_g = 0; /* Local datatypes */ -/* Parameter block for H5S_hyper_fread, H5S_hyper_fwrite, H5S_hyper_mread & H5S_hyper_mwrite */ -typedef struct { - H5F_t *f; - const struct H5O_layout_t *layout; - const struct H5O_pline_t *pline; - const struct H5O_fill_t *fill; - const struct H5O_efl_t *efl; - size_t elmt_size; - const H5S_t *space; - H5S_sel_iter_t *iter; - hsize_t nelmts; - hid_t dxpl_id; - const void *src; - void *dst; - hsize_t mem_size[H5O_LAYOUT_NDIMS]; - hssize_t offset[H5O_LAYOUT_NDIMS]; - hsize_t hsize[H5O_LAYOUT_NDIMS]; -} H5S_hyper_io_info_t; - /* Parameter block for H5S_hyper_select_iter_mem */ typedef struct { hid_t dt; @@ -53,62 +34,40 @@ typedef struct { const H5S_t *space; H5S_sel_iter_t *iter; void *src; - hsize_t mem_size[H5O_LAYOUT_NDIMS]; - hssize_t mem_offset[H5O_LAYOUT_NDIMS]; H5D_operator_t op; void * op_data; } H5S_hyper_iter_info_t; /* Static function prototypes */ -static H5S_hyper_region_t * H5S_hyper_get_regions (size_t *num_regions, - unsigned rank, unsigned dim, size_t bound_count, - H5S_hyper_bound_t **lo_bounds, hssize_t *pos, hssize_t *offset); -static hsize_t H5S_hyper_fread (int dim, H5S_hyper_io_info_t *io_info); -static hsize_t H5S_hyper_fread_opt (H5F_t *f, const struct H5O_layout_t *layout, - const struct H5O_pline_t *pline, const struct H5O_fill_t *fill, +static herr_t H5S_hyper_init (const H5S_t *space, size_t elmt_size, H5S_sel_iter_t *iter); +static hsize_t H5S_hyper_favail (const H5S_t UNUSED *space, + const H5S_sel_iter_t *sel_iter, hsize_t max); +static hsize_t H5S_hyper_fgath (H5F_t *f, const struct H5O_layout_t *layout, + const struct H5O_pline_t *pline, + const struct H5O_fill_t *fill, const struct H5O_efl_t *efl, size_t elmt_size, const H5S_t *file_space, H5S_sel_iter_t *file_iter, hsize_t nelmts, hid_t dxpl_id, void *_buf/*out*/); -static hsize_t H5S_hyper_fwrite (int dim, - H5S_hyper_io_info_t *io_info); -static hsize_t H5S_hyper_fwrite_opt (H5F_t *f, const struct H5O_layout_t *layout, - const struct H5O_pline_t *pline, const struct H5O_fill_t *fill, +static herr_t H5S_hyper_fscat (H5F_t *f, const struct H5O_layout_t *layout, + const struct H5O_pline_t *pline, + const struct H5O_fill_t *fill, const struct H5O_efl_t *efl, size_t elmt_size, const H5S_t *file_space, H5S_sel_iter_t *file_iter, hsize_t nelmts, hid_t dxpl_id, const void *_buf); -static herr_t H5S_hyper_init (const H5S_t *space, H5S_sel_iter_t *iter); -static hsize_t H5S_hyper_favail (const H5S_t *space, const H5S_sel_iter_t *iter, - hsize_t max); -static hsize_t H5S_hyper_fgath (H5F_t *f, const struct H5O_layout_t *layout, - const struct H5O_pline_t *pline, - const struct H5O_fill_t *fill, - const struct H5O_efl_t *efl, size_t elmt_size, - const H5S_t *file_space, - H5S_sel_iter_t *file_iter, hsize_t nelmts, - hid_t dxpl_id, void *buf/*out*/); -static herr_t H5S_hyper_fscat (H5F_t *f, const struct H5O_layout_t *layout, - const struct H5O_pline_t *pline, - const struct H5O_fill_t *fill, - const struct H5O_efl_t *efl, size_t elmt_size, - const H5S_t *file_space, - H5S_sel_iter_t *file_iter, hsize_t nelmts, - hid_t dxpl_id, const void *buf); -static hsize_t H5S_hyper_mread (int dim, H5S_hyper_io_info_t *io_info); -static hsize_t H5S_hyper_mread_opt (const void *_buf, size_t elmt_size, +static hsize_t H5S_hyper_mgath (const void *_buf, size_t elmt_size, const H5S_t *mem_space, H5S_sel_iter_t *mem_iter, hsize_t nelmts, void *_tconv_buf/*out*/); -static hsize_t H5S_hyper_mgath (const void *_buf, size_t elmt_size, - const H5S_t *mem_space, - H5S_sel_iter_t *mem_iter, hsize_t nelmts, - void *_tconv_buf/*out*/); -static size_t H5S_hyper_mwrite (int dim, H5S_hyper_io_info_t *io_info); -static hsize_t H5S_hyper_mwrite_opt (const void *_tconv_buf, size_t elmt_size, +static herr_t H5S_hyper_mscat (const void *_tconv_buf, size_t elmt_size, const H5S_t *mem_space, H5S_sel_iter_t *mem_iter, hsize_t nelmts, void *_buf/*out*/); -static herr_t H5S_hyper_mscat (const void *_tconv_buf, size_t elmt_size, - const H5S_t *mem_space, - H5S_sel_iter_t *mem_iter, hsize_t nelmts, - void *_buf/*out*/); +static herr_t H5S_hyper_free_span_info (H5S_hyper_span_info_t *span_info); +static herr_t H5S_hyper_free_span (H5S_hyper_span_t *span); +static H5S_hyper_span_info_t *H5S_hyper_copy_span (H5S_hyper_span_info_t *spans); +static herr_t H5S_hyper_span_scratch (H5S_hyper_span_info_t *spans, void *scr_value); +static herr_t H5S_hyper_span_precompute (H5S_hyper_span_info_t *spans, size_t elmt_size); +static herr_t H5S_select_hyperslab (H5S_t *space, H5S_seloper_t op, const hssize_t start[], + const hsize_t stride[], const hsize_t count[], + const hsize_t block[]); const H5S_fconv_t H5S_HYPER_FCONV[1] = {{ "hslab", /*name */ @@ -127,14 +86,14 @@ const H5S_mconv_t H5S_HYPER_MCONV[1] = {{ H5S_hyper_mscat, /*scatter */ }}; -/* Array for use with I/O algorithms which frequently need array of zeros */ -static const hssize_t zero[H5O_LAYOUT_NDIMS]={0}; /* Array of zeros */ +/* Declare a free list to manage the H5S_hyper_span_t struct */ +H5FL_DEFINE_STATIC(H5S_hyper_span_t); -/* Declare a free list to manage the H5S_hyper_node_t struct */ -H5FL_DEFINE_STATIC(H5S_hyper_node_t); +/* Declare a free list to manage arrays of H5S_hyper_span_t */ +H5FL_ARR_DEFINE_STATIC(H5S_hyper_span_t,H5S_MAX_RANK); -/* Declare a free list to manage the H5S_hyper_list_t struct */ -H5FL_DEFINE_STATIC(H5S_hyper_list_t); +/* Declare a free list to manage the H5S_hyper_span_info_t struct */ +H5FL_DEFINE_STATIC(H5S_hyper_span_info_t); /* Declare a free list to manage arrays of size_t */ H5FL_ARR_DEFINE_STATIC(size_t,-1); @@ -142,57 +101,160 @@ H5FL_ARR_DEFINE_STATIC(size_t,-1); /* Declare a free list to manage arrays of hsize_t */ H5FL_ARR_DEFINE_STATIC(hsize_t,-1); -typedef H5S_hyper_bound_t *H5S_hyper_bound_ptr_t; -/* Declare a free list to manage arrays of H5S_hyper_bound_ptr_t */ -H5FL_ARR_DEFINE_STATIC(H5S_hyper_bound_ptr_t,H5S_MAX_RANK); - /* Declare a free list to manage arrays of H5S_hyper_dim_t */ H5FL_ARR_DEFINE_STATIC(H5S_hyper_dim_t,H5S_MAX_RANK); -/* Declare a free list to manage arrays of H5S_hyper_bound_t */ -H5FL_ARR_DEFINE_STATIC(H5S_hyper_bound_t,-1); +#ifdef QAK +static herr_t +H5S_hyper_print_spans_helper(struct H5S_hyper_span_t *span,unsigned depth) +{ + struct H5S_hyper_span_t *tmp_span; + + FUNC_ENTER(H5S_hyper_print_spans_helper, FAIL); -/* Declare a free list to manage arrays of H5S_hyper_region_t */ -H5FL_ARR_DEFINE_STATIC(H5S_hyper_region_t,-1); + tmp_span=span; + while(tmp_span) { + printf("%s: depth=%u, span=%p, (%d, %d), nelem=%u, pstride=%u\n",FUNC,depth,tmp_span,(int)tmp_span->low,(int)tmp_span->high,(unsigned)tmp_span->nelem,(unsigned)tmp_span->pstride); + if(tmp_span->down && tmp_span->down->head) { + printf("%s: spans=%p, count=%u, scratch=%p, head=%p\n",FUNC,tmp_span->down,tmp_span->down->count,tmp_span->down->scratch,tmp_span->down->head); + H5S_hyper_print_spans_helper(tmp_span->down->head,depth+1); + } /* end if */ + tmp_span=tmp_span->next; + } /* end while */ -/* Declare a free list to manage blocks of hyperslab data */ -H5FL_BLK_DEFINE_STATIC(hyper_block); + FUNC_LEAVE(SUCCEED); +} + +static herr_t +H5S_hyper_print_spans(const struct H5S_hyper_span_info_t *span_lst) +{ + FUNC_ENTER(H5S_hyper_print_spans, FAIL); + + if(span_lst!=NULL) { + printf("%s: spans=%p, count=%u, scratch=%p, head=%p\n",FUNC,span_lst,span_lst->count,span_lst->scratch,span_lst->head); + H5S_hyper_print_spans_helper(span_lst->head,0); + } /* end if */ + + FUNC_LEAVE(SUCCEED); +} +#endif /* QAK */ /*------------------------------------------------------------------------- * Function: H5S_hyper_init * - * Purpose: Initializes iteration information for hyperslab selection. + * Purpose: Initializes iteration information for hyperslab span tree selection. * * Return: non-negative on success, negative on failure. * * Programmer: Quincey Koziol - * Tuesday, June 16, 1998 + * Saturday, February 24, 2001 * * Modifications: * *------------------------------------------------------------------------- */ static herr_t -H5S_hyper_init (const H5S_t *space, H5S_sel_iter_t *sel_iter) +H5S_hyper_init (const H5S_t *space, size_t elmt_size, H5S_sel_iter_t *sel_iter) { + H5S_hyper_span_info_t *spans; /* Pointer to hyperslab span info node */ + unsigned u; /* Index variable */ + FUNC_ENTER (H5S_hyper_init, FAIL); /* Check args */ - assert (space && H5S_SEL_HYPERSLABS==space->select.type); - assert (sel_iter); + assert(space && H5S_SEL_HYPERSLABS==space->select.type); + assert(sel_iter); + assert(space->select.sel_info.hslab.span_lst); /* Initialize the number of points to iterate over */ sel_iter->hyp.elmt_left=space->select.num_elem; +/* Initialize the information needed for non-regular hyperslab I/O */ + /* Make a copy of the span tree to iterate over */ + sel_iter->hyp.spans=H5S_hyper_copy_span(space->select.sel_info.hslab.span_lst); + + /* Set the nelem & pstride values according to the element size */ + H5S_hyper_span_precompute(sel_iter->hyp.spans,elmt_size); + + /* Allocate the span tree pointers, span pointers and positions */ + sel_iter->hyp.span = H5FL_ARR_ALLOC(H5S_hyper_span_t,space->extent.u.simple.rank,0); + sel_iter->hyp.off = H5FL_ARR_ALLOC(hsize_t,space->extent.u.simple.rank,0); + + /* Initialize the starting span_info's and spans */ + spans=sel_iter->hyp.spans; + for(u=0; u<space->extent.u.simple.rank; u++) { + /* Set the pointers to the initial span in each dimension */ + assert(spans); + assert(spans->head); + + /* Set the pointer to the first span in the list for this node */ + sel_iter->hyp.span[u] = spans->head; + + /* Set the initial offset to low bound of span */ + sel_iter->hyp.off[u]=sel_iter->hyp.span[u]->low; + + /* Get the pointer to the next level down */ + spans=spans->head->down; + } /* end for */ + +/* Initialize the information needed for regular hyperslab I/O */ /* Allocate the position & initialize to invalid location */ sel_iter->hyp.pos = H5FL_ARR_ALLOC(hsize_t,space->extent.u.simple.rank,0); sel_iter->hyp.pos[0]=(-1); H5V_array_fill(sel_iter->hyp.pos, sel_iter->hyp.pos, sizeof(hssize_t), space->extent.u.simple.rank); - + FUNC_LEAVE (SUCCEED); } /* H5S_hyper_init() */ + + +/*-------------------------------------------------------------------------- + NAME + H5S_hyper_sel_iter_release + PURPOSE + Release "new" hyperslab selection iterator information for a dataspace + USAGE + herr_t H5S_hyper_sel_iter_release(sel_iter) + H5S_sel_iter_t *sel_iter; IN: Pointer to selection iterator + RETURNS + Non-negative on success/Negative on failure + DESCRIPTION + Releases all information for a dataspace "new" hyperslab selection iterator + GLOBAL VARIABLES + COMMENTS, BUGS, ASSUMPTIONS + EXAMPLES + REVISION LOG +--------------------------------------------------------------------------*/ +herr_t +H5S_hyper_sel_iter_release (H5S_sel_iter_t *sel_iter) +{ + FUNC_ENTER (H5S_hyper_sel_iter_release, FAIL); + + /* Check args */ + assert (sel_iter); + +/* Release the information needed for non-regular hyperslab I/O */ + /* Free the copy of the selections span tree */ + if(sel_iter->hyp.spans!=NULL) + H5S_hyper_free_span_info(sel_iter->hyp.spans); + + /* Release the array of pointers to span nodes */ + if(sel_iter->hyp.span!=NULL) + H5FL_ARR_FREE(H5S_hyper_span_t,sel_iter->hyp.span); + + /* Release the array of offsets */ + if(sel_iter->hyp.off!=NULL) + H5FL_ARR_FREE(hsize_t,sel_iter->hyp.off); + +/* Release the information needed for regular hyperslab I/O */ + /* Release the hyperslab position */ + if(sel_iter->hyp.pos!=NULL) + H5FL_ARR_FREE(hsize_t,sel_iter->hyp.pos); + + FUNC_LEAVE (SUCCEED); +} /* H5S_hyper_sel_iter_release() */ + /*------------------------------------------------------------------------- * Function: H5S_hyper_favail @@ -223,711 +285,541 @@ H5S_hyper_favail (const H5S_t * UNUSED space, #endif /* QAK */ FUNC_LEAVE (MIN(sel_iter->hyp.elmt_left,max)); } /* H5S_hyper_favail() */ + /*------------------------------------------------------------------------- - * Function: H5S_hyper_compare_regions + * Function: H5S_hyper_iter_next * - * Purpose: Compares two regions for equality (regions must not overlap!) + * Purpose: Moves a hyperslab iterator to the beginning of the next sequence + * of elements to read. Handles walking off the end in all dimensions. * - * Return: an integer less than, equal to, or greater than zero if the - * first region is considered to be respectively less than, - * equal to, or greater than the second + * Return: Success: non-negative + * Failure: negative * * Programmer: Quincey Koziol - * Friday, July 17, 1998 - * - * Modifications: - * - *------------------------------------------------------------------------- - */ -int -H5S_hyper_compare_regions (const void *r1, const void *r2) -{ - if (((const H5S_hyper_region_t *)r1)->start < ((const H5S_hyper_region_t *)r2)->start) - return(-1); - else if (((const H5S_hyper_region_t *)r1)->start > ((const H5S_hyper_region_t *)r2)->start) - return(1); - else - return(0); -} /* end H5S_hyper_compare_regions */ - -/*------------------------------------------------------------------------- - * Function: H5S_hyper_get_regions - * - * Purpose: Builds a sorted array of the overlaps in a dimension - * - * Return: Success: Pointer to valid array (num_regions parameter - * set to array size) - * - * Failure: 0 + * Friday, September 8, 2000 * - * Programmer: Quincey Koziol - * Monday, June 29, 1998 + * Notes: + * Only used for the optimized hyperslab I/O routines * * Modifications: * *------------------------------------------------------------------------- */ -static H5S_hyper_region_t * -H5S_hyper_get_regions (size_t *num_regions, unsigned rank, unsigned dim, - size_t bound_count, H5S_hyper_bound_t **lo_bounds, hssize_t *pos, - hssize_t *offset) +static int +H5S_hyper_iter_next (const H5S_t *file_space, H5S_sel_iter_t *file_iter) { - H5S_hyper_region_t *ret_value=NULL; /* Pointer to array of regions to return */ - H5S_hyper_region_t *reg=NULL; /* Pointer to array of regions */ - H5S_hyper_bound_t *lo_bound_dim; /* Pointer to the boundary nodes for a given dimension */ - H5S_hyper_node_t *node; /* Region node for a given boundary */ - hssize_t *node_start,*node_end; /* Extra pointers to node's start & end arrays */ - hssize_t *tmp_pos,*tmp_off; /* Extra pointers into the position and offset arrays */ - hssize_t pos_dim,off_dim; /* The position & offset in the dimension passed in */ - size_t num_reg=0; /* Number of regions in array */ - int curr_reg=-1; /* The current region we are working with */ - int temp_dim; /* Temporary dim. holder */ - size_t i; /* Counters */ - - FUNC_ENTER (H5S_hyper_get_regions, NULL); - - assert(num_regions); - assert(lo_bounds); - assert(pos); - -#ifdef QAK - printf("%s: check 1.0, rank=%u, dim=%d\n",FUNC,rank,dim); - for(i=0; i<rank; i++) - printf("%s: %d - pos=%d, offset=%d\n",FUNC,i,(int)pos[i],offset!=NULL ? (int)offset[i] : 0); -#endif /* QAK */ + hsize_t iter_offset[H5O_LAYOUT_NDIMS]; + hsize_t iter_count[H5O_LAYOUT_NDIMS]; + int fast_dim; /* Rank of the fastest changing dimension for the dataspace */ + int temp_dim; /* Temporary rank holder */ + unsigned i; /* Counters */ + unsigned ndims; /* Number of dimensions of dataset */ - /* Iterate over the blocks which fit the position, or all of the blocks, if pos[dim]==-1 */ - lo_bound_dim=lo_bounds[dim]; - pos_dim=pos[dim]; - off_dim=offset[dim]; -#ifdef QAK - printf("%s: check 1.1, bound_count=%d, pos_dim=%d\n",FUNC,bound_count,(int)pos_dim); -#endif /* QAK */ + FUNC_ENTER (H5S_hyper_iter_next, FAIL); - for(i=0; i<bound_count; i++,lo_bound_dim++) { -#ifdef QAK - printf("%s: check 1.2, i=%d, num_reg=%d, curr_reg=%d\n",FUNC,(int)i,(int)num_reg,(int)curr_reg); - printf("%s: check 1.2.1, lo_bound_dim->bound=%d\n",FUNC,(int)lo_bound_dim->bound); -#endif /* QAK */ - /* Check if each boundary overlaps in the higher dimensions */ - node=lo_bound_dim->node; - if(pos_dim<0 || (node->end[dim]+off_dim)>=pos_dim) { - temp_dim=(dim-1); - if(temp_dim>=0) { - node_start=node->start+temp_dim; - node_end=node->end+temp_dim; - tmp_pos=pos+temp_dim; - tmp_off=offset+temp_dim; - while(temp_dim>=0 && *tmp_pos>=(*node_start+*tmp_off) && *tmp_pos<=(*node_end+*tmp_off)) { - temp_dim--; - node_start--; - node_end--; - tmp_pos--; - tmp_off--; - } /* end while */ - } /* end if */ + /* Set some useful rank information */ + fast_dim=file_space->extent.u.simple.rank-1; + ndims=file_space->extent.u.simple.rank; -#ifdef QAK - printf("%s: check 1.3, i=%d, temp_dim=%d\n",FUNC,(int)i,(int)temp_dim); -#endif /* QAK */ - /* Yes, all previous positions match, this is a valid region */ - if(temp_dim<0) { -#ifdef QAK - printf("%s: check 1.4, node->start[%d]=%d, node->end[%d]=%d\n",FUNC,(int)dim,(int)node->start[dim],(int)dim,(int)node->end[dim]); -#endif /* QAK */ - /* Check if we've allocated the array yet */ - if(num_reg==0) { - /* Allocate temporary buffer, big enough for worst case size */ - reg=H5FL_ARR_ALLOC(H5S_hyper_region_t,bound_count,0); - - /* Initialize with first region */ - reg[num_reg].start=MAX(node->start[dim],pos[dim])+offset[dim]; - reg[num_reg].end=node->end[dim]+offset[dim]; - reg[num_reg].node=node; - - /* Increment the number of regions */ - num_reg++; - curr_reg++; - } else { - /* Try to merge regions together in all dimensions, except the final one */ - if(dim<(rank-1) && (node->start[dim]+offset[dim])<=(reg[curr_reg].end+1)) { -#ifdef QAK - printf("%s: check 1.4.1\n",FUNC); -#endif /* QAK */ - reg[curr_reg].end=MAX(node->end[dim],reg[curr_reg].end)+offset[dim]; - } else { /* no overlap with previous region, add new region */ -#ifdef QAK - printf("%s: check 1.4.2\n",FUNC); -#endif /* QAK */ - /* Initialize with new region */ - reg[num_reg].start=node->start[dim]+offset[dim]; - reg[num_reg].end=node->end[dim]+offset[dim]; - reg[num_reg].node=node; - - /* - * Increment the number of regions & the current - * region. - */ - num_reg++; - curr_reg++; - } /* end else */ - } /* end else */ - } /* end if */ - } /* end if */ + /* Calculate the offset and block count for each dimension */ + for(i=0; i<ndims; i++) { + iter_offset[i]=(file_iter->hyp.pos[i]-file_space->select.sel_info.hslab.diminfo[i].start)%file_space->select.sel_info.hslab.diminfo[i].stride; + iter_count[i]=(file_iter->hyp.pos[i]-file_space->select.sel_info.hslab.diminfo[i].start)/file_space->select.sel_info.hslab.diminfo[i].stride; } /* end for */ - /* Save the number of regions we generated */ - *num_regions=num_reg; - - /* Set return value */ - ret_value=reg; - -#ifdef QAK - printf("%s: check 10.0, reg=%p, num_reg=%d\n", - FUNC,reg,num_reg); - for(i=0; i<num_reg; i++) - printf("%s: start[%d]=%d, end[%d]=%d\n", - FUNC,i,(int)reg[i].start,i,(int)reg[i].end); -#endif /* QAK */ - - FUNC_LEAVE (ret_value); -} /* end H5S_hyper_get_regions() */ - - -/*------------------------------------------------------------------------- - * Function: H5S_hyper_block_cache - * - * Purpose: Cache a hyperslab block for reading or writing. - * - * Return: Non-negative on success/Negative on failure - * - * Programmer: Quincey Koziol - * Monday, September 21, 1998 - * - * Modifications: - * - *------------------------------------------------------------------------- - */ -static herr_t -H5S_hyper_block_cache (H5S_hyper_node_t *node, - H5S_hyper_io_info_t *io_info, unsigned block_read) -{ - hssize_t file_offset[H5O_LAYOUT_NDIMS]; /*offset of slab in file*/ - hsize_t hsize[H5O_LAYOUT_NDIMS]; /*size of hyperslab */ - unsigned u; /* Counters */ + /* Start with the fastest changing dimension */ + temp_dim=fast_dim; + while(temp_dim>=0) { + if(temp_dim==fast_dim) { + /* Move to the next block in the current dimension */ + iter_offset[temp_dim]=0; /* reset the offset in the fastest dimension */ + iter_count[temp_dim]++; - FUNC_ENTER (H5S_hyper_block_cache, SUCCEED); + /* If this block is still in the range of blocks to output for the dimension, break out of loop */ + if(iter_count[temp_dim]<file_space->select.sel_info.hslab.diminfo[temp_dim].count) + break; + else + iter_count[temp_dim]=0; /* reset back to the beginning of the line */ + } /* end if */ + else { + /* Move to the next row in the curent dimension */ + iter_offset[temp_dim]++; - assert(node); - assert(io_info); + /* If this block is still in the range of blocks to output for the dimension, break out of loop */ + if(iter_offset[temp_dim]<file_space->select.sel_info.hslab.diminfo[temp_dim].block) + break; + else { + /* Move to the next block in the current dimension */ + iter_offset[temp_dim]=0; + iter_count[temp_dim]++; - /* Allocate temporary buffer of proper size */ - if((node->cinfo.block=H5FL_BLK_ALLOC(hyper_block,(node->cinfo.size*io_info->elmt_size),0))==NULL) - HRETURN_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, - "can't allocate hyperslab cache block"); + /* If this block is still in the range of blocks to output for the dimension, break out of loop */ + if(iter_count[temp_dim]<file_space->select.sel_info.hslab.diminfo[temp_dim].count) + break; + else + iter_count[temp_dim]=0; /* reset back to the beginning of the line */ + } /* end else */ + } /* end else */ - /* Read in block, if we are read caching */ - if(block_read) { - /* Copy the location of the region in the file */ - HDmemcpy(file_offset,node->start,(io_info->space->extent.u.simple.rank * sizeof(hssize_t))); - file_offset[io_info->space->extent.u.simple.rank]=0; - - /* Set the hyperslab size to read */ - for(u=0; u<io_info->space->extent.u.simple.rank; u++) - hsize[u]=(node->end[u]-node->start[u])+1; - hsize[io_info->space->extent.u.simple.rank]=io_info->elmt_size; - - if (H5F_arr_read(io_info->f, io_info->dxpl_id, - io_info->layout, io_info->pline, - io_info->fill, io_info->efl, hsize, hsize, - zero, file_offset, node->cinfo.block/*out*/)<0) - HRETURN_ERROR (H5E_DATASPACE, H5E_READERROR, FAIL, "read error"); - } /* end if */ - else { -/* keep information for writing block later? */ - } /* end else */ - - /* Set up parameters for accessing block (starting the read and write information at the same point) */ - node->cinfo.wleft=node->cinfo.rleft=(unsigned)node->cinfo.size; - node->cinfo.wpos=node->cinfo.rpos=node->cinfo.block; + /* Decrement dimension count */ + temp_dim--; + } /* end while */ - /* Set cached flag */ - node->cinfo.cached=1; + /* Translate current iter_offset and iter_count into iterator position */ + for(i=0; i<ndims; i++) + file_iter->hyp.pos[i]=file_space->select.sel_info.hslab.diminfo[i].start+(file_space->select.sel_info.hslab.diminfo[i].stride*iter_count[i])+iter_offset[i]; FUNC_LEAVE (SUCCEED); -} /* H5S_hyper_block_cache() */ +} /* H5S_hyper_iter_next() */ + /*------------------------------------------------------------------------- - * Function: H5S_hyper_block_read + * Function: H5S_hyper_fread * - * Purpose: Read in data from a cached hyperslab block + * Purpose: Performs an optimized gather from the file, based on a hyperslab + * span tree. * - * Return: Non-negative on success/Negative on failure + * Return: Success: Number of elements copied. + * Failure: 0 * * Programmer: Quincey Koziol - * Monday, September 21, 1998 + * Friday, September 8, 2000 * * Modifications: * *------------------------------------------------------------------------- */ -static herr_t -H5S_hyper_block_read (H5S_hyper_node_t *node, H5S_hyper_io_info_t *io_info, hsize_t region_size) +static hsize_t +H5S_hyper_fread (H5F_t *f, const struct H5O_layout_t *layout, + const struct H5O_pline_t *pline, + const struct H5O_fill_t *fill, + const struct H5O_efl_t *efl, size_t elmt_size, + const H5S_t *space, H5S_sel_iter_t *iter, + hsize_t nelem, hid_t dxpl_id, void *_buf/*out*/) { - FUNC_ENTER (H5S_hyper_block_read, SUCCEED); - - assert(node && node->cinfo.cached); - assert(io_info); + uint8_t *dst=(uint8_t *)_buf; /* Alias for pointer arithmetic */ + H5S_hyper_span_t **ispan; /* Iterator's hyperslab span nodes */ + H5S_hyper_span_t *curr_span; /* Current hyperslab span node */ + hsize_t slab[H5O_LAYOUT_NDIMS]; /* Cumulative size of each dimension in bytes */ + hsize_t acc; /* Accumulator for computing cumulative sizes */ + hssize_t *abs_arr; /* Absolute hyperslab span position */ + hssize_t *off_arr; /* Offset within the dataspace extent */ + int fast_dim; /* Rank of the fastest changing dimension for the dataspace */ + int curr_dim; /* Current dimension being operated on */ + int ndims; /* Number of dimensions of dataset */ + hsize_t loc_off; /* Element offset in the dataspace */ + size_t span_size; /* Number of bytes in current span to actually process */ + size_t io_bytes_left; /* Number of bytes left to process */ + int i; /* Index variable */ + size_t *seq_len_arr=NULL; /* Array of sequence lengths */ + hsize_t *buf_off_arr=NULL; /* Array of dataset offsets */ + size_t last_io_bytes_left=0; /* Last I/O bytes left before readv() called */ + size_t nseq=0; /* Number of sequence/offsets stored in the arrays */ + size_t vector_size; /* Value for vector size */ + hssize_t ret_value=FAIL; - /* Copy the elements into the user's buffer */ - /* - !! NOTE !! This will need to be changed for different dimension - permutations from the standard 'C' ordering! - */ + FUNC_ENTER (H5S_hyper_fread, 0); #ifdef QAK - printf("%s: check 1.0, io_info->dst=%p, node->cinfo.rpos=%p, region_size=%lu, io_info->elmt_size=%lu\n",FUNC,io_info->dst,node->cinfo.rpos,(unsigned long)region_size,(unsigned long)io_info->elmt_size); +printf("%s: Called!\n",FUNC); #endif /* QAK */ - HDmemcpy(io_info->dst, node->cinfo.rpos, (size_t)(region_size*io_info->elmt_size)); - /* - * Decrement the number of elements left in block to read & move the - * offset - */ - node->cinfo.rpos+=region_size*io_info->elmt_size; - node->cinfo.rleft-=region_size; + /* Check args */ + assert(f); + assert(layout); + assert(pline); + assert(fill); + assert(efl); + assert(elmt_size>0); + assert(space); + assert(iter); + assert(nelem>0); + assert(dst); - /* If we've read in all the elements from the block, throw it away */ - if(node->cinfo.rleft==0 && (node->cinfo.wleft==0 || node->cinfo.wleft==node->cinfo.size)) { - /* Release the temporary buffer */ - H5FL_BLK_FREE(hyper_block,node->cinfo.block); + /* Set the rank of the fastest changing dimension */ + ndims=space->extent.u.simple.rank; + fast_dim=(ndims-1); + + /* Get the pointers to the current span info and span nodes */ + curr_span=iter->hyp.span[fast_dim]; + abs_arr=iter->hyp.off; + off_arr=space->select.offset; + ispan=iter->hyp.span; + + /* Set the amount of elements to perform I/O on, etc. */ + assert(nelem==(hsize_t)((size_t)(nelem))); /*check for overflow*/ + io_bytes_left=nelem*elmt_size; + + /* Compute the cumulative size of dataspace dimensions */ + for(i=fast_dim, acc=elmt_size; i>=0; i--) { + slab[i]=acc; + acc*=space->extent.u.simple.size[i]; + } /* end for */ - /* Reset the caching flag for next time */ - node->cinfo.cached=0; - } /* end if */ + /* Set the offset of the first element iterated on */ + for(i=0, loc_off=0; i<ndims; i++) + /* Compute the sequential element offset */ + loc_off+=(abs_arr[i]+space->select.offset[i])*slab[i]; - FUNC_LEAVE (SUCCEED); -} /* H5S_hyper_block_read() */ - -/*------------------------------------------------------------------------- - * Function: H5S_hyper_block_write - * - * Purpose: Write out data to a cached hyperslab block - * - * Return: Non-negative on success/Negative on failure - * - * Programmer: Quincey Koziol - * Monday, September 21, 1998 - * - * Modifications: - * - *------------------------------------------------------------------------- - */ -static herr_t -H5S_hyper_block_write (H5S_hyper_node_t *node, - H5S_hyper_io_info_t *io_info, - hsize_t region_size) -{ - hssize_t file_offset[H5O_LAYOUT_NDIMS]; /*offset of slab in file*/ - hsize_t hsize[H5O_LAYOUT_NDIMS]; /*size of hyperslab */ - unsigned u; /* Counters */ + /* Get the hyperslab vector size */ + if (H5P_get(dxpl_id,H5D_XFER_HYPER_VECTOR_SIZE_NAME,&vector_size)<0) + HGOTO_ERROR(H5E_PLIST, H5E_CANTGET, 0, "unable to get value"); - FUNC_ENTER (H5S_hyper_block_write, SUCCEED); + /* Allocate the vector I/O arrays */ + if((seq_len_arr = H5FL_ARR_ALLOC(size_t,vector_size,0))==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, 0, "can't allocate vector I/O array"); + if((buf_off_arr = H5FL_ARR_ALLOC(hsize_t,vector_size,0))==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, 0, "can't allocate vector I/O array"); - assert(node && node->cinfo.cached); - assert(io_info); + /* Range check against number of elements left in selection */ + assert(io_bytes_left<=(iter->hyp.elmt_left*elmt_size)); - /* Copy the elements into the user's buffer */ - /* - !! NOTE !! This will need to be changed for different dimension - permutations from the standard 'C' ordering! - */ - HDmemcpy(node->cinfo.wpos, io_info->src, (size_t)(region_size*io_info->elmt_size)); + /* Take care of any partial spans leftover from previous I/Os */ + if(abs_arr[fast_dim]!=curr_span->low) { - /* - * Decrement the number of elements left in block to read & move the - * offset - */ - node->cinfo.wpos+=region_size*io_info->elmt_size; - node->cinfo.wleft-=region_size; + /* Finish the span in the fastest changing dimension */ - /* If we've read in all the elements from the block, throw it away */ - if(node->cinfo.wleft==0 && (node->cinfo.rleft==0 || node->cinfo.rleft==node->cinfo.size)) { - /* Copy the location of the region in the file */ - HDmemcpy(file_offset, node->start, (io_info->space->extent.u.simple.rank * sizeof(hssize_t))); - file_offset[io_info->space->extent.u.simple.rank]=0; + /* Compute the number of bytes to attempt in this span */ + span_size=((curr_span->high-abs_arr[fast_dim])+1)*elmt_size; - /* Set the hyperslab size to write */ - for(u=0; u<io_info->space->extent.u.simple.rank; u++) - hsize[u]=(node->end[u]-node->start[u])+1; - hsize[io_info->space->extent.u.simple.rank]=io_info->elmt_size; + /* Check number of bytes against upper bounds allowed */ + if(span_size>io_bytes_left) + span_size=io_bytes_left; - if (H5F_arr_write(io_info->f, io_info->dxpl_id, io_info->layout, - io_info->pline, io_info->fill, io_info->efl, hsize, - hsize, zero, file_offset, - node->cinfo.block/*out*/)<0) - HRETURN_ERROR (H5E_DATASPACE, H5E_WRITEERROR, FAIL, "write error"); + if (H5F_seq_read(f, dxpl_id, layout, pline, fill, efl, space, + elmt_size, span_size, loc_off, dst/*out*/)<0) { + HGOTO_ERROR(H5E_DATASPACE, H5E_READERROR, 0, "read error"); + } - /* Release the temporary buffer */ - H5FL_BLK_FREE(hyper_block,node->cinfo.block); + /* Increment offset in destination */ + dst+=span_size; - /* Reset the caching flag for next time */ - node->cinfo.cached=0; - } /* end if */ + /* Decrement I/O left to perform */ + io_bytes_left-=span_size; - FUNC_LEAVE (SUCCEED); -} /* H5S_hyper_block_write() */ + /* Check if we are done */ + if(io_bytes_left>0) { + /* Move to next span in fastest changing dimension */ + curr_span=curr_span->next; - -/*------------------------------------------------------------------------- - * Function: H5S_hyper_fread - * - * Purpose: Recursively gathers data points from a file using the - * parameters passed to H5S_hyper_fgath. - * - * Return: Success: Number of elements copied. - * - * Failure: 0 - * - * Programmer: Quincey Koziol - * Tuesday, June 16, 1998 - * - * Modifications: - * - *------------------------------------------------------------------------- - */ -static hsize_t -H5S_hyper_fread (int dim, H5S_hyper_io_info_t *io_info) -{ - hsize_t region_size; /* Size of lowest region */ - unsigned parm_init=0; /* Whether one-shot parameters set up */ - H5S_hyper_region_t *regions; /* Pointer to array of hyperslab nodes overlapped */ - size_t num_regions; /* number of regions overlapped */ - size_t i; /* Counters */ - int j; -#ifdef QAK - unsigned u; -#endif /* QAK */ - hsize_t num_read=0; /* Number of elements read */ - unsigned cache_hyper; /* Hyperslab caching turned on? */ - unsigned block_limit; /* Hyperslab cache limit */ + if(curr_span!=NULL) { + /* Move location offset of destination */ + loc_off+=(curr_span->low-abs_arr[fast_dim])*elmt_size; - FUNC_ENTER (H5S_hyper_fread, 0); + /* Move iterator for fastest changing dimension */ + abs_arr[fast_dim]=curr_span->low; + } /* end if */ + } /* end if */ + else { + abs_arr[fast_dim]+=span_size/elmt_size; - assert(io_info); + /* Check if we are still within the span */ + if(abs_arr[fast_dim]<=curr_span->high) { + iter->hyp.span[fast_dim]=curr_span; - /* Get the hyperslab cache setting and limit */ - if (H5P_get(io_info->dxpl_id,H5D_XFER_HYPER_CACHE_NAME,&cache_hyper)<0) - HRETURN_ERROR(H5E_PLIST, H5E_CANTGET, 0, "unable to get value"); - if (H5P_get(io_info->dxpl_id,H5D_XFER_HYPER_CACHE_LIM_NAME,&block_limit)<0) - HRETURN_ERROR(H5E_PLIST, H5E_CANTGET, 0, "unable to get value"); + goto partial_done; /* finished with partial span */ + } /* end if */ + /* If we walked off that span, advance to the next span */ + else { + /* Advance span in this dimension */ + curr_span=curr_span->next; -#ifdef QAK - printf("%s: check 1.0, dim=%d\n",FUNC,dim); -#endif /* QAK */ + /* Check if we have a valid span in this dimension still */ + if(curr_span!=NULL) { + /* Reset absolute position */ + abs_arr[fast_dim]=curr_span->low; + iter->hyp.span[fast_dim]=curr_span; - /* Get a sorted list (in the next dimension down) of the regions which */ - /* overlap the current index in this dim */ - if((regions=H5S_hyper_get_regions(&num_regions,io_info->space->extent.u.simple.rank, - (unsigned)(dim+1), - io_info->space->select.sel_info.hslab.hyper_lst->count, - io_info->space->select.sel_info.hslab.hyper_lst->lo_bounds, - io_info->iter->hyp.pos,io_info->space->select.offset))!=NULL) { + goto partial_done; /* finished with partial span */ + } /* end if */ + } /* end else */ + } /* end else */ - /* - * Check if this is the second to last dimension in dataset (Which - * means that we've got a list of the regions in the fastest changing - * dimension and should input those regions). - */ -#ifdef QAK - if(dim>=0) { - printf("%s: check 2.0, rank=%d, ", - FUNC,(int)io_info->space->extent.u.simple.rank); - printf("%s: pos={",FUNC); - for(u=0; u<io_info->space->extent.u.simple.rank; u++) { - printf("%d",(int)io_info->iter->hyp.pos[u]); - if(u<io_info->space->extent.u.simple.rank-1) - printf(", "); - } /* end for */ - printf("}\n"); - } /* end if */ - else - printf("%s: check 2.0, rank=%d\n", - FUNC,(int)io_info->space->extent.u.simple.rank); - for(i=0; i<num_regions; i++) - printf("%s: check 2.1, region #%d: start=%d, end=%d\n", - FUNC,i,(int)regions[i].start,(int)regions[i].end); -#endif /* QAK */ - if((unsigned)(dim+2)==io_info->space->extent.u.simple.rank) { -#ifdef QAK - printf("%s: check 2.1.1, num_regions=%d\n",FUNC,(int)num_regions); -#endif /* QAK */ - /* perform I/O on data from regions */ - for(i=0; i<num_regions && io_info->nelmts>0; i++) { - /* Compute the size of the region to read */ - H5_CHECK_OVERFLOW(io_info->nelmts,hsize_t,hssize_t); - region_size=MIN((hssize_t)io_info->nelmts, (regions[i].end-regions[i].start)+1); + /* Adjust iterator pointers */ -#ifdef QAK - printf("%s: check 2.1.2, region=%d, region_size=%d, num_read=%lu\n",FUNC,(int)i,(int)region_size,(unsigned long)num_read); -#endif /* QAK */ - /* Check if this hyperslab block is cached or could be cached */ - if(!regions[i].node->cinfo.cached && - (cache_hyper && - (block_limit==0 || block_limit>=(regions[i].node->cinfo.size*io_info->elmt_size)))) { - /* if we aren't cached, attempt to cache the block */ -#ifdef QAK - printf("%s: check 2.1.3, caching block\n",FUNC); -#endif /* QAK */ - H5S_hyper_block_cache(regions[i].node,io_info,1); - } /* end if */ + if(curr_span==NULL) { +/* Same as code in main loop */ + /* Start at the next fastest dim */ + curr_dim=fast_dim-1; - /* Read information from the cached block */ - if(regions[i].node->cinfo.cached) { -#ifdef QAK - printf("%s: check 2.1.4, reading block from cache\n",FUNC); -#endif /* QAK */ - if(H5S_hyper_block_read(regions[i].node,io_info,region_size)<0) - HRETURN_ERROR (H5E_DATASPACE, H5E_READERROR, 0, "read error"); - } + /* Work back up through the dimensions */ + while(curr_dim>=0) { + /* Reset the current span */ + curr_span=iter->hyp.span[curr_dim]; + + /* Increment absolute position */ + abs_arr[curr_dim]++; + + /* Check if we are still within the span */ + if(abs_arr[curr_dim]<=curr_span->high) { + break; + } /* end if */ + /* If we walked off that span, advance to the next span */ else { -#ifdef QAK - printf("%s: check 2.1.5, reading block from file, parm_init=%d\n",FUNC,(int)parm_init); -#endif /* QAK */ - /* Set up hyperslab I/O parameters which apply to all regions */ - if(!parm_init) { - /* Copy the location of the region in the file */ - HDmemcpy(io_info->offset,io_info->iter->hyp.pos,(io_info->space->extent.u.simple.rank * sizeof(hssize_t))); - io_info->offset[io_info->space->extent.u.simple.rank]=0; - - /* Set flag */ - parm_init=1; - } /* end if */ + /* Advance span in this dimension */ + curr_span=curr_span->next; -#ifdef QAK - printf("%s: check 2.2, i=%d, region_size=%d\n",FUNC,(int)i,(int)region_size); -#endif /* QAK */ - /* Fill in the region specific parts of the I/O request */ - io_info->hsize[io_info->space->extent.u.simple.rank-1]=region_size; - io_info->offset[io_info->space->extent.u.simple.rank-1]=regions[i].start; - - /* - * Gather from file. - */ - if (H5F_arr_read(io_info->f, io_info->dxpl_id, - io_info->layout, io_info->pline, - io_info->fill, io_info->efl, - io_info->hsize, io_info->hsize, - zero, io_info->offset, - io_info->dst/*out*/)<0) { - HRETURN_ERROR (H5E_DATASPACE, H5E_READERROR, 0, - "read error"); - } + /* Check if we have a valid span in this dimension still */ + if(curr_span!=NULL) { + /* Reset absolute position */ + abs_arr[curr_dim]=curr_span->low; + + break; + } /* end if */ + else { + /* If we finished the span list in this dimension, decrement the dimension worked on and loop again */ + curr_dim--; + } /* end else */ } /* end else */ -#ifdef QAK - printf("%s: check 2.3, region #%d\n",FUNC,(int)i); - printf("pos={"); - for(u=0; u<io_info->space->extent.u.simple.rank; u++) { - printf("%d",(int)io_info->iter->hyp.pos[u]); - if(u<io_info->space->extent.u.simple.rank-1) - printf(", "); - } /* end for */ - printf("}\n"); -#endif /* QAK */ + } /* end while */ - /* Advance the pointer in the buffer */ - io_info->dst = ((uint8_t *)io_info->dst) + region_size*io_info->elmt_size; + /* Check if we are finished with the spans in the tree */ + if(curr_dim<0) { + /* We had better be done with I/O or bad things are going to happen... */ + assert(io_bytes_left==0); - /* Increment the number of elements read */ - num_read+=region_size; + goto partial_done; /* finished with partial span */ + } /* end if */ + else { + /* Reset the span in the current dimension */ + ispan[curr_dim]=curr_span; - /* Decrement the buffer left */ - io_info->nelmts-=region_size; + /* Walk back down the iterator positions, reseting them */ + while(curr_dim<fast_dim) { + assert(curr_span); + assert(curr_span->down); + assert(curr_span->down->head); - /* Set the next position to start at */ - if(region_size==(hsize_t)((regions[i].end-regions[i].start)+1) - && i==(num_regions-1)) - io_info->iter->hyp.pos[dim+1]=(-1); - else - io_info->iter->hyp.pos[dim+1] = regions[i].start + region_size; -#ifdef QAK - printf("%s: check 2.3.5, region #%d\n",FUNC,(int)i); - printf("pos={"); - for(j=0; j<io_info->space->extent.u.simple.rank; j++) { - printf("%d",(int)io_info->iter->hyp.pos[j]); - if(j<io_info->space->extent.u.simple.rank-1) - printf(", "); - } /* end for */ - printf("}\n"); -#endif /* QAK */ + /* Set the new span_info & span for this dimension */ + iter->hyp.span[curr_dim+1]=curr_span->down->head; - /* Decrement the iterator count */ - io_info->iter->hyp.elmt_left-=region_size; - } /* end for */ - } else { /* recurse on each region to next dimension down */ -#ifdef QAK - printf("%s: check 3.0, num_regions=%d\n",FUNC,(int)num_regions); - for(i=0; i<num_regions; i++) - printf("%s: region %d={%d, %d}\n", FUNC,i,(int)regions[i].start,(int)regions[i].end); -#endif /* QAK */ + /* Advance span down the tree */ + curr_span=curr_span->down->head; - /* Increment the dimension we are working with */ - dim++; + /* Reset the absolute offset for the dim */ + abs_arr[curr_dim+1]=curr_span->low; - /* Step through each region in this dimension */ - for(i=0; i<num_regions && io_info->nelmts>0; i++) { -#ifdef QAK - printf("%s: check 3.5, dim=%d, region #%d={%d, %d}\n",FUNC,(int)dim,(int)i,(int)regions[i].start,(int)regions[i].end); -{ - int k; + /* Increment current dimension */ + curr_dim++; + } /* end while */ - printf("pos={"); - for(k=0; k<io_info->space->extent.u.simple.rank; k++) { - printf("%d",(int)io_info->iter->hyp.pos[k]); - if(k<io_info->space->extent.u.simple.rank-1) - printf(", "); - } /* end for */ - printf("}\n"); -} -#endif /* QAK */ - /* Step through each location in each region */ - for(j=MAX(io_info->iter->hyp.pos[dim],regions[i].start); j<=regions[i].end && io_info->nelmts>0; j++) { -#ifdef QAK - printf("%s: check 4.0, dim=%d, j=%d, num_read=%lu\n",FUNC,dim,j,(unsigned long)num_read); -#endif /* QAK */ + /* Verify that the curr_span points to the fastest dim */ + assert(curr_span==iter->hyp.span[fast_dim]); + } /* end else */ - /* Set the correct position we are working on */ - io_info->iter->hyp.pos[dim]=j; + /* Reset the buffer offset */ + for(i=0, loc_off=0; i<ndims; i++) + loc_off+=(abs_arr[i]+off_arr[i])*slab[i]; + } /* end if */ + } /* end if */ - /* Go get the regions in the next lower dimension */ - num_read+=H5S_hyper_fread(dim, io_info); +partial_done: /* Yes, goto's are evil, so sue me... :-) */ + /* Get the number of bytes left to process currently */ + last_io_bytes_left=io_bytes_left; + + /* Perform the I/O on the elements, based on the position of the iterator */ + while(io_bytes_left>0) { + /* Adjust location offset of destination to compensate for initial increment below */ + loc_off-=curr_span->pstride; + + /* Loop over all the spans in the fastest changing dimension */ + while(curr_span!=NULL) { + /* Move location offset of destination */ + loc_off+=curr_span->pstride; + + /* Compute the number of elements to attempt in this span */ + assert(curr_span->nelem==(hsize_t)((size_t)(curr_span->nelem))); /*check for overflow*/ + span_size=curr_span->nelem; + + /* Check number of elements against upper bounds allowed */ + if(span_size>=io_bytes_left) { + /* Trim the number of bytes to output */ + span_size=io_bytes_left; + io_bytes_left=0; + +/* COMMON */ + /* Store the I/O information for the span */ + seq_len_arr[nseq]=span_size; + buf_off_arr[nseq]=loc_off; + + /* Increment the number of sequences in arrays */ + nseq++; + + /* If the sequence & offset arrays are full, read them in */ + if(nseq>=vector_size) { + /* Read in the sequences */ + if (H5F_seq_readv(f, dxpl_id, layout, pline, fill, efl, space, + elmt_size, nseq, seq_len_arr, buf_off_arr, dst/*out*/)<0) { + HGOTO_ERROR(H5E_DATASPACE, H5E_READERROR, 0, "read error"); + } /* end if */ - /* Advance to the next row if we got the whole region */ - if(io_info->iter->hyp.pos[dim+1]==(-1)) - io_info->iter->hyp.pos[dim]=j+1; - } /* end for */ -#ifdef QAK -{ - printf("%s: check 5.0, dim=%d, j=%d, region #%d={%d, %d}\n",FUNC,(int)dim,(int)j,(int)i,(int)regions[i].start,(int)regions[i].end); - printf("%s: pos={",FUNC); - for(u=0; u<io_info->space->extent.u.simple.rank; u++) { - printf("%d",(int)io_info->iter->hyp.pos[u]); - if(u<io_info->space->extent.u.simple.rank-1) - printf(", "); - } /* end for */ - printf("}\n"); -} -#endif /* QAK */ - if(j>regions[i].end && io_info->iter->hyp.pos[dim+1]==(-1) - && i==(num_regions-1)) - io_info->iter->hyp.pos[dim]=(-1); - } /* end for */ -#ifdef QAK -{ - int k; - - printf("%s: check 6.0, dim=%d\n",FUNC,(int)dim); - printf("pos={"); - for(k=0; k<io_info->space->extent.u.simple.rank; k++) { - printf("%d",(int)io_info->iter->hyp.pos[k]); - if(k<io_info->space->extent.u.simple.rank-1) - printf(", "); - } /* end for */ - printf("}\n"); -} -#endif /* QAK */ - } /* end else */ + /* Increment the offset of the destination buffer */ + dst+=(last_io_bytes_left-io_bytes_left); - /* Release the temporary buffer */ - H5FL_ARR_FREE(H5S_hyper_region_t,regions); - } /* end if */ + /* Keep around the current number of I/O bytes left */ + last_io_bytes_left=io_bytes_left; + nseq=0; + } /* end else */ +/* end COMMON */ - FUNC_LEAVE (num_read); -} /* H5S_hyper_fread() */ + /* Break out now, we are finished with I/O */ + break; + } /* end if */ + else { + /* Decrement I/O left to perform */ + io_bytes_left-=span_size; - -/*------------------------------------------------------------------------- - * Function: H5S_hyper_iter_next - * - * Purpose: Moves a hyperslab iterator to the beginning of the next sequence - * of elements to read. Handles walking off the end in all dimensions. - * - * Return: Success: non-negative - * Failure: negative - * - * Programmer: Quincey Koziol - * Friday, September 8, 2000 - * - * Modifications: - * - *------------------------------------------------------------------------- - */ -static int -H5S_hyper_iter_next (const H5S_t *file_space, H5S_sel_iter_t *file_iter) -{ - hsize_t iter_offset[H5O_LAYOUT_NDIMS]; - hsize_t iter_count[H5O_LAYOUT_NDIMS]; - int fast_dim; /* Rank of the fastest changing dimension for the dataspace */ - int temp_dim; /* Temporary rank holder */ - unsigned i; /* Counters */ - unsigned ndims; /* Number of dimensions of dataset */ +/* COMMON */ + /* Store the I/O information for the span */ + seq_len_arr[nseq]=span_size; + buf_off_arr[nseq]=loc_off; + + /* Increment the number of sequences in arrays */ + nseq++; + + /* If the sequence & offset arrays are full, read them in */ + if(nseq>=vector_size) { + /* Read in the sequences */ + if (H5F_seq_readv(f, dxpl_id, layout, pline, fill, efl, space, + elmt_size, nseq, seq_len_arr, buf_off_arr, dst/*out*/)<0) { + HGOTO_ERROR(H5E_DATASPACE, H5E_READERROR, 0, "read error"); + } /* end if */ - FUNC_ENTER (H5S_hyper_iter_next, FAIL); + /* Increment the offset of the destination buffer */ + dst+=(last_io_bytes_left-io_bytes_left); - /* Set some useful rank information */ - fast_dim=file_space->extent.u.simple.rank-1; - ndims=file_space->extent.u.simple.rank; + /* Keep around the current number of I/O bytes left */ + last_io_bytes_left=io_bytes_left; + nseq=0; + } /* end else */ +/* end COMMON */ + } /* end else */ - /* Calculate the offset and block count for each dimension */ - for(i=0; i<ndims; i++) { - iter_offset[i]=(file_iter->hyp.pos[i]-file_space->select.sel_info.hslab.diminfo[i].start)%file_space->select.sel_info.hslab.diminfo[i].stride; - iter_count[i]=(file_iter->hyp.pos[i]-file_space->select.sel_info.hslab.diminfo[i].start)/file_space->select.sel_info.hslab.diminfo[i].stride; - } /* end for */ + /* Move to next span in fastest changing dimension */ + curr_span=curr_span->next; + } /* end while */ - /* Start with the fastest changing dimension */ - temp_dim=fast_dim; - while(temp_dim>=0) { - if(temp_dim==fast_dim) { - /* Move to the next block in the current dimension */ - iter_offset[temp_dim]=0; /* reset the offset in the fastest dimension */ - iter_count[temp_dim]++; + /* Check if we are done */ + if(io_bytes_left==0) { + abs_arr[fast_dim]=curr_span->low+(span_size/elmt_size); - /* If this block is still in the range of blocks to output for the dimension, break out of loop */ - if(iter_count[temp_dim]<file_space->select.sel_info.hslab.diminfo[temp_dim].count) + /* Check if we are still within the span */ + if(abs_arr[fast_dim]<=curr_span->high) { + iter->hyp.span[fast_dim]=curr_span; break; - else - iter_count[temp_dim]=0; /* reset back to the beginning of the line */ + } /* end if */ + /* If we walked off that span, advance to the next span */ + else { + /* Advance span in this dimension */ + curr_span=curr_span->next; + + /* Check if we have a valid span in this dimension still */ + if(curr_span!=NULL) { + /* Reset absolute position */ + abs_arr[fast_dim]=curr_span->low; + iter->hyp.span[fast_dim]=curr_span; + break; + } /* end if */ + } /* end else */ } /* end if */ - else { - /* Move to the next row in the curent dimension */ - iter_offset[temp_dim]++; - /* If this block is still in the range of blocks to output for the dimension, break out of loop */ - if(iter_offset[temp_dim]<file_space->select.sel_info.hslab.diminfo[temp_dim].block) + /* Adjust iterator pointers */ + + /* Start at the next fastest dim */ + curr_dim=fast_dim-1; + + /* Work back up through the dimensions */ + while(curr_dim>=0) { + /* Reset the current span */ + curr_span=iter->hyp.span[curr_dim]; + + /* Increment absolute position */ + abs_arr[curr_dim]++; + + /* Check if we are still within the span */ + if(abs_arr[curr_dim]<=curr_span->high) { break; + } /* end if */ + /* If we walked off that span, advance to the next span */ else { - /* Move to the next block in the current dimension */ - iter_offset[temp_dim]=0; - iter_count[temp_dim]++; + /* Advance span in this dimension */ + curr_span=curr_span->next; + + /* Check if we have a valid span in this dimension still */ + if(curr_span!=NULL) { + /* Reset absolute position */ + abs_arr[curr_dim]=curr_span->low; - /* If this block is still in the range of blocks to output for the dimension, break out of loop */ - if(iter_count[temp_dim]<file_space->select.sel_info.hslab.diminfo[temp_dim].count) break; - else - iter_count[temp_dim]=0; /* reset back to the beginning of the line */ + } /* end if */ + else { + /* If we finished the span list in this dimension, decrement the dimension worked on and loop again */ + curr_dim--; + } /* end else */ } /* end else */ + } /* end while */ + + /* Check if we are finished with the spans in the tree */ + if(curr_dim<0) { + /* We had better be done with I/O or bad things are going to happen... */ + assert(io_bytes_left==0); + break; + } /* end if */ + else { + /* Reset the span in the current dimension */ + ispan[curr_dim]=curr_span; + + /* Walk back down the iterator positions, reseting them */ + while(curr_dim<fast_dim) { + assert(curr_span); + assert(curr_span->down); + assert(curr_span->down->head); + + /* Set the new span for the next dimension down */ + iter->hyp.span[curr_dim+1]=curr_span->down->head; + + /* Advance span down the tree */ + curr_span=curr_span->down->head; + + /* Reset the absolute offset for the dim */ + abs_arr[curr_dim+1]=curr_span->low; + + /* Increment current dimension */ + curr_dim++; + } /* end while */ + + /* Verify that the curr_span points to the fastest dim */ + assert(curr_span==iter->hyp.span[fast_dim]); } /* end else */ - /* Decrement dimension count */ - temp_dim--; + /* Reset the buffer offset */ + for(i=0, loc_off=0; i<ndims; i++) + loc_off+=(abs_arr[i]+off_arr[i])*slab[i]; } /* end while */ + + /* Check for any stored sequences which need to be flushed */ + if(nseq>0) { + /* Read in the sequence */ + if (H5F_seq_readv(f, dxpl_id, layout, pline, fill, efl, space, + elmt_size, nseq, seq_len_arr, buf_off_arr, dst/*out*/)<0) { + HRETURN_ERROR(H5E_DATASPACE, H5E_READERROR, 0, "read error"); + } /* end if */ + } /* end if */ - /* Translate current iter_offset and iter_count into iterator position */ - for(i=0; i<ndims; i++) - file_iter->hyp.pos[i]=file_space->select.sel_info.hslab.diminfo[i].start+(file_space->select.sel_info.hslab.diminfo[i].stride*iter_count[i])+iter_offset[i]; + /* Increment amount of I/O performed */ + iter->hyp.elmt_left-=nelem; - FUNC_LEAVE (SUCCEED); -} /* H5S_hyper_iter_next() */ + /* Success! */ + ret_value=nelem; + +done: + if(seq_len_arr!=NULL) + H5FL_ARR_FREE(size_t,seq_len_arr); + if(buf_off_arr!=NULL) + H5FL_ARR_FREE(hsize_t,buf_off_arr); + + FUNC_LEAVE (ret_value); +} /* H5S_hyper_fread() */ /*------------------------------------------------------------------------- @@ -1550,7 +1442,6 @@ H5S_hyper_fgath (H5F_t *f, const struct H5O_layout_t *layout, const H5S_t *file_space, H5S_sel_iter_t *file_iter, hsize_t nelmts, hid_t dxpl_id, void *_buf/*out*/) { - H5S_hyper_io_info_t io_info; /* Block of parameters to pass into recursive calls */ hsize_t num_read=0; /* number of elements read into buffer */ herr_t ret_value=SUCCEED; @@ -1565,42 +1456,14 @@ H5S_hyper_fgath (H5F_t *f, const struct H5O_layout_t *layout, assert (nelmts>0); assert (_buf); -#ifdef QAK - printf("%s: check 1.0\n", FUNC); -#endif /* QAK */ - /* Check for the special case of just one H5Sselect_hyperslab call made */ if(file_space->select.sel_info.hslab.diminfo!=NULL) { /* Use optimized call to read in regular hyperslab */ num_read=H5S_hyper_fread_opt(f,layout,pline,fill,efl,elmt_size,file_space,file_iter,nelmts,dxpl_id,_buf); } /* end if */ - /* Perform generic hyperslab operation */ else { - /* Initialize parameter block for recursive calls */ - io_info.f=f; - io_info.layout=layout; - io_info.pline=pline; - io_info.fill=fill; - io_info.efl=efl; - io_info.elmt_size=elmt_size; - io_info.space=file_space; - io_info.iter=file_iter; - io_info.nelmts=nelmts; - io_info.dxpl_id = dxpl_id; - io_info.src=NULL; - io_info.dst=_buf; - - /* Set the hyperslab size to copy */ - io_info.hsize[0]=1; - H5V_array_fill(io_info.hsize,io_info.hsize,sizeof(io_info.hsize[0]),file_space->extent.u.simple.rank); - io_info.hsize[file_space->extent.u.simple.rank]=elmt_size; - - /* Recursively input the hyperslabs currently defined */ - /* starting with the slowest changing dimension */ - num_read=H5S_hyper_fread(-1,&io_info); -#ifdef QAK - printf("%s: check 5.0, num_read=%d\n",FUNC,(int)num_read); -#endif /* QAK */ + /* Perform generic hyperslab operation */ + num_read=H5S_hyper_fread(f,layout,pline,fill,efl,elmt_size,file_space,file_iter,nelmts,dxpl_id,_buf); } /* end else */ FUNC_LEAVE (ret_value==SUCCEED ? num_read : 0); @@ -1610,167 +1473,449 @@ H5S_hyper_fgath (H5F_t *f, const struct H5O_layout_t *layout, /*------------------------------------------------------------------------- * Function: H5S_hyper_fwrite * - * Purpose: Recursively scatters data points to a file using the parameters - * passed to H5S_hyper_fscat. + * Purpose: Performs an optimized scatter to the file, based on a hyperslab + * span selection. * * Return: Success: Number of elements copied. - * * Failure: 0 * * Programmer: Quincey Koziol - * Tuesday, June 16, 1998 + * Tuesday, September 12, 2000 * * Modifications: * *------------------------------------------------------------------------- */ static hsize_t -H5S_hyper_fwrite (int dim, H5S_hyper_io_info_t *io_info) +H5S_hyper_fwrite (H5F_t *f, const struct H5O_layout_t *layout, + const struct H5O_pline_t *pline, + const struct H5O_fill_t *fill, + const struct H5O_efl_t *efl, size_t elmt_size, + const H5S_t *space, H5S_sel_iter_t *iter, + hsize_t nelem, hid_t dxpl_id, const void *_buf) { - hsize_t region_size; /* Size of lowest region */ - unsigned parm_init=0; /* Whether one-shot parameters set up */ - H5S_hyper_region_t *regions; /* Pointer to array of hyperslab nodes overlapped */ - size_t num_regions; /* number of regions overlapped */ - size_t i; /* Counters */ - int j; - hsize_t num_written=0; /* Number of elements read */ - unsigned cache_hyper; /* Hyperslab caching turned on? */ - unsigned block_limit; /* Hyperslab cache limit */ + const uint8_t *src=(const uint8_t *)_buf; /* Alias for pointer arithmetic */ + H5S_hyper_span_t **ispan; /* Iterator's hyperslab span nodes */ + H5S_hyper_span_t *curr_span; /* Current hyperslab span node */ + hsize_t slab[H5O_LAYOUT_NDIMS]; /* Cumulative size of each dimension in bytes */ + hsize_t acc; /* Accumulator for computing cumulative sizes */ + hssize_t *abs_arr; /* Absolute hyperslab span position */ + hssize_t *off_arr; /* Offset within the dataspace extent */ + int fast_dim; /* Rank of the fastest changing dimension for the dataspace */ + int curr_dim; /* Current dimension being operated on */ + int ndims; /* Number of dimensions of dataset */ + hsize_t loc_off; /* Element offset in the dataspace */ + size_t span_size; /* Number of bytes in current span to actually process */ + size_t io_bytes_left; /* Number of bytes left to process */ + int i; /* Index variable */ + size_t *seq_len_arr=NULL; /* Array of sequence lengths */ + hsize_t *buf_off_arr=NULL; /* Array of dataset offsets */ + size_t last_io_bytes_left=0; /* Last I/O bytes left before readv() called */ + size_t nseq=0; /* Number of sequence/offsets stored in the arrays */ + size_t vector_size; /* Value for vector size */ + hssize_t ret_value=FAIL; FUNC_ENTER (H5S_hyper_fwrite, 0); +#ifdef QAK +printf("%s: Called!\n",FUNC); +#endif /* QAK */ - assert(io_info); + /* Check args */ + assert(f); + assert(layout); + assert(pline); + assert(fill); + assert(efl); + assert(elmt_size>0); + assert(space); + assert(iter); + assert(nelem>0); + assert(src); - /* Get the hyperslab cache setting and limit */ - if (H5P_get(io_info->dxpl_id,H5D_XFER_HYPER_CACHE_NAME,&cache_hyper)<0) - HRETURN_ERROR(H5E_PLIST, H5E_CANTGET, 0, "unable to get value"); - if (H5P_get(io_info->dxpl_id,H5D_XFER_HYPER_CACHE_LIM_NAME,&block_limit)<0) - HRETURN_ERROR(H5E_PLIST, H5E_CANTGET, 0, "unable to get value"); + /* Set the rank of the fastest changing dimension */ + ndims=space->extent.u.simple.rank; + fast_dim=(ndims-1); + + /* Get the pointers to the current span info and span nodes */ + curr_span=iter->hyp.span[fast_dim]; + abs_arr=iter->hyp.off; + off_arr=space->select.offset; + ispan=iter->hyp.span; + + /* Set the amount of elements to perform I/O on, etc. */ + assert(nelem==(hsize_t)((size_t)(nelem))); /*check for overflow*/ + io_bytes_left=nelem*elmt_size; + + /* Compute the cumulative size of dataspace dimensions */ + for(i=fast_dim, acc=elmt_size; i>=0; i--) { + slab[i]=acc; + acc*=space->extent.u.simple.size[i]; + } /* end for */ + /* Set the offset of the first element iterated on */ + for(i=0, loc_off=0; i<ndims; i++) + /* Compute the sequential element offset */ + loc_off+=(abs_arr[i]+space->select.offset[i])*slab[i]; -#ifdef QAK - printf("%s: check 1.0\n", FUNC); -#endif /* QAK */ - /* Get a sorted list (in the next dimension down) of the regions which */ - /* overlap the current index in this dim */ - if((regions=H5S_hyper_get_regions(&num_regions,io_info->space->extent.u.simple.rank, - (unsigned)(dim+1), - io_info->space->select.sel_info.hslab.hyper_lst->count, - io_info->space->select.sel_info.hslab.hyper_lst->lo_bounds, - io_info->iter->hyp.pos,io_info->space->select.offset))!=NULL) { + /* Range check against number of elements left in selection */ + assert(io_bytes_left<=(iter->hyp.elmt_left*elmt_size)); -#ifdef QAK - printf("%s: check 1.1, regions=%p\n", FUNC,regions); - printf("%s: check 1.2, rank=%d\n", - FUNC,(int)io_info->space->extent.u.simple.rank); - for(i=0; i<num_regions; i++) - printf("%s: check 2.1, region #%d: start=%d, end=%d\n", - FUNC,i,(int)regions[i].start,(int)regions[i].end); -#endif /* QAK */ + /* Get the hyperslab vector size */ + if (H5P_get(dxpl_id,H5D_XFER_HYPER_VECTOR_SIZE_NAME,&vector_size)<0) + HGOTO_ERROR(H5E_PLIST, H5E_CANTGET, 0, "unable to get value"); + + /* Allocate the vector I/O arrays */ + if((seq_len_arr = H5FL_ARR_ALLOC(size_t,vector_size,0))==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, 0, "can't allocate vector I/O array"); + if((buf_off_arr = H5FL_ARR_ALLOC(hsize_t,vector_size,0))==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, 0, "can't allocate vector I/O array"); + + /* Take care of any partial spans leftover from previous I/Os */ + if(abs_arr[fast_dim]!=curr_span->low) { + + /* Finish the span in the fastest changing dimension */ + + /* Compute the number of bytes to attempt in this span */ + span_size=((curr_span->high-abs_arr[fast_dim])+1)*elmt_size; + + /* Check number of bytes against upper bounds allowed */ + if(span_size>io_bytes_left) + span_size=io_bytes_left; + + if (H5F_seq_write(f, dxpl_id, layout, pline, fill, efl, space, + elmt_size, span_size, loc_off, src)<0) { + HRETURN_ERROR(H5E_DATASPACE, H5E_WRITEERROR, 0, "write error"); + } /* end if */ + + /* Increment offset in destination */ + src+=span_size; + + /* Decrement I/O left to perform */ + io_bytes_left-=span_size; + + /* Check if we are done */ + if(io_bytes_left>0) { + /* Move to next span in fastest changing dimension */ + curr_span=curr_span->next; + + if(curr_span!=NULL) { + /* Move location offset of destination */ + loc_off+=(curr_span->low-abs_arr[fast_dim])*elmt_size; + + /* Move iterator for fastest changing dimension */ + abs_arr[fast_dim]=curr_span->low; + } /* end if */ + } /* end if */ + else { + abs_arr[fast_dim]+=span_size/elmt_size; + + /* Check if we are still within the span */ + if(abs_arr[fast_dim]<=curr_span->high) { + iter->hyp.span[fast_dim]=curr_span; + + goto partial_done; /* finished with partial span */ + } /* end if */ + /* If we walked off that span, advance to the next span */ + else { + /* Advance span in this dimension */ + curr_span=curr_span->next; + + /* Check if we have a valid span in this dimension still */ + if(curr_span!=NULL) { + /* Reset absolute position */ + abs_arr[fast_dim]=curr_span->low; + iter->hyp.span[fast_dim]=curr_span; - /* Check if this is the second to last dimension in dataset */ - /* (Which means that we've got a list of the regions in the fastest */ - /* changing dimension and should input those regions) */ - if((unsigned)(dim+2)==io_info->space->extent.u.simple.rank) { - - /* perform I/O on data from regions */ - for(i=0; i<num_regions && io_info->nelmts>0; i++) { - /* Compute the size of the region to read */ - H5_CHECK_OVERFLOW(io_info->nelmts,hsize_t,hssize_t); - region_size=MIN((hssize_t)io_info->nelmts, (regions[i].end-regions[i].start)+1); - - /* Check if this hyperslab block is cached or could be cached */ - if(!regions[i].node->cinfo.cached && (cache_hyper && (block_limit==0 || block_limit>=(regions[i].node->cinfo.size*io_info->elmt_size)))) { - /* if we aren't cached, attempt to cache the block */ - H5S_hyper_block_cache(regions[i].node,io_info,0); + goto partial_done; /* finished with partial span */ } /* end if */ + } /* end else */ + } /* end else */ + + /* Adjust iterator pointers */ + + if(curr_span==NULL) { +/* Same as code in main loop */ + /* Start at the next fastest dim */ + curr_dim=fast_dim-1; - /* Write information to the cached block */ - if(regions[i].node->cinfo.cached) { - if(H5S_hyper_block_write(regions[i].node,io_info,region_size)<0) - HRETURN_ERROR (H5E_DATASPACE, H5E_WRITEERROR, 0, "write error"); - } + /* Work back up through the dimensions */ + while(curr_dim>=0) { + /* Reset the current span */ + curr_span=iter->hyp.span[curr_dim]; + + /* Increment absolute position */ + abs_arr[curr_dim]++; + + /* Check if we are still within the span */ + if(abs_arr[curr_dim]<=curr_span->high) { + break; + } /* end if */ + /* If we walked off that span, advance to the next span */ else { - /* Set up hyperslab I/O parameters which apply to all regions */ - if(!parm_init) { - /* Copy the location of the region in the file */ - HDmemcpy(io_info->offset, io_info->iter->hyp.pos, (io_info->space->extent.u.simple.rank * sizeof(hssize_t))); - io_info->offset[io_info->space->extent.u.simple.rank]=0; - - /* Set flag */ - parm_init=1; + /* Advance span in this dimension */ + curr_span=curr_span->next; + + /* Check if we have a valid span in this dimension still */ + if(curr_span!=NULL) { + /* Reset absolute position */ + abs_arr[curr_dim]=curr_span->low; + + break; + } /* end if */ + else { + /* If we finished the span list in this dimension, decrement the dimension worked on and loop again */ + curr_dim--; + } /* end else */ + } /* end else */ + } /* end while */ + + /* Check if we are finished with the spans in the tree */ + if(curr_dim<0) { + /* We had better be done with I/O or bad things are going to happen... */ + assert(io_bytes_left==0); + + goto partial_done; /* finished with partial span */ + } /* end if */ + else { + /* Reset the span in the current dimension */ + ispan[curr_dim]=curr_span; + + /* Walk back down the iterator positions, reseting them */ + while(curr_dim<fast_dim) { + assert(curr_span); + assert(curr_span->down); + assert(curr_span->down->head); + + /* Set the new span for this dimension */ + iter->hyp.span[curr_dim+1]=curr_span->down->head; + + /* Advance span down the tree */ + curr_span=curr_span->down->head; + + /* Reset the absolute offset for the dim */ + abs_arr[curr_dim+1]=curr_span->low; + + /* Increment current dimension */ + curr_dim++; + } /* end while */ + + /* Verify that the curr_span points to the fastest dim */ + assert(curr_span==iter->hyp.span[fast_dim]); + } /* end else */ + + /* Reset the buffer offset */ + for(i=0, loc_off=0; i<ndims; i++) + loc_off+=(abs_arr[i]+off_arr[i])*slab[i]; + } /* end if */ + } /* end if */ + +partial_done: /* Yes, goto's are evil, so sue me... :-) */ + /* Get the number of bytes left to process currently */ + last_io_bytes_left=io_bytes_left; + + /* Perform the I/O on the elements, based on the position of the iterator */ + while(io_bytes_left>0) { + /* Adjust location offset of destination to compensate for initial increment below */ + loc_off-=curr_span->pstride; + + /* Loop over all the spans in the fastest changing dimension */ + while(curr_span!=NULL) { + /* Move location offset of destination */ + loc_off+=curr_span->pstride; + + /* Compute the number of elements to attempt in this span */ + assert(curr_span->nelem==(hsize_t)((size_t)(curr_span->nelem))); /*check for overflow*/ + span_size=curr_span->nelem; + + /* Check number of elements against upper bounds allowed */ + if(span_size>=io_bytes_left) { + /* Trim the number of bytes to output */ + span_size=io_bytes_left; + io_bytes_left=0; + +/* COMMON */ + /* Store the I/O information for the span */ + seq_len_arr[nseq]=span_size; + buf_off_arr[nseq]=loc_off; + + /* Increment the number of sequences in arrays */ + nseq++; + + /* If the sequence & offset arrays are full, read them in */ + if(nseq>=vector_size) { + /* Write out the sequences */ + if (H5F_seq_writev(f, dxpl_id, layout, pline, fill, efl, space, + elmt_size, nseq, seq_len_arr, buf_off_arr, src)<0) { + HGOTO_ERROR(H5E_DATASPACE, H5E_WRITEERROR, 0, "write error"); } /* end if */ - io_info->hsize[io_info->space->extent.u.simple.rank-1]=region_size; - io_info->offset[io_info->space->extent.u.simple.rank-1]=regions[i].start; - - /* - * Scatter to file. - */ - if (H5F_arr_write(io_info->f, io_info->dxpl_id, - io_info->layout, io_info->pline, - io_info->fill, io_info->efl, - io_info->hsize, io_info->hsize, zero, - io_info->offset, io_info->src)<0) { - HRETURN_ERROR (H5E_DATASPACE, H5E_WRITEERROR, 0, "write error"); - } + /* Increment the offset of the destination buffer */ + src+=(last_io_bytes_left-io_bytes_left); + + /* Keep around the current number of I/O bytes left */ + last_io_bytes_left=io_bytes_left; + nseq=0; } /* end else */ +/* end COMMON */ - /* Advance the pointer in the buffer */ - io_info->src = ((const uint8_t *)io_info->src) + - region_size*io_info->elmt_size; + /* Break out now, we are finished with I/O */ + break; + } /* end if */ + else { + /* Decrement I/O left to perform */ + io_bytes_left-=span_size; - /* Increment the number of elements read */ - num_written+=region_size; +/* COMMON */ + /* Store the I/O information for the span */ + seq_len_arr[nseq]=span_size; + buf_off_arr[nseq]=loc_off; + + /* Increment the number of sequences in arrays */ + nseq++; + + /* If the sequence & offset arrays are full, read them in */ + if(nseq>=vector_size) { + /* Write out the sequences */ + if (H5F_seq_writev(f, dxpl_id, layout, pline, fill, efl, space, + elmt_size, nseq, seq_len_arr, buf_off_arr, src)<0) { + HGOTO_ERROR(H5E_DATASPACE, H5E_WRITEERROR, 0, "write error"); + } /* end if */ - /* Decrement the buffer left */ - io_info->nelmts-=region_size; + /* Increment the offset of the destination buffer */ + src+=(last_io_bytes_left-io_bytes_left); - /* Set the next position to start at */ - if(region_size==(hsize_t)((regions[i].end-regions[i].start)+1) - && i==(num_regions-1)) - io_info->iter->hyp.pos[dim+1]=(-1); - else - io_info->iter->hyp.pos[dim+1] = regions[i].start + - region_size; + /* Keep around the current number of I/O bytes left */ + last_io_bytes_left=io_bytes_left; + nseq=0; + } /* end else */ +/* end COMMON */ + } /* end else */ - /* Decrement the iterator count */ - io_info->iter->hyp.elmt_left-=region_size; - } /* end for */ - } else { /* recurse on each region to next dimension down */ - - /* Increment the dimension we are working with */ - dim++; - - /* Step through each region in this dimension */ - for(i=0; i<num_regions && io_info->nelmts>0; i++) { - /* Step through each location in each region */ - for(j=MAX(io_info->iter->hyp.pos[dim],regions[i].start); j<=regions[i].end && io_info->nelmts>0; j++) { - /* Set the correct position we are working on */ - io_info->iter->hyp.pos[dim]=j; - - /* Go get the regions in the next lower dimension */ - num_written+=H5S_hyper_fwrite(dim, io_info); - - /* Advance to the next row if we got the whole region */ - if(io_info->iter->hyp.pos[dim+1]==(-1)) - io_info->iter->hyp.pos[dim]=j+1; - } /* end for */ - if(j>regions[i].end && io_info->iter->hyp.pos[dim+1]==(-1) - && i==(num_regions-1)) - io_info->iter->hyp.pos[dim]=(-1); - } /* end for */ + /* Move to next span in fastest changing dimension */ + curr_span=curr_span->next; + } /* end while */ + + /* Check if we are done */ + if(io_bytes_left==0) { + abs_arr[fast_dim]=curr_span->low+(span_size/elmt_size); + + /* Check if we are still within the span */ + if(abs_arr[fast_dim]<=curr_span->high) { + iter->hyp.span[fast_dim]=curr_span; + break; + } /* end if */ + /* If we walked off that span, advance to the next span */ + else { + /* Advance span in this dimension */ + curr_span=curr_span->next; + + /* Check if we have a valid span in this dimension still */ + if(curr_span!=NULL) { + /* Reset absolute position */ + abs_arr[fast_dim]=curr_span->low; + iter->hyp.span[fast_dim]=curr_span; + break; + } /* end if */ + } /* end else */ + } /* end if */ + + /* Adjust iterator pointers */ + + /* Start at the next fastest dim */ + curr_dim=fast_dim-1; + + /* Work back up through the dimensions */ + while(curr_dim>=0) { + /* Reset the current span */ + curr_span=iter->hyp.span[curr_dim]; + + /* Increment absolute position */ + abs_arr[curr_dim]++; + + /* Check if we are still within the span */ + if(abs_arr[curr_dim]<=curr_span->high) { + break; + } /* end if */ + /* If we walked off that span, advance to the next span */ + else { + /* Advance span in this dimension */ + curr_span=curr_span->next; + + /* Check if we have a valid span in this dimension still */ + if(curr_span!=NULL) { + /* Reset absolute position */ + abs_arr[curr_dim]=curr_span->low; + + break; + } /* end if */ + else { + /* If we finished the span list in this dimension, decrement the dimension worked on and loop again */ + curr_dim--; + } /* end else */ + } /* end else */ + } /* end while */ + + /* Check if we are finished with the spans in the tree */ + if(curr_dim<0) { + /* We had better be done with I/O or bad things are going to happen... */ + assert(io_bytes_left==0); + break; + } /* end if */ + else { + /* Reset the span in the current dimension */ + ispan[curr_dim]=curr_span; + + /* Walk back down the iterator positions, reseting them */ + while(curr_dim<fast_dim) { + assert(curr_span); + assert(curr_span->down); + assert(curr_span->down->head); + + /* Set the new span for the next dimension down */ + iter->hyp.span[curr_dim+1]=curr_span->down->head; + + /* Advance span down the tree */ + curr_span=curr_span->down->head; + + /* Reset the absolute offset for the dim */ + abs_arr[curr_dim+1]=curr_span->low; + + /* Increment current dimension */ + curr_dim++; + } /* end while */ + + /* Verify that the curr_span points to the fastest dim */ + assert(curr_span==iter->hyp.span[fast_dim]); } /* end else */ - /* Release the temporary buffer */ - H5FL_ARR_FREE(H5S_hyper_region_t,regions); + /* Reset the buffer offset */ + for(i=0, loc_off=0; i<ndims; i++) + loc_off+=(abs_arr[i]+off_arr[i])*slab[i]; + } /* end while */ + + /* Check for any stored sequences which need to be flushed */ + if(nseq>0) { + /* Write out the sequence */ + if (H5F_seq_writev(f, dxpl_id, layout, pline, fill, efl, space, + elmt_size, nseq, seq_len_arr, buf_off_arr, src)<0) { + HGOTO_ERROR(H5E_DATASPACE, H5E_WRITEERROR, 0, "write error"); + } /* end if */ } /* end if */ -#ifdef QAK - printf("%s: check 2.0\n", FUNC); -#endif /* QAK */ - FUNC_LEAVE (num_written); -} /* H5S_hyper_fwrite() */ + /* Increment amount of I/O performed */ + iter->hyp.elmt_left-=nelem; + + /* Success! */ + ret_value=nelem; + +done: + if(seq_len_arr!=NULL) + H5FL_ARR_FREE(size_t,seq_len_arr); + if(buf_off_arr!=NULL) + H5FL_ARR_FREE(hsize_t,buf_off_arr); + + FUNC_LEAVE (ret_value); +} /* H5S_hyper_fwrite() */ /*------------------------------------------------------------------------- @@ -2387,7 +2532,6 @@ H5S_hyper_fscat (H5F_t *f, const struct H5O_layout_t *layout, const H5S_t *file_space, H5S_sel_iter_t *file_iter, hsize_t nelmts, hid_t dxpl_id, const void *_buf) { - H5S_hyper_io_info_t io_info; /* Block of parameters to pass into recursive calls */ hsize_t num_written=0; /* number of elements read into buffer */ herr_t ret_value=SUCCEED; @@ -2402,41 +2546,14 @@ H5S_hyper_fscat (H5F_t *f, const struct H5O_layout_t *layout, assert (nelmts>0); assert (_buf); -#ifdef QAK - printf("%s: check 1.0\n", FUNC); -#endif /* QAK */ - /* Check for the special case of just one H5Sselect_hyperslab call made */ if(file_space->select.sel_info.hslab.diminfo!=NULL) { /* Use optimized call to write out regular hyperslab */ num_written=H5S_hyper_fwrite_opt(f,layout,pline,fill,efl,elmt_size,file_space,file_iter,nelmts,dxpl_id,_buf); - } + } /* end if */ else { - /* Initialize parameter block for recursive calls */ - io_info.f=f; - io_info.layout=layout; - io_info.pline=pline; - io_info.fill=fill; - io_info.efl=efl; - io_info.elmt_size=elmt_size; - io_info.space=file_space; - io_info.iter=file_iter; - io_info.nelmts=nelmts; - io_info.dxpl_id = dxpl_id; - io_info.src=_buf; - io_info.dst=NULL; - - /* Set the hyperslab size to copy */ - io_info.hsize[0]=1; - H5V_array_fill(io_info.hsize,io_info.hsize,sizeof(io_info.hsize[0]),file_space->extent.u.simple.rank); - io_info.hsize[file_space->extent.u.simple.rank]=elmt_size; - - /* Recursively input the hyperslabs currently defined */ - /* starting with the slowest changing dimension */ - num_written=H5S_hyper_fwrite(-1,&io_info); -#ifdef QAK - printf("%s: check 2.0\n", FUNC); -#endif /* QAK */ + /* Perform generic hyperslab operation */ + num_written=H5S_hyper_fwrite(f,layout,pline,fill,efl,elmt_size,file_space,file_iter,nelmts,dxpl_id,_buf); } /* end else */ FUNC_LEAVE (ret_value==FAIL ? ret_value : (num_written >0) ? SUCCEED : FAIL); @@ -2446,145 +2563,376 @@ H5S_hyper_fscat (H5F_t *f, const struct H5O_layout_t *layout, /*------------------------------------------------------------------------- * Function: H5S_hyper_mread * - * Purpose: Recursively gathers data points from memory using the - * parameters passed to H5S_hyper_mgath. + * Purpose: Performs an optimized gather from a memory buffer, based on a + * hyperslab span selection. * * Return: Success: Number of elements copied. - * * Failure: 0 * * Programmer: Quincey Koziol - * Tuesday, June 16, 1998 + * Tuesday, September 12, 2000 * * Modifications: * *------------------------------------------------------------------------- */ -static hsize_t -H5S_hyper_mread (int dim, H5S_hyper_io_info_t *io_info) +static hssize_t +H5S_hyper_mread (const void *_buf, size_t elmt_size, const H5S_t *space, + H5S_sel_iter_t *iter, hsize_t nelem, void *_tconv_buf/*out*/) { - hsize_t region_size; /* Size of lowest region */ - H5S_hyper_region_t *regions; /* Pointer to array of hyperslab nodes overlapped */ - size_t num_regions; /* number of regions overlapped */ - size_t i; /* Counters */ - int j; - hsize_t num_read=0; /* Number of elements read */ - - FUNC_ENTER (H5S_hyper_mread, 0); - - assert(io_info); + const uint8_t *src=(const uint8_t *)_buf; /* Alias for pointer arithmetic */ + const uint8_t *tmp_src; /* Alias for pointer arithmetic */ + uint8_t *dst=(uint8_t *)_tconv_buf; /* Alias for pointer arithmetic */ + H5S_hyper_span_t **ispan; /* Iterator's hyperslab span nodes */ + H5S_hyper_span_t *curr_span; /* Current hyperslab span node */ + hsize_t slab[H5O_LAYOUT_NDIMS]; /* Cumulative size of each dimension in bytes */ + hsize_t acc; /* Accumulator for computing cumulative sizes */ + hssize_t *abs_arr; /* Absolute hyperslab span position */ + hssize_t *off_arr; /* Offset within the dataspace extent */ + int fast_dim; /* Rank of the fastest changing dimension for the dataspace */ + int curr_dim; /* Current dimension being operated on */ + int ndims; /* Number of dimensions of dataset */ + size_t span_size; /* Number of bytes in current span to actually process */ + size_t io_bytes_left; /* Number of bytes left to process */ + int i; /* Index variable */ + hssize_t ret_value=FAIL; + FUNC_ENTER (H5S_hyper_mread, FAIL); #ifdef QAK - printf("%s: check 1.0, dim=%d\n",FUNC,dim); +printf("%s: Called!\n",FUNC); #endif /* QAK */ - /* Get a sorted list (in the next dimension down) of the regions which */ - /* overlap the current index in this dim */ - if((regions=H5S_hyper_get_regions(&num_regions,io_info->space->extent.u.simple.rank, - (unsigned)(dim+1), - io_info->space->select.sel_info.hslab.hyper_lst->count, - io_info->space->select.sel_info.hslab.hyper_lst->lo_bounds, - io_info->iter->hyp.pos,io_info->space->select.offset))!=NULL) { - - /* Check if this is the second to last dimension in dataset */ - /* (Which means that we've got a list of the regions in the fastest */ - /* changing dimension and should input those regions) */ -#ifdef QAK - printf("%s: check 2.0, rank=%d, num_regions=%d\n", - FUNC, (int)io_info->space->extent.u.simple.rank, - (int)num_regions); - for(i=0; i<num_regions; i++) - printf("%s: check 2.1, region #%d: start=%d, end=%d\n", - FUNC,i,(int)regions[i].start,(int)regions[i].end); -#endif /* QAK */ + /* Check args */ + assert(src); + assert(elmt_size>0); + assert(space); + assert(iter); + assert(nelem>0); + assert(dst); - if((unsigned)(dim+2)==io_info->space->extent.u.simple.rank) { + /* Set the rank of the fastest changing dimension */ + ndims=space->extent.u.simple.rank; + fast_dim=(ndims-1); + + /* Get the pointers to the current span info and span nodes */ + curr_span=iter->hyp.span[fast_dim]; + abs_arr=iter->hyp.off; + off_arr=space->select.offset; + ispan=iter->hyp.span; + + /* Set the amount of elements to perform I/O on, etc. */ + assert(nelem==(hsize_t)((size_t)(nelem))); /*check for overflow*/ + io_bytes_left=nelem*elmt_size; + + /* Compute the cumulative size of dataspace dimensions */ + for(i=fast_dim, acc=elmt_size; i>=0; i--) { + slab[i]=acc; + acc*=space->extent.u.simple.size[i]; + } /* end for */ - /* Set up hyperslab I/O parameters which apply to all regions */ + /* Set the offset of the first element iterated on */ + for(i=0, tmp_src=src; i<ndims; i++) + /* Compute the sequential element offset */ + tmp_src+=(abs_arr[i]+space->select.offset[i])*slab[i]; - /* Copy the location of the region in the file */ - HDmemcpy(io_info->offset, io_info->iter->hyp.pos, (io_info->space->extent.u.simple.rank * sizeof(hssize_t))); - io_info->offset[io_info->space->extent.u.simple.rank]=0; + /* Range check against number of elements left in selection */ + assert(io_bytes_left<=(iter->hyp.elmt_left*elmt_size)); - /* perform I/O on data from regions */ - for(i=0; i<num_regions && io_info->nelmts>0; i++) { - H5_CHECK_OVERFLOW(io_info->nelmts,hsize_t,hssize_t); - region_size=MIN((hssize_t)io_info->nelmts,(regions[i].end-regions[i].start)+1); - io_info->hsize[io_info->space->extent.u.simple.rank-1]=region_size; - io_info->offset[io_info->space->extent.u.simple.rank-1]=regions[i].start; -#ifdef QAK - printf("%s: check 2.1, i=%d, region_size=%d\n", - FUNC,(int)i,(int)region_size); -#endif /* QAK */ + /* Take care of any partial spans leftover from previous I/Os */ + if(abs_arr[fast_dim]!=curr_span->low) { - /* - * Gather from memory. - */ - if (H5V_hyper_copy (io_info->space->extent.u.simple.rank+1, - io_info->hsize, io_info->hsize, zero, io_info->dst, - io_info->mem_size, io_info->offset, io_info->src)<0) { - HRETURN_ERROR (H5E_DATASPACE, H5E_READERROR, 0, - "unable to gather data from memory"); - } - - /* Advance the pointer in the buffer */ - io_info->dst = ((uint8_t *)io_info->dst) + region_size*io_info->elmt_size; - - /* Increment the number of elements read */ - num_read+=region_size; - - /* Decrement the buffer left */ - io_info->nelmts-=region_size; - - /* Set the next position to start at */ - if(region_size==(hsize_t)((regions[i].end-regions[i].start)+1) - && i==(num_regions-1)) - io_info->iter->hyp.pos[dim+1]=(-1); - else - io_info->iter->hyp.pos[dim+1] =regions[i].start + - region_size; + /* Finish the span in the fastest changing dimension */ - /* Decrement the iterator count */ - io_info->iter->hyp.elmt_left-=region_size; - } /* end for */ - } else { /* recurse on each region to next dimension down */ -#ifdef QAK - printf("%s: check 3.0, num_regions=%d\n",FUNC,(int)num_regions); -#endif /* QAK */ + /* Compute the number of bytes to attempt in this span */ + span_size=((curr_span->high-abs_arr[fast_dim])+1)*elmt_size; - /* Increment the dimension we are working with */ - dim++; + /* Check number of elements against upper bounds allowed */ + if(span_size>io_bytes_left) + span_size=io_bytes_left; - /* Step through each region in this dimension */ - for(i=0; i<num_regions && io_info->nelmts>0; i++) { - /* Step through each location in each region */ - for(j=MAX(io_info->iter->hyp.pos[dim],regions[i].start); j<=regions[i].end && io_info->nelmts>0; j++) { -#ifdef QAK - printf("%s: check 4.0, dim=%d, location=%d\n",FUNC,dim,j); -#endif /* QAK */ + HDmemcpy(dst,tmp_src,(size_t)span_size); - /* Set the correct position we are working on */ - io_info->iter->hyp.pos[dim]=j; + /* Increment offset in destination */ + dst+=span_size; - /* Go get the regions in the next lower dimension */ - num_read+=H5S_hyper_mread(dim, io_info); + /* Decrement I/O left to perform */ + io_bytes_left-=span_size; - /* Advance to the next row if we got the whole region */ - if(io_info->iter->hyp.pos[dim+1]==(-1)) - io_info->iter->hyp.pos[dim]=j+1; - } /* end for */ - if(j>regions[i].end && io_info->iter->hyp.pos[dim+1]==(-1) - && i==(num_regions-1)) - io_info->iter->hyp.pos[dim]=(-1); - } /* end for */ + /* Check if we are done */ + if(io_bytes_left>0) { + /* Move to next span in fastest changing dimension */ + curr_span=curr_span->next; + + if(curr_span!=NULL) { + /* Move location offset of destination */ + tmp_src+=(curr_span->low-abs_arr[fast_dim])*elmt_size; + + /* Move iterator for fastest changing dimension */ + abs_arr[fast_dim]=curr_span->low; + } /* end if */ + } /* end if */ + else { + abs_arr[fast_dim]+=span_size/elmt_size; + + /* Check if we are still within the span */ + if(abs_arr[fast_dim]<=curr_span->high) { + iter->hyp.span[fast_dim]=curr_span; + + goto partial_done; /* finished with partial span */ + } /* end if */ + /* If we walked off that span, advance to the next span */ + else { + /* Advance span in this dimension */ + curr_span=curr_span->next; + + /* Check if we have a valid span in this dimension still */ + if(curr_span!=NULL) { + /* Reset absolute position */ + abs_arr[fast_dim]=curr_span->low; + iter->hyp.span[fast_dim]=curr_span; + + goto partial_done; /* finished with partial span */ + } /* end if */ + } /* end else */ } /* end else */ - /* Release the temporary buffer */ - H5FL_ARR_FREE(H5S_hyper_region_t,regions); + /* Adjust iterator pointers */ + + if(curr_span==NULL) { +/* Same as code in main loop */ + /* Start at the next fastest dim */ + curr_dim=fast_dim-1; + + /* Work back up through the dimensions */ + while(curr_dim>=0) { + /* Reset the current span */ + curr_span=iter->hyp.span[curr_dim]; + + /* Increment absolute position */ + abs_arr[curr_dim]++; + + /* Check if we are still within the span */ + if(abs_arr[curr_dim]<=curr_span->high) { + break; + } /* end if */ + /* If we walked off that span, advance to the next span */ + else { + /* Advance span in this dimension */ + curr_span=curr_span->next; + + /* Check if we have a valid span in this dimension still */ + if(curr_span!=NULL) { + /* Reset absolute position */ + abs_arr[curr_dim]=curr_span->low; + + break; + } /* end if */ + else { + /* If we finished the span list in this dimension, decrement the dimension worked on and loop again */ + curr_dim--; + } /* end else */ + } /* end else */ + } /* end while */ + + /* Check if we are finished with the spans in the tree */ + if(curr_dim<0) { + /* We had better be done with I/O or bad things are going to happen... */ + assert(io_bytes_left==0); + + goto partial_done; /* finished with partial span */ + } /* end if */ + else { + /* Reset the span in the current dimension */ + ispan[curr_dim]=curr_span; + + /* Walk back down the iterator positions, reseting them */ + while(curr_dim<fast_dim) { + assert(curr_span); + assert(curr_span->down); + assert(curr_span->down->head); + + /* Set the new span for this dimension */ + iter->hyp.span[curr_dim+1]=curr_span->down->head; + + /* Advance span down the tree */ + curr_span=curr_span->down->head; + + /* Reset the absolute offset for the dim */ + abs_arr[curr_dim+1]=curr_span->low; + + /* Increment current dimension */ + curr_dim++; + } /* end while */ + + /* Verify that the curr_span points to the fastest dim */ + assert(curr_span==iter->hyp.span[fast_dim]); + } /* end else */ + + /* Reset the buffer offset */ + for(i=0, tmp_src=src; i<ndims; i++) + tmp_src+=(abs_arr[i]+off_arr[i])*slab[i]; + } /* end if */ } /* end if */ - FUNC_LEAVE (num_read); -} /* H5S_hyper_mread() */ +partial_done: /* Yes, goto's are evil, so sue me... :-) */ + + /* Perform the I/O on the elements, based on the position of the iterator */ + while(io_bytes_left>0) { + /* Adjust buffer offset of source to compensate for initial increment below */ + tmp_src-=curr_span->pstride; + + /* Loop over all the spans in the fastest changing dimension */ + while(curr_span!=NULL) { + /* Move buffer offset of source */ + tmp_src+=curr_span->pstride; + + /* Compute the number of elements to attempt in this span */ + assert(curr_span->nelem==(hsize_t)((size_t)(curr_span->nelem))); /*check for overflow*/ + span_size=curr_span->nelem; + + /* Check number of elements against upper bounds allowed */ + if(span_size>=io_bytes_left) { + /* Trim the number of bytes to output */ + span_size=io_bytes_left; + io_bytes_left=0; + +/* COMMON */ + /* "Read" the data from the source buffer */ + HDmemcpy(dst,tmp_src,(size_t)span_size); + + /* Increment offset in destination */ + dst+=span_size; +/* end COMMON */ + + /* Break out now, we are finished with I/O */ + break; + } /* end if */ + else { + /* Decrement I/O left to perform */ + io_bytes_left-=span_size; + +/* COMMON */ + /* "Read" the data from the source buffer */ + HDmemcpy(dst,tmp_src,(size_t)span_size); + + /* Increment offset in destination */ + dst+=span_size; +/* end COMMON */ + } /* end else */ + + /* Move to next span in fastest changing dimension */ + curr_span=curr_span->next; + } /* end while */ + + /* Check if we are done */ + if(io_bytes_left==0) { + abs_arr[fast_dim]=curr_span->low+(span_size/elmt_size); + + /* Check if we are still within the span */ + if(abs_arr[fast_dim]<=curr_span->high) { + iter->hyp.span[fast_dim]=curr_span; + break; + } /* end if */ + /* If we walked off that span, advance to the next span */ + else { + /* Advance span in this dimension */ + curr_span=curr_span->next; + + /* Check if we have a valid span in this dimension still */ + if(curr_span!=NULL) { + /* Reset absolute position */ + abs_arr[fast_dim]=curr_span->low; + iter->hyp.span[fast_dim]=curr_span; + break; + } /* end if */ + } /* end else */ + } /* end if */ + + /* Adjust iterator pointers */ + + /* Start at the next fastest dim */ + curr_dim=fast_dim-1; + + /* Work back up through the dimensions */ + while(curr_dim>=0) { + /* Reset the current span */ + curr_span=iter->hyp.span[curr_dim]; + + /* Increment absolute position */ + abs_arr[curr_dim]++; + + /* Check if we are still within the span */ + if(abs_arr[curr_dim]<=curr_span->high) { + break; + } /* end if */ + /* If we walked off that span, advance to the next span */ + else { + /* Advance span in this dimension */ + curr_span=curr_span->next; + + /* Check if we have a valid span in this dimension still */ + if(curr_span!=NULL) { + /* Reset absolute position */ + abs_arr[curr_dim]=curr_span->low; + + break; + } /* end if */ + else { + /* If we finished the span list in this dimension, decrement the dimension worked on and loop again */ + curr_dim--; + } /* end else */ + } /* end else */ + } /* end while */ + + /* Check if we are finished with the spans in the tree */ + if(curr_dim<0) { + /* We had better be done with I/O or bad things are going to happen... */ + assert(io_bytes_left==0); + break; + } /* end if */ + else { + /* Reset the span in the current dimension */ + ispan[curr_dim]=curr_span; + + /* Walk back down the iterator positions, reseting them */ + while(curr_dim<fast_dim) { + assert(curr_span); + assert(curr_span->down); + assert(curr_span->down->head); + + /* Set the new span for the next dimension down */ + iter->hyp.span[curr_dim+1]=curr_span->down->head; + + /* Advance span down the tree */ + curr_span=curr_span->down->head; + + /* Reset the absolute offset for the dim */ + abs_arr[curr_dim+1]=curr_span->low; + + /* Increment current dimension */ + curr_dim++; + } /* end while */ + + /* Verify that the curr_span points to the fastest dim */ + assert(curr_span==iter->hyp.span[fast_dim]); + } /* end else */ + + /* Reset the buffer offset */ + for(i=0, tmp_src=src; i<ndims; i++) + tmp_src+=(abs_arr[i]+off_arr[i])*slab[i]; + } /* end while */ + + /* Increment amount of I/O performed */ + iter->hyp.elmt_left-=nelem; + + /* Success! */ + ret_value=nelem; + +#ifdef LATER +done: +#endif /* LATER */ + FUNC_LEAVE (ret_value); +} /* end H5S_hyper_mread() */ /*------------------------------------------------------------------------- @@ -3062,18 +3410,10 @@ H5S_hyper_mgath (const void *_buf, size_t elmt_size, const H5S_t *mem_space, H5S_sel_iter_t *mem_iter, hsize_t nelmts, void *_tconv_buf/*out*/) { - H5S_hyper_io_info_t io_info; /* Block of parameters to pass into recursive calls */ hsize_t num_read; /* number of elements read into buffer */ FUNC_ENTER (H5S_hyper_mgath, 0); -#ifdef QAK - printf("%s: check 1.0, elmt_size=%d, mem_space=%p\n", - FUNC,(int)elmt_size,mem_space); - printf("%s: check 1.0, mem_iter=%p, nelmts=%d\n",FUNC,mem_iter,nelmts); - printf("%s: check 1.0, _buf=%p, _tconv_buf=%p\n",FUNC,_buf,_tconv_buf); -#endif /* QAK */ - /* Check args */ assert (elmt_size>0); assert (mem_space); @@ -3086,31 +3426,10 @@ H5S_hyper_mgath (const void *_buf, size_t elmt_size, if(mem_space->select.sel_info.hslab.diminfo!=NULL) { /* Use optimized call to read in regular hyperslab */ num_read=H5S_hyper_mread_opt(_buf,elmt_size,mem_space,mem_iter,nelmts,_tconv_buf); - } + } /* end if */ else { - /* Initialize parameter block for recursive calls */ - io_info.elmt_size=elmt_size; - io_info.space=mem_space; - io_info.iter=mem_iter; - io_info.nelmts=nelmts; - io_info.src=_buf; - io_info.dst=_tconv_buf; - - /* Set up the size of the memory space */ - HDmemcpy(io_info.mem_size, mem_space->extent.u.simple.size,mem_space->extent.u.simple.rank*sizeof(hsize_t)); - io_info.mem_size[mem_space->extent.u.simple.rank]=elmt_size; - - /* Set the hyperslab size to copy */ - io_info.hsize[0]=1; - H5V_array_fill(io_info.hsize, io_info.hsize, sizeof(io_info.hsize[0]),mem_space->extent.u.simple.rank); - io_info.hsize[mem_space->extent.u.simple.rank]=elmt_size; - - /* Recursively input the hyperslabs currently defined */ - /* starting with the slowest changing dimension */ - num_read=H5S_hyper_mread(-1,&io_info); -#ifdef QAK - printf("%s: check 5.0, num_read=%d\n",FUNC,(int)num_read); -#endif /* QAK */ + /* Perform generic hyperslab operation */ + num_read=H5S_hyper_mread(_buf,elmt_size,mem_space,mem_iter,nelmts,_tconv_buf); } /* end else */ FUNC_LEAVE (num_read); @@ -3120,144 +3439,376 @@ H5S_hyper_mgath (const void *_buf, size_t elmt_size, /*------------------------------------------------------------------------- * Function: H5S_hyper_mwrite * - * Purpose: Recursively scatters data points from memory using the parameters - * passed to H5S_hyper_mscat. + * Purpose: Performs an optimized gather from a memory buffer, based on a + * hyperslab span selection. * * Return: Success: Number of elements copied. - * * Failure: 0 * * Programmer: Quincey Koziol - * Tuesday, June 16, 1998 + * Tuesday, September 12, 2000 * * Modifications: * *------------------------------------------------------------------------- */ -static size_t -H5S_hyper_mwrite (int dim, H5S_hyper_io_info_t *io_info) +static hssize_t +H5S_hyper_mwrite (const void *_tconv_buf, size_t elmt_size, const H5S_t *space, + H5S_sel_iter_t *iter, hsize_t nelem, void *_buf/*out*/) { - hsize_t region_size; /* Size of lowest region */ - H5S_hyper_region_t *regions; /* Pointer to array of hyperslab nodes overlapped */ - size_t num_regions; /* number of regions overlapped */ - size_t i; /* Counters */ - int j; - hsize_t num_write=0; /* Number of elements written */ - - FUNC_ENTER (H5S_hyper_mwrite, 0); + const uint8_t *src=(const uint8_t *)_tconv_buf; /* Alias for pointer arithmetic */ + uint8_t *dst=(uint8_t *)_buf; /* Alias for pointer arithmetic */ + uint8_t *tmp_dst; /* Alias for pointer arithmetic */ + H5S_hyper_span_t **ispan; /* Iterator's hyperslab span nodes */ + H5S_hyper_span_t *curr_span; /* Current hyperslab span node */ + hsize_t slab[H5O_LAYOUT_NDIMS]; /* Cumulative size of each dimension in bytes */ + hsize_t acc; /* Accumulator for computing cumulative sizes */ + hssize_t *abs_arr; /* Absolute hyperslab span position */ + hssize_t *off_arr; /* Offset within the dataspace extent */ + int fast_dim; /* Rank of the fastest changing dimension for the dataspace */ + int curr_dim; /* Current dimension being operated on */ + int ndims; /* Number of dimensions of dataset */ + size_t span_size; /* Number of bytes in current span to actually process */ + size_t io_bytes_left; /* Number of bytes left to process */ + int i; /* Index variable */ + hssize_t ret_value=FAIL; - assert(io_info); + FUNC_ENTER (H5S_hyper_mwrite, FAIL); #ifdef QAK - printf("%s: check 1.0\n",FUNC); +printf("%s: Called!\n",FUNC); #endif /* QAK */ - /* Get a sorted list (in the next dimension down) of the regions which */ - /* overlap the current index in this dim */ - if((regions=H5S_hyper_get_regions(&num_regions,io_info->space->extent.u.simple.rank, - (unsigned)(dim+1), - io_info->space->select.sel_info.hslab.hyper_lst->count, - io_info->space->select.sel_info.hslab.hyper_lst->lo_bounds, - io_info->iter->hyp.pos,io_info->space->select.offset))!=NULL) { + /* Check args */ + assert(src); + assert(elmt_size>0); + assert(space); + assert(iter); + assert(nelem>0); + assert(dst); -#ifdef QAK - printf("%s: check 2.0, rank=%d\n", - FUNC,(int)io_info->space->extent.u.simple.rank); - for(i=0; i<num_regions; i++) - printf("%s: check 2.1, region #%d: start=%d, end=%d\n", - FUNC,i,(int)regions[i].start,(int)regions[i].end); -#endif /* QAK */ - /* Check if this is the second to last dimension in dataset */ - /* (Which means that we've got a list of the regions in the fastest */ - /* changing dimension and should input those regions) */ - if((unsigned)(dim+2)==io_info->space->extent.u.simple.rank) { + /* Set the rank of the fastest changing dimension */ + ndims=space->extent.u.simple.rank; + fast_dim=(ndims-1); + + /* Get the pointers to the current span info and span nodes */ + curr_span=iter->hyp.span[fast_dim]; + abs_arr=iter->hyp.off; + off_arr=space->select.offset; + ispan=iter->hyp.span; + + /* Set the amount of elements to perform I/O on, etc. */ + assert(nelem==(hsize_t)((size_t)(nelem))); /*check for overflow*/ + io_bytes_left=nelem*elmt_size; + + /* Compute the cumulative size of dataspace dimensions */ + for(i=fast_dim, acc=elmt_size; i>=0; i--) { + slab[i]=acc; + acc*=space->extent.u.simple.size[i]; + } /* end for */ - /* Set up hyperslab I/O parameters which apply to all regions */ + /* Set the offset of the first element iterated on */ + for(i=0, tmp_dst=dst; i<ndims; i++) + /* Compute the sequential element offset */ + tmp_dst+=(abs_arr[i]+space->select.offset[i])*slab[i]; - /* Copy the location of the region in the file */ - HDmemcpy(io_info->offset, io_info->iter->hyp.pos, (io_info->space->extent.u.simple.rank* sizeof(hssize_t))); - io_info->offset[io_info->space->extent.u.simple.rank]=0; + /* Range check against number of elements left in selection */ + assert(io_bytes_left<=(iter->hyp.elmt_left*elmt_size)); -#ifdef QAK - printf("%s: check 3.0\n",FUNC); -#endif /* QAK */ - /* perform I/O on data from regions */ - for(i=0; i<num_regions && io_info->nelmts>0; i++) { - H5_CHECK_OVERFLOW(io_info->nelmts,hsize_t,hssize_t); - region_size=MIN((hssize_t)io_info->nelmts, (regions[i].end-regions[i].start)+1); - io_info->hsize[io_info->space->extent.u.simple.rank-1]=region_size; - io_info->offset[io_info->space->extent.u.simple.rank-1]=regions[i].start; - - /* - * Scatter to memory - */ - if (H5V_hyper_copy (io_info->space->extent.u.simple.rank+1, - io_info->hsize, io_info->mem_size, io_info->offset, - io_info->dst, io_info->hsize, zero, - io_info->src)<0) { - HRETURN_ERROR (H5E_DATASPACE, H5E_READERROR, 0, "unable to gather data from memory"); - } - - /* Advance the pointer in the buffer */ - io_info->src = ((const uint8_t *)io_info->src) + - region_size*io_info->elmt_size; - - /* Increment the number of elements read */ - num_write+=region_size; - - /* Decrement the buffer left */ - io_info->nelmts-=region_size; - - /* Set the next position to start at */ - if(region_size==(hsize_t)((regions[i].end-regions[i].start)+1) - && i==(num_regions-1)) - io_info->iter->hyp.pos[dim+1]=(-1); - else - io_info->iter->hyp.pos[dim+1] = regions[i].start + - region_size; + /* Take care of any partial spans leftover from previous I/Os */ + if(abs_arr[fast_dim]!=curr_span->low) { - /* Decrement the iterator count */ - io_info->iter->hyp.elmt_left-=region_size; - } /* end for */ - } else { /* recurse on each region to next dimension down */ + /* Finish the span in the fastest changing dimension */ - /* Increment the dimension we are working with */ - dim++; + /* Compute the number of bytes to attempt in this span */ + span_size=((curr_span->high-abs_arr[fast_dim])+1)*elmt_size; -#ifdef QAK - printf("%s: check 6.0, num_regions=%d\n",FUNC,(int)num_regions); -#endif /* QAK */ - /* Step through each region in this dimension */ - for(i=0; i<num_regions && io_info->nelmts>0; i++) { - /* Step through each location in each region */ -#ifdef QAK - printf("%s: check 7.0, start[%d]=%d, end[%d]=%d, nelmts=%d\n", - FUNC, i, (int)regions[i].start, i, - (int)regions[i].end, (int)io_info->nelmts); -#endif /* QAK */ - for(j=MAX(io_info->iter->hyp.pos[dim],regions[i].start); j<=regions[i].end && io_info->nelmts>0; j++) { + /* Check number of elements against upper bounds allowed */ + if(span_size>io_bytes_left) + span_size=io_bytes_left; - /* Set the correct position we are working on */ - io_info->iter->hyp.pos[dim]=j; + HDmemcpy(tmp_dst,src,(size_t)span_size); - /* Go get the regions in the next lower dimension */ - num_write+=H5S_hyper_mwrite(dim, io_info); + /* Increment offset in destination */ + src+=span_size; - /* Advance to the next row if we got the whole region */ - if(io_info->iter->hyp.pos[dim+1]==(-1)) - io_info->iter->hyp.pos[dim]=j+1; - } /* end for */ - if(j>regions[i].end && io_info->iter->hyp.pos[dim+1]==(-1) - && i==(num_regions-1)) - io_info->iter->hyp.pos[dim]=(-1); - } /* end for */ + /* Decrement I/O left to perform */ + io_bytes_left-=span_size; + + /* Check if we are done */ + if(io_bytes_left>0) { + /* Move to next span in fastest changing dimension */ + curr_span=curr_span->next; + + if(curr_span!=NULL) { + /* Move location offset of destination */ + tmp_dst+=(curr_span->low-abs_arr[fast_dim])*elmt_size; + + /* Move iterator for fastest changing dimension */ + abs_arr[fast_dim]=curr_span->low; + } /* end if */ + } /* end if */ + else { + abs_arr[fast_dim]+=span_size/elmt_size; + + /* Check if we are still within the span */ + if(abs_arr[fast_dim]<=curr_span->high) { + iter->hyp.span[fast_dim]=curr_span; + + goto partial_done; /* finished with partial span */ + } /* end if */ + /* If we walked off that span, advance to the next span */ + else { + /* Advance span in this dimension */ + curr_span=curr_span->next; + + /* Check if we have a valid span in this dimension still */ + if(curr_span!=NULL) { + /* Reset absolute position */ + abs_arr[fast_dim]=curr_span->low; + iter->hyp.span[fast_dim]=curr_span; + + goto partial_done; /* finished with partial span */ + } /* end if */ + } /* end else */ } /* end else */ - /* Release the temporary buffer */ - H5FL_ARR_FREE(H5S_hyper_region_t,regions); + /* Adjust iterator pointers */ + + if(curr_span==NULL) { +/* Same as code in main loop */ + /* Start at the next fastest dim */ + curr_dim=fast_dim-1; + + /* Work back up through the dimensions */ + while(curr_dim>=0) { + /* Reset the current span */ + curr_span=iter->hyp.span[curr_dim]; + + /* Increment absolute position */ + abs_arr[curr_dim]++; + + /* Check if we are still within the span */ + if(abs_arr[curr_dim]<=curr_span->high) { + break; + } /* end if */ + /* If we walked off that span, advance to the next span */ + else { + /* Advance span in this dimension */ + curr_span=curr_span->next; + + /* Check if we have a valid span in this dimension still */ + if(curr_span!=NULL) { + /* Reset absolute position */ + abs_arr[curr_dim]=curr_span->low; + + break; + } /* end if */ + else { + /* If we finished the span list in this dimension, decrement the dimension worked on and loop again */ + curr_dim--; + } /* end else */ + } /* end else */ + } /* end while */ + + /* Check if we are finished with the spans in the tree */ + if(curr_dim<0) { + /* We had better be done with I/O or bad things are going to happen... */ + assert(io_bytes_left==0); + + goto partial_done; /* finished with partial span */ + } /* end if */ + else { + /* Reset the span in the current dimension */ + ispan[curr_dim]=curr_span; + + /* Walk back down the iterator positions, reseting them */ + while(curr_dim<fast_dim) { + assert(curr_span); + assert(curr_span->down); + assert(curr_span->down->head); + + /* Set the new span_info & span for this dimension */ + iter->hyp.span[curr_dim+1]=curr_span->down->head; + + /* Advance span down the tree */ + curr_span=curr_span->down->head; + + /* Reset the absolute offset for the dim */ + abs_arr[curr_dim+1]=curr_span->low; + + /* Increment current dimension */ + curr_dim++; + } /* end while */ + + /* Verify that the curr_span points to the fastest dim */ + assert(curr_span==iter->hyp.span[fast_dim]); + } /* end else */ + + /* Reset the buffer offset */ + for(i=0, tmp_dst=dst; i<ndims; i++) + tmp_dst+=(abs_arr[i]+off_arr[i])*slab[i]; + } /* end if */ } /* end if */ - FUNC_LEAVE (num_write); -} /* H5S_hyper_mwrite() */ +partial_done: /* Yes, goto's are evil, so sue me... :-) */ + + /* Perform the I/O on the elements, based on the position of the iterator */ + while(io_bytes_left>0) { + /* Adjust buffer offset of destination to compensate for initial increment below */ + tmp_dst-=(size_t)curr_span->pstride; + + /* Loop over all the spans in the fastest changing dimension */ + while(curr_span!=NULL) { + /* Move buffer offset of destination */ + tmp_dst+=(size_t)curr_span->pstride; + + /* Compute the number of elements to attempt in this span */ + assert(curr_span->nelem==(hsize_t)((size_t)(curr_span->nelem))); /*check for overflow*/ + span_size=curr_span->nelem; + + /* Check number of elements against upper bounds allowed */ + if(span_size>=io_bytes_left) { + /* Trim the number of bytes to output */ + span_size=io_bytes_left; + io_bytes_left=0; + +/* COMMON */ + /* "Write" the data into the destination buffer */ + HDmemcpy(tmp_dst,src,(size_t)span_size); + + /* Increment offset in destination */ + src+=span_size; +/* end COMMON */ + + /* Break out now, we are finished with I/O */ + break; + } /* end if */ + else { + /* Decrement I/O left to perform */ + io_bytes_left-=span_size; + +/* COMMON */ + /* "Write" the data into the destination buffer */ + HDmemcpy(tmp_dst,src,(size_t)span_size); + + /* Increment offset in destination */ + src+=span_size; +/* end COMMON */ + } /* end else */ + + /* Move to next span in fastest changing dimension */ + curr_span=curr_span->next; + } /* end while */ + + /* Check if we are done */ + if(io_bytes_left==0) { + abs_arr[fast_dim]=curr_span->low+(span_size/elmt_size); + + /* Check if we are still within the span */ + if(abs_arr[fast_dim]<=curr_span->high) { + iter->hyp.span[fast_dim]=curr_span; + break; + } /* end if */ + /* If we walked off that span, advance to the next span */ + else { + /* Advance span in this dimension */ + curr_span=curr_span->next; + + /* Check if we have a valid span in this dimension still */ + if(curr_span!=NULL) { + /* Reset absolute position */ + abs_arr[fast_dim]=curr_span->low; + iter->hyp.span[fast_dim]=curr_span; + break; + } /* end if */ + } /* end else */ + } /* end if */ + + /* Adjust iterator pointers */ + + /* Start at the next fastest dim */ + curr_dim=fast_dim-1; + + /* Work back up through the dimensions */ + while(curr_dim>=0) { + /* Reset the current span */ + curr_span=iter->hyp.span[curr_dim]; + + /* Increment absolute position */ + abs_arr[curr_dim]++; + + /* Check if we are still within the span */ + if(abs_arr[curr_dim]<=curr_span->high) { + break; + } /* end if */ + /* If we walked off that span, advance to the next span */ + else { + /* Advance span in this dimension */ + curr_span=curr_span->next; + + /* Check if we have a valid span in this dimension still */ + if(curr_span!=NULL) { + /* Reset absolute position */ + abs_arr[curr_dim]=curr_span->low; + + break; + } /* end if */ + else { + /* If we finished the span list in this dimension, decrement the dimension worked on and loop again */ + curr_dim--; + } /* end else */ + } /* end else */ + } /* end while */ + + /* Check if we are finished with the spans in the tree */ + if(curr_dim<0) { + /* We had better be done with I/O or bad things are going to happen... */ + assert(io_bytes_left==0); + break; + } /* end if */ + else { + /* Reset the span in the current dimension */ + ispan[curr_dim]=curr_span; + + /* Walk back down the iterator positions, reseting them */ + while(curr_dim<fast_dim) { + assert(curr_span); + assert(curr_span->down); + assert(curr_span->down->head); + + /* Set the new span_info & span for the next dimension down */ + iter->hyp.span[curr_dim+1]=curr_span->down->head; + + /* Advance span down the tree */ + curr_span=curr_span->down->head; + + /* Reset the absolute offset for the dim */ + abs_arr[curr_dim+1]=curr_span->low; + + /* Increment current dimension */ + curr_dim++; + } /* end while */ + + /* Verify that the curr_span points to the fastest dim */ + assert(curr_span==iter->hyp.span[fast_dim]); + } /* end else */ + + /* Reset the buffer offset */ + for(i=0, tmp_dst=dst; i<ndims; i++) + tmp_dst+=(abs_arr[i]+off_arr[i])*slab[i]; + } /* end while */ + + /* Increment amount of I/O performed */ + iter->hyp.elmt_left-=nelem; + + /* Success! */ + ret_value=nelem; + +#ifdef LATER +done: +#endif /* LATER */ + FUNC_LEAVE (ret_value); +} /* end H5S_hyper_mwrite() */ /*------------------------------------------------------------------------- @@ -3732,7 +4283,6 @@ H5S_hyper_mscat (const void *_tconv_buf, size_t elmt_size, const H5S_t *mem_space, H5S_sel_iter_t *mem_iter, hsize_t nelmts, void *_buf/*out*/) { - H5S_hyper_io_info_t io_info; /* Block of parameters to pass into recursive calls */ hsize_t num_written; /* number of elements written into buffer */ FUNC_ENTER (H5S_hyper_mscat, 0); @@ -3749,34 +4299,10 @@ H5S_hyper_mscat (const void *_tconv_buf, size_t elmt_size, if(mem_space->select.sel_info.hslab.diminfo!=NULL) { /* Use optimized call to write out regular hyperslab */ num_written=H5S_hyper_mwrite_opt(_tconv_buf,elmt_size,mem_space,mem_iter,nelmts,_buf); - } + } /* end if */ else { - /* Initialize parameter block for recursive calls */ - io_info.elmt_size=elmt_size; - io_info.space=mem_space; - io_info.iter=mem_iter; - io_info.nelmts=nelmts; - io_info.src=_tconv_buf; - io_info.dst=_buf; - - /* Set up the size of the memory space */ - HDmemcpy(io_info.mem_size, mem_space->extent.u.simple.size,mem_space->extent.u.simple.rank*sizeof(hsize_t)); - io_info.mem_size[mem_space->extent.u.simple.rank]=elmt_size; - - /* Set the hyperslab size to copy */ - io_info.hsize[0]=1; - H5V_array_fill(io_info.hsize, io_info.hsize, sizeof(io_info.hsize[0]), mem_space->extent.u.simple.rank); - io_info.hsize[mem_space->extent.u.simple.rank]=elmt_size; - - /* Recursively input the hyperslabs currently defined */ - /* starting with the slowest changing dimension */ -#ifdef QAK - printf("%s: check 1.0\n",FUNC); -#endif /* QAK */ - num_written=H5S_hyper_mwrite(-1,&io_info); -#ifdef QAK - printf("%s: check 2.0\n",FUNC); -#endif /* QAK */ + /* Perform generic hyperslab operation */ + num_written=H5S_hyper_mwrite(_tconv_buf,elmt_size,mem_space,mem_iter,nelmts,_buf); } /* end else */ FUNC_LEAVE (num_written>0 ? SUCCEED : FAIL); @@ -3785,957 +4311,570 @@ H5S_hyper_mscat (const void *_tconv_buf, size_t elmt_size, /*-------------------------------------------------------------------------- NAME - H5S_hyper_bound_comp + H5S_hyper_npoints PURPOSE - Compare two hyperslab boundary elements (for qsort) + Compute number of elements in current selection USAGE - herr_t H5S_hyper_bound_comp(b1,b2) - const H5S_hyper_bound_t *b1; IN: Pointer to the first boundary element - const H5S_hyper_bound_t *b2; IN: Pointer to the first boundary element + hsize_t H5S_hyper_npoints(space) + H5S_t *space; IN: Pointer to dataspace RETURNS - <0 if b1 compares less than b2 - 0 if b1 compares equal to b2 - >0 if b1 compares greater than b2 + The number of elements in selection on success, 0 on failure DESCRIPTION - Callback routine for qsort to compary boundary elements. + Compute number of elements in current selection. GLOBAL VARIABLES COMMENTS, BUGS, ASSUMPTIONS EXAMPLES REVISION LOG --------------------------------------------------------------------------*/ -int -H5S_hyper_bound_comp(const void *_b1, const void *_b2) +hsize_t +H5S_hyper_npoints (const H5S_t *space) { - const H5S_hyper_bound_t *b1=(const H5S_hyper_bound_t *)_b1; /* Ptr to first boundary element */ - const H5S_hyper_bound_t *b2=(const H5S_hyper_bound_t *)_b2; /* Ptr to second boundary element */ + FUNC_ENTER (H5S_hyper_npoints, 0); -#ifdef LATER - FUNC_ENTER (H5S_hyper_bsearch, FAIL); -#endif /* LATER */ + /* Check args */ + assert (space); - assert(b1); - assert(b2); + FUNC_LEAVE (space->select.num_elem); +} /* H5S_hyper_npoints() */ - if(b1->bound<b2->bound) - return(-1); - if(b1->bound>b2->bound) - return(1); - return(0); + +/*-------------------------------------------------------------------------- + NAME + H5S_hyper_new_span + PURPOSE + Make a new hyperslab span node + USAGE + H5S_hyper_span_t *H5S_hyper_new_span(low, high, down, next) + hssize_t low, high; IN: Low and high bounds for new span node + H5S_hyper_span_info_t *down; IN: Down span tree for new node + H5S_hyper_span_t *next; IN: Next span for new node + RETURNS + Pointer to next span node on success, NULL on failure + DESCRIPTION + Allocate and initialize a new hyperslab span node, filling in the low & + high bounds, the down span and next span pointers also. Increment the + reference count of the 'down span' if applicable. + GLOBAL VARIABLES + COMMENTS, BUGS, ASSUMPTIONS + EXAMPLES + REVISION LOG +--------------------------------------------------------------------------*/ +static H5S_hyper_span_t * +H5S_hyper_new_span (hssize_t low, hssize_t high, H5S_hyper_span_info_t *down, H5S_hyper_span_t *next) +{ + H5S_hyper_span_t *ret_value=NULL; + + FUNC_ENTER (H5S_hyper_new_span, NULL); + + /* Allocate a new span node */ + if((ret_value = H5FL_ALLOC(H5S_hyper_span_t,0))==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span"); + + /* Copy the span's basic information */ + ret_value->low=low; + ret_value->high=high; + ret_value->nelem=(high-low)+1; + ret_value->pstride=0; + ret_value->down=down; + ret_value->next=next; + + /* Increment the reference count of the 'down span' if there is one */ + if(ret_value->down!=NULL) + ret_value->down->count++; -#ifdef LATER +done: FUNC_LEAVE (ret_value); -#endif /* LATER */ -} /* H5S_hyper_bsearch() */ +} /* H5S_hyper_new_span() */ /*-------------------------------------------------------------------------- NAME - H5S_hyper_node_add + H5S_hyper_span_precompute_helper PURPOSE - Add a new node to a list of hyperslab nodes + Helper routine to precompute the nelem and pstrides in bytes. USAGE - herr_t H5S_hyper_node_add(head, start, size) - H5S_hyper_node_t *head; IN: Pointer to head of hyperslab list - int endflag; IN: "size" array actually contains "end" array - unsigned rank; IN: # of dimensions of the node - const hssize_t *start; IN: Offset of block - const hsize_t *size; IN: Size of block + herr_t H5S_hyper_span_precompute_helper(span_info, elmt_size) + H5S_hyper_span_info_t *span_info; IN/OUT: Span tree to work on + size_t elmt_size; IN: element size to work with RETURNS - Non-negative on success/Negative on failure + Non-negative on success, negative on failure DESCRIPTION - Adds a new hyperslab node to a list of them. + Change the nelem and pstride values in the span tree from elements to + bytes using the elmt_size parameter. GLOBAL VARIABLES COMMENTS, BUGS, ASSUMPTIONS EXAMPLES REVISION LOG --------------------------------------------------------------------------*/ -herr_t -H5S_hyper_node_add (H5S_hyper_node_t **head, int endflag, unsigned rank, const hssize_t *start, const hsize_t *size) +static herr_t +H5S_hyper_span_precompute_helper (H5S_hyper_span_info_t *spans, size_t elmt_size) { - H5S_hyper_node_t *slab; /* New hyperslab node to add */ - unsigned u; /* Counters */ - herr_t ret_value=SUCCEED; + H5S_hyper_span_t *span; /* Hyperslab span */ + herr_t ret_value=FAIL; - FUNC_ENTER (H5S_hyper_node_add, FAIL); + FUNC_ENTER (H5S_hyper_span_precompute, FAIL); - /* Check args */ - assert (head); - assert (start); - assert (size); + assert(spans); -#ifdef QAK - printf("%s: check 1.0, head=%p, *head=%p, rank=%u, endflag=%d\n",FUNC,head,*head,rank,endflag); -#endif /* QAK */ - /* Create new hyperslab node to insert */ - if((slab = H5FL_ALLOC(H5S_hyper_node_t,0))==NULL) - HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab node"); - if((slab->start = H5FL_ARR_ALLOC(hsize_t,rank,0))==NULL) - HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab start boundary"); - if((slab->end = H5FL_ARR_ALLOC(hsize_t,rank,0))==NULL) - HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab end boundary"); + /* Check if we've already set this down span tree */ + if(spans->scratch!=(void *)~(NULL)) { + /* Set the tree's scratch pointer */ + spans->scratch=(void *)~(NULL); -#ifdef QAK - printf("%s: check 2.0, slab=%p, slab->start=%p, slab->end=%p\n",FUNC,slab,slab->start,slab->end); -#endif /* QAK */ - /* Set boundary on new node */ - for(u=0; u<rank; u++) { - slab->start[u]=start[u]; - if(endflag) - slab->end[u]=size[u]; - else - slab->end[u]=start[u]+size[u]-1; - } /* end for */ + /* Set the scratch pointers in all the nodes */ + span=spans->head; + + /* Loop over all the spans for this down span tree */ + while(span!=NULL) { + /* If there are down spans, set their scratch value also */ + if(span->down!=NULL) { + if(H5S_hyper_span_precompute_helper(span->down,elmt_size)==FAIL) + HGOTO_ERROR(H5E_INTERNAL, H5E_CANTFREE, FAIL, "can't reset hyperslab scratch pointer"); + } /* end if */ - /* Prepend on list of hyperslabs for this selection */ - slab->next=*head; - *head=slab; + /* Change the nelem & pstride values into bytes */ + span->nelem *= elmt_size; + span->pstride *= elmt_size; + + /* Advance to next span */ + span=span->next; + } /* end while */ + } /* end if */ + + /* Success! */ + ret_value=SUCCEED; done: FUNC_LEAVE (ret_value); -} /* H5S_hyper_node_add() */ +} /* H5S_hyper_span_precompute_helper() */ /*-------------------------------------------------------------------------- NAME - H5S_hyper_node_prepend + H5S_hyper_span_precompute PURPOSE - Prepend an existing node to an existing list of hyperslab nodes + Precompute the nelem and pstrides in bytes. USAGE - herr_t H5S_hyper_node_prepend(head, node) - H5S_hyper_node_t **head; IN: Pointer to pointer to head of hyperslab list - H5S_hyper_node_t *node; IN: Pointer to node to prepend + herr_t H5S_hyper_span_precompute(span_info, elmt_size) + H5S_hyper_span_info_t *span_info; IN/OUT: Span tree to work on + size_t elmt_size; IN: element size to work with RETURNS - Non-negative on success/Negative on failure + Non-negative on success, negative on failure DESCRIPTION - Prepends an existing hyperslab node to a list of them. + Change the nelem and pstride values in the span tree from elements to + bytes using the elmt_size parameter. GLOBAL VARIABLES COMMENTS, BUGS, ASSUMPTIONS EXAMPLES REVISION LOG --------------------------------------------------------------------------*/ static herr_t -H5S_hyper_node_prepend (H5S_hyper_node_t **head, H5S_hyper_node_t *node) +H5S_hyper_span_precompute (H5S_hyper_span_info_t *spans, size_t elmt_size) { - herr_t ret_value=SUCCEED; + herr_t ret_value=FAIL; - FUNC_ENTER (H5S_hyper_node_prepend, FAIL); + FUNC_ENTER (H5S_hyper_span_precompute, FAIL); - /* Check args */ - assert (head); - assert (node); + assert(spans); + + /* Call the helper routine to actually do the work */ + if(H5S_hyper_span_precompute_helper(spans,elmt_size)==FAIL) + HGOTO_ERROR(H5E_INTERNAL, H5E_CANTFREE, FAIL, "can't precompute span info"); + + /* Reset the scratch pointers for the next routine which needs them */ + if(H5S_hyper_span_scratch(spans,NULL)==FAIL) + HGOTO_ERROR(H5E_INTERNAL, H5E_CANTFREE, FAIL, "can't reset hyperslab scratch pointer"); - /* Prepend on list of hyperslabs for this selection */ - node->next=*head; - *head=node; + /* Success! */ + ret_value=SUCCEED; +done: FUNC_LEAVE (ret_value); -} /* H5S_hyper_node_prepend() */ +} /* H5S_hyper_span_precompute() */ + /*-------------------------------------------------------------------------- NAME - H5S_hyper_node_release + H5S_hyper_span_scratch PURPOSE - Free the memory for a hyperslab node + Set the scratch pointers on hyperslab span trees USAGE - herr_t H5S_hyper_node_release(node) - H5S_hyper_node_t *node; IN: Pointer to node to free + herr_t H5S_hyper_span_scratch(span_info) + H5S_hyper_span_info_t *span_info; IN: Span tree to reset RETURNS - Non-negative on success/Negative on failure + Non-negative on success, negative on failure DESCRIPTION - Frees a hyperslab node. + Set the scratch pointers on a hyperslab span tree. GLOBAL VARIABLES COMMENTS, BUGS, ASSUMPTIONS EXAMPLES REVISION LOG --------------------------------------------------------------------------*/ static herr_t -H5S_hyper_node_release (H5S_hyper_node_t *node) +H5S_hyper_span_scratch (H5S_hyper_span_info_t *spans, void *scr_value) { - herr_t ret_value=SUCCEED; + H5S_hyper_span_t *span; /* Hyperslab span */ + herr_t ret_value=FAIL; - FUNC_ENTER (H5S_hyper_node_release, FAIL); + FUNC_ENTER (H5S_hyper_span_scratch, FAIL); - /* Check args */ - assert (node); + assert(spans); + + /* Check if we've already set this down span tree */ + if(spans->scratch!=scr_value) { + /* Set the tree's scratch pointer */ + spans->scratch=scr_value; - /* Free the hyperslab node */ - H5FL_ARR_FREE(hsize_t,node->start); - H5FL_ARR_FREE(hsize_t,node->end); - H5FL_FREE(H5S_hyper_node_t,node); + /* Set the scratch pointers in all the nodes */ + span=spans->head; + while(span!=NULL) { + /* If there are down spans, set their scratch value also */ + if(span->down!=NULL) { + if(H5S_hyper_span_scratch(span->down,scr_value)==FAIL) + HGOTO_ERROR(H5E_INTERNAL, H5E_CANTFREE, FAIL, "can't reset hyperslab scratch pointer"); + } /* end if */ + /* Advance to next span */ + span=span->next; + } /* end while */ + } /* end if */ + + /* Success! */ + ret_value=SUCCEED; + +done: FUNC_LEAVE (ret_value); -} /* H5S_hyper_node_release() */ +} /* H5S_hyper_span_scratch() */ /*-------------------------------------------------------------------------- NAME - H5S_hyper_add + H5S_hyper_copy_span_helper PURPOSE - Add a block to hyperslab selection + Helper routine to copy a hyperslab span tree USAGE - herr_t H5S_hyper_add(space, start, size) - H5S_t *space; IN: Pointer to dataspace - const hssize_t *start; IN: Offset of block - const hsize_t *end; IN: Offset of end of block + H5S_hyper_span_info_t * H5S_hyper_copy_span_helper(spans) + H5S_hyper_span_info_t *spans; IN: Span tree to copy RETURNS - Non-negative on success/Negative on failure + Pointer to the copied span tree on success, NULL on failure DESCRIPTION - Adds a block to an existing hyperslab selection. + Copy a hyperslab span tree, using reference counting as appropriate. GLOBAL VARIABLES COMMENTS, BUGS, ASSUMPTIONS EXAMPLES REVISION LOG --------------------------------------------------------------------------*/ -static herr_t -H5S_hyper_add (H5S_t *space, H5S_hyper_node_t *piece_lst) +static H5S_hyper_span_info_t * +H5S_hyper_copy_span_helper (H5S_hyper_span_info_t *spans) { - H5S_hyper_node_t *slab; /* New hyperslab node to insert */ - H5S_hyper_node_t *tmp_slab; /* Temporary hyperslab node */ - H5S_hyper_bound_t *tmp; /* Temporary pointer to an hyperslab bound array */ - size_t elem_count; /* Number of elements in hyperslab selection */ - unsigned piece_count; /* Number of hyperslab pieces being added */ - unsigned u; /* Counters */ - herr_t ret_value=SUCCEED; - - FUNC_ENTER (H5S_hyper_add, FAIL); - - /* Check args */ - assert (space); + H5S_hyper_span_t *span; /* Hyperslab span */ + H5S_hyper_span_t *new_span; /* Temporary hyperslab span */ + H5S_hyper_span_t *prev_span; /* Previous hyperslab span */ + H5S_hyper_span_info_t *new_down; /* New down span tree */ + H5S_hyper_span_info_t *ret_value=NULL; - /* Count the number of hyperslab pieces to add to the selection */ - piece_count=0; - tmp_slab=piece_lst; - while(tmp_slab!=NULL) { - piece_count++; - tmp_slab=tmp_slab->next; - } /* end while */ - -#ifdef QAK - printf("%s: check 1.0, piece_count=%u, lo_bounds=%p\n", - FUNC, (unsigned)piece_count,space->select.sel_info.hslab.hyper_lst->lo_bounds); -#endif /* QAK */ - /* Increase size of boundary arrays for dataspace's selection by piece_count */ - for(u=0; u<space->extent.u.simple.rank; u++) { - tmp=space->select.sel_info.hslab.hyper_lst->lo_bounds[u]; -#ifdef QAK - printf("%s: check 1.1, u=%u, space->sel_info.count=%d, tmp=%p\n",FUNC,(unsigned)u, space->select.sel_info.hslab.hyper_lst->count,tmp); -#endif /* QAK */ - if((space->select.sel_info.hslab.hyper_lst->lo_bounds[u]=H5FL_ARR_REALLOC(H5S_hyper_bound_t,tmp,(space->select.sel_info.hslab.hyper_lst->count+piece_count)))==NULL) { - space->select.sel_info.hslab.hyper_lst->lo_bounds[u]=tmp; - HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, - "can't allocate hyperslab lo boundary array"); - } /* end if */ - } /* end for */ + FUNC_ENTER (H5S_hyper_copy_span_helper, NULL); - while(piece_lst!=NULL) { -#ifdef QAK - printf("%s: check 2.0\n",FUNC); -#endif /* QAK */ - /* Re-use the current H5S_hyper_node_t */ - slab=piece_lst; + assert(spans); - /* Don't loose place in list of nodes to add.. */ - piece_lst=piece_lst->next; + /* Check if the span tree was already copied */ + if(spans->scratch!=NULL && spans->scratch!=(void *)~NULL) { + /* Just return the value of the already copied span tree */ + ret_value=spans->scratch; -#ifdef QAK - printf("%s: check 3.0\n",FUNC); -#endif /* QAK */ - /* Set boundary on new node */ - for(u=0,elem_count=1; u<space->extent.u.simple.rank; u++) { -#ifdef QAK - printf("%s: check 3.1, %u: start=%d, end=%d, elem_count=%d\n", - FUNC,(unsigned)u,(int)start[u],(int)end[u],(int)elem_count); -#endif /* QAK */ - elem_count*=(slab->end[u]-slab->start[u])+1; - } /* end for */ + /* Increment the reference count of the span tree */ + ret_value->count++; + } /* end if */ + else { + /* Allocate a new span_info node */ + if((ret_value = H5FL_ALLOC(H5S_hyper_span_info_t,0))==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span"); + + /* Copy the span_info information */ + ret_value->count=1; + ret_value->scratch=NULL; + ret_value->head=NULL; + + /* Set the scratch pointer in the node being copied to the newly allocated node */ + spans->scratch=ret_value; + + /* Copy over the nodes in the span list */ + span=spans->head; + prev_span=NULL; + while(span!=NULL) { + /* Allocate a new node */ + if((new_span = H5S_hyper_new_span(span->low,span->high,NULL,NULL))==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span"); + + /* Append to list of spans */ + if(prev_span==NULL) + ret_value->head=new_span; + else + prev_span->next=new_span; - /* Initialize caching parameters */ - slab->cinfo.cached=0; - slab->cinfo.size=elem_count; - slab->cinfo.wleft=slab->cinfo.rleft=0; - slab->cinfo.block=slab->cinfo.wpos=slab->cinfo.rpos=NULL; + /* Copy the pstride */ + new_span->pstride=span->pstride; -#ifdef QAK - printf("%s: check 4.0\n",FUNC); - { - unsigned v; - - for(u=0; u<space->extent.u.simple.rank; u++) { - for(v=0; v<space->select.sel_info.hslab.hyper_lst->count; v++) { - printf("%s: lo_bound[%u][%u]=%d(%p)\n", FUNC, - u,v,(int)space->select.sel_info.hslab.hyper_lst->lo_bounds[u][v].bound, - space->select.sel_info.hslab.hyper_lst->lo_bounds[u][v].node); - } - } - } -#endif /* QAK */ - /* Insert each boundary of the hyperslab into the sorted lists of bounds */ - for(u=0; u<space->extent.u.simple.rank; u++) { -#ifdef QAK - printf("%s: check 4.1, start[%u]=%d, end[%u]=%d\n", - FUNC, u, (int)slab->start[u],u,(int)slab->end[u]); - printf("%s: check 4.1,.hslab.hyper_lst->count=%d\n", - FUNC,(int)space->select.sel_info.hslab.hyper_lst->count); -#endif /* QAK */ - space->select.sel_info.hslab.hyper_lst->lo_bounds[u][space->select.sel_info.hslab.hyper_lst->count].bound=slab->start[u]; - space->select.sel_info.hslab.hyper_lst->lo_bounds[u][space->select.sel_info.hslab.hyper_lst->count].node=slab; - } /* end for */ + /* Recurse to copy the 'down' spans, if there are any */ + if(span->down!=NULL) { + if((new_down = H5S_hyper_copy_span_helper(span->down))==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span"); + new_span->down=new_down; + } /* end if */ - /* Increment the number of bounds in the array */ - space->select.sel_info.hslab.hyper_lst->count++; -#ifdef QAK - printf("%s: check 5.0, count=%d\n",FUNC,(int)space->select.sel_info.hslab.hyper_lst->count); -#endif /* QAK */ - - /* Prepend on list of hyperslabs for this selection */ - slab->next=space->select.sel_info.hslab.hyper_lst->head; - space->select.sel_info.hslab.hyper_lst->head=slab; + /* Update the previous (new) span */ + prev_span=new_span; - /* Increment the number of elements in the hyperslab selection */ - space->select.num_elem+=elem_count; -#ifdef QAK - printf("%s: check 6.0, elem_count=%d\n",FUNC,(int)elem_count); - { - unsigned v; - - for(u=0; u<space->extent.u.simple.rank; u++) { - for(v=0; v<space->select.sel_info.hslab.hyper_lst->count; v++) { - printf("%s: lo_bound[%u][%u]=%d(%p)\n", FUNC, - u,v,(int)space->select.sel_info.hslab.hyper_lst->lo_bounds[u][v].bound, - space->select.sel_info.hslab.hyper_lst->lo_bounds[u][v].node); - } - } - } -#endif /* QAK */ - } /* end while */ - - /* Sort each dimension's array of bounds, now that they are all in the array */ - for(u=0; u<space->extent.u.simple.rank; u++) - HDqsort(space->select.sel_info.hslab.hyper_lst->lo_bounds[u],space->select.sel_info.hslab.hyper_lst->count,sizeof(H5S_hyper_bound_t),H5S_hyper_bound_comp); + /* Advance to next span */ + span=span->next; + } /* end while */ + } /* end else */ done: FUNC_LEAVE (ret_value); -} /* H5S_hyper_add() */ +} /* H5S_hyper_copy_span_helper() */ /*-------------------------------------------------------------------------- NAME - H5S_hyper_clip + H5S_hyper_copy_span PURPOSE - Clip a list of nodes against the current selection + Copy a hyperslab span tree USAGE - herr_t H5S_hyper_clip(space, nodes, uniq, overlap) - H5S_t *space; IN: Pointer to dataspace - H5S_hyper_node_t *nodes; IN: Pointer to list of nodes - H5S_hyper_node_t **uniq; IN: Handle to list of non-overlapping nodes - H5S_hyper_node_t **overlap; IN: Handle to list of overlapping nodes + H5S_hyper_span_info_t * H5S_hyper_copy_span(span_info) + H5S_hyper_span_info_t *span_info; IN: Span tree to copy RETURNS - Non-negative on success/Negative on failure + Non-negative on success, negative on failure DESCRIPTION - Clips a list of hyperslab nodes against the current hyperslab selection. - The list of non-overlapping and overlapping nodes which are generated from - this operation are returned in the 'uniq' and 'overlap' pointers. If - either of those lists are not needed, they may be set to NULL and the - list will be released. + Copy a hyperslab span tree, using reference counting as appropriate. + (Which means that just the nodes in the top span tree are duplicated and + the reference counts of their 'down spans' are just incremented) GLOBAL VARIABLES COMMENTS, BUGS, ASSUMPTIONS - Clipping a multi-dimensional space against another multi-dimensional - space generates at most 1 overlapping region and 2*<rank> non-overlapping - regions, falling into the following categories in each dimension: - Case 1 - A overlaps B on both sides: - node <----AAAAAAAA---> - clipped against: - existing <-----BBBBB-----> - generates: - overlapping <-----CCCCC-----> - non-overlapping <----D----------> - non-overlapping <----------EE---> - - Case 2 - A overlaps B on one side: (need to check both sides!) - Case 2a: - node <------AAAAAA---> - clipped against: - existing <-----BBBBB-----> - generates: - overlapping <------CCCC-----> - non-overlapping <----------EE---> - Case 2b: - node <---AAAAA-------> - clipped against: - existing <-----BBBBB-----> - generates: - overlapping <-----CCC-------> - non-overlapping <---EE----------> - - Case 3 - A is entirely within B: - node <------AA-------> - clipped against: - existing <-----BBBBB-----> - generates: - overlapping <------CC-------> - - Case 4 - A is entirely outside B: (doesn't matter which side) - node <-----------AAA-> - clipped against: - existing <-----BBBBB-----> - generates: - non-overlapping <-----------AAA-> - - This algorithm could be sped up by keeping track of the last (existing) - region the new node was compared against when it was split and resume - comparing against the region following that one when it's returned to - later (for non-overlapping blocks). - - Another optimization is to build a n-tree (not certain about how many - times each dimension should be cut, but at least once) for the dataspace - and build a list of existing blocks which overlap each "n"-tant and only - compare the new nodes against existing node in the region of the n-tree - which the are located in. - EXAMPLES REVISION LOG --------------------------------------------------------------------------*/ -herr_t -H5S_hyper_clip (H5S_t *space, H5S_hyper_node_t *nodes, H5S_hyper_node_t **uniq, - H5S_hyper_node_t **overlap) +static H5S_hyper_span_info_t * +H5S_hyper_copy_span (H5S_hyper_span_info_t *spans) { - H5S_hyper_node_t *region, /* Temp. hyperslab selection region pointer */ - *node, /* Temp. hyperslab node pointer */ - *next_node, /* Pointer to next node in node list */ - *new_nodes=NULL; /* List of new nodes added */ - hssize_t *start=NULL; /* Temporary arrays of start & sizes (for splitting nodes) */ - hsize_t *end=NULL; /* Temporary arrays of start & sizes (for splitting nodes) */ - unsigned rank; /* Cached copy of the rank of the dataspace */ - int overlapped; /* Flag for overlapping nodes */ - int non_intersect; /* Flag for non-intersecting nodes */ - unsigned u; /* Counters */ - enum /* Cases for edge overlaps */ - {OVERLAP_BOTH,OVERLAP_LOWER,OVERLAP_UPPER,WITHIN,NO_OVERLAP} clip_case; - herr_t ret_value=SUCCEED; + H5S_hyper_span_info_t *ret_value=NULL; - FUNC_ENTER (H5S_hyper_clip, FAIL); + FUNC_ENTER (H5S_hyper_copy_span, NULL); - /* Check args */ - assert (space); - assert (nodes); - assert (uniq || overlap); + assert(spans); - /* Allocate space for the temporary starts & sizes */ - if((start = H5FL_ARR_ALLOC(hsize_t,space->extent.u.simple.rank,0))==NULL) - HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab start array"); - if((end = H5FL_ARR_ALLOC(hsize_t,space->extent.u.simple.rank,0))==NULL) - HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab size array"); + /* Copy the hyperslab span tree */ + ret_value=H5S_hyper_copy_span_helper(spans); - /* Set up local variables */ - rank=space->extent.u.simple.rank; -#ifdef QAK - printf("%s: check 1.0, start=%p, end=%p\n",FUNC,start,end); -#endif /* QAK */ + /* Reset the scratch pointers for the next routine which needs them */ + if(H5S_hyper_span_scratch(spans,NULL)==FAIL) + HGOTO_ERROR(H5E_INTERNAL, H5E_CANTFREE, NULL, "can't reset span tree scratch pointers"); - /* - * Cycle through all the hyperslab nodes, clipping them against the - * existing hyperslab selection. - */ - node=nodes; - while(node!=NULL) { -#ifdef QAK - printf("%s: check 2.0, node=%p, nodes=%p\n",FUNC,node,nodes); -#endif /* QAK */ - /* Remove current node from head of list to evaulate it */ - next_node=node->next; /* retain next node in list */ - node->next=NULL; /* just to be safe */ -#ifdef QAK - printf("%s: check 2.1, node=%p, next_node=%p\n",FUNC,node,next_node); - printf("node->start={",FUNC); - for(u=0; u<rank; u++) { - printf("%d",(int)node->start[u]); - if(u<rank-1) - printf(", "); - } /* end for */ - printf("}\n"); - printf("node->end={",FUNC); - for(u=0; u<rank; u++) { - printf("%d",(int)node->end[u]); - if(u<rank-1) - printf(", "); - } /* end for */ - printf("}\n"); - region=new_nodes; - while(region!=NULL) { - printf("new_nodes=%p, new_nodes->next=%p\n",region,region->next); - printf("\tstart={",FUNC); - for(u=0; u<rank; u++) { - printf("%d",(int)region->start[u]); - if(u<rank-1) - printf(", "); - } /* end for */ - printf("}\n"); - printf("\tend={",FUNC); - for(u=0; u<rank; u++) { - printf("%d",(int)region->end[u]); - if(u<rank-1) - printf(", "); - } /* end for */ - printf("}\n"); - region=region->next; - } /* end while */ +done: + FUNC_LEAVE (ret_value); +} /* H5S_hyper_copy_span() */ - region=space->select.sel_info.hslab.hyper_lst->head; - while(region!=NULL) { - printf("region=%p, region->next=%p\n",region,region->next); - printf("\tstart={",FUNC); - for(u=0; u<rank; u++) { - printf("%d",(int)region->start[u]); - if(u<rank-1) - printf(", "); - } /* end for */ - printf("}\n"); - printf("\tend={",FUNC); - for(u=0; u<rank; u++) { - printf("%d",(int)region->end[u]); - if(u<rank-1) - printf(", "); - } /* end for */ - printf("}\n"); - region=region->next; - } /* end while */ -#endif /* QAK */ + +/*-------------------------------------------------------------------------- + NAME + H5S_hyper_cmp_spans + PURPOSE + Check if two hyperslab slabs are the same + USAGE + htri_d H5S_hyper_cmp_spans(span1, span2) + H5S_hyper_span_t *span1; IN: First span tree to compare + H5S_hyper_span_t *span2; IN: Second span tree to compare + RETURNS + TRUE (1) or FALSE (0) on success, negative on failure + DESCRIPTION + Compare two hyperslab slabs to determine if they refer to the same + selection. If span1 & span2 are both NULL, that counts as equal + GLOBAL VARIABLES + COMMENTS, BUGS, ASSUMPTIONS + EXAMPLES + REVISION LOG +--------------------------------------------------------------------------*/ +static htri_t +H5S_hyper_cmp_spans (H5S_hyper_span_info_t *span_info1, H5S_hyper_span_info_t *span_info2) +{ + H5S_hyper_span_t *span1; + H5S_hyper_span_t *span2; + htri_t nest=FAIL; + htri_t ret_value=FAIL; - overlapped=0; /* Reset overlapped flag */ - region=space->select.sel_info.hslab.hyper_lst->head; - while(region!=NULL && overlapped==0) { -#ifdef QAK - printf("%s: check 3.0, new_nodes=%p, region=%p, head=%p, overlapped=%d\n",FUNC,new_nodes,region,space->select.sel_info.hslab.hyper_lst->head,overlapped); - printf("region->start={",FUNC); - for(u=0; u<rank; u++) { - printf("%d",(int)region->start[u]); - if(u<rank-1) - printf(", "); - } /* end for */ - printf("}\n"); - printf("region->end={",FUNC); - for(u=0; u<rank; u++) { - printf("%d",(int)region->end[u]); - if(u<rank-1) - printf(", "); - } /* end for */ - printf("}\n"); -#endif /* QAK */ - /* Check for intersection */ - for(u=0, non_intersect=0; u<rank && non_intersect==0; u++) { - if(node->end[u]<region->start[u] || node->start[u]>region->end[u]) - non_intersect=1; - } /* end for */ + FUNC_ENTER (H5S_hyper_cmp_spans, FAIL); -#ifdef QAK - printf("%s: check 3.0.1, new_nodes=%p, region=%p, head=%p, non_intersect=%d\n",FUNC,new_nodes,region,space->select.sel_info.hslab.hyper_lst->head,non_intersect); -#endif /* QAK */ - /* Only compare node with regions that actually intersect */ - if(non_intersect==0) { - /* Compare the boundaries of the two objects in each dimension */ - for(u=0; u<rank && overlapped==0; u++) { - /* Find overlap case we are in */ - - /* True if case 1, 4 or 2b */ - if(node->start[u]<region->start[u]) { -#ifdef QAK - printf("%s: check 3.1, overlapped=%d\n",FUNC,overlapped); -#endif /* QAK */ - /* Test for case 4 */ - /* NO_OVERLAP cases could be taken out, but are left in for clarity */ - if(node->end[u]<region->start[u]) { -#ifdef QAK - printf("%s: check 3.1.1, overlapped=%d\n",FUNC,overlapped); -#endif /* QAK */ - clip_case=NO_OVERLAP; - assert("invalid clipping case" && 0); - } /* end if */ - else { -#ifdef QAK - printf("%s: check 3.1.2, overlapped=%d\n",FUNC,overlapped); -#endif /* QAK */ - /* Test for case 2b */ - if(node->end[u]<=region->end[u]) { -#ifdef QAK - printf("%s: check 3.1.2.1, overlapped=%d\n",FUNC,overlapped); -#endif /* QAK */ - clip_case=OVERLAP_LOWER; - } /* end if */ - /* Must be case 1 */ - else { -#ifdef QAK - printf("%s: check 3.1.2.2, overlapped=%d\n",FUNC,overlapped); -#endif /* QAK */ - clip_case=OVERLAP_BOTH; - } /* end else */ - } /* end else */ + /* Check for redundant comparison */ + if(span_info1==span_info2) + ret_value=TRUE; + else { + /* Check for both spans being NULL */ + if(span_info1==NULL && span_info2==NULL) + ret_value=TRUE; + else { + /* Check for one span being NULL */ + if(span_info1==NULL || span_info2==NULL) + ret_value=FALSE; + else { + /* Get the pointers to the actual lists of spans */ + span1=span_info1->head; + span2=span_info2->head; + + /* Sanity checking */ + assert(span1); + assert(span2); + + /* infinite loop which must be broken out of */ + while (1) { + /* Check for both spans being NULL */ + if(span1==NULL && span2==NULL) { + ret_value=TRUE; + break; } /* end if */ - /* Case 2a, 3 or 4 (on the other side)*/ else { -#ifdef QAK - printf("%s: check 3.2, overlapped=%d\n",FUNC,overlapped); -#endif /* QAK */ - /* Test for case 4 */ - if(node->start[u]>region->end[u]) { -#ifdef QAK - printf("%s: check 3.2.1, overlapped=%d\n",FUNC,overlapped); -#endif /* QAK */ - clip_case=NO_OVERLAP; - assert("invalid clipping case" && 0); + /* Check for one span being NULL */ + if(span1==NULL || span2==NULL) { + ret_value=FALSE; + break; } /* end if */ - /* Case 2a or 3 */ else { -#ifdef QAK - printf("%s: check 3.2.2, overlapped=%d\n",FUNC,overlapped); -#endif /* QAK */ - /* Test for case 2a */ - if(node->end[u]>region->end[u]) { -#ifdef QAK - printf("%s: check 3.2.2.1, overlapped=%d\n",FUNC,overlapped); -#endif /* QAK */ - clip_case=OVERLAP_UPPER; + /* Check if the actual low & high span information is the same */ + if(span1->low!=span2->low || span1->high!=span2->high) { + ret_value=FALSE; + break; } /* end if */ - /* Must be case 3 */ else { -#ifdef QAK - printf("%s: check 3.2.2.2, overlapped=%d\n",FUNC,overlapped); -#endif /* QAK */ - clip_case=WITHIN; + if(span1->down!=NULL || span2!=NULL) { + if((nest=H5S_hyper_cmp_spans(span1->down,span2->down))==FAIL) { + ret_value=FAIL; + break; + } /* end if */ + else { + if(nest==FALSE) { + ret_value=FALSE; + break; + } /* end if */ + else { + /* Keep going... */ + } /* end else */ + } /* end else */ + } /* end if */ + else { + /* Keep going... */ + } /* end else */ } /* end else */ } /* end else */ } /* end else */ - - if(clip_case!=WITHIN) { -#ifdef QAK - printf("%s: check 3.3, new_nodes=%p\n",FUNC,new_nodes); -#endif /* QAK */ - /* Copy all the dimensions start & end points */ - HDmemcpy(start,node->start,rank*sizeof(hssize_t)); - HDmemcpy(end,node->end,rank*sizeof(hssize_t)); - } /* end if */ - - /* Work on upper overlapping block */ - if(clip_case==OVERLAP_BOTH || clip_case==OVERLAP_LOWER) { -#ifdef QAK - printf("%s: check 3.4, new_nodes=%p\n",FUNC,new_nodes); -#endif /* QAK */ - /* Modify the end point in the current dimension of the overlap */ - end[u]=region->start[u]-1; - /* Clip the existing non-overlapped portion off the current node */ - node->start[u]=region->start[u]; - /* Add the non-overlapping portion to the list of new nodes */ - if(H5S_hyper_node_add(&new_nodes,1,rank,(const hssize_t *)start,(const hsize_t *)end)<0) - HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslab"); -#ifdef QAK - printf("%s: check 3.4.1, new_nodes=%p\n",FUNC,new_nodes); -#ifdef QAK -{ - H5S_hyper_node_t *tmp_reg; /* Temp. hyperslab selection region pointer */ - unsigned v; - - tmp_reg=space->select.sel_info.hslab.hyper_lst->head; - while(tmp_reg!=NULL) { - printf("tmp_reg=%p\n",tmp_reg); - printf("\tstart={",FUNC); - for(v=0; v<rank; v++) { - printf("%d",(int)tmp_reg->start[v]); - if(v<rank-1) - printf(", "); - } /* end for */ - printf("}\n"); - printf("\tend={",FUNC); - for(v=0; v<rank; v++) { - printf("%d",(int)tmp_reg->end[v]); - if(v<rank-1) - printf(", "); - } /* end for */ - printf("}\n"); - tmp_reg=tmp_reg->next; - } /* end while */ -} -#endif /* QAK */ -#endif /* QAK */ - } /* end if */ -#ifdef QAK - printf("%s: check 3.4.5, new_nodes=%p\n",FUNC,new_nodes); -#endif /* QAK */ - /* Work on lower overlapping block */ - if(clip_case==OVERLAP_BOTH || clip_case==OVERLAP_UPPER) { - /* Modify the start & end point in the current dimension of the overlap */ - start[u]=region->end[u]+1; - end[u]=node->end[u]; - /* Clip the existing non-overlapped portion off the current node */ - node->end[u]=region->end[u]; - /* Add the non-overlapping portion to the list of new nodes */ -#ifdef QAK - printf("%s: check 3.5, &new_nodes=%p, new_nodes=%p\n",FUNC,&new_nodes,new_nodes); -#endif /* QAK */ - if(H5S_hyper_node_add(&new_nodes,1,rank,(const hssize_t *)start,(const hsize_t *)end)<0) - HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslab"); -#ifdef QAK - printf("%s: check 3.5.1, &new_nodes=%p, new_nodes=%p\n",FUNC,&new_nodes,new_nodes); -#ifdef QAK -{ - H5S_hyper_node_t *tmp_reg; /* Temp. hyperslab selection region pointer */ - unsigned v; - - tmp_reg=space->select.sel_info.hslab.hyper_lst->head; - while(tmp_reg!=NULL) { - printf("tmp_reg=%p\n",tmp_reg); - printf("\tstart={",FUNC); - for(v=0; v<rank; v++) { - printf("%d",(int)tmp_reg->start[v]); - if(v<rank-1) - printf(", "); - } /* end for */ - printf("}\n"); - printf("\tend={",FUNC); - for(v=0; v<rank; v++) { - printf("%d",(int)tmp_reg->end[v]); - if(v<rank-1) - printf(", "); - } /* end for */ - printf("}\n"); - tmp_reg=tmp_reg->next; - } /* end while */ -} -#endif /* QAK */ -#endif /* QAK */ - } /* end if */ - -#ifdef QAK - printf("%s: check 3.5.5, new_nodes=%p\n",FUNC,new_nodes); -#endif /* QAK */ - /* Check if this is the last dimension */ - /* Add the block to the "overlapped" list, if so */ - /* Allow the algorithm to proceed to the next dimension otherwise */ - if(u==(rank-1)) { -#ifdef QAK - printf("%s: check 3.6, overlapped=%d\n",FUNC,overlapped); -#endif /* QAK */ - if(overlap!=NULL) { - if(H5S_hyper_node_prepend(overlap,node)<0) - HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslab"); - } - else { /* Free the node if we aren't going to keep it */ -#ifdef QAK - printf("%s: check 3.6.1, node=%p\n",FUNC,node); -#endif /* QAK */ - H5S_hyper_node_release(node); - } /* end else */ - overlapped=1; /* stop the algorithm for this block */ - } /* end if */ - } /* end for */ - } /* end if */ - - /* Advance to next hyperslab region */ - region=region->next; - } /* end while */ - - /* Check whether we should add the node to the non-overlapping list */ - if(!overlapped) { -#ifdef QAK - printf("%s: check 3.7, node=%p\n",FUNC,node); -#endif /* QAK */ - if(uniq!=NULL) { - if(H5S_hyper_node_prepend(uniq,node)<0) - HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslab"); - } - else { /* Free the node if we aren't going to keep it */ -#ifdef QAK - printf("%s: check 3.7.1\n",FUNC); -#endif /* QAK */ - H5S_hyper_node_release(node); + /* Advance to the next nodes in the span list */ + span1=span1->next; + span2=span2->next; + } /* end while */ } /* end else */ - } /* end if */ - - /* Advance to next hyperslab node */ - node=next_node; - - /* Check if we've added more nodes from splitting to the list */ - if(node==NULL && new_nodes!=NULL) { - node=new_nodes; - new_nodes=NULL; - } /* end if */ - } /* end while */ + } /* end else */ + } /* end else */ +#ifdef LATER done: - if(start!=NULL) - H5FL_ARR_FREE(hsize_t,start); - if(end!=NULL) - H5FL_ARR_FREE(hsize_t,end); - +#endif /* LATER */ FUNC_LEAVE (ret_value); -} /* H5S_hyper_clip() */ +} /* H5S_hyper_cmp_spans() */ /*-------------------------------------------------------------------------- NAME - H5S_hyper_release + H5S_hyper_free_span_info PURPOSE - Release hyperslab selection information for a dataspace + Free a hyperslab span info node USAGE - herr_t H5S_hyper_release(space) - H5S_t *space; IN: Pointer to dataspace + herr_t H5S_hyper_free_span_info(span_info) + H5S_hyper_span_info_t *span_info; IN: Span info node to free RETURNS - Non-negative on success/Negative on failure + Non-negative on success, negative on failure DESCRIPTION - Releases all hyperslab selection information for a dataspace + Free a hyperslab span info node, along with all the span nodes and the + 'down spans' from the nodes, if reducing their reference count to zero + indicates it is appropriate to do so. GLOBAL VARIABLES COMMENTS, BUGS, ASSUMPTIONS EXAMPLES REVISION LOG - * Robb Matzke, 1998-08-25 - * The fields which are freed are set to NULL to prevent them from being - * freed again later. This fixes some allocation problems where - * changing the hyperslab selection of one data space causes a core dump - * when closing some other data space. --------------------------------------------------------------------------*/ -herr_t -H5S_hyper_release (H5S_t *space) +static herr_t +H5S_hyper_free_span_info (H5S_hyper_span_info_t *span_info) { - H5S_hyper_node_t *curr,*next; /* Pointer to hyperslab nodes */ - unsigned u; /* Counters */ + H5S_hyper_span_t *span, *next_span; + herr_t ret_value=SUCCEED; - FUNC_ENTER (H5S_hyper_release, FAIL); + FUNC_ENTER (H5S_hyper_free_span_info, FAIL); - /* Check args */ - assert (space && H5S_SEL_HYPERSLABS==space->select.type); -#ifdef QAK - printf("%s: check 1.0\n",FUNC); -#endif /* QAK */ + assert(span_info); - /* Reset the number of points selected */ - space->select.num_elem=0; + /* Decrement the span tree's reference count */ + span_info->count--; - /* Release the regular selection info */ - if(space->select.sel_info.hslab.diminfo!=NULL) { - H5FL_ARR_FREE(H5S_hyper_dim_t,space->select.sel_info.hslab.diminfo); - space->select.sel_info.hslab.diminfo = NULL; - H5FL_ARR_FREE(H5S_hyper_dim_t,space->select.sel_info.hslab.app_diminfo); - space->select.sel_info.hslab.app_diminfo = NULL; - } /* end if */ + /* Free the span tree if the reference count drops to zero */ + if(span_info->count==0) { - /* Release irregular hyperslab information */ - if(space->select.sel_info.hslab.hyper_lst!=NULL) { - /* Release hi and lo boundary information */ - if(space->select.sel_info.hslab.hyper_lst->lo_bounds!=NULL) { - for(u=0; u<space->extent.u.simple.rank; u++) { - H5FL_ARR_FREE(H5S_hyper_bound_t,space->select.sel_info.hslab.hyper_lst->lo_bounds[u]); - space->select.sel_info.hslab.hyper_lst->lo_bounds[u] = NULL; - } /* end for */ - H5FL_ARR_FREE(H5S_hyper_bound_ptr_t,space->select.sel_info.hslab.hyper_lst->lo_bounds); - space->select.sel_info.hslab.hyper_lst->lo_bounds = NULL; - } /* end if */ - - /* Release list of selected regions */ - curr=space->select.sel_info.hslab.hyper_lst->head; - while(curr!=NULL) { - next=curr->next; - H5S_hyper_node_release(curr); - curr=next; + /* Work through the list of spans pointed to by this 'info' node */ + span=span_info->head; + while(span!=NULL) { + next_span=span->next; + if(H5S_hyper_free_span(span)<0) + HGOTO_ERROR(H5E_INTERNAL, H5E_CANTFREE, FAIL, "failed to release hyperslab span"); + span=next_span; } /* end while */ - /* Release hyperslab selection node itself */ - H5FL_FREE(H5S_hyper_list_t,space->select.sel_info.hslab.hyper_lst); - space->select.sel_info.hslab.hyper_lst=NULL; + /* Free this span info */ + H5FL_FREE(H5S_hyper_span_info_t,span_info); } /* end if */ -#ifdef QAK - printf("%s: check 2.0\n",FUNC); -#endif /* QAK */ +done: + FUNC_LEAVE (ret_value); +} /* H5S_hyper_free_span_info() */ - FUNC_LEAVE (SUCCEED); -} /* H5S_hyper_release() */ /*-------------------------------------------------------------------------- NAME - H5S_hyper_npoints + H5S_hyper_free_span PURPOSE - Compute number of elements in current selection + Free a hyperslab span node USAGE - hsize_t H5S_hyper_npoints(space) - H5S_t *space; IN: Pointer to dataspace + herr_t H5S_hyper_free_span(span) + H5S_hyper_span_t *span; IN: Span node to free RETURNS - The number of elements in selection on success, 0 on failure + Non-negative on success, negative on failure DESCRIPTION - Compute number of elements in current selection. + Free a hyperslab span node, along with the 'down spans' from the node, + if reducing their reference count to zero indicates it is appropriate to + do so. GLOBAL VARIABLES COMMENTS, BUGS, ASSUMPTIONS EXAMPLES REVISION LOG --------------------------------------------------------------------------*/ -hsize_t -H5S_hyper_npoints (const H5S_t *space) +static herr_t +H5S_hyper_free_span (H5S_hyper_span_t *span) { - FUNC_ENTER (H5S_hyper_npoints, 0); + herr_t ret_value=SUCCEED; - /* Check args */ - assert (space); + FUNC_ENTER (H5S_hyper_free_span, FAIL); - FUNC_LEAVE (space->select.num_elem); -} /* H5S_hyper_npoints() */ - -/*-------------------------------------------------------------------------- - NAME - H5S_hyper_sel_iter_release - PURPOSE - Release hyperslab selection iterator information for a dataspace - USAGE - herr_t H5S_hyper_sel_iter_release(sel_iter) - H5S_t *space; IN: Pointer to dataspace iterator is for - H5S_sel_iter_t *sel_iter; IN: Pointer to selection iterator - RETURNS - Non-negative on success/Negative on failure - DESCRIPTION - Releases all information for a dataspace hyperslab selection iterator - GLOBAL VARIABLES - COMMENTS, BUGS, ASSUMPTIONS - EXAMPLES - REVISION LOG ---------------------------------------------------------------------------*/ -herr_t -H5S_hyper_sel_iter_release (H5S_sel_iter_t *sel_iter) -{ - FUNC_ENTER (H5S_hyper_sel_iter_release, FAIL); + assert(span); - /* Check args */ - assert (sel_iter); + /* Decrement the reference count of the 'down spans', freeing them if appropriate */ + if(span->down!=NULL) { + if(H5S_hyper_free_span_info(span->down)<0) + HGOTO_ERROR(H5E_INTERNAL, H5E_CANTFREE, FAIL, "failed to release hyperslab span tree"); + } /* end if */ - if(sel_iter->hyp.pos!=NULL) - H5FL_ARR_FREE(hsize_t,sel_iter->hyp.pos); + /* Free this span */ + H5FL_FREE(H5S_hyper_span_t,span); + +done: + FUNC_LEAVE (ret_value); +} /* H5S_hyper_free_span() */ - FUNC_LEAVE (SUCCEED); -} /* H5S_hyper_sel_iter_release() */ - -/*------------------------------------------------------------------------- - * Function: H5S_hyper_compare_bounds - * - * Purpose: Compares two bounds for equality - * - * Return: an integer less than, equal to, or greater than zero if the first - * region is considered to be respectively less than, equal to, or - * greater than the second - * - * Programmer: Quincey Koziol - * Friday, July 17, 1998 - * - * Modifications: - * - *------------------------------------------------------------------------- - */ -int -H5S_hyper_compare_bounds (const void *r1, const void *r2) -{ - if(((const H5S_hyper_bound_t *)r1)->bound<((const H5S_hyper_bound_t *)r2)->bound) - return(-1); - else - if(((const H5S_hyper_bound_t *)r1)->bound>((const H5S_hyper_bound_t *)r2)->bound) - return(1); - else - return(0); -} /* end H5S_hyper_compare_bounds */ /*-------------------------------------------------------------------------- NAME @@ -4759,11 +4898,8 @@ H5S_hyper_compare_bounds (const void *r1, const void *r2) herr_t H5S_hyper_copy (H5S_t *dst, const H5S_t *src) { - H5S_hyper_list_t *new_hyper=NULL; /* New hyperslab selection */ - H5S_hyper_node_t *curr, *new_node, *new_head; /* Hyperslab information nodes */ H5S_hyper_dim_t *new_diminfo=NULL; /* New per-dimension info array[rank] */ unsigned u; /* Counters */ - size_t v; /* Counters */ herr_t ret_value=SUCCEED; /* return value */ FUNC_ENTER (H5S_hyper_copy, FAIL); @@ -4771,9 +4907,6 @@ H5S_hyper_copy (H5S_t *dst, const H5S_t *src) assert(src); assert(dst); -#ifdef QAK - printf("%s: check 3.0\n", FUNC); -#endif /* QAK */ /* Check if there is regular hyperslab information to copy */ if(src->select.sel_info.hslab.diminfo!=NULL) { /* Create the per-dimension selection info */ @@ -4807,90 +4940,81 @@ H5S_hyper_copy (H5S_t *dst, const H5S_t *src) dst->select.sel_info.hslab.app_diminfo = new_diminfo; } /* end else */ - /* Check if there is irregular hyperslab information to copy */ - if(src->select.sel_info.hslab.hyper_lst!=NULL) { - /* Create the new hyperslab information node */ - if((new_hyper = H5FL_ALLOC(H5S_hyper_list_t,0))==NULL) - HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, - "can't allocate point node"); - - /* Copy the basic hyperslab selection information */ - *new_hyper=*(src->select.sel_info.hslab.hyper_lst); - -#ifdef QAK - printf("%s: check 4.0\n", FUNC); -#endif /* QAK */ - /* Allocate space for the low & high bound arrays */ - if((new_hyper->lo_bounds = H5FL_ARR_ALLOC(H5S_hyper_bound_ptr_t,src->extent.u.simple.rank,0))==NULL) - HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, - "can't allocate boundary node"); - for(u=0; u<src->extent.u.simple.rank; u++) { - if((new_hyper->lo_bounds[u] = H5FL_ARR_ALLOC(H5S_hyper_bound_t,src->select.sel_info.hslab.hyper_lst->count,0))==NULL) - HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, - "can't allocate boundary list"); - } /* end for */ + /* Check if there is hyperslab span information to copy */ + if(src->select.sel_info.hslab.span_lst!=NULL) { + /* Copy the hyperslab span information */ + dst->select.sel_info.hslab.span_lst=H5S_hyper_copy_span(src->select.sel_info.hslab.span_lst); + } /* end if */ -#ifdef QAK - printf("%s: check 5.0\n", FUNC); -#endif /* QAK */ - /* Copy the hyperslab selection nodes, adding them to the lo & hi bound arrays also */ - curr=src->select.sel_info.hslab.hyper_lst->head; - new_head=NULL; - v=0; - while(curr!=NULL) { -#ifdef QAK - printf("%s: check 5.1\n", FUNC); -#endif /* QAK */ - /* Create each point */ - if((new_node = H5FL_ALLOC(H5S_hyper_node_t,0))==NULL) - HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, - "can't allocate point node"); - HDmemcpy(new_node,curr,sizeof(H5S_hyper_node_t)); /* copy caching information */ - if((new_node->start = H5FL_ARR_ALLOC(hsize_t,src->extent.u.simple.rank,0))==NULL) - HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, - "can't allocate coordinate information"); - if((new_node->end = H5FL_ARR_ALLOC(hsize_t,src->extent.u.simple.rank,0))==NULL) - HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, - "can't allocate coordinate information"); - HDmemcpy(new_node->start,curr->start,(src->extent.u.simple.rank*sizeof(hssize_t))); - HDmemcpy(new_node->end,curr->end,(src->extent.u.simple.rank*sizeof(hssize_t))); - new_node->next=NULL; - - /* Insert into low & high bound arrays */ - for(u=0; u<src->extent.u.simple.rank; u++) { - new_hyper->lo_bounds[u][v].bound=new_node->start[u]; - new_hyper->lo_bounds[u][v].node=new_node; - } /* end for */ - v++; /* Increment the location of the next node in the boundary arrays */ +done: + FUNC_LEAVE (ret_value); +} /* end H5S_hyper_copy() */ - /* Keep the order the same when copying */ - if(new_head==NULL) - new_head=new_hyper->head=new_node; - else { - new_head->next=new_node; - new_head=new_node; - } /* end else */ + +/*-------------------------------------------------------------------------- + NAME + H5S_hyper_select_valid_helper + PURPOSE + Check whether the selection fits within the extent, with the current + offset defined. + USAGE + htri_t H5S_hyper_select_valid_helper(spans, offset, rank); + const H5S_hyper_span_info_t *spans; IN: Pointer to current hyperslab span tree + const hssize_t *offset; IN: Pointer to offset array + const hsize_t *size; IN: Pointer to size array + hsize_t rank; IN: Current rank looking at + RETURNS + TRUE if the selection fits within the extent, FALSE if it does not and + Negative on an error. + DESCRIPTION + Determines if the current selection at the current offet fits within the + extent for the dataspace. + GLOBAL VARIABLES + COMMENTS, BUGS, ASSUMPTIONS + EXAMPLES + REVISION LOG +--------------------------------------------------------------------------*/ +static htri_t +H5S_hyper_select_valid_helper (const H5S_hyper_span_info_t *spans, const hssize_t *offset, const hsize_t *size, hsize_t rank) +{ + H5S_hyper_span_t *curr; /* Hyperslab information nodes */ + htri_t tmp; /* temporary return value */ + htri_t ret_value=TRUE; /* return value */ - curr=curr->next; - } /* end while */ -#ifdef QAK - printf("%s: check 6.0\n", FUNC); -#endif /* QAK */ + FUNC_ENTER (H5S_hyper_select_valid_helper, FAIL); + + assert(spans); + assert(offset); + assert(size); + assert(rank<H5O_LAYOUT_NDIMS); + + /* Check each point to determine whether selection+offset is within extent */ + curr=spans->head; + while(curr!=NULL && ret_value==TRUE) { + /* Check if an offset has been defined */ + /* Bounds check the selected point + offset against the extent */ + if(((curr->low+offset[rank])>(hssize_t)size[rank]) + || ((curr->low+offset[rank])<0) + || ((curr->high+offset[rank])>(hssize_t)size[rank]) + || ((curr->high+offset[rank])<0)) { + ret_value=FALSE; + break; + } /* end if */ - /* Sort the boundary array */ - for(u=0; u<src->extent.u.simple.rank; u++) - HDqsort(new_hyper->lo_bounds[u], new_hyper->count, sizeof(H5S_hyper_bound_t), H5S_hyper_compare_bounds); -#ifdef QAK - printf("%s: check 7.0\n", FUNC); -#endif /* QAK */ - } /* end if */ + /* Recurse if this node has down spans */ + if(curr->down!=NULL) { + if((tmp=H5S_hyper_select_valid_helper(curr->down,offset,size,rank+1))!=TRUE) { + ret_value=tmp; + break; + } /* end if */ + } /* end if */ - /* Attach the hyperslab information to the destination dataspace */ - dst->select.sel_info.hslab.hyper_lst=new_hyper; + /* Advance to next node */ + curr=curr->next; + } /* end while */ -done: FUNC_LEAVE (ret_value); -} /* end H5S_hyper_copy() */ +} /* end H5S_hyper_select_valid_helper() */ /*-------------------------------------------------------------------------- @@ -4916,7 +5040,6 @@ done: htri_t H5S_hyper_select_valid (const H5S_t *space) { - H5S_hyper_node_t *curr; /* Hyperslab information nodes */ unsigned u; /* Counter */ htri_t ret_value=TRUE; /* return value */ @@ -4953,28 +5076,64 @@ H5S_hyper_select_valid (const H5S_t *space) } /* end for */ } /* end if */ else { - /* Check each point to determine whether selection+offset is within extent */ - curr=space->select.sel_info.hslab.hyper_lst->head; - while(curr!=NULL && ret_value==TRUE) { - /* Check each dimension */ - for(u=0; u<space->extent.u.simple.rank; u++) { - /* Check if an offset has been defined */ - /* Bounds check the selected point + offset against the extent */ - if(((curr->start[u]+space->select.offset[u])>(hssize_t)space->extent.u.simple.size[u]) - || ((curr->start[u]+space->select.offset[u])<0) - || ((curr->end[u]+space->select.offset[u])>(hssize_t)space->extent.u.simple.size[u]) - || ((curr->end[u]+space->select.offset[u])<0)) { - ret_value=FALSE; - break; - } /* end if */ - } /* end for */ + /* Call the recursive routine to validate the span tree */ + ret_value=H5S_hyper_select_valid_helper(space->select.sel_info.hslab.span_lst,space->select.offset,space->extent.u.simple.size,(hsize_t)0); + } /* end else */ - curr=curr->next; + FUNC_LEAVE (ret_value); +} /* end H5S_hyper_select_valid() */ + + +/*-------------------------------------------------------------------------- + NAME + H5S_hyper_span_nblocks + PURPOSE + Count the number of blocks in a span tree + USAGE + hssize_t H5S_hyper_span_nblocks(spans) + const H5S_hyper_span_info_t *spans; IN: Hyperslan span tree to count elements of + RETURNS + Number of blocks in span tree on success; negative on failure + DESCRIPTION + Counts the number of blocks described by the spans in a span tree. + GLOBAL VARIABLES + COMMENTS, BUGS, ASSUMPTIONS + EXAMPLES + REVISION LOG +--------------------------------------------------------------------------*/ +hssize_t +H5S_hyper_span_nblocks (H5S_hyper_span_info_t *spans) +{ + H5S_hyper_span_t *span; /* Hyperslab span */ + hssize_t ret_value=FAIL; + + FUNC_ENTER (H5S_hyper_span_nblocks, FAIL); + + /* Count the number of elements in the span tree */ + if(spans==NULL) + ret_value=0; + else { + span=spans->head; + ret_value=0; + while(span!=NULL) { + /* If there are down spans, add the total down span blocks */ + if(span->down!=NULL) + ret_value+=H5S_hyper_span_nblocks(span->down); + /* If there are no down spans, just count the block in this span */ + else + ret_value++; + + /* Advance to next span */ + span=span->next; } /* end while */ - } /* end while */ + } /* end else */ +#ifdef LATER +done: +#endif /* LATER */ FUNC_LEAVE (ret_value); -} /* end H5S_hyper_select_valid() */ +} /* H5S_hyper_span_nblocks() */ + /*-------------------------------------------------------------------------- NAME @@ -4998,7 +5157,6 @@ H5S_hyper_select_valid (const H5S_t *space) hssize_t H5S_hyper_select_serial_size (const H5S_t *space) { - H5S_hyper_node_t *curr; /* Hyperslab information nodes */ unsigned u; /* Counter */ hssize_t block_count; /* block counter for regular hyperslabs */ hssize_t ret_value=FAIL; /* return value */ @@ -5021,17 +5179,92 @@ H5S_hyper_select_serial_size (const H5S_t *space) ret_value+=8*block_count*space->extent.u.simple.rank; } /* end if */ else { - /* Spin through hyperslabs to total the space needed to store them */ - curr=space->select.sel_info.hslab.hyper_lst->head; - while(curr!=NULL) { - /* Add 8 bytes times the rank for each element selected */ - ret_value+=8*space->extent.u.simple.rank; - curr=curr->next; - } /* end while */ + /* Spin through hyperslab spans, adding 8 * rank bytes for each block */ + block_count=H5S_hyper_span_nblocks(space->select.sel_info.hslab.span_lst); + ret_value+=8*space->extent.u.simple.rank*block_count; } /* end else */ FUNC_LEAVE (ret_value); } /* end H5S_hyper_select_serial_size() */ + + +/*-------------------------------------------------------------------------- + NAME + H5S_hyper_select_serialize_helper + PURPOSE + Serialize the current selection into a user-provided buffer. + USAGE + herr_t H5S_hyper_select_serialize_helper(spans, start, end, rank, buf) + H5S_hyper_span_info_t *spans; IN: Hyperslab span tree to serialize + hssize_t start[]; IN/OUT: Accumulated start points + hssize_t end[]; IN/OUT: Accumulated end points + hsize_t rank; IN: Current rank looking at + uint8 *buf; OUT: Buffer to put serialized selection into + RETURNS + Non-negative on success/Negative on failure + DESCRIPTION + Serializes the current element selection into a buffer. (Primarily for + storing on disk). + GLOBAL VARIABLES + COMMENTS, BUGS, ASSUMPTIONS + EXAMPLES + REVISION LOG +--------------------------------------------------------------------------*/ +static herr_t +H5S_hyper_select_serialize_helper (const H5S_hyper_span_info_t *spans, hssize_t *start, hssize_t *end, hsize_t rank, uint8_t **buf) +{ + H5S_hyper_span_t *curr; /* Pointer to current hyperslab span */ + hsize_t u; /* Index variable */ + herr_t ret_value=SUCCEED; /* return value */ + + FUNC_ENTER (H5S_hyper_select_serialize_helper, FAIL); + + /* Sanity checks */ + assert(spans); + assert(start); + assert(end); + assert(rank<H5O_LAYOUT_NDIMS); + assert(buf && *buf); + + /* Walk through the list of spans, recursing or outputing them */ + curr=spans->head; + while(curr!=NULL) { + /* Recurse if this node has down spans */ + if(curr->down!=NULL) { + /* Add the starting and ending points for this span to the list */ + start[rank]=curr->low; + end[rank]=curr->high; + + /* Recurse down to the next dimension */ + if(H5S_hyper_select_serialize_helper(curr->down,start,end,rank+1,buf)<0) + HGOTO_ERROR(H5E_INTERNAL, H5E_CANTFREE, FAIL, "failed to release hyperslab spans"); + } /* end if */ + else { + /* Encode all the previous dimensions starting & ending points */ + + /* Encode previous starting points */ + for(u=0; u<rank; u++) + UINT32ENCODE(*buf, (uint32_t)start[u]); + + /* Encode starting point for this span */ + UINT32ENCODE(*buf, (uint32_t)curr->low); + + /* Encode previous ending points */ + for(u=0; u<rank; u++) + UINT32ENCODE(*buf, (uint32_t)end[u]); + + /* Encode starting point for this span */ + UINT32ENCODE(*buf, (uint32_t)curr->high); + } /* end else */ + + /* Advance to next node */ + curr=curr->next; + } /* end while */ + +done: + FUNC_LEAVE (ret_value); +} /* H5S_hyper_select_serialize_helper() */ + /*-------------------------------------------------------------------------- NAME @@ -5058,12 +5291,12 @@ H5S_hyper_select_serialize (const H5S_t *space, uint8_t *buf) H5S_hyper_dim_t *diminfo; /* Alias for dataspace's diminfo information */ hsize_t tmp_count[H5O_LAYOUT_NDIMS]; /* Temporary hyperslab counts */ hssize_t offset[H5O_LAYOUT_NDIMS]; /* Offset of element in dataspace */ + hssize_t start[H5O_LAYOUT_NDIMS]; /* Location of start of hyperslab */ + hssize_t end[H5O_LAYOUT_NDIMS]; /* Location of end of hyperslab */ hssize_t temp_off; /* Offset in a given dimension */ - H5S_hyper_node_t *curr; /* Hyperslab information nodes */ uint8_t *lenp; /* pointer to length location for later storage */ uint32_t len=0; /* number of bytes used */ int i; /* local counting variable */ - unsigned u; /* local counting variable */ hssize_t block_count; /* block counter for regular hyperslabs */ int fast_dim; /* Rank of the fastest changing dimension for the dataspace */ int temp_dim; /* Temporary rank holder */ @@ -5071,7 +5304,7 @@ H5S_hyper_select_serialize (const H5S_t *space, uint8_t *buf) int done; /* Whether we are done with the iteration */ herr_t ret_value=FAIL; /* return value */ - FUNC_ENTER (H5S_point_select_serialize, FAIL); + FUNC_ENTER (H5S_hyper_select_serialize, FAIL); assert(space); @@ -5093,17 +5326,9 @@ H5S_hyper_select_serialize (const H5S_t *space, uint8_t *buf) fast_dim=ndims-1; diminfo=space->select.sel_info.hslab.diminfo; -#ifdef QAK - printf("%s: Serializing regular selection\n",FUNC); - for(i=0; i<ndims; i++) - printf("%s: (%d) start=%d, stride=%d, count=%d, block=%d\n",FUNC,i,(int)diminfo[i].start,(int)diminfo[i].stride,(int)diminfo[i].count,(int)diminfo[i].block); -#endif /*QAK */ /* Check each dimension */ for(block_count=1,i=0; i<ndims; i++) block_count*=diminfo[i].count; -#ifdef QAK -printf("%s: block_count=%d\n",FUNC,(int)block_count); -#endif /*QAK */ /* Encode number of hyperslabs */ UINT32ENCODE(buf, (uint32_t)block_count); @@ -5127,18 +5352,10 @@ printf("%s: block_count=%d\n",FUNC,(int)block_count); /* Add 8 bytes times the rank for each hyperslab selected */ len+=8*ndims; -#ifdef QAK -for(i=0; i<ndims; i++) - printf("%s: offset(%d)=%d\n",FUNC,i,(int)offset[i]); -#endif /*QAK */ /* Encode hyperslab starting location */ for(i=0; i<ndims; i++) UINT32ENCODE(buf, (uint32_t)offset[i]); -#ifdef QAK -for(i=0; i<ndims; i++) - printf("%s: offset+block-1(%d)=%d\n",FUNC,i,(int)(offset[i]+(diminfo[i].block-1))); -#endif /*QAK */ /* Encode hyperslab ending location */ for(i=0; i<ndims; i++) UINT32ENCODE(buf, (uint32_t)(offset[i]+(diminfo[i].block-1))); @@ -5187,25 +5404,15 @@ for(i=0; i<ndims; i++) } /* end if */ else { /* Encode number of hyperslabs */ - UINT32ENCODE(buf, (uint32_t)space->select.sel_info.hslab.hyper_lst->count); + block_count=H5S_hyper_span_nblocks(space->select.sel_info.hslab.span_lst); + UINT32ENCODE(buf, (uint32_t)block_count); len+=4; - /* Encode each hyperslab in selection */ - curr=space->select.sel_info.hslab.hyper_lst->head; - while(curr!=NULL) { - /* Add 8 bytes times the rank for each hyperslab selected */ - len+=8*space->extent.u.simple.rank; - - /* Encode starting point */ - for(u=0; u<space->extent.u.simple.rank; u++) - UINT32ENCODE(buf, (uint32_t)curr->start[u]); - - /* Encode ending point */ - for(u=0; u<space->extent.u.simple.rank; u++) - UINT32ENCODE(buf, (uint32_t)curr->end[u]); + /* Add 8 bytes times the rank for each hyperslab selected */ + len+=8*space->extent.u.simple.rank*block_count; - curr=curr->next; - } /* end while */ + /* Encode each hyperslab in selection */ + H5S_hyper_select_serialize_helper(space->select.sel_info.hslab.span_lst,start,end,(hsize_t)0,&buf); } /* end else */ /* Encode length */ @@ -5216,6 +5423,7 @@ for(i=0; i<ndims; i++) FUNC_LEAVE (ret_value); } /* H5S_hyper_select_serialize() */ + /*-------------------------------------------------------------------------- NAME @@ -5294,9 +5502,8 @@ H5S_hyper_select_deserialize (H5S_t *space, const uint8_t *buf) *tblock=(*tend-*tstart)+1; /* Select or add the hyperslab to the current selection */ - if((ret_value=H5S_select_hyperslab(space,(i==0 ? H5S_SELECT_SET : H5S_SELECT_OR),start,NULL,count,block))<0) { + if((ret_value=H5S_select_hyperslab(space,(i==0 ? H5S_SELECT_SET : H5S_SELECT_OR),start,NULL,count,block))<0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTDELETE, FAIL, "can't change selection"); - } /* end if */ } /* end for */ /* Free temporary buffers */ @@ -5308,6 +5515,178 @@ H5S_hyper_select_deserialize (H5S_t *space, const uint8_t *buf) done: FUNC_LEAVE (ret_value); } /* H5S_hyper_select_deserialize() */ + + +/*-------------------------------------------------------------------------- + NAME + H5S_hyper_span_blocklist + PURPOSE + Get a list of hyperslab blocks currently selected + USAGE + herr_t H5S_hyper_span_blocklist(spans, start, end, rank, startblock, numblocks, buf) + H5S_hyper_span_info_t *spans; IN: Dataspace pointer of selection to query + hssize_t start[]; IN/OUT: Accumulated start points + hssize_t end[]; IN/OUT: Accumulated end points + hsize_t rank; IN: Rank of dataspace + hsize_t *startblock; IN/OUT: Hyperslab block to start with + hsize_t *numblocks; IN/OUT: Number of hyperslab blocks to get + hsize_t **buf; OUT: List of hyperslab blocks selected + RETURNS + Non-negative on success/Negative on failure + DESCRIPTION + Puts a list of the hyperslab blocks into the user's buffer. The blocks + start with the '*startblock'th block in the list of blocks and put + '*numblocks' number of blocks into the user's buffer (or until the end of + the list of blocks, whichever happens first) + The block coordinates have the same dimensionality (rank) as the + dataspace they are located within. The list of blocks is formatted as + follows: <"start" coordinate> immediately followed by <"opposite" corner + coordinate>, followed by the next "start" and "opposite" coordinate, etc. + until all the block information requested has been put into the user's + buffer. + No guarantee of any order of the blocks is implied. + GLOBAL VARIABLES + COMMENTS, BUGS, ASSUMPTIONS + EXAMPLES + REVISION LOG +--------------------------------------------------------------------------*/ +herr_t +H5S_hyper_span_blocklist(H5S_hyper_span_info_t *spans, hssize_t start[], hssize_t end[], hsize_t rank, hsize_t *startblock, hsize_t *numblocks, hsize_t **buf) +{ + H5S_hyper_span_t *curr; /* Pointer to current hyperslab span */ + hsize_t u; /* Index variable */ + herr_t ret_value=SUCCEED; /* return value */ + + FUNC_ENTER (H5S_hyper_span_blocklist, FAIL); + + /* Sanity checks */ + assert(spans); + assert(rank<H5O_LAYOUT_NDIMS); + assert(start); + assert(end); + assert(startblock); + assert(numblocks && *numblocks>0); + assert(buf && *buf); + + /* Walk through the list of spans, recursing or outputing them */ + curr=spans->head; + while(curr!=NULL && *numblocks>0) { + /* Recurse if this node has down spans */ + if(curr->down!=NULL) { + /* Add the starting and ending points for this span to the list */ + start[rank]=curr->low; + end[rank]=curr->high; + + /* Recurse down to the next dimension */ + if(H5S_hyper_span_blocklist(curr->down,start,end,rank+1,startblock,numblocks,buf)<0) + HGOTO_ERROR(H5E_INTERNAL, H5E_CANTFREE, FAIL, "failed to release hyperslab spans"); + } /* end if */ + else { + /* Skip this block if we haven't skipped all the startblocks yet */ + if(*startblock>0) { + /* Decrement the starting block */ + (*startblock)--; + } + /* Process this block */ + else { + /* Encode all the previous dimensions starting & ending points */ + + /* Copy previous starting points */ + for(u=0; u<rank; u++, (*buf)++) + HDmemcpy(*buf, &start[u], sizeof(hsize_t)); + + /* Copy starting point for this span */ + HDmemcpy(*buf, &curr->low, sizeof(hsize_t)); + (*buf)++; + + /* Copy previous ending points */ + for(u=0; u<rank; u++, (*buf)++) + HDmemcpy(*buf, &end[u], sizeof(hsize_t)); + + /* Copy starting point for this span */ + HDmemcpy(*buf, &curr->high, sizeof(hsize_t)); + (*buf)++; + + /* Decrement the number of blocks processed */ + (*numblocks)--; + } /* end else */ + } /* end else */ + + /* Advance to next node */ + curr=curr->next; + } /* end while */ + +done: + FUNC_LEAVE (ret_value); +} /* H5S_hyper_span_blocklist() */ + + +/*-------------------------------------------------------------------------- + NAME + H5S_hyper_bounds_helper + PURPOSE + Gets the bounding box containing the selection. + USAGE + htri_t H5S_hyper_bounds_helper(spans, offset, rank); + const H5S_hyper_span_info_t *spans; IN: Pointer to current hyperslab span tree + const hssize_t *offset; IN: Pointer to offset array + hsize_t rank; IN: Current rank looking at + hsize_t *start; OUT: Start array bounds + hsize_t *end; OUT: End array bounds + RETURNS + Non-negative on success, negative on failure + DESCRIPTION + Retrieves the bounding box containing the current selection and places + it into the user's buffers. The start and end buffers must be large + enough to hold the dataspace rank number of coordinates. The bounding box + exactly contains the selection, ie. if a 2-D element selection is currently + defined with the following points: (4,5), (6,8) (10,7), the bounding box + with be (4, 5), (10, 8). + The bounding box calculations _does_ include the current offset of the + selection within the dataspace extent. + GLOBAL VARIABLES + COMMENTS, BUGS, ASSUMPTIONS + EXAMPLES + REVISION LOG +--------------------------------------------------------------------------*/ +static herr_t +H5S_hyper_bounds_helper (const H5S_hyper_span_info_t *spans, const hssize_t *offset, hsize_t rank, hsize_t *start, hsize_t *end) +{ + H5S_hyper_span_t *curr; /* Hyperslab information nodes */ + herr_t ret_value=SUCCEED; /* return value */ + + FUNC_ENTER (H5S_hyper_bounds_helper, FAIL); + + assert(spans); + assert(offset); + assert(rank<H5O_LAYOUT_NDIMS); + assert(start); + assert(end); + + /* Check each point to determine whether selection+offset is within extent */ + curr=spans->head; + while(curr!=NULL) { + /* Check if the current span extends the bounding box */ + if((curr->low+offset[rank])<(hssize_t)start[rank]) + start[rank]=curr->low+offset[rank]; + if((curr->high+offset[rank])>(hssize_t)end[rank]) + end[rank]=curr->high+offset[rank]; + + /* Recurse if this node has down spans */ + if(curr->down!=NULL) { + if(H5S_hyper_bounds_helper(curr->down,offset,rank+1,start,end)<0) { + ret_value=FAIL; + break; + } /* end if */ + } /* end if */ + + /* Advance to next node */ + curr=curr->next; + } /* end while */ + + FUNC_LEAVE (ret_value); +} /* end H5S_hyper_bounds_helper() */ + /*-------------------------------------------------------------------------- NAME @@ -5338,9 +5717,6 @@ done: herr_t H5S_hyper_bounds(H5S_t *space, hsize_t *start, hsize_t *end) { - H5S_hyper_node_t *node; /* Hyperslab node */ - int rank; /* Dataspace rank */ - int i; /* index variable */ herr_t ret_value=SUCCEED; /* return value */ FUNC_ENTER (H5S_hyper_bounds, FAIL); @@ -5349,12 +5725,14 @@ H5S_hyper_bounds(H5S_t *space, hsize_t *start, hsize_t *end) assert(start); assert(end); - /* Get the dataspace extent rank */ - rank=space->extent.u.simple.rank; - /* Check for a "regular" hyperslab selection */ if(space->select.sel_info.hslab.diminfo!=NULL) { const H5S_hyper_dim_t *diminfo=space->select.sel_info.hslab.diminfo; /* local alias for diminfo */ + int rank; /* Dataspace rank */ + int i; /* index variable */ + + /* Get the dataspace extent rank */ + rank=space->extent.u.simple.rank; /* Check each dimension */ for(i=0; i<rank; i++) { @@ -5366,17 +5744,8 @@ H5S_hyper_bounds(H5S_t *space, hsize_t *start, hsize_t *end) } /* end for */ } /* end if */ else { - /* Iterate through the node, copying each hyperslab's information */ - node=space->select.sel_info.hslab.hyper_lst->head; - while(node!=NULL) { - for(i=0; i<rank; i++) { - if(start[i]>(hsize_t)(node->start[i]+space->select.offset[i])) - start[i]=node->start[i]+space->select.offset[i]; - if(end[i]<(hsize_t)(node->end[i]+space->select.offset[i])) - end[i]=node->end[i]+space->select.offset[i]; - } /* end for */ - node=node->next; - } /* end while */ + /* Call the recursive routine to get the bounds for the span tree */ + ret_value=H5S_hyper_bounds_helper(space->select.sel_info.hslab.span_lst,space->select.offset,(hsize_t)0,start,end); } /* end if */ FUNC_LEAVE (ret_value); @@ -5405,15 +5774,15 @@ htri_t H5S_hyper_select_contiguous(const H5S_t *space) { htri_t ret_value=FAIL; /* return value */ - H5S_hyper_node_t *node; /* Hyperslab node */ - unsigned rank; /* Dataspace rank */ + H5S_hyper_span_info_t *spans; /* Hyperslab span info node */ + H5S_hyper_span_t *span; /* Hyperslab span node */ unsigned u; /* index variable */ FUNC_ENTER (H5S_hyper_select_contiguous, FAIL); assert(space); - /* Check for a "regular" hyperslab selection */ + /* Quicker check for a "regular" hyperslab selection */ if(space->select.sel_info.hslab.diminfo != NULL) { /* * For a regular hyperslab to be contiguous, it must have only one @@ -5430,33 +5799,1861 @@ H5S_hyper_select_contiguous(const H5S_t *space) } /* end for */ } /* end if */ else { - /* If there is more than one hyperslab in the selection, they are not contiguous */ - if(space->select.sel_info.hslab.hyper_lst->count>1) + /* + * For a hyperslab to be contiguous, it's size must be the same as the + * dataspace extent's in all but the slowest changing dimension + */ + ret_value=TRUE; /* assume true and reset if the dimensions don't match */ + + /* Get information for slowest changing information */ + spans=space->select.sel_info.hslab.span_lst; + span=spans->head; + + /* If there are multiple spans in the slowest changing dimension, the selection isn't contiguous */ + if(span->next!=NULL) ret_value=FALSE; - else { /* If there is one hyperslab, then it might be contiguous */ - /* Get the dataspace extent rank */ - rank=space->extent.u.simple.rank; - - /* Get the hyperslab node */ - node=space->select.sel_info.hslab.hyper_lst->head; - - /* - * For a hyperslab to be contiguous, it's size must be the same as the - * dataspace extent's in all but the slowest changing dimension - */ - ret_value=TRUE; /* assume true and reset if the dimensions don't match */ - for(u=1; u<rank; u++) { - if(((node->end[u]-node->start[u])+1)!=(hssize_t)space->extent.u.simple.size[u]) { - ret_value=FALSE; + else { + /* Now check the rest of the dimensions */ + if(span->down!=NULL) { + u=1; /* Current dimension working on */ + + /* Get the span information for the next fastest dimension */ + spans=span->down; + + /* Cycle down the spans until we run out of down spans or find a non-contiguous span */ + while(spans!=NULL) { + span=spans->head; + + /* Check that this is the only span and it spans the entire dimension */ + if(span->next!=NULL) { + ret_value=FALSE; + break; + } /* end if */ + else { + /* If this span doesn't cover the entire dimension, then this selection isn't contiguous */ + if(((span->high-span->low)+1)!=(hssize_t)space->extent.u.simple.size[u]) { + ret_value=FALSE; + break; + } /* end if */ + else { + /* Walk down to the next span */ + spans=span->down; + + /* Increment dimension */ + u++; + } /* end else */ + } /* end else */ + } /* end while */ + } /* end if */ + } /* end else */ + } /* end else */ + + FUNC_LEAVE (ret_value); +} /* H5S_hyper_select_contiguous() */ + + +/*-------------------------------------------------------------------------- + NAME + H5S_hyper_select_iterate_helper + PURPOSE + Internal routine to iterate over the elements of a span tree hyperslab selection + USAGE + herr_t H5S_iterate_hyperslab_io(iter_info) + H5S_hyper_iter_info_t *iter_info; IN/OUT: Block of iteration parameters to pass into recursive calls + RETURNS + Non-negative on success, negative on failure + DESCRIPTION + Iterates over the elements in a hyperslab span tree selection, calling a + user's callback routine for each element. + GLOBAL VARIABLES + COMMENTS, BUGS, ASSUMPTIONS + EXAMPLES + REVISION LOG +--------------------------------------------------------------------------*/ +static herr_t +H5S_hyper_select_iterate_helper(H5S_hyper_iter_info_t *iter_info) +{ + const H5S_t *space; /* Dataspace operating with */ + H5S_sel_iter_t *iter; /* Selection iterator */ + H5S_hyper_span_t *curr_span; /* Current hyperslab span node */ + hsize_t slab[H5O_LAYOUT_NDIMS]; /* Cumulative size of each dimension in bytes */ + hsize_t acc; /* Accumulator for computing cumulative sizes */ + hssize_t off_arr[H5O_LAYOUT_NDIMS]; /* Current hyperslab span position */ + int fast_dim; /* Rank of the fastest changing dimension for the dataspace */ + int curr_dim; /* Current dimension being operated on */ + int ndims; /* Number of dimensions of dataset */ + hsize_t span_io; /* Number of elements in current span to actually process */ + herr_t user_ret=0; /* User's return value */ + uint8_t *loc; /* Current element location pointer */ + hsize_t loc_off; /* Element offset in the dataspace */ + int i; /* Index variable */ + unsigned u; /* Index variable */ + hssize_t ret_value=FAIL; + + FUNC_ENTER (H5S_hyper_select_iterate_helper, FAIL); + + /* Check args */ + assert(iter_info); + + /* Retrieve some information from the interation info */ + space=iter_info->space; + iter=iter_info->iter; + + /* Set the rank of the fastest changing dimension */ + ndims=space->extent.u.simple.rank; + fast_dim=(ndims-1); + + /* Get the pointers to the current span info and span nodes */ + curr_span=iter->hyp.span[fast_dim]; + + /* Compute the cumulative size of dataspace dimensions */ + for(i=fast_dim, acc=iter_info->elem_size; i>=0; i--) { + slab[i]=acc; + acc*=space->extent.u.simple.size[i]; + } /* end for */ + + /* Set the offset of the first element iterated on */ + for(i=0, loc_off=0; i<ndims; i++) { + /* Set the location */ + off_arr[i]=iter->hyp.span[i]->low; + + /* Compute the sequential element offset */ + loc_off+=off_arr[i]*slab[i]; + } /* end for */ + + /* Perform the I/O on the elements, based on the position of the iterator */ + user_ret=0; + while(curr_span!=NULL && user_ret==0) { + /* Compute the number of elements to attempt in this span */ + span_io=(curr_span->high-curr_span->low)+1; + + /* Iterate through all the span elements */ + for(u=0, loc=(uint8_t *)iter_info->src+loc_off; u<span_io && user_ret==0; u++) { + /* Call the user's callback routine */ + user_ret=(*(iter_info->op))(loc,iter_info->dt,(hsize_t)ndims,off_arr,iter_info->op_data); + + /* Increment the element location */ + off_arr[fast_dim]++; + + /* Increment the buffer offset */ + loc+=slab[fast_dim]; + } /* end for */ + + /* Get out now for user return values not zero */ + if(user_ret!=0) + break; + + /* Adjust iterator pointers */ + + /* Advance span in fastest dimension */ + curr_span=curr_span->next; + + /* See if we are still in the fastest changing dimension */ + if(curr_span!=NULL) { + /* Move the buffer offset */ + loc_off+=(span_io+(curr_span->low-off_arr[fast_dim]))*iter_info->elem_size; + + /* Move the element location */ + off_arr[fast_dim]=curr_span->low; + } /* end if */ + /* We walked off the spans for the fastest dimension, work our way back up */ + else { + /* Start at the fastest dim */ + curr_dim=fast_dim-1; + + /* Get the pointer to the correct dimension */ + curr_span=iter->hyp.span[curr_dim]; + + /* Work back up through the dimensions */ + while(curr_dim>=0) { + /* Increment position in span */ + off_arr[curr_dim]++; + + /* Check if we are still within the span */ + if(off_arr[curr_dim]<=curr_span->high) { break; } /* end if */ - } /* end for */ + /* If we walked off that span, advance to the next span */ + else { + /* Advance span in this dimension */ + curr_span=curr_span->next; + + /* Check if we have a valid span in this dimension still */ + if(curr_span!=NULL) { + /* Reset the offset for the dim */ + off_arr[curr_dim]=curr_span->low; + + break; + } /* end if */ + else { + /* If we finished the span list in this dimension, decrement the dimension worked on and loop again */ + curr_dim--; + + /* Reset the curr_span to the next dim */ + if(curr_dim>=0) + curr_span=iter->hyp.span[curr_dim]; + } /* end else */ + } /* end else */ + } /* end while */ + + /* Check if we are finished with the spans in the tree */ + if(curr_dim<0) { + /* We had better be done with I/O or bad things are going to happen... */ + break; + } /* end if */ + else { + /* Reset the span in the current dimension */ + iter->hyp.span[curr_dim]=curr_span; + + /* Walk back down the iterator positions, reseting them */ + while(curr_dim<fast_dim) { + assert(curr_span); + assert(curr_span->down); + assert(curr_span->down->head); + + /* Set the new span for this dimension */ + iter->hyp.span[curr_dim+1]=curr_span->down->head; + + /* Advance span down the tree */ + curr_span=curr_span->down->head; + + /* Reset the offset for the dim */ + off_arr[curr_dim+1]=curr_span->low; + + /* Increment current dimension */ + curr_dim++; + } /* end while */ + + /* Verify that the curr_span points to the fastest dim */ + assert(curr_span==iter->hyp.span[fast_dim]); + + /* Verify that the offset is correct for the fastest dim */ + assert(off_arr[fast_dim]==curr_span->low); + } /* end else */ + + /* Reset the buffer offset */ + for(i=0, loc_off=0; i<ndims; i++) + loc_off+=off_arr[i]*slab[i]; } /* end else */ + } /* end while */ + + /* Success! */ + ret_value=(user_ret==0 ? SUCCEED : user_ret); + +#ifdef LATER +done: +#endif /* LATER */ + FUNC_LEAVE (ret_value); +} /* end H5S_hyper_select_iterate_helper() */ + + +/*-------------------------------------------------------------------------- + NAME + H5S_hyper_select_iterate_mem_opt + PURPOSE + Iterate over the data points in a regular hyperslab selection, calling a + user's function for each element. + USAGE + herr_t H5S_hyper_select_iterate_mem_opt(buf, type_id, space, op, operator_data) + H5S_sel_iter_t *iter; IN/OUT: Selection iterator + void *buf; IN/OUT: Buffer containing elements to iterate over + hid_t type_id; IN: Datatype ID of BUF array. + H5S_t *space; IN: Dataspace object containing selection to iterate over + H5D_operator_t op; IN: Function pointer to the routine to be + called for each element in BUF iterated over. + void *op_data; IN/OUT: Pointer to any user-defined data associated + with the operation. + RETURNS + Returns the return value of the last operator if it was non-zero, or zero + if all elements were processed. Otherwise returns a negative value. + DESCRIPTION + Iterates over the selected elements in a memory buffer, calling the user's + callback function for each element. The selection in the dataspace is + modified so that any elements already iterated over are removed from the + selection if the iteration is interrupted (by the H5D_operator_t function + returning non-zero) in the "middle" of the iteration and may be re-started + by the user where it left off. + + NOTE: Until "subtracting" elements from a selection is implemented, + the selection is not modified. + GLOBAL VARIABLES + COMMENTS, BUGS, ASSUMPTIONS + EXAMPLES + REVISION LOG +--------------------------------------------------------------------------*/ +static herr_t +H5S_hyper_select_iterate_mem_opt(H5S_sel_iter_t * UNUSED iter, void *buf, hid_t type_id, H5S_t *space, H5D_operator_t op, + void *op_data) +{ + H5S_hyper_dim_t *diminfo; /* Alias for dataspace's diminfo information */ + hsize_t tmp_count[H5O_LAYOUT_NDIMS]; /* Temporary hyperslab counts */ + hsize_t tmp_block[H5O_LAYOUT_NDIMS]; /* Temporary hyperslab blocks */ + hssize_t offset[H5O_LAYOUT_NDIMS]; /* Offset of element in dataspace */ + hsize_t slab[H5O_LAYOUT_NDIMS]; /* Size of objects in buffer */ + size_t elem_size; /* Size of data element in buffer */ + hssize_t temp_off; /* Offset in a given dimension */ + uint8_t *loc; /* Current element location */ + int i; /* Counter */ + unsigned u; /* Counter */ + int fast_dim; /* Rank of the fastest changing dimension for the dataspace */ + int temp_dim; /* Temporary rank holder */ + unsigned ndims; /* Rank of the dataspace */ + herr_t user_ret=0; /* User's return value */ + + FUNC_ENTER (H5S_hyper_select_iterate_mem_opt, FAIL); + + /* Set some convienence values */ + ndims=space->extent.u.simple.rank; + fast_dim=ndims-1; + diminfo=space->select.sel_info.hslab.diminfo; + + /* Get the data element size */ + elem_size=H5Tget_size(type_id); + + /* Elements in the fastest dimension are 'elem_size' */ + slab[ndims-1]=elem_size; + + /* If we have two or more dimensions, build the other dimension's element sizes */ + if(ndims>=2) { + /* Build the table of next-dimension down 'element' sizes */ + for(i=ndims-2; i>=0; i--) + slab[i]=slab[i+1]*space->extent.u.simple.size[i+1]; + } /* end if */ + + /* Build the tables of count & block sizes as well as the initial offset */ + for(u=0; u<ndims; u++) { + tmp_count[u]=diminfo[u].count; + tmp_block[u]=diminfo[u].block; + offset[u]=diminfo[u].start; + } /* end for */ + + /* Initialize the starting location */ + for(loc=buf,u=0; u<ndims; u++) + loc+=diminfo[u].start*slab[u]; + + /* Go iterate over the hyperslabs */ + while(user_ret==0) { + /* Iterate over the blocks in the fastest dimension */ + while(tmp_count[fast_dim]>0 && user_ret==0) { + + /* Iterate over the elements in the fastest dimension */ + while(tmp_block[fast_dim]>0 && user_ret==0) { + user_ret=(*op)(loc,type_id,(hsize_t)ndims,offset,op_data); + + /* Increment the buffer location */ + loc+=slab[fast_dim]; + + /* Increment the offset in the dataspace */ + offset[fast_dim]++; + + /* Decrement the sequence count */ + tmp_block[fast_dim]--; + } /* end while */ + + /* Reset the sequence count */ + tmp_block[fast_dim]=diminfo[fast_dim].block; + + /* Move the location to the next sequence to start */ + loc+=(diminfo[fast_dim].stride-diminfo[fast_dim].block)*slab[fast_dim]; + + /* Move the offset to the next sequence to start */ + offset[fast_dim]+=(diminfo[fast_dim].stride-diminfo[fast_dim].block); + + /* Decrement the block count */ + tmp_count[fast_dim]--; + } /* end while */ + + /* Check for getting out of iterator, we're done in the 1-D case */ + if(ndims==1) + goto done; /* Yes, an evil goto.. :-) -QAK */ + + /* Work on other dimensions if necessary */ + if(fast_dim>0 && user_ret==0) { + /* Reset the sequence and block counts */ + tmp_block[fast_dim]=diminfo[fast_dim].block; + tmp_count[fast_dim]=diminfo[fast_dim].count; + + /* Bubble up the decrement to the slower changing dimensions */ + temp_dim=fast_dim-1; + while(temp_dim>=0) { + /* Decrement the sequence count in this dimension */ + tmp_block[temp_dim]--; + + /* Check if we are still in the sequence */ + if(tmp_block[temp_dim]>0) + break; + + /* Reset the sequence count in this dimension */ + tmp_block[temp_dim]=diminfo[temp_dim].block; + + /* Decrement the block count */ + tmp_count[temp_dim]--; + + /* Check if we have more blocks left */ + if(tmp_count[temp_dim]>0) + break; + + /* Check for getting out of iterator */ + if(temp_dim==0) + goto done; /* Yes, an evil goto.. :-) -QAK */ + + /* Reset the block count in this dimension */ + tmp_count[temp_dim]=diminfo[temp_dim].count; + + /* Wrapped a dimension, go up to next dimension */ + temp_dim--; + } /* end while */ + } /* end if */ + + /* Re-compute buffer location & offset array */ + for(loc=buf,u=0; u<ndims; u++) { + temp_off=diminfo[u].start + +diminfo[u].stride*(diminfo[u].count-tmp_count[u]) + +(diminfo[u].block-tmp_block[u]); + loc+=temp_off*slab[u]; + offset[u]=temp_off; + } /* end for */ + } /* end while */ + +done: + FUNC_LEAVE (user_ret); +} /* end H5S_hyper_select_iterate_mem_opt() */ + + +/*-------------------------------------------------------------------------- + NAME + H5S_hyper_select_iterate + PURPOSE + Iterate over a hyperslab selection, calling a user's function for each + element. + USAGE + herr_t H5S_hyper_select_iterate(buf, type_id, space, op, operator_data) + void *buf; IN/OUT: Buffer containing elements to iterate over + hid_t type_id; IN: Datatype ID of BUF array. + H5S_t *space; IN: Dataspace object containing selection to iterate over + H5D_operator_t op; IN: Function pointer to the routine to be + called for each element in BUF iterated over. + void *operator_data; IN/OUT: Pointer to any user-defined data + associated with the operation. + RETURNS + Returns the return value of the last operator if it was non-zero, or zero + if all elements were processed. Otherwise returns a negative value. + DESCRIPTION + Iterates over the selected elements in a memory buffer, calling the user's + callback function for each element. The selection in the dataspace is + modified so that any elements already iterated over are removed from the + selection if the iteration is interrupted (by the H5D_operator_t function + returning non-zero) in the "middle" of the iteration and may be re-started + by the user where it left off. + + NOTE: Until "subtracting" elements from a selection is implemented, + the selection is not modified. + GLOBAL VARIABLES + COMMENTS, BUGS, ASSUMPTIONS + EXAMPLES + REVISION LOG +--------------------------------------------------------------------------*/ +herr_t +H5S_hyper_select_iterate(void *buf, hid_t type_id, H5S_t *space, H5D_operator_t op, + void *operator_data) +{ + H5S_hyper_iter_info_t iter_info; /* Block of parameters to pass into recursive calls */ + H5S_sel_iter_t iter; /* selection iteration info*/ + size_t elmt_size; /* Datatype size */ + herr_t ret_value=FAIL; /* return value */ + + FUNC_ENTER (H5S_hyper_select_iterate, FAIL); + + assert(buf); + assert(space); + assert(op); + assert(H5I_DATATYPE == H5I_get_type(type_id)); + + /* Initialize iterator */ + HDmemset(&iter,0,sizeof(H5S_sel_iter_t)); + + /* Get the datatype size */ + elmt_size=H5Tget_size(type_id); + + /* Construct iterator for hyperslab selection */ + if (H5S_hyper_init(space, elmt_size, &iter)<0) + HGOTO_ERROR (H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to initialize selection information"); + + /* Check for the special case of just one H5Sselect_hyperslab call made */ + if(space->select.sel_info.hslab.diminfo!=NULL) { + /* Use optimized call to iterate over regular hyperslab */ + ret_value=H5S_hyper_select_iterate_mem_opt(&iter,buf,type_id,space,op,operator_data); + } + else { + /* Initialize parameter block for recursive calls */ + iter_info.dt=type_id; + iter_info.elem_size=elmt_size; + iter_info.space=space; + iter_info.iter=&iter; + iter_info.src=buf; + + /* Copy the location of the region in the file */ + iter_info.op=op; + iter_info.op_data=operator_data; + + /* Call the recursive iterator routine */ + ret_value=H5S_hyper_select_iterate_helper(&iter_info); } /* end else */ + + /* Release selection iterator */ + H5S_sel_iter_release(space,&iter); + +done: FUNC_LEAVE (ret_value); -} /* H5S_hyper_select_contiguous() */ +} /* H5S_hyper_select_iterate() */ +/*-------------------------------------------------------------------------- + NAME + H5S_hyper_release + PURPOSE + Release hyperslab selection information for a dataspace + USAGE + herr_t H5S_hyper_release(space) + H5S_t *space; IN: Pointer to dataspace + RETURNS + Non-negative on success/Negative on failure + DESCRIPTION + Releases all hyperslab selection information for a dataspace + GLOBAL VARIABLES + COMMENTS, BUGS, ASSUMPTIONS + EXAMPLES + REVISION LOG + * Robb Matzke, 1998-08-25 + * The fields which are freed are set to NULL to prevent them from being + * freed again later. This fixes some allocation problems where + * changing the hyperslab selection of one data space causes a core dump + * when closing some other data space. +--------------------------------------------------------------------------*/ +herr_t +H5S_hyper_release (H5S_t *space) +{ + herr_t ret_value=FAIL; + + FUNC_ENTER (H5S_hyper_release, FAIL); + + /* Check args */ + assert (space && H5S_SEL_HYPERSLABS==space->select.type); + + /* Reset the number of points selected */ + space->select.num_elem=0; + + /* Release the regular selection info */ + if(space->select.sel_info.hslab.diminfo!=NULL) { + H5FL_ARR_FREE(H5S_hyper_dim_t,space->select.sel_info.hslab.diminfo); + space->select.sel_info.hslab.diminfo = NULL; + H5FL_ARR_FREE(H5S_hyper_dim_t,space->select.sel_info.hslab.app_diminfo); + space->select.sel_info.hslab.app_diminfo = NULL; + } /* end if */ + + /* Release irregular hyperslab information */ + if(space->select.sel_info.hslab.span_lst!=NULL) { + if(H5S_hyper_free_span_info(space->select.sel_info.hslab.span_lst)<0) + HGOTO_ERROR(H5E_INTERNAL, H5E_CANTFREE, FAIL, "failed to release hyperslab spans"); + space->select.sel_info.hslab.span_lst=NULL; + } /* end if */ + + /* Success! */ + ret_value=SUCCEED; + +done: + FUNC_LEAVE (SUCCEED); +} /* H5S_hyper_release() */ + + +/*-------------------------------------------------------------------------- + NAME + H5S_hyper_recover_span + PURPOSE + Recover a generated span, if appropriate + USAGE + herr_t H5S_hyper_recover_span(recover, curr_span, next_span) + unsigned *recover; IN/OUT: Pointer recover flag + H5S_hyper_span_t **curr_span; IN/OUT: Pointer to current span in list + H5S_hyper_span_t *next_span; IN: Pointer to next span + RETURNS + Non-negative on success, negative on failure + DESCRIPTION + Check if the current span needs to be recovered and free it if so. + Set the current span to the next span in any case. + GLOBAL VARIABLES + COMMENTS, BUGS, ASSUMPTIONS + EXAMPLES + REVISION LOG +--------------------------------------------------------------------------*/ +static herr_t +H5S_hyper_recover_span (unsigned *recover, H5S_hyper_span_t **curr_span, H5S_hyper_span_t *next_span) +{ + herr_t ret_value=FAIL; + + FUNC_ENTER (H5S_hyper_recover_span, FAIL); + + assert(recover); + assert(curr_span); + + /* Check if the span should be recovered */ + if(*recover) { + H5S_hyper_free_span(*curr_span); + *recover=0; + } /* end if */ + + /* Set the current span to next span */ + *curr_span=next_span; + + /* Success! */ + ret_value=SUCCEED; + +#ifdef LATER +done: +#endif /* LATER */ + FUNC_LEAVE (ret_value); +} /* H5S_hyper_recover_span() */ + + +/*-------------------------------------------------------------------------- + NAME + H5S_hyper_append_span + PURPOSE + Create a new span and append to span list + USAGE + herr_t H5S_hyper_append_span(prev_span, span_tree, low, high, down, next) + H5S_hyper_span_t **prev_span; IN/OUT: Pointer to previous span in list + H5S_hyper_span_info_t **span_tree; IN/OUT: Pointer to span tree to append to + hssize_t low, high; IN: Low and high bounds for new span node + H5S_hyper_span_info_t *down; IN: Down span tree for new node + H5S_hyper_span_t *next; IN: Next span for new node + RETURNS + Non-negative on success, negative on failure + DESCRIPTION + Create a new span node and append to a span list. Update the previous + span in the list also. + GLOBAL VARIABLES + COMMENTS, BUGS, ASSUMPTIONS + EXAMPLES + REVISION LOG +--------------------------------------------------------------------------*/ +static herr_t +H5S_hyper_append_span (H5S_hyper_span_t **prev_span, H5S_hyper_span_info_t ** span_tree, hssize_t low, hssize_t high, H5S_hyper_span_info_t *down, H5S_hyper_span_t *next) +{ + H5S_hyper_span_t *new_span; + herr_t ret_value=FAIL; + + FUNC_ENTER (H5S_hyper_append_span, FAIL); + + assert(prev_span); + assert(span_tree); + + /* Check for adding first node to merged spans */ + if(*prev_span==NULL) { + /* Allocate new span node to append to list */ + if((new_span = H5S_hyper_new_span(low,high,down,next))==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span"); + + /* Make first node in span list */ + + /* Check that we haven't already allocated a span tree */ + assert(*span_tree==NULL); + + /* Allocate a new span_info node */ + if((*span_tree = H5FL_ALLOC(H5S_hyper_span_info_t,0))==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span"); + + /* Set the span tree's basic information */ + (*span_tree)->count=1; + (*span_tree)->scratch=NULL; + (*span_tree)->head=new_span; + + /* Update previous merged span */ + *prev_span=new_span; + } /* end if */ + /* Merge or append to existing merged spans list */ + else { + /* Check if span can just extend the previous merged span */ + if((((*prev_span)->high+1)==low) && + H5S_hyper_cmp_spans(down,(*prev_span)->down)==TRUE) { + /* Extend previous merged span to include new high bound */ + (*prev_span)->high=high; + (*prev_span)->nelem+=(high-low)+1; + } /* end if */ + else { + /* Allocate new span node to append to list */ + if((new_span = H5S_hyper_new_span(low,high,down,next))==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span"); + + /* Check if there is actually a down span */ + if(new_span->down) { + /* Check if the down spans for the new span node are the same as the previous span node */ + if(H5S_hyper_cmp_spans(new_span->down,(*prev_span)->down)==TRUE) { + /* Release the down span for the new node */ + H5S_hyper_free_span_info(new_span->down); + + /* Point the new node's down span at the previous node's down span */ + new_span->down=(*prev_span)->down; + + /* Increment the reference count to the shared down span */ + new_span->down->count++; + } /* end if */ + } /* end if */ + + /* Indicate elements to previous span */ + new_span->pstride=low-(*prev_span)->low; + + /* Append to end of merged spans list */ + (*prev_span)->next=new_span; + *prev_span=new_span; + } /* end else */ + } /* end else */ + +done: + FUNC_LEAVE (ret_value); +} /* H5S_hyper_append_span() */ + + +/*-------------------------------------------------------------------------- + NAME + H5S_hyper_clip_spans + PURPOSE + Clip a new span tree against the current spans in the hyperslab selection + USAGE + herr_t H5S_hyper_clip_spans(span_a, span_b, a_not_b, a_and_b, b_not_a) + H5S_hyper_span_t *a_spans; IN: Span tree 'a' to clip with. + H5S_hyper_span_t *b_spans; IN: Span tree 'b' to clip with. + H5S_hyper_span_t **a_not_b; OUT: Span tree of 'a' hyperslab spans which + doesn't overlap with 'b' hyperslab + spans. + H5S_hyper_span_t **a_and_b; OUT: Span tree of 'a' hyperslab spans which + overlaps with 'b' hyperslab spans. + H5S_hyper_span_t **b_not_a; OUT: Span tree of 'b' hyperslab spans which + doesn't overlap with 'a' hyperslab + spans. + RETURNS + non-negative on success, negative on failure + DESCRIPTION + Clip one span tree ('a') against another span tree ('b'). Creates span + trees for the area defined by the 'a' span tree which does not overlap the + 'b' span tree, the area defined by the overlap of the 'a' hyperslab span + tree and the 'b' span tree, and the area defined by the 'b' hyperslab span + tree which does not overlap the 'a' span tree. + GLOBAL VARIABLES + COMMENTS, BUGS, ASSUMPTIONS + EXAMPLES + REVISION LOG +--------------------------------------------------------------------------*/ +static herr_t +H5S_hyper_clip_spans (H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_spans, + H5S_hyper_span_info_t **a_not_b, H5S_hyper_span_info_t **a_and_b, + H5S_hyper_span_info_t **b_not_a) +{ + H5S_hyper_span_t *span_a; /* Pointer to a node in span tree 'a' */ + H5S_hyper_span_t *span_b; /* Pointer to a node in span tree 'b' */ + H5S_hyper_span_t *tmp_span; /* Temporary pointer to new span */ + H5S_hyper_span_t *last_a_not_b; /* Pointer to previous node in span tree 'a_not_b' */ + H5S_hyper_span_t *last_a_and_b; /* Pointer to previous node in span tree 'a_and_b' */ + H5S_hyper_span_t *last_b_not_a; /* Pointer to previous node in span tree 'b_not_a' */ + H5S_hyper_span_info_t *down_a_not_b; /* Temporary pointer to a_not_b span tree of down spans for overlapping nodes */ + H5S_hyper_span_info_t *down_a_and_b; /* Temporary pointer to a_and_b span tree of down spans for overlapping nodes */ + H5S_hyper_span_info_t *down_b_not_a; /* Temporary pointer to b_and_a span tree of down spans for overlapping nodes */ + unsigned recover_a, recover_b; /* Flags to indicate when to recover temporary spans */ + herr_t ret_value=FAIL; + + FUNC_ENTER (H5S_hyper_clip_spans, FAIL); + + /* Check args */ + assert (a_spans); + assert (b_spans); + assert (a_not_b); + assert (a_and_b); + assert (b_not_a); + +#ifdef QAK +printf("%s: a_spans=%p, b_spans=%p\n",FUNC,a_spans,b_spans); +#endif /* QAK */ + /* Check if both span trees are not defined */ + if(a_spans==NULL && b_spans==NULL) { +#ifdef QAK +printf("%s: check 1.0\n",FUNC); +#endif /* QAK */ + *a_not_b=NULL; + *a_and_b=NULL; + *b_not_a=NULL; + } /* end if */ + /* If span 'a' is not defined, but 'b' is, copy 'b' and set the other return span trees to empty */ + else if(a_spans==NULL) { +#ifdef QAK +printf("%s: check 2.0\n",FUNC); +#endif /* QAK */ + *a_not_b=NULL; + *a_and_b=NULL; + if((*b_not_a=H5S_hyper_copy_span(b_spans))==NULL) + HGOTO_ERROR(H5E_INTERNAL, H5E_CANTCOPY, FAIL, "can't copy hyperslab span tree"); + } /* end if */ + /* If span 'b' is not defined, but 'a' is, copy 'a' and set the other return span trees to empty */ + else if(b_spans==NULL) { +#ifdef QAK +printf("%s: check 3.0\n",FUNC); +#endif /* QAK */ + if((*a_not_b=H5S_hyper_copy_span(a_spans))==NULL) + HGOTO_ERROR(H5E_INTERNAL, H5E_CANTCOPY, FAIL, "can't copy hyperslab span tree"); + *a_and_b=NULL; + *b_not_a=NULL; + } /* end if */ + /* If span 'a' and 'b' are both defined, calculate the proper span trees */ + else { +#ifdef QAK +printf("%s: check 4.0\n",FUNC); +#endif /* QAK */ + /* Check if both span trees completely overlap */ + if(H5S_hyper_cmp_spans(a_spans,b_spans)==TRUE) { +#ifdef QAK +printf("%s: check 4.1\n",FUNC); +#endif /* QAK */ + *a_not_b=NULL; + if((*a_and_b=H5S_hyper_copy_span(a_spans))==NULL) + HGOTO_ERROR(H5E_INTERNAL, H5E_CANTCOPY, FAIL, "can't copy hyperslab span tree"); + *b_not_a=NULL; + } /* end if */ + else { +#ifdef QAK +printf("%s: check 4.2\n",FUNC); +#endif /* QAK */ + /* Get the pointers to the new and old span lists */ + span_a=a_spans->head; + span_b=b_spans->head; + + /* Set the pointer to the previous spans */ + last_a_not_b=NULL; + last_a_and_b=NULL; + last_b_not_a=NULL; + + /* No spans to recover yet */ + recover_a=recover_b=0; + + /* Work through the list of spans in the new list */ + while(span_a!=NULL && span_b!=NULL) { +#ifdef QAK +printf("%s: check 4.3, span_a=%p, span_b=%p\n",FUNC,span_a,span_b); +#endif /* QAK */ + /* Check if span 'a' is completely before span 'b' */ + /* AAAAAAA */ + /* <-----------------------------------> */ + /* BBBBBBBBBB */ + if(span_a->high<span_b->low) { +#ifdef QAK +printf("%s: check 4.3.1, span_a->(low, high)=(%ld, %ld), span_b->(low, high)=(%ld, %ld)\n",FUNC,(long)span_a->low,(long)span_a->high,(long)span_b->low,(long)span_b->high); +#endif /* QAK */ + /* Copy span 'a' and add to a_not_b list */ + + /* Merge/add span 'a' with/to a_not_b list */ + if(H5S_hyper_append_span(&last_a_not_b,a_not_b,span_a->low,span_a->high,span_a->down,NULL)==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span"); + + /* Advance span 'a', leave span 'b' */ + H5S_hyper_recover_span(&recover_a,&span_a,span_a->next); + } /* end if */ + /* Check if span 'a' overlaps only the lower bound */ + /* of span 'b' , up to the upper bound of span 'b' */ + /* AAAAAAAAAAAA */ + /* <-----------------------------------> */ + /* BBBBBBBBBB */ + else if(span_a->low<span_b->low && (span_a->high>=span_b->low && span_a->high<=span_b->high)) { +#ifdef QAK +printf("%s: check 4.3.2, span_a->(low, high)=(%ld, %ld), span_b->(low, high)=(%ld, %ld)\n",FUNC,(long)span_a->low,(long)span_a->high,(long)span_b->low,(long)span_b->high); +#endif /* QAK */ + /* Split span 'a' into two parts at the low bound of span 'b' */ + + /* Merge/add lower part of span 'a' with/to a_not_b list */ + if(H5S_hyper_append_span(&last_a_not_b,a_not_b,span_a->low,span_b->low-1,span_a->down,NULL)==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span"); + + /* Check for overlaps between upper part of span 'a' and lower part of span 'b' */ + + /* Make certain both spans either have a down span or both don't have one */ + assert((span_a->down!=NULL && span_b->down!=NULL) || (span_a->down==NULL && span_b->down==NULL)); + + /* If there are no down spans, just add the overlapping area to the a_and_b list */ + if(span_a->down==NULL) { + /* Merge/add overlapped part with/to a_and_b list */ + if(H5S_hyper_append_span(&last_a_and_b,a_and_b,span_b->low,span_a->high,NULL,NULL)==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span"); + } /* end if */ + /* If there are down spans, check for the overlap in them and add to each appropriate list */ + else { + /* NULL out the temporary pointers to clipped areas in down spans */ + down_a_not_b=NULL; + down_a_and_b=NULL; + down_b_not_a=NULL; + + /* Check for overlaps in the 'down spans' of span 'a' & 'b' */ + if(H5S_hyper_clip_spans(span_a->down,span_b->down,&down_a_not_b,&down_a_and_b,&down_b_not_a)<0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCLIP, FAIL, "can't clip hyperslab information"); + + /* Check for additions to the a_not_b list */ + if(down_a_not_b!=NULL) { + /* Merge/add overlapped part with/to a_not_b list */ + if(H5S_hyper_append_span(&last_a_not_b,a_not_b,span_b->low,span_a->high,down_a_not_b,NULL)==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span"); + + /* Release the down span tree generated */ + H5S_hyper_free_span_info(down_a_not_b); + } /* end if */ + + /* Check for additions to the a_and_b list */ + if(down_a_and_b!=NULL) { + /* Merge/add overlapped part with/to a_and_b list */ + if(H5S_hyper_append_span(&last_a_and_b,a_and_b,span_b->low,span_a->high,down_a_and_b,NULL)==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span"); + + /* Release the down span tree generated */ + H5S_hyper_free_span_info(down_a_and_b); + } /* end if */ + + /* Check for additions to the b_not_a list */ + if(down_b_not_a!=NULL) { + /* Merge/add overlapped part with/to b_not_a list */ + if(H5S_hyper_append_span(&last_b_not_a,b_not_a,span_b->low,span_a->high,down_b_not_a,NULL)==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span"); + + /* Release the down span tree generated */ + H5S_hyper_free_span_info(down_b_not_a); + } /* end if */ + } /* end else */ + + /* Split off upper part of span 'b' at upper span of span 'a' */ + + /* Check if there is actually an upper part of span 'b' to split off */ + if(span_a->high<span_b->high) { + /* Allocate new span node for upper part of span 'b' */ + if((tmp_span = H5S_hyper_new_span(span_a->high+1,span_b->high,span_b->down,span_b->next))==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span"); + + /* Advance span 'a' */ + H5S_hyper_recover_span(&recover_a,&span_a,span_a->next); + + /* Make upper part of span 'b' into new span 'b' */ + H5S_hyper_recover_span(&recover_b,&span_b,tmp_span); + recover_b=1; + } /* end if */ + /* No upper part of span 'b' to split */ + else { + /* Advance both 'a' and 'b' */ + H5S_hyper_recover_span(&recover_a,&span_a,span_a->next); + H5S_hyper_recover_span(&recover_b,&span_b,span_b->next); + } /* end else */ + } /* end if */ + /* Check if span 'a' overlaps the lower & upper bound */ + /* of span 'b' */ + /* AAAAAAAAAAAAAAAAAAAAA */ + /* <-----------------------------------> */ + /* BBBBBBBBBB */ + else if(span_a->low<span_b->low && span_a->high>span_b->high) { +#ifdef QAK +printf("%s: check 4.3.3, span_a->(low, high)=(%ld, %ld), span_b->(low, high)=(%ld, %ld)\n",FUNC,(long)span_a->low,(long)span_a->high,(long)span_b->low,(long)span_b->high); +#endif /* QAK */ + /* Split off lower part of span 'a' at lower span of span 'b' */ + + /* Merge/add lower part of span 'a' with/to a_not_b list */ + if(H5S_hyper_append_span(&last_a_not_b,a_not_b,span_a->low,span_b->low-1,span_a->down,NULL)==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span"); + + /* Check for overlaps between middle part of span 'a' and span 'b' */ + + /* Make certain both spans either have a down span or both don't have one */ + assert((span_a->down!=NULL && span_b->down!=NULL) || (span_a->down==NULL && span_b->down==NULL)); + + /* If there are no down spans, just add the overlapping area to the a_and_b list */ + if(span_a->down==NULL) { + /* Merge/add overlapped part with/to a_and_b list */ + if(H5S_hyper_append_span(&last_a_and_b,a_and_b,span_b->low,span_b->high,NULL,NULL)==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span"); + } /* end if */ + /* If there are down spans, check for the overlap in them and add to each appropriate list */ + else { + /* NULL out the temporary pointers to clipped areas in down spans */ + down_a_not_b=NULL; + down_a_and_b=NULL; + down_b_not_a=NULL; + + /* Check for overlaps in the 'down spans' of span 'a' & 'b' */ + if(H5S_hyper_clip_spans(span_a->down,span_b->down,&down_a_not_b,&down_a_and_b,&down_b_not_a)<0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCLIP, FAIL, "can't clip hyperslab information"); + + /* Check for additions to the a_not_b list */ + if(down_a_not_b!=NULL) { + /* Merge/add overlapped part with/to a_not_b list */ + if(H5S_hyper_append_span(&last_a_not_b,a_not_b,span_b->low,span_b->high,down_a_not_b,NULL)==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span"); + + /* Release the down span tree generated */ + H5S_hyper_free_span_info(down_a_not_b); + } /* end if */ + + /* Check for additions to the a_and_b list */ + if(down_a_and_b!=NULL) { + /* Merge/add overlapped part with/to a_and_b list */ + if(H5S_hyper_append_span(&last_a_and_b,a_and_b,span_b->low,span_b->high,down_a_and_b,NULL)==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span"); + + /* Release the down span tree generated */ + H5S_hyper_free_span_info(down_a_and_b); + } /* end if */ + + /* Check for additions to the b_not_a list */ + if(down_b_not_a!=NULL) { + /* Merge/add overlapped part with/to b_not_a list */ + if(H5S_hyper_append_span(&last_b_not_a,b_not_a,span_b->low,span_b->high,down_b_not_a,NULL)==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span"); + + /* Release the down span tree generated */ + H5S_hyper_free_span_info(down_b_not_a); + } /* end if */ + } /* end else */ + + /* Split off upper part of span 'a' at upper span of span 'b' */ + + /* Allocate new span node for upper part of span 'a' */ + if((tmp_span = H5S_hyper_new_span(span_b->high+1,span_a->high,span_a->down,span_a->next))==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span"); + + /* Make upper part of span 'a' the new span 'a' */ + H5S_hyper_recover_span(&recover_a,&span_a,tmp_span); + recover_a=1; + + /* Advance span 'b' */ + H5S_hyper_recover_span(&recover_b,&span_b,span_b->next); + } /* end if */ + /* Check if span 'a' is entirely within span 'b' */ + /* AAAAA */ + /* <-----------------------------------> */ + /* BBBBBBBBBB */ + else if(span_a->low>=span_b->low && span_a->high<=span_b->high) { +#ifdef QAK +printf("%s: check 4.3.4, span_a->(low, high)=(%ld, %ld), span_b->(low, high)=(%ld, %ld)\n",FUNC,(long)span_a->low,(long)span_a->high,(long)span_b->low,(long)span_b->high); +#endif /* QAK */ + /* Split off lower part of span 'b' at lower span of span 'a' */ + + /* Check if there is actually a lower part of span 'b' to split off */ + if(span_a->low>span_b->low) { + /* Merge/add lower part of span 'b' with/to b_not_a list */ + if(H5S_hyper_append_span(&last_b_not_a,b_not_a,span_b->low,span_a->low-1,span_b->down,NULL)==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span"); + } /* end if */ + else { + /* Keep going, nothing to split off */ + } /* end else */ + + /* Check for overlaps between span 'a' and midle of span 'b' */ + + /* Make certain both spans either have a down span or both don't have one */ + assert((span_a->down!=NULL && span_b->down!=NULL) || (span_a->down==NULL && span_b->down==NULL)); + + /* If there are no down spans, just add the overlapping area to the a_and_b list */ + if(span_a->down==NULL) { + /* Merge/add overlapped part with/to a_and_b list */ + if(H5S_hyper_append_span(&last_a_and_b,a_and_b,span_a->low,span_a->high,NULL,NULL)==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span"); + } /* end if */ + /* If there are down spans, check for the overlap in them and add to each appropriate list */ + else { + /* NULL out the temporary pointers to clipped areas in down spans */ + down_a_not_b=NULL; + down_a_and_b=NULL; + down_b_not_a=NULL; + + /* Check for overlaps in the 'down spans' of span 'a' & 'b' */ + if(H5S_hyper_clip_spans(span_a->down,span_b->down,&down_a_not_b,&down_a_and_b,&down_b_not_a)<0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCLIP, FAIL, "can't clip hyperslab information"); + + /* Check for additions to the a_not_b list */ + if(down_a_not_b!=NULL) { + /* Merge/add overlapped part with/to a_not_b list */ + if(H5S_hyper_append_span(&last_a_not_b,a_not_b,span_a->low,span_a->high,down_a_not_b,NULL)==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span"); + + /* Release the down span tree generated */ + H5S_hyper_free_span_info(down_a_not_b); + } /* end if */ + + /* Check for additions to the a_and_b list */ + if(down_a_and_b!=NULL) { + /* Merge/add overlapped part with/to a_and_b list */ + if(H5S_hyper_append_span(&last_a_and_b,a_and_b,span_a->low,span_a->high,down_a_and_b,NULL)==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span"); + + /* Release the down span tree generated */ + H5S_hyper_free_span_info(down_a_and_b); + } /* end if */ + + /* Check for additions to the b_not_a list */ + if(down_b_not_a!=NULL) { + /* Merge/add overlapped part with/to b_not_a list */ + if(H5S_hyper_append_span(&last_b_not_a,b_not_a,span_a->low,span_a->high,down_b_not_a,NULL)==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span"); + + /* Release the down span tree generated */ + H5S_hyper_free_span_info(down_b_not_a); + } /* end if */ + } /* end else */ + + /* Check if there is actually an upper part of span 'b' to split off */ + if(span_a->high<span_b->high) { + /* Split off upper part of span 'b' at upper span of span 'a' */ + + /* Allocate new span node for upper part of spans 'a' */ + if((tmp_span = H5S_hyper_new_span(span_a->high+1,span_b->high,span_b->down,span_b->next))==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span"); + + /* And advance span 'a' */ + H5S_hyper_recover_span(&recover_a,&span_a,span_a->next); + + /* Make upper part of span 'b' the new span 'b' */ + H5S_hyper_recover_span(&recover_b,&span_b,tmp_span); + recover_b=1; + } /* end if */ + else { + /* Advance both span 'a' & span 'b' */ + H5S_hyper_recover_span(&recover_a,&span_a,span_a->next); + H5S_hyper_recover_span(&recover_b,&span_b,span_b->next); + } /* end else */ + } /* end if */ + /* Check if span 'a' overlaps only the upper bound */ + /* of span 'b' */ + /* AAAAAAAAAA */ + /* <-----------------------------------> */ + /* BBBBBBBBBB */ + else if((span_a->low>=span_b->low && span_a->low<=span_b->high) && span_a->high>span_b->high) { +#ifdef QAK +printf("%s: check 4.3.5, span_a->(low, high)=(%ld, %ld), span_b->(low, high)=(%ld, %ld)\n",FUNC,(long)span_a->low,(long)span_a->high,(long)span_b->low,(long)span_b->high); +#endif /* QAK */ + /* Check if there is actually a lower part of span 'b' to split off */ + if(span_a->low>span_b->low) { + /* Split off lower part of span 'b' at lower span of span 'a' */ + + /* Merge/add lower part of span 'b' with/to b_not_a list */ + if(H5S_hyper_append_span(&last_b_not_a,b_not_a,span_b->low,span_a->low-1,span_b->down,NULL)==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span"); + } /* end if */ + else { + /* Keep going, nothing to split off */ + } /* end else */ + + /* Check for overlaps between lower part of span 'a' and upper part of span 'b' */ + + /* Make certain both spans either have a down span or both don't have one */ + assert((span_a->down!=NULL && span_b->down!=NULL) || (span_a->down==NULL && span_b->down==NULL)); + + /* If there are no down spans, just add the overlapping area to the a_and_b list */ + if(span_a->down==NULL) { + /* Merge/add overlapped part with/to a_and_b list */ + if(H5S_hyper_append_span(&last_a_and_b,a_and_b,span_a->low,span_b->high,NULL,NULL)==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span"); + } /* end if */ + /* If there are down spans, check for the overlap in them and add to each appropriate list */ + else { + /* NULL out the temporary pointers to clipped areas in down spans */ + down_a_not_b=NULL; + down_a_and_b=NULL; + down_b_not_a=NULL; + + /* Check for overlaps in the 'down spans' of span 'a' & 'b' */ + if(H5S_hyper_clip_spans(span_a->down,span_b->down,&down_a_not_b,&down_a_and_b,&down_b_not_a)<0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCLIP, FAIL, "can't clip hyperslab information"); + + /* Check for additions to the a_not_b list */ + if(down_a_not_b!=NULL) { + /* Merge/add overlapped part with/to a_not_b list */ + if(H5S_hyper_append_span(&last_a_not_b,a_not_b,span_a->low,span_b->high,down_a_not_b,NULL)==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span"); + + /* Release the down span tree generated */ + H5S_hyper_free_span_info(down_a_not_b); + } /* end if */ + + /* Check for additions to the a_and_b list */ + if(down_a_and_b!=NULL) { + /* Merge/add overlapped part with/to a_and_b list */ + if(H5S_hyper_append_span(&last_a_and_b,a_and_b,span_a->low,span_b->high,down_a_and_b,NULL)==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span"); + + /* Release the down span tree generated */ + H5S_hyper_free_span_info(down_a_and_b); + } /* end if */ + + /* Check for additions to the b_not_a list */ + if(down_b_not_a!=NULL) { + /* Merge/add overlapped part with/to b_not_a list */ + if(H5S_hyper_append_span(&last_b_not_a,b_not_a,span_a->low,span_b->high,down_b_not_a,NULL)==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span"); + + /* Release the down span tree generated */ + H5S_hyper_free_span_info(down_b_not_a); + } /* end if */ + } /* end else */ + + /* Split off upper part of span 'a' at upper span of span 'b' */ + + /* Allocate new span node for upper part of span 'a' */ + if((tmp_span = H5S_hyper_new_span(span_b->high+1,span_a->high,span_a->down,span_a->next))==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span"); + + /* Make upper part of span 'a' into new span 'a' */ + H5S_hyper_recover_span(&recover_a,&span_a,tmp_span); + recover_a=1; + + /* Advance span 'b' */ + H5S_hyper_recover_span(&recover_b,&span_b,span_b->next); + } /* end if */ + /* span 'a' must be entirely above span 'b' */ + /* AAAAA */ + /* <-----------------------------------> */ + /* BBBBBBBBBB */ + else { +#ifdef QAK +printf("%s: check 4.3.6, span_a->(low, high)=(%ld, %ld), span_b->(low, high)=(%ld, %ld)\n",FUNC,(long)span_a->low,(long)span_a->high,(long)span_b->low,(long)span_b->high); +#endif /* QAK */ + /* Copy span 'b' and add to b_not_a list */ + + /* Merge/add span 'b' with/to b_not_a list */ + if(H5S_hyper_append_span(&last_b_not_a,b_not_a,span_b->low,span_b->high,span_b->down,NULL)==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span"); + + /* Advance span 'b', leave span 'a' */ + H5S_hyper_recover_span(&recover_b,&span_b,span_b->next); + } /* end else */ + } /* end while */ +#ifdef QAK +printf("%s: check 5.0, span_a=%p, span_b=%p\n",FUNC,span_a,span_b); +#endif /* QAK */ + + /* Clean up 'a' spans which haven't been covered yet */ + if(span_a!=NULL && span_b==NULL) { +#ifdef QAK +printf("%s: check 6.0, span_a=%p, span_b=%p\n",FUNC,span_a,span_b); +#endif /* QAK */ + while(span_a!=NULL) { + /* Copy span 'a' and add to a_not_b list */ + + /* Merge/add span 'a' with/to a_not_b list */ + if(H5S_hyper_append_span(&last_a_not_b,a_not_b,span_a->low,span_a->high,span_a->down,NULL)==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span"); + + /* Advance to the next 'a' span */ + H5S_hyper_recover_span(&recover_a,&span_a,span_a->next); + } /* end while */ + } /* end if */ + /* Clean up 'b' spans which haven't been covered yet */ + else if(span_a==NULL && span_b!=NULL) { +#ifdef QAK +printf("%s: check 7.0, span_a=%p, span_b=%p\n",FUNC,span_a,span_b); +#endif /* QAK */ + while(span_b!=NULL) { + /* Copy span 'b' and add to b_not_a list */ + + /* Merge/add span 'b' with/to b_not_a list */ + if(H5S_hyper_append_span(&last_b_not_a,b_not_a,span_b->low,span_b->high,span_b->down,NULL)==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span"); + + /* Advance to the next 'b' span */ + H5S_hyper_recover_span(&recover_b,&span_b,span_b->next); + } /* end while */ + } /* end if */ + } /* end else */ + } /* end else */ + + /* Success! */ + ret_value=SUCCEED; + +done: + FUNC_LEAVE (ret_value); +} /* H5S_hyper_clip_spans() */ + + +/*-------------------------------------------------------------------------- + NAME + H5S_hyper_merge_spans_helper + PURPOSE + Merge two hyperslab span tree together + USAGE + H5S_hyper_span_info_t *H5S_hyper_merge_spans_helper(a_spans, b_spans) + H5S_hyper_span_info_t *a_spans; IN: First hyperslab spans to merge + together + H5S_hyper_span_info_t *b_spans; IN: Second hyperslab spans to merge + together + RETURNS + Pointer to span tree containing the merged spans on success, NULL on failure + DESCRIPTION + Merge two sets of hyperslab spans together and return the span tree from + the merged set. + GLOBAL VARIABLES + COMMENTS, BUGS, ASSUMPTIONS + EXAMPLES + REVISION LOG +--------------------------------------------------------------------------*/ +static H5S_hyper_span_info_t * +H5S_hyper_merge_spans_helper (H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_spans) +{ + H5S_hyper_span_info_t *merged_spans=NULL; /* Pointer to the merged span tree */ + H5S_hyper_span_info_t *tmp_spans; /* Pointer to temporary new span tree */ + H5S_hyper_span_t *tmp_span; /* Pointer to temporary new span */ + H5S_hyper_span_t *span_a; /* Pointer to current span 'a' working on */ + H5S_hyper_span_t *span_b; /* Pointer to current span 'b' working on */ + H5S_hyper_span_t *prev_span_merge; /* Pointer to previous merged span */ + unsigned recover_a, recover_b; /* Flags to indicate when to recover temporary spans */ + H5S_hyper_span_info_t *ret_value=NULL; + + FUNC_ENTER (H5S_hyper_merge_spans_helper, NULL); + +#ifdef QAK +printf("%s: a_spans=%p, b_spans=%p\n",FUNC,a_spans,b_spans); +#endif /* QAK */ + + /* Make certain both 'a' & 'b' spans have down span trees or neither does */ + assert((a_spans!=NULL && b_spans!=NULL) || (a_spans==NULL && b_spans==NULL)); + + /* Check if the span trees for the 'a' span and the 'b' span are the same */ + if(H5S_hyper_cmp_spans(a_spans,b_spans)==TRUE) { +#ifdef QAK +printf("%s: check 0.5\n",FUNC); +#endif /* QAK */ + if(a_spans==NULL) + merged_spans=NULL; + else { + /* Copy one of the span trees to return */ + if((merged_spans=H5S_hyper_copy_span(a_spans))==NULL) + HGOTO_ERROR(H5E_INTERNAL, H5E_CANTCOPY, NULL, "can't copy hyperslab span tree"); + } /* end else */ + } /* end if */ + else { +#ifdef QAK +printf("%s: check 1.0\n",FUNC); +#endif /* QAK */ + /* Get the pointers to the 'a' and 'b' span lists */ + span_a=a_spans->head; + span_b=b_spans->head; + + /* Set the pointer to the previous spans */ + prev_span_merge=NULL; + + /* No spans to recover yet */ + recover_a=recover_b=0; + + /* Work through the list of spans in the new list */ + while(span_a!=NULL && span_b!=NULL) { +#ifdef QAK +printf("%s: check 3.0, span_a=%p, span_b=%p\n",FUNC,span_a,span_b); +#endif /* QAK */ + /* Check if the 'a' span is completely before 'b' span */ + /* AAAAAAA */ + /* <-----------------------------------> */ + /* BBBBBBBBBB */ + if(span_a->high<span_b->low) { +#ifdef QAK +printf("%s: check 3.1, span_a->(low, high)=(%ld, %ld), span_b->(low, high)=(%ld, %ld)\n",FUNC,(long)span_a->low,(long)span_a->high,(long)span_b->low,(long)span_b->high); +#endif /* QAK */ + /* Merge/add span 'a' with/to the merged spans */ + if(H5S_hyper_append_span(&prev_span_merge,&merged_spans,span_a->low,span_a->high,span_a->down,NULL)==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span"); + + /* Advance span 'a' */ + H5S_hyper_recover_span(&recover_a,&span_a,span_a->next); + } /* end if */ + /* Check if span 'a' overlaps only the lower bound */ + /* of span 'b', up to the upper bound of span 'b' */ + /* AAAAAAAAAAAA */ + /* <-----------------------------------> */ + /* BBBBBBBBBB */ + else if(span_a->low<span_b->low && (span_a->high>=span_b->low && span_a->high<=span_b->high)) { +#ifdef QAK +printf("%s: check 3.2, span_a->(low, high)=(%ld, %ld), span_b->(low, high)=(%ld, %ld)\n",FUNC,(long)span_a->low,(long)span_a->high,(long)span_b->low,(long)span_b->high); +#endif /* QAK */ + /* Check if span 'a' and span 'b' down spans are equal */ + if(H5S_hyper_cmp_spans(span_a->down,span_b->down)==TRUE) { + /* Merge/add copy of span 'a' with/to merged spans */ + if(H5S_hyper_append_span(&prev_span_merge,&merged_spans,span_a->low,span_a->high,span_a->down,NULL)==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span"); + } /* end if */ + else { + /* Merge/add lower part of span 'a' with/to merged spans */ + if(H5S_hyper_append_span(&prev_span_merge,&merged_spans,span_a->low,span_b->low-1,span_a->down,NULL)==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span"); + + /* Get merged span tree for overlapped section */ + tmp_spans=H5S_hyper_merge_spans_helper(span_a->down,span_b->down); + + /* Merge/add overlapped section to merged spans */ + if(H5S_hyper_append_span(&prev_span_merge,&merged_spans,span_b->low,span_a->high,tmp_spans,NULL)==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span"); + + /* Release merged span tree for overlapped section */ + H5S_hyper_free_span_info(tmp_spans); + } /* end else */ + + /* Check if there is an upper part of span 'b' */ + if(span_a->high<span_b->high) { + /* Copy upper part of span 'b' as new span 'b' */ + + /* Allocate new span node to append to list */ + if((tmp_span = H5S_hyper_new_span(span_a->high+1,span_b->high,span_b->down,span_b->next))==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span"); + + /* Advance span 'a' */ + H5S_hyper_recover_span(&recover_a,&span_a,span_a->next); + + /* Set new span 'b' to tmp_span */ + H5S_hyper_recover_span(&recover_b,&span_b,tmp_span); + recover_b=1; + } /* end if */ + else { + /* Advance both span 'a' & 'b' */ + H5S_hyper_recover_span(&recover_a,&span_a,span_a->next); + H5S_hyper_recover_span(&recover_b,&span_b,span_b->next); + } /* end else */ + } /* end if */ + /* Check if span 'a' overlaps the lower & upper bound */ + /* of span 'b' */ + /* AAAAAAAAAAAAAAAAAAAAA */ + /* <-----------------------------------> */ + /* BBBBBBBBBB */ + else if(span_a->low<span_b->low && span_a->high>span_b->high) { +#ifdef QAK +printf("%s: check 3.3, span_a->(low, high)=(%ld, %ld), span_b->(low, high)=(%ld, %ld)\n",FUNC,(long)span_a->low,(long)span_a->high,(long)span_b->low,(long)span_b->high); +#endif /* QAK */ + /* Check if span 'a' and span 'b' down spans are equal */ + if(H5S_hyper_cmp_spans(span_a->down,span_b->down)==TRUE) { + /* Merge/add copy of lower & middle parts of span 'a' to merged spans */ + if(H5S_hyper_append_span(&prev_span_merge,&merged_spans,span_a->low,span_b->high,span_a->down,NULL)==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span"); + } /* end if */ + else { + /* Merge/add lower part of span 'a' to merged spans */ + if(H5S_hyper_append_span(&prev_span_merge,&merged_spans,span_a->low,span_b->low-1,span_a->down,NULL)==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span"); + + /* Get merged span tree for overlapped section */ + tmp_spans=H5S_hyper_merge_spans_helper(span_a->down,span_b->down); + + /* Merge/add overlapped section to merged spans */ + if(H5S_hyper_append_span(&prev_span_merge,&merged_spans,span_b->low,span_b->high,tmp_spans,NULL)==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span"); + + /* Release merged span tree for overlapped section */ + H5S_hyper_free_span_info(tmp_spans); + } /* end else */ + + /* Copy upper part of span 'a' as new span 'a' (remember to free) */ + + /* Allocate new span node to append to list */ + if((tmp_span = H5S_hyper_new_span(span_b->high+1,span_a->high,span_a->down,span_a->next))==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span"); + + /* Set new span 'a' to tmp_span */ + H5S_hyper_recover_span(&recover_a,&span_a,tmp_span); + recover_a=1; + + /* Advance span 'b' */ + H5S_hyper_recover_span(&recover_b,&span_b,span_b->next); + } /* end if */ + /* Check if span 'a' is entirely within span 'b' */ + /* AAAAA */ + /* <-----------------------------------> */ + /* BBBBBBBBBB */ + else if(span_a->low>=span_b->low && span_a->high<=span_b->high) { +#ifdef QAK +printf("%s: check 3.4, span_a->(low, high)=(%ld, %ld), span_b->(low, high)=(%ld, %ld)\n",FUNC,(long)span_a->low,(long)span_a->high,(long)span_b->low,(long)span_b->high); +#endif /* QAK */ + /* Check if span 'a' and span 'b' down spans are equal */ + if(H5S_hyper_cmp_spans(span_a->down,span_b->down)==TRUE) { + /* Merge/add copy of lower & middle parts of span 'b' to merged spans */ + if(H5S_hyper_append_span(&prev_span_merge,&merged_spans,span_b->low,span_a->high,span_a->down,NULL)==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span"); + } /* end if */ + else { + /* Check if there is a lower part of span 'b' */ + if(span_a->low>span_b->low) { + /* Merge/add lower part of span 'b' to merged spans */ + if(H5S_hyper_append_span(&prev_span_merge,&merged_spans,span_b->low,span_a->low-1,span_b->down,NULL)==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span"); + } /* end if */ + else { + /* No lower part of span 'b' , keep going... */ + } /* end else */ + + /* Get merged span tree for overlapped section */ + tmp_spans=H5S_hyper_merge_spans_helper(span_a->down,span_b->down); + + /* Merge/add overlapped section to merged spans */ + if(H5S_hyper_append_span(&prev_span_merge,&merged_spans,span_a->low,span_a->high,tmp_spans,NULL)==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span"); + + /* Release merged span tree for overlapped section */ + H5S_hyper_free_span_info(tmp_spans); + } /* end else */ + + /* Check if there is an upper part of span 'b' */ + if(span_a->high<span_b->high) { + /* Copy upper part of span 'b' as new span 'b' (remember to free) */ + + /* Allocate new span node to append to list */ + if((tmp_span = H5S_hyper_new_span(span_a->high+1,span_b->high,span_b->down,span_b->next))==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span"); + + /* Advance span 'a' */ + H5S_hyper_recover_span(&recover_a,&span_a,span_a->next); + + /* Set new span 'b' to tmp_span */ + H5S_hyper_recover_span(&recover_b,&span_b,tmp_span); + recover_b=1; + } /* end if */ + else { + /* Advance both spans */ + H5S_hyper_recover_span(&recover_a,&span_a,span_a->next); + H5S_hyper_recover_span(&recover_b,&span_b,span_b->next); + } /* end else */ + } /* end if */ + /* Check if span 'a' overlaps only the upper bound */ + /* of span 'b' */ + /* AAAAAAAAAA */ + /* <-----------------------------------> */ + /* BBBBBBBBBB */ + else if((span_a->low>=span_b->low && span_a->low<=span_b->high) && span_a->high>span_b->high) { +#ifdef QAK +printf("%s: check 3.5, span_a->(low, high)=(%ld, %ld), span_b->(low, high)=(%ld, %ld)\n",FUNC,(long)span_a->low,(long)span_a->high,(long)span_b->low,(long)span_b->high); +#endif /* QAK */ + /* Check if span 'a' and span 'b' down spans are equal */ + if(H5S_hyper_cmp_spans(span_a->down,span_b->down)==TRUE) { + /* Merge/add copy of span 'b' to merged spans if so */ + if(H5S_hyper_append_span(&prev_span_merge,&merged_spans,span_b->low,span_b->high,span_b->down,NULL)==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span"); + } /* end if */ + else { + /* Check if there is a lower part of span 'b' */ + if(span_a->low>span_b->low) { + /* Merge/add lower part of span 'b' to merged spans */ + if(H5S_hyper_append_span(&prev_span_merge,&merged_spans,span_b->low,span_a->low-1,span_b->down,NULL)==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span"); + } /* end if */ + else { + /* No lower part of span 'b' , keep going... */ + } /* end else */ + + /* Get merged span tree for overlapped section */ + tmp_spans=H5S_hyper_merge_spans_helper(span_a->down,span_b->down); + + /* Merge/add overlapped section to merged spans */ + if(H5S_hyper_append_span(&prev_span_merge,&merged_spans,span_a->low,span_b->high,tmp_spans,NULL)==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span"); + + /* Release merged span tree for overlapped section */ + H5S_hyper_free_span_info(tmp_spans); + } /* end else */ + + /* Copy upper part of span 'a' as new span 'a' */ + + /* Allocate new span node to append to list */ + if((tmp_span = H5S_hyper_new_span(span_b->high+1,span_a->high,span_a->down,span_a->next))==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span"); + + /* Set new span 'a' to tmp_span */ + H5S_hyper_recover_span(&recover_a,&span_a,tmp_span); + recover_a=1; + + /* Advance span 'b' */ + H5S_hyper_recover_span(&recover_b,&span_b,span_b->next); + } /* end if */ + /* Span 'a' must be entirely above span 'b' */ + /* AAAAA */ + /* <-----------------------------------> */ + /* BBBBBBBBBB */ + else { +#ifdef QAK +printf("%s: check 3.6, span_a->(low, high)=(%ld, %ld), span_b->(low, high)=(%ld, %ld)\n",FUNC,(long)span_a->low,(long)span_a->high,(long)span_b->low,(long)span_b->high); +#endif /* QAK */ + /* Merge/add span 'b' with the merged spans */ + if(H5S_hyper_append_span(&prev_span_merge,&merged_spans,span_b->low,span_b->high,span_b->down,NULL)==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span"); + + /* Advance span 'b' */ + H5S_hyper_recover_span(&recover_b,&span_b,span_b->next); + } /* end else */ + } /* end while */ +#ifdef QAK +printf("%s: check 4.0, span_a=%p, span_b=%p\n",FUNC,span_a,span_b); +#endif /* QAK */ + + /* Clean up 'a' spans which haven't been added to the list of merged spans */ + if(span_a!=NULL && span_b==NULL) { + while(span_a!=NULL) { +#ifdef QAK +printf("%s: check 5.0, span_a->(low, high)=(%ld, %ld)\n",FUNC,(long)span_a->low,(long)span_a->high); +#endif /* QAK */ + /* Merge/add all 'a' spans into the merged spans */ + if(H5S_hyper_append_span(&prev_span_merge,&merged_spans,span_a->low,span_a->high,span_a->down,NULL)==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span"); + + /* Advance to next 'a' span, until all processed */ + H5S_hyper_recover_span(&recover_a,&span_a,span_a->next); + } /* end while */ + } /* end if */ + + /* Clean up 'b' spans which haven't been added to the list of merged spans */ + if(span_a==NULL && span_b!=NULL) { + while(span_b!=NULL) { +#ifdef QAK +printf("%s: check 6.0, span_b->(low, high)=(%ld, %ld)\n",FUNC,(long)span_b->low,(long)span_b->high); +#endif /* QAK */ + /* Merge/add all 'b' spans into the merged spans */ + if(H5S_hyper_append_span(&prev_span_merge,&merged_spans,span_b->low,span_b->high,span_b->down,NULL)==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span"); + + /* Advance to next 'b' span, until all processed */ + H5S_hyper_recover_span(&recover_b,&span_b,span_b->next); + } /* end while */ + } /* end if */ +#ifdef QAK +printf("%s: check 7.0, span_a=%p, span_b=%p\n",FUNC,span_a,span_b); +#endif /* QAK */ + } /* end else */ + + /* Success! */ + ret_value=merged_spans; + +done: + FUNC_LEAVE (ret_value); +} /* H5S_hyper_merge_spans_helper() */ + + +/*-------------------------------------------------------------------------- + NAME + H5S_hyper_merge_spans + PURPOSE + Merge new hyperslab spans to existing hyperslab selection + USAGE + herr_t H5S_hyper_merge_spans(space, new_spans) + H5S_t *space; IN: Dataspace to add new spans to hyperslab + selection. + H5S_hyper_span_t *new_spans; IN: Span tree of new spans to add to + hyperslab selection + RETURNS + non-negative on success, negative on failure + DESCRIPTION + Add a set of hyperslab spans to an existing hyperslab selection. The + new spans are required to be non-overlapping with the existing spans in + the dataspace's current hyperslab selection. + GLOBAL VARIABLES + COMMENTS, BUGS, ASSUMPTIONS + EXAMPLES + REVISION LOG +--------------------------------------------------------------------------*/ +static herr_t +H5S_hyper_merge_spans (H5S_t *space, H5S_hyper_span_info_t *new_spans) +{ + herr_t ret_value=FAIL; + + FUNC_ENTER (H5S_hyper_merge_spans, FAIL); + + /* Check args */ + assert (space); + assert (new_spans); + +#ifdef QAK +printf("%s: space->select.sel_info.hslab.span_lst=%p, new_spans=%p\n",FUNC,space->select.sel_info.hslab.span_lst,new_spans); +#endif /* QAK */ + /* If this is the first span tree in the hyperslab selection, just use it */ + if(space->select.sel_info.hslab.span_lst==NULL) { + space->select.sel_info.hslab.span_lst=H5S_hyper_copy_span(new_spans); + } /* end if */ + else { + H5S_hyper_span_info_t *merged_spans; + + /* Get the merged spans */ + merged_spans=H5S_hyper_merge_spans_helper(space->select.sel_info.hslab.span_lst, new_spans); + + /* Sanity checking since we started with some spans, we should still have some after the merge */ + assert(merged_spans); + + /* Free the previous spans */ + H5S_hyper_free_span_info(space->select.sel_info.hslab.span_lst); + + /* Point to the new merged spans */ + space->select.sel_info.hslab.span_lst=merged_spans; + } /* end else */ + + /* Success! */ + ret_value=SUCCEED; + +#ifdef LATER +done: +#endif /* LATER */ + FUNC_LEAVE (ret_value); +} /* H5S_hyper_merge_spans() */ + + +/*-------------------------------------------------------------------------- + NAME + H5S_hyper_spans_nelem + PURPOSE + Count the number of elements in a span tree + USAGE + hssize_t H5S_hyper_spans_nelem(spans) + const H5S_hyper_span_info_t *spans; IN: Hyperslan span tree to count elements of + RETURNS + Number of elements in span tree on success; negative on failure + DESCRIPTION + Counts the number of elements described by the spans in a span tree. + GLOBAL VARIABLES + COMMENTS, BUGS, ASSUMPTIONS + EXAMPLES + REVISION LOG +--------------------------------------------------------------------------*/ +static hssize_t +H5S_hyper_spans_nelem (H5S_hyper_span_info_t *spans) +{ + H5S_hyper_span_t *span; /* Hyperslab span */ + hssize_t ret_value=FAIL; + + FUNC_ENTER (H5S_hyper_spans_nelem, FAIL); + + /* Count the number of elements in the span tree */ + if(spans==NULL) + ret_value=0; + else { + span=spans->head; + ret_value=0; + while(span!=NULL) { + /* If there are down spans, multiply the size of this span by the total down span elements */ + if(span->down!=NULL) + ret_value+=span->nelem*H5S_hyper_spans_nelem(span->down); + /* If there are no down spans, just count the elements in this span */ + else + ret_value+=span->nelem; + + /* Advance to next span */ + span=span->next; + } /* end while */ + } /* end else */ + +#ifdef LATER +done: +#endif /* LATER */ + FUNC_LEAVE (ret_value); +} /* H5S_hyper_spans_nelem() */ + + +/*-------------------------------------------------------------------------- + NAME + H5S_hyper_make_spans + PURPOSE + Create a span tree + USAGE + H5S_hyper_span_t *H5S_hyper_make_spans(rank, start, stride, count, block) + unsigned rank; IN: # of dimensions of the space + const hssize_t *start; IN: Starting location of the hyperslabs + const hsize_t *stride; IN: Stride from the beginning of one block to + the next + const hsize_t *count; IN: Number of blocks + const hsize_t *block; IN: Size of hyperslab block + RETURNS + Pointer to new span tree on success, NULL on failure + DESCRIPTION + Generates a new span tree for the hyperslab parameters specified. + Each span tree has a list of the elements spanned in each dimension, with + each span node containing a pointer to the list of spans in the next + dimension down. + GLOBAL VARIABLES + COMMENTS, BUGS, ASSUMPTIONS + EXAMPLES + REVISION LOG +--------------------------------------------------------------------------*/ +static H5S_hyper_span_info_t * +H5S_hyper_make_spans (unsigned rank, const hssize_t *start, const hsize_t *stride, + const hsize_t *count, const hsize_t *block) +{ + H5S_hyper_span_info_t *down;/* Pointer to spans in next dimension down */ + H5S_hyper_span_t *span; /* New hyperslab span */ + H5S_hyper_span_t *last_span;/* Current position in hyperslab span list */ + H5S_hyper_span_t *head; /* Head of new hyperslab span list */ + int i; /* Counters */ + unsigned u; /* Counters */ + H5S_hyper_span_info_t *ret_value=NULL; + + FUNC_ENTER (H5S_hyper_make_spans, NULL); + + /* Check args */ + assert (rank>0); + assert (start); + assert (stride); + assert (count); + assert (block); + + /* Start creating spans in fastest changing dimension */ + down=NULL; + for(i=(rank-1); i>=0; i--) { + + /* Start a new list in this dimension */ + head=last_span=NULL; + + /* Generate all the spans segments for this dimension */ + for(u=0; u<count[i]; u++) { + /* Allocate a span node */ + if((span = H5FL_ALLOC(H5S_hyper_span_t,0))==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span"); + + /* Set the span's basic information */ + span->low=start[i]+(stride[i]*u); + span->high=span->low+(block[i]-1); + span->nelem=block[i]; + span->pstride=stride[i]; + span->next=NULL; + + /* Append to the list of spans in this dimension */ + if(head==NULL) + head=span; + else + last_span->next=span; + + /* Move current pointer */ + last_span=span; + + /* Set the information for the next dimension down's spans, if appropriate */ + if(down!=NULL) { + span->down=down; + down->count++; /* Increment reference count for shared span */ + } /* end if */ + else { + span->down=NULL; + } /* end else */ + } /* end for */ + + /* Allocate a span info node */ + if((down = H5FL_ALLOC(H5S_hyper_span_info_t,0))==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span"); + + /* Set the reference count */ + down->count=0; + + /* Reset the scratch pad space */ + down->scratch=0; + + /* Keep the pointer to the next dimension down's completed list */ + down->head=head; + } /* end for */ + + /* Indicate that there is a pointer to this tree */ + down->count=1; + + /* Success! Return the head of the list in the slowest changing dimension */ + ret_value=down; + +done: + FUNC_LEAVE (ret_value); +} /* H5S_hyper_make_spans() */ + +#ifndef NEW_HYPERSLAB_API + /*------------------------------------------------------------------------- * Function: H5S_generate_hyperlab * @@ -5473,163 +7670,198 @@ H5S_hyper_select_contiguous(const H5S_t *space) */ static herr_t H5S_generate_hyperslab (H5S_t *space, H5S_seloper_t op, - const hssize_t start[/*space_id*/], - const hsize_t stride[/*space_id*/], - const hsize_t count[/*space_id*/], - const hsize_t block[/*space_id*/]) + const hssize_t start[], + const hsize_t _stride[], + const hsize_t _count[], + const hsize_t _block[]) { - hssize_t slab[H5O_LAYOUT_NDIMS]; /* Location of the block to add for strided selections */ - size_t slice[H5O_LAYOUT_NDIMS]; /* Size of preceding dimension's slice */ - H5S_hyper_node_t *add=NULL, /* List of hyperslab nodes to add */ - *uniq=NULL; /* List of unique hyperslab nodes */ - unsigned acc; /* Accumulator for building slices */ - unsigned contig; /* whether selection is contiguous or not */ - int i; /* Counters */ - unsigned u,v; /* Counters */ + hsize_t stride[H5O_LAYOUT_NDIMS]; /* Optimized stride information */ + hsize_t count[H5O_LAYOUT_NDIMS]; /* Optimized count information */ + hsize_t block[H5O_LAYOUT_NDIMS]; /* Optimized block information */ + H5S_hyper_span_info_t *new_spans; /* Span tree for new hyperslab */ + H5S_hyper_span_info_t *a_not_b=NULL; /* Span tree for hyperslab spans in old span tree and not in new span tree */ + H5S_hyper_span_info_t *a_and_b=NULL; /* Span tree for hyperslab spans in both old and new span trees */ + H5S_hyper_span_info_t *b_not_a=NULL; /* Span tree for hyperslab spans in new span tree and not in old span tree */ + hssize_t nelem; /* Number of elements in hyperslab span tree */ + unsigned u; /* Counters */ herr_t ret_value=FAIL; /* return value */ FUNC_ENTER (H5S_generate_hyperslab, FAIL); /* Check args */ - assert(block); - assert(stride); assert(space); - assert(start); - assert(count); assert(op>H5S_SELECT_NOOP && op<H5S_SELECT_INVALID); + assert(start); + assert(_stride); + assert(_count); + assert(_block); - /* Determine if selection is contiguous */ - /* assume hyperslab is contiguous, until proven otherwise */ - contig=1; +#ifdef QAK +printf("%s: space=%p\n",FUNC,space); +#endif /* QAK */ + /* Optimize hyperslab selection to merge contiguous blocks */ for(u=0; u<space->extent.u.simple.rank; u++) { /* contiguous hyperslabs have the block size equal to the stride */ - if(stride[u]!=block[u]) { - contig=0; /* hyperslab isn't contiguous */ - break; /* no use looking further */ + if(_stride[u]==_block[u]) { + count[u]=1; + stride[u]=1; + block[u]=_block[u]*_count[u]; + } + else { + stride[u]=_stride[u]; + count[u]=_count[u]; + block[u]=_block[u]; } /* end if */ } /* end for */ + /* Generate span tree for new hyperslab information */ + if((new_spans=H5S_hyper_make_spans(space->extent.u.simple.rank,start,stride,count,block))==NULL) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't create hyperslab information"); #ifdef QAK - printf("%s: check 1.0, contig=%d, op=%s\n",FUNC,(int)contig,(op==H5S_SELECT_SET? "H5S_SELECT_SET" : (op==H5S_SELECT_OR ? "H5S_SELECT_OR" : "Unknown"))); +printf("%s: new_spans=%p\n",FUNC,new_spans); #endif /* QAK */ -#ifdef QAK - printf("%s: check 2.0, rank=%d\n",FUNC,(int)space->extent.u.simple.rank); -#endif /* QAK */ - /* Allocate space for the hyperslab selection information if necessary */ - if(space->select.type!=H5S_SEL_HYPERSLABS || space->select.sel_info.hslab.hyper_lst==NULL) { - if((space->select.sel_info.hslab.hyper_lst = H5FL_ALLOC(H5S_hyper_list_t,0))==NULL) - HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab information"); - - /* Set the fields for the hyperslab list */ - space->select.sel_info.hslab.hyper_lst->count=0; - space->select.sel_info.hslab.hyper_lst->head=NULL; - if((space->select.sel_info.hslab.hyper_lst->lo_bounds = H5FL_ARR_ALLOC(H5S_hyper_bound_ptr_t,space->extent.u.simple.rank,1))==NULL) - HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab lo bound information"); + /* Generate list of blocks to add/remove based on selection operation */ + if(op==H5S_SELECT_SET) { + /* Add new spans to current selection */ + if(H5S_hyper_merge_spans(space,new_spans)<0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslabs"); + + /* Set the number of elements in current selection */ + if((nelem=H5S_hyper_spans_nelem(new_spans))<0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOUNT, FAIL, "can't count hyperslab span elements"); + space->select.num_elem=nelem; } /* end if */ + else { + /* Generate lists of spans which overlap and don't overlap */ + if(H5S_hyper_clip_spans(space->select.sel_info.hslab.span_lst,new_spans,&a_not_b,&a_and_b,&b_not_a)<0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCLIP, FAIL, "can't clip hyperslab information"); + + switch(op) { + case H5S_SELECT_OR: + /* Add any new spans from b_not_a to current selection */ + if(b_not_a!=NULL) { + if(H5S_hyper_merge_spans(space,b_not_a)<0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslabs"); + + /* Update the number of elements in current selection */ + if((nelem=H5S_hyper_spans_nelem(b_not_a))<0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOUNT, FAIL, "can't count hyperslab span elements"); + space->select.num_elem+=nelem; + } /* end if */ + break; -#ifdef QAK - printf("%s: check 3.0\n",FUNC); -#endif /* QAK */ - /* Generate list of blocks to add/remove based on selection operation */ - switch(op) { - case H5S_SELECT_SET: - case H5S_SELECT_OR: -#ifdef QAK - printf("%s: check 4.0\n",FUNC); -#endif /* QAK */ - /* Generate list of blocks to add to selection */ - if(contig) { /* Check for trivial case */ -#ifdef QAK - printf("%s: check 4.1\n",FUNC); -#endif /* QAK */ + case H5S_SELECT_AND: + /* Free the current selection */ + if(H5S_hyper_free_span_info(space->select.sel_info.hslab.span_lst)<0) + HGOTO_ERROR(H5E_INTERNAL, H5E_CANTFREE, FAIL, "failed to release hyperslab spans"); + space->select.sel_info.hslab.span_lst=NULL; - /* Account for strides & blocks being equal, but larger than one */ - /* (Why someone would torture us this way, I don't know... -QAK :-) */ - for(u=0; u<space->extent.u.simple.rank; u++) - slab[u]=count[u]*stride[u]; -#ifdef QAK - printf("%s: check 4.2\n",FUNC); - printf("%s: start = {",FUNC); - for(u=0; u<space->extent.u.simple.rank; u++) { - printf("%d",(int)start[u]); - if(u<(space->extent.u.simple.rank-1)) - printf(", "); - else - printf("}\n"); - } - printf("%s: slab = {",FUNC); - for(u=0; u<space->extent.u.simple.rank; u++) { - printf("%d",(int)slab[u]); - if(u<(space->extent.u.simple.rank-1)) - printf(", "); - else - printf("}\n"); - } -#endif /* QAK */ + /* Reset the number of items in selection */ + space->select.num_elem=0; - /* Add the contiguous hyperslab to the selection */ - if(H5S_hyper_node_add(&add,0,space->extent.u.simple.rank,start,(const hsize_t *)slab)<0) { - HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslab"); - } - } else { -#ifdef QAK - printf("%s: check 4.3\n",FUNC); -#endif /* QAK */ - /* Build the slice sizes for each dimension */ - for(u=0, acc=1; u<space->extent.u.simple.rank; u++) { - slice[u]=acc; - acc*=count[u]; - } /* end for */ - - /* Step through all the blocks to add */ - /* (reuse the count in ACC above) */ - /* Adding the blocks in reverse order reduces the time spent moving memory around in H5S_hyper_add() */ - for(i=(int)acc-1; i>=0; i--) { - /* Build the location of the block */ - for(v=0; v<space->extent.u.simple.rank; v++) - slab[v]=start[v]+((i/slice[v])%count[v])*stride[v]; - - /* Add the block to the list of hyperslab selections */ - if(H5S_hyper_node_add(&add,0,space->extent.u.simple.rank,(const hssize_t *)slab, (const hsize_t *)block)<0) { - HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslab"); - } /* end if */ - } /* end for */ - } /* end else */ + /* Check if there are any overlapped selections */ + if(a_and_b!=NULL) { + if(H5S_hyper_merge_spans(space,a_and_b)<0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslabs"); -#ifdef QAK - printf("%s: check 4.5\n",FUNC); -#endif /* QAK */ - /* Clip list of new blocks to add against current selection */ - if(op==H5S_SELECT_OR) { -#ifdef QAK - printf("%s: check 4.5.1\n",FUNC); -#endif /* QAK */ - H5S_hyper_clip(space,add,&uniq,NULL); - add=uniq; - } /* end if */ -#ifdef QAK - printf("%s: check 4.5.5\n",FUNC); -#endif /* QAK */ - break; + /* Update the number of elements in current selection */ + if((nelem=H5S_hyper_spans_nelem(a_and_b))<0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOUNT, FAIL, "can't count hyperslab span elements"); + space->select.num_elem=nelem; + } /* end if */ + break; - default: - HRETURN_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "invalid selection operation"); - } /* end switch */ + case H5S_SELECT_XOR: + /* Free the current selection */ + if(H5S_hyper_free_span_info(space->select.sel_info.hslab.span_lst)<0) + HGOTO_ERROR(H5E_INTERNAL, H5E_CANTFREE, FAIL, "failed to release hyperslab spans"); + space->select.sel_info.hslab.span_lst=NULL; -#ifdef QAK - printf("%s: check 5.0\n",FUNC); -#endif /* QAK */ - /* Add new blocks to current selection */ - if(H5S_hyper_add(space,add)<0) - HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslabs"); + /* Reset the number of items in selection */ + space->select.num_elem=0; + + /* Check if there are any non-overlapped selections */ + if(a_not_b!=NULL) { + if(H5S_hyper_merge_spans(space,a_not_b)<0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslabs"); + + /* Update the number of elements in current selection */ + if((nelem=H5S_hyper_spans_nelem(a_not_b))<0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOUNT, FAIL, "can't count hyperslab span elements"); + space->select.num_elem=nelem; + } /* end if */ + if(b_not_a!=NULL) { + if(H5S_hyper_merge_spans(space,b_not_a)<0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslabs"); + + /* Update the number of elements in current selection */ + if((nelem=H5S_hyper_spans_nelem(b_not_a))<0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOUNT, FAIL, "can't count hyperslab span elements"); + space->select.num_elem+=nelem; + } /* end if */ + break; + + case H5S_SELECT_NOTB: + /* Free the current selection */ + if(H5S_hyper_free_span_info(space->select.sel_info.hslab.span_lst)<0) + HGOTO_ERROR(H5E_INTERNAL, H5E_CANTFREE, FAIL, "failed to release hyperslab spans"); + space->select.sel_info.hslab.span_lst=NULL; + + /* Reset the number of items in selection */ + space->select.num_elem=0; - /* Merge blocks for better I/O performance */ - /* Regenerate lo/hi bounds arrays? */ + /* Check if there are any non-overlapped selections */ + if(a_not_b!=NULL) { + if(H5S_hyper_merge_spans(space,a_not_b)<0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslabs"); + /* Update the number of elements in current selection */ + if((nelem=H5S_hyper_spans_nelem(a_not_b))<0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOUNT, FAIL, "can't count hyperslab span elements"); + space->select.num_elem=nelem; + } /* end if */ + break; + + case H5S_SELECT_NOTA: + /* Free the current selection */ + if(H5S_hyper_free_span_info(space->select.sel_info.hslab.span_lst)<0) + HGOTO_ERROR(H5E_INTERNAL, H5E_CANTFREE, FAIL, "failed to release hyperslab spans"); + space->select.sel_info.hslab.span_lst=NULL; + + /* Reset the number of items in selection */ + space->select.num_elem=0; + + /* Check if there are any non-overlapped selections */ + if(b_not_a!=NULL) { + if(H5S_hyper_merge_spans(space,b_not_a)<0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslabs"); + + /* Update the number of elements in current selection */ + if((nelem=H5S_hyper_spans_nelem(b_not_a))<0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOUNT, FAIL, "can't count hyperslab span elements"); + space->select.num_elem=nelem; + } /* end if */ + break; + + default: + HRETURN_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "invalid selection operation"); + } /* end switch */ #ifdef QAK - printf("%s: check 6.0\n",FUNC); +printf("%s: a_not_b=%p, a_and_b=%p, b_not_a=%p\n",FUNC,a_not_b,a_and_b,b_not_a); #endif /* QAK */ + /* Free the hyperslab trees generated from the clipping algorithm */ + if(a_not_b) + H5S_hyper_free_span_info(a_not_b); + if(a_and_b) + H5S_hyper_free_span_info(a_and_b); + if(b_not_a) + H5S_hyper_free_span_info(b_not_a); + } /* end else */ + + /* Free the new spans */ + if(H5S_hyper_free_span_info(new_spans)<0) + HGOTO_ERROR(H5E_INTERNAL, H5E_CANTFREE, FAIL, "failed to release temporary hyperslab spans"); /* Set return value */ ret_value=SUCCEED; @@ -5646,8 +7878,8 @@ done: * * Return: Non-negative on success/Negative on failure * - * Programmer: Robb Matzke (split from HSselect_hyperslab()). - * Tuesday, August 25, 1998 + * Programmer: Quincey Koziol + * Wednesday, January 10, 2001 * * Modifications: * @@ -5655,10 +7887,10 @@ done: */ herr_t H5S_select_hyperslab (H5S_t *space, H5S_seloper_t op, - const hssize_t start[/*space_id*/], - const hsize_t stride[/*space_id*/], - const hsize_t count[/*space_id*/], - const hsize_t block[/*space_id*/]) + const hssize_t start[], + const hsize_t stride[], + const hsize_t count[], + const hsize_t block[]) { hsize_t *_stride=NULL; /* Stride array */ hsize_t *_block=NULL; /* Block size array */ @@ -5680,8 +7912,7 @@ H5S_select_hyperslab (H5S_t *space, H5S_seloper_t op, /* Allocate temporary buffer */ if ((_stride=H5FL_ARR_ALLOC(hsize_t,space->extent.u.simple.rank,0))==NULL) - HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, - "memory allocation failed for stride buffer"); + HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for stride buffer"); H5V_array_fill(_stride,&fill,sizeof(hssize_t),space->extent.u.simple.rank); stride = _stride; } @@ -5692,8 +7923,7 @@ H5S_select_hyperslab (H5S_t *space, H5S_seloper_t op, /* Allocate temporary buffer */ if ((_block=H5FL_ARR_ALLOC(hsize_t,space->extent.u.simple.rank,0))==NULL) - HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, - "memory allocation failed for stride buffer"); + HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for stride buffer"); H5V_array_fill(_block,&fill,sizeof(hssize_t),space->extent.u.simple.rank); block = _block; } @@ -5706,35 +7936,22 @@ H5S_select_hyperslab (H5S_t *space, H5S_seloper_t op, if(space->select.type==H5S_SEL_NONE && op==H5S_SELECT_OR) op=H5S_SELECT_SET; -#ifdef QAK - printf("%s: check 1.0, op=%s\n",FUNC,(op==H5S_SELECT_SET? "H5S_SELECT_SET" : (op==H5S_SELECT_OR ? "H5S_SELECT_OR" : "Unknown"))); -#endif /* QAK */ if(op==H5S_SELECT_SET) { /* - * Check for overlapping hyperslab blocks in new selection - * (remove when real block-merging algorithm is in place? -QAK). + * Check for overlapping hyperslab blocks in new selection. */ -#ifdef QAK -for(u=0; u<space->extent.u.simple.rank; u++) - printf("%s: (%u) start=%d, stride=%d, count=%d, block=%d\n",FUNC,u,(int)start[u],(int)stride[u],(int)count[u],(int)block[u]); -#endif /* QAK */ for(u=0; u<space->extent.u.simple.rank; u++) { - if(count[u]>1 && stride[u]<block[u]) { - HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, - "hyperslab blocks overlap"); - } /* end if */ + if(count[u]>1 && stride[u]<block[u]) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "hyperslab blocks overlap"); } /* end for */ /* If we are setting a new selection, remove current selection first */ - if(H5S_select_release(space)<0) { - HGOTO_ERROR(H5E_DATASPACE, H5E_CANTDELETE, FAIL, - "can't release hyperslab"); - } /* end if */ + if(H5S_select_release(space)<0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTDELETE, FAIL, "can't release hyperslab"); /* Copy all the application per-dimension selection info into the space descriptor */ - if((diminfo = H5FL_ARR_ALLOC(H5S_hyper_dim_t,space->extent.u.simple.rank,0))==NULL) { + if((diminfo = H5FL_ARR_ALLOC(H5S_hyper_dim_t,space->extent.u.simple.rank,0))==NULL) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate per-dimension vector"); - } /* end if */ for(u=0; u<space->extent.u.simple.rank; u++) { diminfo[u].start = start[u]; diminfo[u].stride = stride[u]; @@ -5744,9 +7961,8 @@ for(u=0; u<space->extent.u.simple.rank; u++) space->select.sel_info.hslab.app_diminfo = diminfo; /* Allocate room for the optimized per-dimension selection info */ - if((diminfo = H5FL_ARR_ALLOC(H5S_hyper_dim_t,space->extent.u.simple.rank,0))==NULL) { + if((diminfo = H5FL_ARR_ALLOC(H5S_hyper_dim_t,space->extent.u.simple.rank,0))==NULL) HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate per-dimension vector"); - } /* end if */ /* Optimize the hyperslab selection to detect contiguously selected block/stride information */ /* Modify the stride, block & count for contiguous hyperslab selections */ @@ -5768,11 +7984,11 @@ for(u=0; u<space->extent.u.simple.rank; u++) } /* end for */ space->select.sel_info.hslab.diminfo = diminfo; - /* Set the number of elements in the hyperslab selection */ - for(space->select.num_elem=1,u=0; u<space->extent.u.simple.rank; u++) - space->select.num_elem*=block[u]*count[u]; + /* Build the hyperslab information also */ + if(H5S_generate_hyperslab (space, H5S_SELECT_SET, start, stride, count, block)<0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't generate hyperslabs"); } /* end if */ - else if(op==H5S_SELECT_OR) { + else if(op>=H5S_SELECT_OR && op<=H5S_SELECT_NOTA) { switch(space->select.type) { case H5S_SEL_ALL: /* break out now, 'or'ing with an all selection leaves the all selection */ @@ -5781,29 +7997,6 @@ for(u=0; u<space->extent.u.simple.rank; u++) case H5S_SEL_HYPERSLABS: /* Is this the first 'or' operation? */ if(space->select.sel_info.hslab.diminfo != NULL) { - /* yes, a "regular" hyperslab is selected currently */ - - hssize_t tmp_start[H5O_LAYOUT_NDIMS]; - hsize_t tmp_stride[H5O_LAYOUT_NDIMS]; - hsize_t tmp_count[H5O_LAYOUT_NDIMS]; - hsize_t tmp_block[H5O_LAYOUT_NDIMS]; - - /* Generate the hyperslab information for the regular hyperslab */ - - /* Copy over the 'diminfo' information */ - for(u=0; u<space->extent.u.simple.rank; u++) { - tmp_start[u]=space->select.sel_info.hslab.diminfo[u].start; - tmp_stride[u]=space->select.sel_info.hslab.diminfo[u].stride; - tmp_count[u]=space->select.sel_info.hslab.diminfo[u].count; - tmp_block[u]=space->select.sel_info.hslab.diminfo[u].block; - } /* end for */ - - /* Reset the number of selection elements */ - space->select.num_elem=0; - - /* Build the hyperslab information */ - H5S_generate_hyperslab (space, H5S_SELECT_SET, tmp_start, tmp_stride, tmp_count, tmp_block); - /* Remove the 'diminfo' information, since we're adding to it */ H5FL_ARR_FREE(H5S_hyper_dim_t,space->select.sel_info.hslab.diminfo); space->select.sel_info.hslab.diminfo = NULL; @@ -5811,24 +8004,19 @@ for(u=0; u<space->extent.u.simple.rank; u++) /* Remove the 'app_diminfo' information also, since we're adding to it */ H5FL_ARR_FREE(H5S_hyper_dim_t,space->select.sel_info.hslab.app_diminfo); space->select.sel_info.hslab.app_diminfo = NULL; - - /* Add in the new hyperslab information */ - H5S_generate_hyperslab (space, op, start, stride, count, block); } /* end if */ - else { - /* nope, an "irregular" hyperslab is selected currently */ - /* Add in the new hyperslab information */ - H5S_generate_hyperslab (space, op, start, stride, count, block); - } /* end else */ + + /* Add in the new hyperslab information */ + if(H5S_generate_hyperslab (space, op, start, stride, count, block)<0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't generate hyperslabs"); break; default: HRETURN_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "invalid selection operation"); } /* end switch() */ } /* end if */ - else { + else HRETURN_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "invalid selection operation"); - } /* end else */ /* Set selection type */ space->select.type=H5S_SEL_HYPERSLABS; @@ -5863,417 +8051,788 @@ done: Combines a hyperslab selection with the current selection for a dataspace. If the current selection is not a hyperslab, it is freed and the hyperslab parameters passed in are combined with the H5S_SEL_ALL hyperslab (ie. a - selection composing the entire current extent). Currently, only the - H5S_SELECT_SET & H5S_SELECT_OR operations are supported. If STRIDE or - BLOCK is NULL, they are assumed to be set to all '1'. + selection composing the entire current extent). If STRIDE or BLOCK is + NULL, they are assumed to be set to all '1'. GLOBAL VARIABLES COMMENTS, BUGS, ASSUMPTIONS EXAMPLES REVISION LOG --------------------------------------------------------------------------*/ herr_t -H5Sselect_hyperslab(hid_t space_id, H5S_seloper_t op, - const hssize_t start[/*space_id*/], - const hsize_t _stride[/*space_id*/], - const hsize_t count[/*space_id*/], - const hsize_t _block[/*space_id*/]) +H5Sselect_hyperslab(hid_t space_id, H5S_seloper_t op, const hssize_t start[], + const hsize_t stride[], const hsize_t count[], const hsize_t block[]) { H5S_t *space = NULL; /* Dataspace to modify selection of */ FUNC_ENTER (H5Sselect_hyperslab, FAIL); - H5TRACE6("e","iSs*[a0]Hs*[a0]h*[a0]h*[a0]h",space_id,op,start,_stride, - count,_block); + H5TRACE6("e","iSs*[a0]Hs*[a0]h*[a0]h*[a0]h",space_id,op,start,stride, + count,block); /* Check args */ if (H5I_DATASPACE != H5I_get_type(space_id) || NULL == (space=H5I_object(space_id))) { HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space"); } - if(start==NULL || count==NULL) { + if(start==NULL || count==NULL) HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "hyperslab not specified"); - } /* end if */ - if(!(op>H5S_SELECT_NOOP && op<H5S_SELECT_INVALID)) { + if(!(op>H5S_SELECT_NOOP && op<H5S_SELECT_INVALID)) HRETURN_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "invalid selection operation"); - } /* end if */ - if (H5S_select_hyperslab(space, op, start, _stride, count, _block)<0) { - HRETURN_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, - "unable to set hyperslab selection"); - } + if (H5S_select_hyperslab(space, op, start, stride, count, block)<0) + HRETURN_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to set hyperslab selection"); FUNC_LEAVE (SUCCEED); -} +} /* end H5Sselect_hyperslab() */ +#else /* OLD_WAY */ /* Works */ + +/*------------------------------------------------------------------------- + * Function: H5S_operate_hyperslab + * + * Purpose: Combines two hyperslabs with an operation, putting the + * result into a third hyperslab selection + * + * Return: non-negative on success/NULL on failure + * + * Programmer: Quincey Koziol + * Tuesday, October 30, 2001 + * + * Modifications: + * + *------------------------------------------------------------------------- + */ +static herr_t +H5S_operate_hyperslab (H5S_t *result, H5S_hyper_span_info_t *spans1, H5S_seloper_t op, H5S_hyper_span_info_t *spans2) +{ + H5S_hyper_span_info_t *a_not_b=NULL; /* Span tree for hyperslab spans in old span tree and not in new span tree */ + H5S_hyper_span_info_t *a_and_b=NULL; /* Span tree for hyperslab spans in both old and new span trees */ + H5S_hyper_span_info_t *b_not_a=NULL; /* Span tree for hyperslab spans in new span tree and not in old span tree */ + hssize_t nelem; /* Number of elements in hyperslab span tree */ + herr_t ret_value=FAIL; /* return value */ + + FUNC_ENTER (H5S_operate_hyperslab, NULL); + + /* Check args */ + assert(result); + assert(spans2); + assert(op>H5S_SELECT_NOOP && op<H5S_SELECT_INVALID); + + /* Free the current selection for the result space */ + if(H5S_select_release(result)<0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTDELETE, FAIL, "can't release result selection"); + + /* Just copy the selection from spans2 if we are setting the selection */ + /* ('space1' to 'result' aliasing happens at the next layer up) */ + if(op==H5S_SELECT_SET) { + if(H5S_hyper_merge_spans(result,spans2)<0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslabs"); + + /* Update the number of elements in current selection */ + if((nelem=H5S_hyper_spans_nelem(spans2))<0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOUNT, FAIL, "can't count hyperslab span elements"); + result->select.num_elem=nelem; + } /* end if */ + else { + assert(spans1); + + /* Generate lists of spans which overlap and don't overlap */ + if(H5S_hyper_clip_spans(spans1,spans2,&a_not_b,&a_and_b,&b_not_a)<0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCLIP, FAIL, "can't clip hyperslab information"); + + /* Switch on the operation */ + switch(op) { + case H5S_SELECT_OR: + /* Copy spans from spans1 to current selection */ + if(spans1!=NULL) { + if(H5S_hyper_merge_spans(result,spans1)<0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslabs"); + + /* Update the number of elements in current selection */ + if((nelem=H5S_hyper_spans_nelem(spans1))<0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOUNT, FAIL, "can't count hyperslab span elements"); + result->select.num_elem=nelem; + } /* end if */ + + /* Add any new spans from spans2 to current selection */ + if(b_not_a!=NULL) { + if(H5S_hyper_merge_spans(result,b_not_a)<0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslabs"); + + /* Update the number of elements in current selection */ + if((nelem=H5S_hyper_spans_nelem(b_not_a))<0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOUNT, FAIL, "can't count hyperslab span elements"); + result->select.num_elem+=nelem; + } /* end if */ + break; + + case H5S_SELECT_AND: + /* Check if there are any overlapped selections */ + if(a_and_b!=NULL) { + if(H5S_hyper_merge_spans(result,a_and_b)<0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslabs"); + + /* Update the number of elements in current selection */ + if((nelem=H5S_hyper_spans_nelem(a_and_b))<0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOUNT, FAIL, "can't count hyperslab span elements"); + result->select.num_elem=nelem; + } /* end if */ + break; + + case H5S_SELECT_XOR: + /* Check if there are any non-overlapped selections */ + if(a_not_b!=NULL) { + if(H5S_hyper_merge_spans(result,a_not_b)<0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslabs"); + + /* Update the number of elements in current selection */ + if((nelem=H5S_hyper_spans_nelem(a_not_b))<0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOUNT, FAIL, "can't count hyperslab span elements"); + result->select.num_elem=nelem; + } /* end if */ + if(b_not_a!=NULL) { + if(H5S_hyper_merge_spans(result,b_not_a)<0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslabs"); + + /* Update the number of elements in current selection */ + if((nelem=H5S_hyper_spans_nelem(b_not_a))<0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOUNT, FAIL, "can't count hyperslab span elements"); + result->select.num_elem+=nelem; + } /* end if */ + break; + + case H5S_SELECT_NOTB: + /* Check if there are any non-overlapped selections */ + if(a_not_b!=NULL) { + if(H5S_hyper_merge_spans(result,a_not_b)<0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslabs"); + + /* Update the number of elements in current selection */ + if((nelem=H5S_hyper_spans_nelem(a_not_b))<0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOUNT, FAIL, "can't count hyperslab span elements"); + result->select.num_elem=nelem; + } /* end if */ + break; + + case H5S_SELECT_NOTA: + /* Check if there are any non-overlapped selections */ + if(b_not_a!=NULL) { + if(H5S_hyper_merge_spans(result,b_not_a)<0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslabs"); + + /* Update the number of elements in current selection */ + if((nelem=H5S_hyper_spans_nelem(b_not_a))<0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOUNT, FAIL, "can't count hyperslab span elements"); + result->select.num_elem=nelem; + } /* end if */ + break; + + default: + HRETURN_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "invalid selection operation"); + } /* end switch */ + + /* Free the hyperslab trees generated from the clipping algorithm */ + if(a_not_b) + H5S_hyper_free_span_info(a_not_b); + if(a_and_b) + H5S_hyper_free_span_info(a_and_b); + if(b_not_a) + H5S_hyper_free_span_info(b_not_a); + } /* end else */ + + /* Set selection type */ + result->select.type=H5S_SEL_HYPERSLABS; + + /* Set the return value */ + ret_value=SUCCEED; + +done: + + FUNC_LEAVE (ret_value); +} /* end H5S_operate_hyperslab() */ /*------------------------------------------------------------------------- - * Function: H5S_hyper_select_iterate_mem + * Function: H5S_generate_hyperlab * - * Purpose: Recursively iterates over data points in memory using the parameters - * passed to H5S_hyper_select_iterate. + * Purpose: Generate hyperslab information from H5S_select_hyperslab() * - * Return: Success: Number of elements copied. + * Return: Non-negative on success/Negative on failure * - * Failure: 0 + * Programmer: Quincey Koziol (split from HS_select_hyperslab()). + * Tuesday, September 12, 2000 + * + * Modifications: + * + *------------------------------------------------------------------------- + */ +static herr_t +H5S_generate_hyperslab (H5S_t *space, H5S_seloper_t op, + const hssize_t start[], + const hsize_t _stride[], + const hsize_t _count[], + const hsize_t _block[]) +{ + hsize_t stride[H5O_LAYOUT_NDIMS]; /* Optimized stride information */ + hsize_t count[H5O_LAYOUT_NDIMS]; /* Optimized count information */ + hsize_t block[H5O_LAYOUT_NDIMS]; /* Optimized block information */ + H5S_hyper_span_info_t *new_spans=NULL; /* Span tree for new hyperslab */ + H5S_hyper_span_info_t *tmp_spans=NULL; /* Temporary copy of selection */ + unsigned u; /* Counters */ + herr_t ret_value=FAIL; /* return value */ + + FUNC_ENTER (H5S_generate_hyperslab, FAIL); + + /* Check args */ + assert(space); + assert(op>H5S_SELECT_NOOP && op<H5S_SELECT_INVALID); + assert(start); + assert(_stride); + assert(_count); + assert(_block); + + /* Optimize hyperslab selection to merge contiguous blocks */ + for(u=0; u<space->extent.u.simple.rank; u++) { + /* contiguous hyperslabs have the block size equal to the stride */ + if(_stride[u]==_block[u]) { + count[u]=1; + stride[u]=1; + block[u]=_block[u]*_count[u]; + } + else { + stride[u]=_stride[u]; + count[u]=_count[u]; + block[u]=_block[u]; + } /* end if */ + } /* end for */ + + /* Generate span tree for new hyperslab information */ + if((new_spans=H5S_hyper_make_spans(space->extent.u.simple.rank,start,stride,count,block))==NULL) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't create hyperslab information"); + + /* Copy the original dataspace */ + if(space->select.sel_info.hslab.span_lst!=NULL) + if (NULL==(tmp_spans=H5S_hyper_copy_span(space->select.sel_info.hslab.span_lst))) + HGOTO_ERROR (H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to copy data space"); + + /* Combine tmp_space (really space) & new_space, with the result in space */ + if(H5S_operate_hyperslab(space,tmp_spans,op,new_spans)<0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCLIP, FAIL, "can't clip hyperslab information"); + + /* Set return value */ + ret_value=SUCCEED; + +done: + /* Free temporary data structures */ + if(tmp_spans!=NULL) + H5S_hyper_free_span_info(tmp_spans); + if(new_spans!=NULL) + H5S_hyper_free_span_info(new_spans); + + FUNC_LEAVE (ret_value); +} /* end H5S_generate_hyperslab() */ + + +/*------------------------------------------------------------------------- + * Function: H5S_select_hyperslab + * + * Purpose: Internal version of H5Sselect_hyperslab(). + * + * Return: Non-negative on success/Negative on failure * * Programmer: Quincey Koziol - * Tuesday, June 22, 1999 + * Wednesday, January 10, 2001 * * Modifications: * *------------------------------------------------------------------------- */ -static herr_t -H5S_hyper_select_iterate_mem (int dim, H5S_hyper_iter_info_t *iter_info) +herr_t +H5S_select_hyperslab (H5S_t *space, H5S_seloper_t op, + const hssize_t start[], + const hsize_t stride[], + const hsize_t count[], + const hsize_t block[]) { - hsize_t offset; /* offset of region in buffer */ - void *tmp_buf; /* temporary location of the element in the buffer */ - H5S_hyper_region_t *regions; /* Pointer to array of hyperslab nodes overlapped */ - size_t num_regions; /* number of regions overlapped */ - herr_t user_ret=0; /* User's return value */ - size_t i; /* Counters */ - int j; + hsize_t *_stride=NULL; /* Stride array */ + hsize_t *_block=NULL; /* Block size array */ + unsigned u; /* Counters */ + H5S_hyper_dim_t *diminfo; /* per-dimension info for the selection */ + herr_t ret_value=FAIL; /* return value */ - FUNC_ENTER (H5S_hyper_select_iterate_mem, 0); + FUNC_ENTER (H5S_select_hyperslab, FAIL); - assert(iter_info); + /* Check args */ + assert(space); + assert(start); + assert(count); + assert(op>H5S_SELECT_NOOP && op<H5S_SELECT_INVALID); + + /* Fill in the correct stride values */ + if(stride==NULL) { + hssize_t fill=1; - /* Get a sorted list (in the next dimension down) of the regions which */ - /* overlap the current index in this dim */ - if((regions=H5S_hyper_get_regions(&num_regions,iter_info->space->extent.u.simple.rank, - (unsigned)(dim+1), - iter_info->space->select.sel_info.hslab.hyper_lst->count, - iter_info->space->select.sel_info.hslab.hyper_lst->lo_bounds, - iter_info->iter->hyp.pos,iter_info->space->select.offset))!=NULL) { - - /* Check if this is the second to last dimension in dataset */ - /* (Which means that we've got a list of the regions in the fastest */ - /* changing dimension and should input those regions) */ - if((unsigned)(dim+2)==iter_info->space->extent.u.simple.rank) { - HDmemcpy(iter_info->mem_offset, iter_info->iter->hyp.pos,(iter_info->space->extent.u.simple.rank*sizeof(hssize_t))); - iter_info->mem_offset[iter_info->space->extent.u.simple.rank]=0; - - /* Iterate over data from regions */ - for(i=0; i<num_regions && user_ret==0; i++) { - /* Set the location of the current hyperslab */ - iter_info->mem_offset[iter_info->space->extent.u.simple.rank-1]=regions[i].start; - - /* Get the offset in the memory buffer */ - offset=H5V_array_offset(iter_info->space->extent.u.simple.rank+1, - iter_info->mem_size,iter_info->mem_offset); - tmp_buf=((char *)iter_info->src+offset); - - /* Iterate over each element in the current region */ - for(j=regions[i].start; j<=regions[i].end && user_ret==0; j++) { - /* Call the user's function */ - user_ret=(*(iter_info->op))(tmp_buf,iter_info->dt,(hsize_t)iter_info->space->extent.u.simple.rank,iter_info->mem_offset,iter_info->op_data); - - /* Subtract the element from the selected region (not implemented yet) */ - - /* Increment the coordinate offset */ - iter_info->mem_offset[iter_info->space->extent.u.simple.rank-1]=j; - - /* Advance the pointer in the buffer */ - tmp_buf=((char *)tmp_buf+iter_info->elem_size); - } /* end for */ - - /* Decrement the iterator count */ - iter_info->iter->hyp.elmt_left-=((regions[i].end-regions[i].start)+1); - } /* end for */ + /* Allocate temporary buffer */ + if ((_stride=H5FL_ARR_ALLOC(hsize_t,space->extent.u.simple.rank,0))==NULL) + HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for stride buffer"); + H5V_array_fill(_stride,&fill,sizeof(hssize_t),space->extent.u.simple.rank); + stride = _stride; + } - /* Set the next position to start at */ - iter_info->iter->hyp.pos[dim+1]=(-1); - } else { /* recurse on each region to next dimension down */ + /* Fill in the correct block values */ + if(block==NULL) { + hssize_t fill=1; - /* Increment the dimension we are working with */ - dim++; + /* Allocate temporary buffer */ + if ((_block=H5FL_ARR_ALLOC(hsize_t,space->extent.u.simple.rank,0))==NULL) + HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for stride buffer"); + H5V_array_fill(_block,&fill,sizeof(hssize_t),space->extent.u.simple.rank); + block = _block; + } - /* Step through each region in this dimension */ - for(i=0; i<num_regions && user_ret==0; i++) { - /* Step through each location in each region */ - for(j=regions[i].start; j<=regions[i].end && user_ret==0; j++) { + /* Fixup operation if selection is 'none' and operation is an OR */ + /* (Allows for 'or'ing a sequence of hyperslab into a 'none' selection to */ + /* have same affect as setting the first hyperslab in the sequence to have */ + /* the 'set' operation and the rest of the hyperslab sequence to be 'or'ed */ + /* after that */ + if(space->select.type==H5S_SEL_NONE && op==H5S_SELECT_OR) + op=H5S_SELECT_SET; - /* - * If we are moving to a new position in this dim, reset - * the next lower dim. location. - */ - if(iter_info->iter->hyp.pos[dim]!=j) - iter_info->iter->hyp.pos[dim+1]=(-1); + if(op==H5S_SELECT_SET) { + /* + * Check for overlapping hyperslab blocks in new selection. + */ + for(u=0; u<space->extent.u.simple.rank; u++) { + if(count[u]>1 && stride[u]<block[u]) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "hyperslab blocks overlap"); + } /* end for */ - /* Set the correct position we are working on */ - iter_info->iter->hyp.pos[dim]=j; + /* If we are setting a new selection, remove current selection first */ + if(H5S_select_release(space)<0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTDELETE, FAIL, "can't release hyperslab"); - /* Go get the regions in the next lower dimension */ - user_ret=H5S_hyper_select_iterate_mem(dim, iter_info); - } /* end for */ - } /* end for */ - } /* end else */ + /* Copy all the application per-dimension selection info into the space descriptor */ + if((diminfo = H5FL_ARR_ALLOC(H5S_hyper_dim_t,space->extent.u.simple.rank,0))==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate per-dimension vector"); + for(u=0; u<space->extent.u.simple.rank; u++) { + diminfo[u].start = start[u]; + diminfo[u].stride = stride[u]; + diminfo[u].count = count[u]; + diminfo[u].block = block[u]; + } /* end for */ + space->select.sel_info.hslab.app_diminfo = diminfo; + + /* Allocate room for the optimized per-dimension selection info */ + if((diminfo = H5FL_ARR_ALLOC(H5S_hyper_dim_t,space->extent.u.simple.rank,0))==NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate per-dimension vector"); - /* Release the temporary buffer */ - H5FL_ARR_FREE(H5S_hyper_region_t,regions); + /* Optimize the hyperslab selection to detect contiguously selected block/stride information */ + /* Modify the stride, block & count for contiguous hyperslab selections */ + for(u=0; u<space->extent.u.simple.rank; u++) { + /* Starting location doesn't get optimized */ + diminfo[u].start = start[u]; + + /* contiguous hyperslabs have the block size equal to the stride */ + if(stride[u]==block[u]) { + diminfo[u].stride=1; + diminfo[u].count=1; + diminfo[u].block=count[u]*block[u]; + } /* end if */ + else { + diminfo[u].stride=stride[u]; + diminfo[u].count=count[u]; + diminfo[u].block=block[u]; + } /* end else */ + } /* end for */ + space->select.sel_info.hslab.diminfo = diminfo; + + /* Build the hyperslab information also */ + if(H5S_generate_hyperslab (space, H5S_SELECT_SET, start, stride, count, block)<0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't generate hyperslabs"); } /* end if */ + else if(op>=H5S_SELECT_OR && op<=H5S_SELECT_NOTA) { + switch(space->select.type) { + case H5S_SEL_HYPERSLABS: + /* Is this the first 'or' operation? */ + if(space->select.sel_info.hslab.diminfo != NULL) { + /* Remove the 'diminfo' information, since we're adding to it */ + H5FL_ARR_FREE(H5S_hyper_dim_t,space->select.sel_info.hslab.diminfo); + space->select.sel_info.hslab.diminfo = NULL; - FUNC_LEAVE (user_ret); -} /* H5S_hyper_select_iterate_mem() */ + /* Remove the 'app_diminfo' information also, since we're adding to it */ + H5FL_ARR_FREE(H5S_hyper_dim_t,space->select.sel_info.hslab.app_diminfo); + space->select.sel_info.hslab.app_diminfo = NULL; + } /* end if */ + + /* Add in the new hyperslab information */ + if(H5S_generate_hyperslab (space, op, start, stride, count, block)<0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't generate hyperslabs"); + break; + + default: + HRETURN_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "invalid selection operation"); + } /* end switch() */ + } /* end if */ + else + HRETURN_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "invalid selection operation"); + + ret_value=SUCCEED; + +done: + if(_stride!=NULL) + H5FL_ARR_FREE(hsize_t,_stride); + if(_block!=NULL) + H5FL_ARR_FREE(hsize_t,_block); + FUNC_LEAVE (ret_value); +} /* end H5S_select_hyperslab() */ /*-------------------------------------------------------------------------- NAME - H5S_hyper_select_iterate_mem_opt + H5Sselect_hyperslab PURPOSE - Iterate over the data points in a regular hyperslab selection, calling a - user's function for each element. + Specify a hyperslab to combine with the current hyperslab selection USAGE - herr_t H5S_hyper_select_iterate_mem_opt(buf, type_id, space, op, operator_data) - H5S_sel_iter_t *iter; IN/OUT: Selection iterator - void *buf; IN/OUT: Buffer containing elements to iterate over - hid_t type_id; IN: Datatype ID of BUF array. - H5S_t *space; IN: Dataspace object containing selection to iterate over - H5D_operator_t op; IN: Function pointer to the routine to be - called for each element in BUF iterated over. - void *op_data; IN/OUT: Pointer to any user-defined data associated - with the operation. + herr_t H5Sselect_hyperslab(dsid, op, start, stride, count, block) + hid_t dsid; IN: Dataspace ID of selection to modify + H5S_seloper_t op; IN: Operation to perform on current selection + const hssize_t *start; IN: Offset of start of hyperslab + const hssize_t *stride; IN: Hyperslab stride + const hssize_t *count; IN: Number of blocks included in hyperslab + const hssize_t *block; IN: Size of block in hyperslab RETURNS - Returns the return value of the last operator if it was non-zero, or zero - if all elements were processed. Otherwise returns a negative value. + Non-negative on success/Negative on failure DESCRIPTION - Iterates over the selected elements in a memory buffer, calling the user's - callback function for each element. The selection in the dataspace is - modified so that any elements already iterated over are removed from the - selection if the iteration is interrupted (by the H5D_operator_t function - returning non-zero) in the "middle" of the iteration and may be re-started - by the user where it left off. + Combines a hyperslab selection with the current selection for a dataspace. + If the current selection is not a hyperslab, it is freed and the hyperslab + parameters passed in are combined with the H5S_SEL_ALL hyperslab (ie. a + selection composing the entire current extent). If STRIDE or BLOCK is + NULL, they are assumed to be set to all '1'. + GLOBAL VARIABLES + COMMENTS, BUGS, ASSUMPTIONS + EXAMPLES + REVISION LOG +--------------------------------------------------------------------------*/ +herr_t +H5Sselect_hyperslab(hid_t space_id, H5S_seloper_t op, const hssize_t start[], + const hsize_t stride[], const hsize_t count[], const hsize_t block[]) +{ + H5S_t *space = NULL; /* Dataspace to modify selection of */ - NOTE: Until "subtracting" elements from a selection is implemented, - the selection is not modified. + FUNC_ENTER (H5Sselect_hyperslab, FAIL); + H5TRACE6("e","iSs*[a0]Hs*[a0]h*[a0]h*[a0]h",space_id,op,start,stride, + count,block); + + /* Check args */ + if (H5I_DATASPACE != H5I_get_type(space_id) || + NULL == (space=H5I_object(space_id))) { + HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space"); + } + if(start==NULL || count==NULL) + HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "hyperslab not specified"); + + if(!(op>H5S_SELECT_NOOP && op<H5S_SELECT_INVALID)) + HRETURN_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "invalid selection operation"); + + if (H5S_select_hyperslab(space, op, start, stride, count, block)<0) + HRETURN_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to set hyperslab selection"); + + FUNC_LEAVE (SUCCEED); +} /* end H5Sselect_hyperslab() */ + + +/*-------------------------------------------------------------------------- + NAME + H5Scombine_hyperslab + PURPOSE + Specify a hyperslab to combine with the current hyperslab selection and + return a new dataspace with the combined selection as the selection in the + new dataspace. + USAGE + hid_t H5Srefine_hyperslab(dsid, op, start, stride, count, block) + hid_t dsid; IN: Dataspace ID of selection to use + H5S_seloper_t op; IN: Operation to perform on current selection + const hssize_t *start; IN: Offset of start of hyperslab + const hssize_t *stride; IN: Hyperslab stride + const hssize_t *count; IN: Number of blocks included in hyperslab + const hssize_t *block; IN: Size of block in hyperslab + RETURNS + Dataspace ID on success/Negative on failure + DESCRIPTION + Combines a hyperslab selection with the current selection for a dataspace, + creating a new dataspace to return the generated selection. + If the current selection is not a hyperslab, it is freed and the hyperslab + parameters passed in are combined with the H5S_SEL_ALL hyperslab (ie. a + selection composing the entire current extent). If STRIDE or BLOCK is + NULL, they are assumed to be set to all '1'. GLOBAL VARIABLES COMMENTS, BUGS, ASSUMPTIONS EXAMPLES REVISION LOG --------------------------------------------------------------------------*/ -static herr_t -H5S_hyper_select_iterate_mem_opt(H5S_sel_iter_t * UNUSED iter, void *buf, hid_t type_id, H5S_t *space, H5D_operator_t op, - void *op_data) +hid_t +H5Scombine_hyperslab(hid_t space_id, H5S_seloper_t op, const hssize_t start[], + const hsize_t stride[], const hsize_t count[], const hsize_t block[]) { - H5S_hyper_dim_t *diminfo; /* Alias for dataspace's diminfo information */ - hsize_t tmp_count[H5O_LAYOUT_NDIMS]; /* Temporary hyperslab counts */ - hsize_t tmp_block[H5O_LAYOUT_NDIMS]; /* Temporary hyperslab blocks */ - hssize_t offset[H5O_LAYOUT_NDIMS]; /* Offset of element in dataspace */ - hsize_t slab[H5O_LAYOUT_NDIMS]; /* Size of objects in buffer */ - size_t elem_size; /* Size of data element in buffer */ - hssize_t temp_off; /* Offset in a given dimension */ - uint8_t *loc; /* Current element location */ - int i; /* Counter */ - unsigned u; /* Counter */ - int fast_dim; /* Rank of the fastest changing dimension for the dataspace */ - int temp_dim; /* Temporary rank holder */ - unsigned ndims; /* Rank of the dataspace */ - herr_t user_ret=0; /* User's return value */ + H5S_t *space = NULL; /* Dataspace to modify selection of */ + H5S_t *new_space = NULL; /* New dataspace created */ + hid_t ret_value = FAIL; - FUNC_ENTER (H5S_hyper_select_iterate_mem_opt, FAIL); + FUNC_ENTER (H5Scombine_hyperslab, FAIL); + H5TRACE6("e","iSs*[a0]Hs*[a0]h*[a0]h*[a0]h",space_id,op,start,stride, + count,block); - /* Set some convienence values */ - ndims=space->extent.u.simple.rank; - fast_dim=ndims-1; - diminfo=space->select.sel_info.hslab.diminfo; + /* Check args */ + if (H5I_DATASPACE != H5I_get_type(space_id) || + NULL == (space=H5I_object(space_id))) { + HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space"); + } + if(start==NULL || count==NULL) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "hyperslab not specified"); - /* Get the data element size */ - elem_size=H5Tget_size(type_id); + if(!(op>H5S_SELECT_NOOP && op<H5S_SELECT_INVALID)) + HGOTO_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "invalid selection operation"); - /* Elements in the fastest dimension are 'elem_size' */ - slab[ndims-1]=elem_size; + /* Copy the first dataspace */ + if (NULL==(new_space=H5S_copy (space))) + HGOTO_ERROR (H5E_DATASPACE, H5E_CANTINIT, NULL, "unable to copy data space"); - /* If we have two or more dimensions, build the other dimension's element sizes */ - if(ndims>=2) { - /* Build the table of next-dimension down 'element' sizes */ - for(i=ndims-2; i>=0; i--) - slab[i]=slab[i+1]*space->extent.u.simple.size[i+1]; - } /* end if */ + /* Go modify the selection in the new dataspace */ + if (H5S_select_hyperslab(new_space, op, start, stride, count, block)<0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to set hyperslab selection"); - /* Build the tables of count & block sizes as well as the initial offset */ - for(u=0; u<ndims; u++) { - tmp_count[u]=diminfo[u].count; - tmp_block[u]=diminfo[u].block; - offset[u]=diminfo[u].start; - } /* end for */ + /* Atomize */ + if ((ret_value=H5I_register (H5I_DATASPACE, new_space))<0) + HGOTO_ERROR (H5E_ATOM, H5E_CANTREGISTER, FAIL, "unable to register dataspace atom"); - /* Initialize the starting location */ - for(loc=buf,u=0; u<ndims; u++) - loc+=diminfo[u].start*slab[u]; +done: + if (ret_value<0 && new_space) + H5S_close(new_space); - /* Go iterate over the hyperslabs */ - while(user_ret==0) { - /* Iterate over the blocks in the fastest dimension */ - while(tmp_count[fast_dim]>0 && user_ret==0) { + FUNC_LEAVE (ret_value); +} /* end H5Scombine_hyperslab() */ - /* Iterate over the elements in the fastest dimension */ - while(tmp_block[fast_dim]>0 && user_ret==0) { - user_ret=(*op)(loc,type_id,(hsize_t)ndims,offset,op_data); + +/*------------------------------------------------------------------------- + * Function: H5S_combine_select + * + * Purpose: Internal version of H5Scombine_select(). + * + * Return: New dataspace on success/NULL on failure + * + * Programmer: Quincey Koziol + * Tuesday, October 30, 2001 + * + * Modifications: + * + *------------------------------------------------------------------------- + */ +static H5S_t * +H5S_combine_select (H5S_t *space1, H5S_seloper_t op, H5S_t *space2) +{ + H5S_t *new_space=NULL; /* New dataspace generated */ + H5S_t *ret_value=NULL; /* return value */ - /* Increment the buffer location */ - loc+=slab[fast_dim]; + FUNC_ENTER (H5S_combine_select, NULL); - /* Increment the offset in the dataspace */ - offset[fast_dim]++; + /* Check args */ + assert(space1); + assert(space2); + assert(op>H5S_SELECT_NOOP && op<H5S_SELECT_INVALID); + + /* Copy the first dataspace */ + if (NULL==(new_space=H5S_copy (space1))) + HGOTO_ERROR (H5E_DATASPACE, H5E_CANTINIT, NULL, "unable to copy data space"); - /* Decrement the sequence count */ - tmp_block[fast_dim]--; - } /* end while */ + /* Combine space1 & space2, with the result in new_space */ + if(H5S_operate_hyperslab(new_space,space1->select.sel_info.hslab.span_lst,op,space2->select.sel_info.hslab.span_lst)<0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCLIP, NULL, "can't clip hyperslab information"); - /* Reset the sequence count */ - tmp_block[fast_dim]=diminfo[fast_dim].block; + /* Set the return value */ + ret_value=new_space; - /* Move the location to the next sequence to start */ - loc+=(diminfo[fast_dim].stride-diminfo[fast_dim].block)*slab[fast_dim]; - - /* Move the offset to the next sequence to start */ - offset[fast_dim]+=(diminfo[fast_dim].stride-diminfo[fast_dim].block); +done: + if(ret_value==NULL && new_space!=NULL) + H5S_close(new_space); - /* Decrement the block count */ - tmp_count[fast_dim]--; - } /* end while */ + FUNC_LEAVE (ret_value); +} /* end H5S_combine_select() */ - /* Check for getting out of iterator, we're done in the 1-D case */ - if(ndims==1) - goto done; /* Yes, an evil goto.. :-) -QAK */ + +/*-------------------------------------------------------------------------- + NAME + H5Scombine_select + PURPOSE + Combine two hyperslab selections with an operation, returning a dataspace + with the resulting selection. + USAGE + hid_t H5Scombine_select(space1, op, space2) + hid_t space1; IN: First Dataspace ID + H5S_seloper_t op; IN: Selection operation + hid_t space2; IN: Second Dataspace ID + RETURNS + Dataspace ID on success/Negative on failure + DESCRIPTION + Combine two existing hyperslab selections with an operation, returning + a new dataspace with the resulting selection. The dataspace extent from + space1 is copied for the dataspace extent of the newly created dataspace. + GLOBAL VARIABLES + COMMENTS, BUGS, ASSUMPTIONS + EXAMPLES + REVISION LOG +--------------------------------------------------------------------------*/ +hid_t +H5Scombine_select(hid_t space1_id, H5S_seloper_t op, hid_t space2_id) +{ + H5S_t *space1; /* First Dataspace */ + H5S_t *space2; /* Second Dataspace */ + H5S_t *new_space = NULL; /* New Dataspace */ + hid_t ret_value = FAIL; - /* Work on other dimensions if necessary */ - if(fast_dim>0 && user_ret==0) { - /* Reset the sequence and block counts */ - tmp_block[fast_dim]=diminfo[fast_dim].block; - tmp_count[fast_dim]=diminfo[fast_dim].count; + FUNC_ENTER (H5Scombine_select, FAIL); + H5TRACE3("e","iSsi",space1_id,op,space2_id); - /* Bubble up the decrement to the slower changing dimensions */ - temp_dim=fast_dim-1; - while(temp_dim>=0) { - /* Decrement the sequence count in this dimension */ - tmp_block[temp_dim]--; + /* Check args */ + if (H5I_DATASPACE != H5I_get_type(space1_id) || + NULL == (space1=H5I_object(space1_id))) { + HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space"); + } + if (H5I_DATASPACE != H5I_get_type(space2_id) || + NULL == (space2=H5I_object(space2_id))) { + HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space"); + } + if(!(op>H5S_SELECT_NOOP && op<H5S_SELECT_INVALID)) + HRETURN_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "invalid selection operation"); - /* Check if we are still in the sequence */ - if(tmp_block[temp_dim]>0) - break; + /* Check that both dataspaces have the same rank */ + if(space1->extent.u.simple.rank!=space2->extent.u.simple.rank) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "dataspaces not same rank"); - /* Reset the sequence count in this dimension */ - tmp_block[temp_dim]=diminfo[temp_dim].block; + /* Check that both dataspaces have hyperslab selections */ + if(space1->select.type!=H5S_SEL_HYPERSLABS || space2->select.type!=H5S_SEL_HYPERSLABS) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "dataspaces don't have hyperslab selections"); - /* Decrement the block count */ - tmp_count[temp_dim]--; + /* Go combine the dataspaces */ + if ((new_space=H5S_combine_select(space1, op, space2))==NULL) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to create hyperslab selection"); - /* Check if we have more blocks left */ - if(tmp_count[temp_dim]>0) - break; + /* Atomize */ + if ((ret_value=H5I_register (H5I_DATASPACE, new_space))<0) + HGOTO_ERROR (H5E_ATOM, H5E_CANTREGISTER, FAIL, "unable to register dataspace atom"); - /* Check for getting out of iterator */ - if(temp_dim==0) - goto done; /* Yes, an evil goto.. :-) -QAK */ +done: + if (ret_value<0 && new_space) + H5S_close(new_space); - /* Reset the block count in this dimension */ - tmp_count[temp_dim]=diminfo[temp_dim].count; - - /* Wrapped a dimension, go up to next dimension */ - temp_dim--; - } /* end while */ - } /* end if */ + FUNC_LEAVE (ret_value); +} /* end H5Scombine_select() */ - /* Re-compute buffer location & offset array */ - for(loc=buf,u=0; u<ndims; u++) { - temp_off=diminfo[u].start - +diminfo[u].stride*(diminfo[u].count-tmp_count[u]) - +(diminfo[u].block-tmp_block[u]); - loc+=temp_off*slab[u]; - offset[u]=temp_off; - } /* end for */ - } /* end while */ + +/*------------------------------------------------------------------------- + * Function: H5S_select_select + * + * Purpose: Internal version of H5Sselect_select(). + * + * Return: New dataspace on success/NULL on failure + * + * Programmer: Quincey Koziol + * Tuesday, October 30, 2001 + * + * Modifications: + * + *------------------------------------------------------------------------- + */ +static herr_t +H5S_select_select (H5S_t *space1, H5S_seloper_t op, H5S_t *space2) +{ + H5S_hyper_span_info_t *tmp_spans=NULL; /* Temporary copy of selection */ + herr_t ret_value=FAIL; /* return value */ + + FUNC_ENTER (H5S_select_select, FAIL); + + /* Check args */ + assert(space1); + assert(space2); + assert(op>H5S_SELECT_NOOP && op<H5S_SELECT_INVALID); + + /* Copy the first dataspace */ + if (NULL==(tmp_spans=H5S_hyper_copy_span(space1->select.sel_info.hslab.span_lst))) + HGOTO_ERROR (H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to copy data space"); + + /* Combine tmp_spans (from space1) & spans from space2, with the result in space1 */ + if(H5S_operate_hyperslab(space1,tmp_spans,op,space2->select.sel_info.hslab.span_lst)<0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCLIP, FAIL, "can't clip hyperslab information"); + + /* Set the return value */ + ret_value=SUCCEED; done: - FUNC_LEAVE (user_ret); -} /* end H5S_hyper_select_iterate_mem_opt() */ + if(tmp_spans!=NULL) + H5S_hyper_free_span_info(tmp_spans); + + FUNC_LEAVE (ret_value); +} /* end H5S_select_select() */ /*-------------------------------------------------------------------------- NAME - H5S_hyper_select_iterate + H5Sselect_select PURPOSE - Iterate over a hyperslab selection, calling a user's function for each - element. + Refine a hyperslab selection with an operation using a second hyperslab + to modify it. USAGE - herr_t H5S_hyper_select_iterate(buf, type_id, space, op, operator_data) - void *buf; IN/OUT: Buffer containing elements to iterate over - hid_t type_id; IN: Datatype ID of BUF array. - H5S_t *space; IN: Dataspace object containing selection to iterate over - H5D_operator_t op; IN: Function pointer to the routine to be - called for each element in BUF iterated over. - void *operator_data; IN/OUT: Pointer to any user-defined data - associated with the operation. + herr_t H5Sselect_select(space1, op, space2) + hid_t space1; IN/OUT: First Dataspace ID + H5S_seloper_t op; IN: Selection operation + hid_t space2; IN: Second Dataspace ID RETURNS - Returns the return value of the last operator if it was non-zero, or zero - if all elements were processed. Otherwise returns a negative value. + Non-negative on success/Negative on failure DESCRIPTION - Iterates over the selected elements in a memory buffer, calling the user's - callback function for each element. The selection in the dataspace is - modified so that any elements already iterated over are removed from the - selection if the iteration is interrupted (by the H5D_operator_t function - returning non-zero) in the "middle" of the iteration and may be re-started - by the user where it left off. - - NOTE: Until "subtracting" elements from a selection is implemented, - the selection is not modified. + Refine an existing hyperslab selection with an operation, using a second + hyperslab. The first selection is modified to contain the result of + space1 operated on by space2. GLOBAL VARIABLES COMMENTS, BUGS, ASSUMPTIONS EXAMPLES REVISION LOG --------------------------------------------------------------------------*/ herr_t -H5S_hyper_select_iterate(void *buf, hid_t type_id, H5S_t *space, H5D_operator_t op, - void *operator_data) +H5Sselect_select(hid_t space1_id, H5S_seloper_t op, hid_t space2_id) { - H5S_hyper_iter_info_t iter_info; /* Block of parameters to pass into recursive calls */ - H5S_sel_iter_t iter; /* selection iteration info*/ - herr_t ret_value=FAIL; /* return value */ - - FUNC_ENTER (H5S_hyper_select_iterate, FAIL); - - assert(buf); - assert(space); - assert(op); - assert(H5I_DATATYPE == H5I_get_type(type_id)); + H5S_t *space1; /* First Dataspace */ + H5S_t *space2; /* Second Dataspace */ + hid_t ret_value = FAIL; - /* Initialize the selection iterator */ - if (H5S_hyper_init(space, &iter)<0) { - HGOTO_ERROR (H5E_DATASPACE, H5E_CANTINIT, FAIL, - "unable to initialize selection information"); - } + FUNC_ENTER (H5Sselect_select, FAIL); + H5TRACE3("e","iSsi",space1_id,op,space2_id); - /* Check for the special case of just one H5Sselect_hyperslab call made */ - if(space->select.sel_info.hslab.diminfo!=NULL) { - /* Use optimized call to iterate over regular hyperslab */ - ret_value=H5S_hyper_select_iterate_mem_opt(&iter,buf,type_id,space,op,operator_data); + /* Check args */ + if (H5I_DATASPACE != H5I_get_type(space1_id) || + NULL == (space1=H5I_object(space1_id))) { + HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space"); } - else { - /* Initialize parameter block for recursive calls */ - iter_info.dt=type_id; - iter_info.elem_size=H5Tget_size(type_id); - iter_info.space=space; - iter_info.iter=&iter; - iter_info.src=buf; + if (H5I_DATASPACE != H5I_get_type(space2_id) || + NULL == (space2=H5I_object(space2_id))) { + HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space"); + } + if(!(op>H5S_SELECT_NOOP && op<H5S_SELECT_INVALID)) + HRETURN_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "invalid selection operation"); - /* Set up the size of the memory space */ - HDmemcpy(iter_info.mem_size, space->extent.u.simple.size, space->extent.u.simple.rank*sizeof(hsize_t)); - iter_info.mem_size[space->extent.u.simple.rank]=iter_info.elem_size; + /* Check that both dataspaces have the same rank */ + if(space1->extent.u.simple.rank!=space2->extent.u.simple.rank) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "dataspaces not same rank"); - /* Copy the location of the region in the file */ - iter_info.op=op; - iter_info.op_data=operator_data; + /* Check that both dataspaces have hyperslab selections */ + if(space1->select.type!=H5S_SEL_HYPERSLABS || space2->select.type!=H5S_SEL_HYPERSLABS) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "dataspaces don't have hyperslab selections"); - /* Recursively input the hyperslabs currently defined */ - /* starting with the slowest changing dimension */ - ret_value=H5S_hyper_select_iterate_mem(-1,&iter_info); - } /* end else */ + /* Go refine the first selection */ + if (H5S_select_select(space1, op, space2)<0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to modify hyperslab selection"); - /* Release selection iterator */ - H5S_sel_iter_release(space,&iter); + /* Set the return value */ + ret_value=SUCCEED; done: FUNC_LEAVE (ret_value); -} /* H5S_hyper_select_iterate() */ - +} /* end H5Sselect_select() */ +#endif /* OLD_WAY */ /* Works */ |