path: root/src/H5V.c

/*
 * Copyright (C) 1997 NCSA
 *                    All rights reserved.
 *
 * Programmer: Robb Matzke <matzke@llnl.gov>
 *             Friday, October 10, 1997
 */

#include <H5private.h>
#include <H5Eprivate.h>
#include <H5Oprivate.h>
#include <H5Vprivate.h>

#define H5V_HYPER_NDIMS	H5O_LAYOUT_NDIMS
#define PABLO_MASK	H5V_mask
static hbool_t		interface_initialize_g = TRUE;
#define INTERFACE_INIT	NULL

static herr_t H5V_stride_optimize1 (size_t *np, size_t *elmt_size,
				    size_t *size, intn *stride1);
static herr_t H5V_stride_optimize2 (size_t *np, size_t *elmt_size,
				    size_t *size, intn *stride1,
				    intn *stride2);


/*-------------------------------------------------------------------------
 * Function:	H5V_stride_optimize1
 *
 * Purpose:	Given a stride vector which references elements of the
 *		specified size, optimize the dimensionality, the stride
 *		vector, and the element size to minimize the dimensionality
 *		and the number of memory accesses.
 *
 *		All arguments are passed by reference and their values may be
 *		modified by this function.
 *
 * Return:	Success:	SUCCEED
 *
 *		Failure:	FAIL
 *
 * Programmer:	Robb Matzke
 *              Saturday, October 11, 1997
 *
 * Modifications:
 *
 *-------------------------------------------------------------------------
 */
static herr_t
H5V_stride_optimize1 (size_t *np, size_t *elmt_size, size_t *size, 
		      intn *stride1)
{
   FUNC_ENTER (H5V_stride_optimize1, FAIL);
   
   /*
    * This has to be true because if we optimize the dimensionality down to
    * zero we still must make one reference.
    */
   assert (1==H5V_vector_reduce_product (0, (void*)1));

   /*
    * Combine adjacent memory accesses
    */
   while (*np && stride1[*np-1]==*elmt_size) {
      
      *elmt_size *= size[*np-1];
      if (--*np) {
	 stride1[*np-1] += size[*np] * stride1[*np];
      }
   }

   FUNC_LEAVE (SUCCEED);
}


/*-------------------------------------------------------------------------
 * Function:	H5V_stride_optimize2
 *
 * Purpose:	Given two stride vectors which reference elements of the
 *		specified size, optimize the dimensionality, the stride
 *		vectors, and the element size to minimize the dimensionality
 *		and the number of memory accesses.
 *
 *		All arguments are passed by reference and their values may be
 *		modified by this function.
 *
 * Return:	Success:	SUCCEED
 *
 *		Failure:	FAIL
 *
 * Programmer:	Robb Matzke
 *              Saturday, October 11, 1997
 *
 * Modifications:
 *
 *-------------------------------------------------------------------------
 */
static herr_t
H5V_stride_optimize2 (size_t *np, size_t *elmt_size, size_t *size, 
		      intn *stride1, intn *stride2)
{
   FUNC_ENTER (H5V_stride_optimize2, FAIL);
   
   /*
    * This has to be true because if we optimize the dimensionality down to
    * zero we still must make one reference.
    */
   assert (1==H5V_vector_reduce_product (0, (void*)1));

   /*
    * Combine adjacent memory accesses
    */
   while (*np && stride1[*np-1]==*elmt_size && stride2[*np-1]==*elmt_size) {
      
      *elmt_size *= size[*np-1];
      if (--*np) {
	 stride1[*np-1] += size[*np] * stride1[*np];
	 stride2[*np-1] += size[*np] * stride2[*np];
      }
   }

   FUNC_LEAVE (SUCCEED);
}


/*-------------------------------------------------------------------------
 * Function:	H5V_hyper_stride
 *
 * Purpose:	Given a description of a hyperslab, this function returns
 *		(through STRIDE[]) the byte strides appropriate for accessing
 *		all bytes of the hyperslab and the byte offset where the
 *		striding will begin.  The SIZE can be passed to the various
 *		stride functions.
 *
 *		The stride and starting point returned will cause the
 *		hyperslab elements to be referenced in C order.
 *
 * Return:	Success:	Byte offset from beginning of array to start
 *				of striding.
 *
 *		Failure:	abort() -- should never fail
 *
 * Programmer:	Robb Matzke
 *              Saturday, October 11, 1997
 *
 * Modifications:
 *
 *-------------------------------------------------------------------------
 */
size_t
H5V_hyper_stride (size_t n, const size_t *size,
		  const size_t *total_size, const size_t *offset,
		  intn *stride /*output arg*/)
{
   size_t	skip;		/*starting point byte offset		*/
   size_t	acc;		/*accumulator				*/
   int		i;		/*counter				*/
   
   FUNC_ENTER (H5V_hyper_stride, (abort(),0));

   assert (n>=0 && n<H5V_HYPER_NDIMS);
   assert (size);
   assert (total_size);
   assert (stride);

   /* init */
   stride[n-1] = 1;
   skip = offset?offset[n-1]:0;

   /* others */
   for (i=n-2,acc=1; i>=0; --i) {
      stride[i] = acc * (total_size[i+1] - size[i+1]);
      acc *= total_size[i+1];
      skip += acc * (offset?offset[i]:0);
   }

   FUNC_LEAVE (skip);
}



/*-------------------------------------------------------------------------
 * Function:	H5V_hyper_eq
 *
 * Purpose:	Determines whether two hyperslabs are equal.  This function
 *		assumes that both hyperslabs are relative to the same array,
 *		for if not, they could not possibly be equal.
 *
 * Return:	Success:	TRUE if the hyperslabs are equal (that is,
 *				both refer to exactly the same elements of an
 *				array)
 *
 * 				FALSE otherwise.
 *
 *		Failure:	TRUE the rank is zero or if both hyperslabs
 *				are of zero size.
 *
 * Programmer:	Robb Matzke
 *              Friday, October 17, 1997
 *
 * Modifications:
 *
 *-------------------------------------------------------------------------
 */
hbool_t
H5V_hyper_eq (size_t n,
	      const size_t *offset1, const size_t *size1,
	      const size_t *offset2, const size_t *size2)
{
   size_t	nelmts1=1, nelmts2=1;
   intn		i;
   
   if (n<=0) return TRUE;

   for (i=0; i<n; i++) {
      if ((offset1?offset1[i]:0)!=(offset2?offset2[i]:0)) {
	 return FALSE;
      }
      if ((size1?size1[i]:0)!=(size2?size2[i]:0)) {
	 return FALSE;
      }
      if (0==(nelmts1*=(size1?size1[i]:0))) return FALSE;
      if (0==(nelmts2*=(size2?size2[i]:0))) return FALSE;
   }
   return TRUE;
}


/*-------------------------------------------------------------------------
 * Function:	H5V_hyper_disjointp
 *
 * Purpose:	Determines if two hyperslabs are disjoint.
 *
 * Return:	Success:	FALSE if they are not disjoint.
 *				TRUE if they are disjoint.
 *
 *		Failure:	A hyperslab of zero size is disjoint from all
 *				other hyperslabs.
 *
 * Programmer:	Robb Matzke
 *              Thursday, October 16, 1997
 *
 * Modifications:
 *
 *-------------------------------------------------------------------------
 */
hbool_t
H5V_hyper_disjointp (size_t n,
		     const size_t *offset1, const size_t *size1,
		     const size_t *offset2, const size_t *size2)
{
   intn		i;

   if (!n || !size1 || !size2) return TRUE;

   for (i=0; i<n; i++) {
      if (0==size1[i] || 0==size2[i]) return TRUE;
      if (((offset1?offset1[i]:0)<(offset2?offset2[i]:0) &&
	   (offset1?offset1[i]:0)+size1[i]<=(offset2?offset2[i]:0)) ||
	  ((offset2?offset2[i]:0)<(offset1?offset1[i]:0) &&
	   (offset2?offset2[i]:0)+size2[i]<=(offset1?offset1[i]:0))) {
	 return TRUE;
      }
   }
   return FALSE;
}


/*-------------------------------------------------------------------------
 * Function:	H5V_hyper_fill
 *
 * Purpose:	Similar to memset() except it operates on hyperslabs...
 *
 * 		Fills a hyperslab of array BUF with some value VAL.  BUF
 *		is treated like a C-order array with N dimensions where the
 *		size of each dimension is TOTAL_SIZE[].  The hyperslab which
 *		will be filled with VAL begins at byte offset OFFSET[] from
 *		the minimum corner of BUF and continues for SIZE[] bytes in
 *		each dimension.
 *		
 * Return:	Success:	SUCCEED
 *
 *		Failure:	FAIL
 *
 * Programmer:	Robb Matzke
 *              Friday, October 10, 1997
 *
 * Modifications:
 *
 *-------------------------------------------------------------------------
 */
herr_t
H5V_hyper_fill (size_t n, const size_t *_size,
		const size_t *total_size, const size_t *offset, void *_dst,
		uint8 fill_value)
{
   uint8	*dst = (uint8 *)_dst;	/*cast for ptr arithmetic	*/
   size_t	size[H5V_HYPER_NDIMS];	/*a modifiable copy of _size	*/
   intn		dst_stride[H5V_HYPER_NDIMS]; /*destination stride info	*/
   size_t	dst_start;		/*byte offset to start of stride*/
   size_t	elmt_size=1;		/*bytes per element		*/
   herr_t	status;			/*function return status	*/
#ifndef NDEBUG
   int		i;
#endif

   FUNC_ENTER (H5V_hyper_fill, FAIL);

   /* check args */
   assert (n>0 && n<=H5V_HYPER_NDIMS);
   assert (_size);
   assert (total_size);
   assert (dst);
#ifndef NDEBUG
   for (i=0; i<n; i++) {
      assert (_size[i]>0);
      assert (total_size[i]>0);
   }
#endif

   /* Copy the size vector so we can modify it */
   H5V_vector_cpy (n, size, _size);

   /* Compute an optimal destination stride vector */
   dst_start = H5V_hyper_stride (n, size, total_size, offset, dst_stride);
   H5V_stride_optimize1 (&n, &elmt_size, size, dst_stride);

   /* Copy */
   status = H5V_stride_fill (n, elmt_size, size, dst_stride, dst+dst_start,
			     fill_value);

   FUNC_LEAVE (status);
}



/*-------------------------------------------------------------------------
 * Function:	H5V_hyper_copy
 *
 * Purpose:	Copies a hyperslab from the source to the destination.
 *
 *		A hyperslab is a logically contiguous region of
 *		multi-dimensional size SIZE of an array whose dimensionality
 *		is N and whose total size is DST_TOTAL_SIZE or SRC_TOTAL_SIZE.
 *		The minimum corner of the hyperslab begins at a
 *		multi-dimensional offset from the minimum corner of the DST
 *		(destination) or SRC (source) array.  The sizes and offsets
 *		are assumed to be in C order, that is, the first size/offset
 *		varies the slowest while the last varies the fastest in the
 *		mapping from N-dimensional space to linear space.  This
 *		function assumes that the array elements are single bytes (if
 *		your array has multi-byte elements then add an additional
 *		dimension whose size is that of your element).
 *
 *		The SRC and DST array may be the same array, but the results
 *		are undefined if the source hyperslab overlaps the
 *		destination hyperslab.
 *
 * Return:	Success:	SUCCEED
 *
 *		Failure:	FAIL
 *
 * Programmer:	Robb Matzke
 *              Friday, October 10, 1997
 *
 * Modifications:
 *
 *-------------------------------------------------------------------------
 */
herr_t
H5V_hyper_copy (size_t n, const size_t *_size, 

		/*destination*/
		const size_t *dst_size, const size_t *dst_offset,
		void *_dst,
		
		/*source*/
		const size_t *src_size, const size_t *src_offset,
		const void *_src)
{
   const uint8	*src = (const uint8 *)_src;	/*cast for ptr arithmtc	*/
   uint8	*dst = (uint8 *)_dst;		/*cast for ptr arithmtc	*/
   size_t	size[H5V_HYPER_NDIMS];		/*a modifiable _size	*/
   intn		src_stride[H5V_HYPER_NDIMS];	/*source stride info	*/
   intn		dst_stride[H5V_HYPER_NDIMS];	/*dest stride info	*/
   size_t	dst_start, src_start;		/*offset to start at	*/
   size_t	elmt_size=1;			/*element size in bytes	*/
   herr_t	status;				/*return status		*/
#ifndef NDEBUG
   intn		i;
#endif

   FUNC_ENTER (H5V_hyper_copy, FAIL);

   /* check args */
   assert (n>0 && n<=H5V_HYPER_NDIMS);
   assert (_size);
   assert (dst_size);
   assert (src_size);
   assert (dst);
   assert (src);
#ifndef NDEBUG
   for (i=0; i<n; i++) {
      assert (_size[i]>0);
      assert (dst_size[i]>0);
      assert (src_size[i]>0);
   }
#endif

   /* Copy the size vector so we can modify it */
   H5V_vector_cpy (n, size, _size);

   /* Compute stride vectors for source and destination */
   dst_start = H5V_hyper_stride (n, size, dst_size, dst_offset, dst_stride);
   src_start = H5V_hyper_stride (n, size, src_size, src_offset, src_stride);

   /* Optimize the strides as a pair */
   H5V_stride_optimize2 (&n, &elmt_size, size, dst_stride, src_stride);

   /* Perform the copy in terms of stride */
   status = H5V_stride_copy (n, elmt_size, size,
			     dst_stride, dst+dst_start,
			     src_stride, src+src_start);

   FUNC_LEAVE (status);
}


/*-------------------------------------------------------------------------
 * Function:	H5V_stride_fill
 *
 * Purpose:	Fills all bytes of a hyperslab with the same value using
 *		memset().
 *
 * Return:	Success:	SUCCEED
 *
 *		Failure:	FAIL
 *
 * Programmer:	Robb Matzke
 *              Saturday, October 11, 1997
 *
 * Modifications:
 *
 *-------------------------------------------------------------------------
 */
herr_t
H5V_stride_fill (size_t n, size_t elmt_size, const size_t *size,
		 const intn *stride, void *_dst, uint8 fill_value)
{
   uint8	*dst = (uint8 *)_dst;	/*cast for ptr arithmetic	*/
   size_t	idx[H5V_HYPER_NDIMS];	/*1-origin indices		*/
   size_t	nelmts;			/*number of elements to fill	*/
   intn		i, j;			/*counters			*/
   hbool_t	carry;			/*subtraction carray value	*/

   FUNC_ENTER (H5V_stride_fill, FAIL);

   H5V_vector_cpy (n, idx, size);
   nelmts = H5V_vector_reduce_product (n, size);
   for (i=0; i<nelmts; i++) {

      /* Copy an element */
      HDmemset (dst, fill_value, elmt_size);

      /* Decrement indices and advance pointer */
      for (j=n-1, carry=TRUE; j>=0 && carry; --j) {
	 dst += stride[j];
	 
	 if (--idx[j]) carry = FALSE;
	 else idx[j] = size[j];
      }
   }

   FUNC_LEAVE (SUCCEED);
}


/*-------------------------------------------------------------------------
 * Function:	H5V_stride_copy
 *
 * Purpose:	Uses DST_STRIDE and SRC_STRIDE to advance through the arrays
 *		DST and SRC while copying bytes from SRC to DST.  This
 *		function minimizes the number of calls to memcpy() by
 *		combining various strides, but it will never touch memory
 *		outside the hyperslab defined by the strides.
 *
 * Note:	If the src_stride is all zero and elmt_size is one, then it's
 *		probably more efficient to use H5V_stride_fill() instead.
 *
 * Return:	Success:	SUCCEED
 *
 *		Failure:	FAIL
 *
 * Programmer:	Robb Matzke
 *              Saturday, October 11, 1997
 *
 * Modifications:
 *
 *-------------------------------------------------------------------------
 */
herr_t
H5V_stride_copy (size_t n, size_t elmt_size, const size_t *size,
		 const intn *dst_stride, void *_dst,
		 const intn *src_stride, const void *_src)
{
   
   uint8	*dst = (uint8 *)_dst;		/*cast for ptr arithmetic*/
   const uint8	*src = (const uint8 *)_src;	/*cast for ptr arithmetic*/
   size_t	idx[H5V_HYPER_NDIMS];		/*1-origin indices	*/
   size_t	nelmts;				/*num elements to copy	*/
   intn		i, j;				/*counters		*/
   hbool_t	carry;				/*carray for subtraction*/

   FUNC_ENTER (H5V_stride_copy, FAIL);

   H5V_vector_cpy (n, idx, size);
   nelmts = H5V_vector_reduce_product (n, size);
   for (i=0; i<nelmts; i++) {

      /* Copy an element */
      HDmemcpy (dst, src, elmt_size);

      /* Decrement indices and advance pointers */
      for (j=n-1, carry=TRUE; j>=0 && carry; --j) {
	 src += src_stride[j];
	 dst += dst_stride[j];
	 
	 if (--idx[j]) carry = FALSE;
	 else idx[j] = size[j];
      }
   }

   FUNC_LEAVE (SUCCEED);
}



/*-------------------------------------------------------------------------
 * Function:	H5V_stride_copy2
 *
 * Purpose:	Similar to H5V_stride_copy() except the source and
 *		destination each have their own dimensionality and size and
 *		we copy exactly NELMTS elements each of size ELMT_SIZE.  The
 *		size counters wrap if NELMTS is more than a size counter.
 *
 * Return:	Success:	SUCCEED
 *
 *		Failure:	FAIL
 *
 * Programmer:	Robb Matzke
 *              Saturday, October 11, 1997
 *
 * Modifications:
 *
 *-------------------------------------------------------------------------
 */
herr_t
H5V_stride_copy2 (size_t nelmts, size_t elmt_size,

		  /* destination */
		  size_t dst_n, const size_t *dst_size, const intn *dst_stride,
		  void *_dst,

		  /* source */
		  size_t src_n, const size_t *src_size, const intn *src_stride,
		  const void *_src)
{
   uint8	*dst = (uint8 *)_dst;
   const uint8	*src = (const uint8 *)_src;
   size_t	dst_idx[H5V_HYPER_NDIMS];
   size_t	src_idx[H5V_HYPER_NDIMS];
   intn		i, j;
   hbool_t	carry;
   
   FUNC_ENTER (H5V_stride_copy2, FAIL);

   H5V_vector_cpy (dst_n, dst_idx, dst_size);
   H5V_vector_cpy (src_n, src_idx, src_size);

   for (i=0; i<nelmts; i++) {

      /* Copy an element */
      HDmemcpy (dst, src, elmt_size);

      /* Decrement indices and advance pointers */
      for (j=dst_n-1, carry=TRUE; j>=0 && carry; --j) {
	 dst += dst_stride[j];
	 if (--dst_idx[j]) carry = FALSE;
	 else dst_idx[j] = dst_size[j];
      }
      for (j=src_n-1, carry=TRUE; j>=0 && carry; --j) {
	 src += src_stride[j];
	 if (--src_idx[j]) carry = FALSE;
	 else src_idx[j] = src_size[j];
      }
   }

   FUNC_LEAVE (SUCCEED);
}