diff options
Diffstat (limited to 'src/H5V.c')
-rw-r--r-- | src/H5V.c | 546 |
1 files changed, 267 insertions, 279 deletions
@@ -1,9 +1,9 @@ /* * Copyright (C) 1997 NCSA - * All rights reserved. + * All rights reserved. * * Programmer: Robb Matzke <matzke@llnl.gov> - * Friday, October 10, 1997 + * Friday, October 10, 1997 */ #include <H5private.h> @@ -12,41 +12,36 @@ #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); +#define PABLO_MASK H5V_mask +static hbool_t interface_initialize_g = TRUE; +#define INTERFACE_INIT NULL + /*------------------------------------------------------------------------- - * Function: H5V_stride_optimize1 + * 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. + * 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. + * All arguments are passed by reference and their values may be + * modified by this function. * - * Return: Success: SUCCEED + * Return: Success: SUCCEED * - * Failure: FAIL + * Failure: FAIL * - * Programmer: Robb Matzke - * Saturday, October 11, 1997 + * Programmer: Robb Matzke + * Saturday, October 11, 1997 * * Modifications: * *------------------------------------------------------------------------- */ -static herr_t +herr_t H5V_stride_optimize1(size_t *np, size_t *elmt_size, size_t *size, - intn *stride1) + intn *stride1) { FUNC_ENTER(H5V_stride_optimize1, FAIL); @@ -60,41 +55,40 @@ H5V_stride_optimize1(size_t *np, size_t *elmt_size, size_t *size, * 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]; - } + *elmt_size *= size[*np - 1]; + if (--*np) { + stride1[*np - 1] += size[*np] * stride1[*np]; + } } FUNC_LEAVE(SUCCEED); } /*------------------------------------------------------------------------- - * Function: H5V_stride_optimize2 + * 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. + * 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. + * All arguments are passed by reference and their values may be + * modified by this function. * - * Return: Success: SUCCEED + * Return: Success: SUCCEED * - * Failure: FAIL + * Failure: FAIL * - * Programmer: Robb Matzke - * Saturday, October 11, 1997 + * Programmer: Robb Matzke + * Saturday, October 11, 1997 * * Modifications: * *------------------------------------------------------------------------- */ -static herr_t +herr_t H5V_stride_optimize2(size_t *np, size_t *elmt_size, size_t *size, - intn *stride1, intn *stride2) + intn *stride1, intn *stride2) { FUNC_ENTER(H5V_stride_optimize2, FAIL); @@ -107,37 +101,42 @@ H5V_stride_optimize2(size_t *np, size_t *elmt_size, size_t *size, /* * 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]; - } + 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 + * 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. * - * 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 dimensionality of the whole array, the hyperslab, and the + * returned stride array is N. The whole array dimensions are + * TOTAL_SIZE and the hyperslab is at offset OFFSET and has + * dimensions SIZE. * - * The stride and starting point returned will cause the - * hyperslab elements to be referenced in C order. + * 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. + * Return: Success: Byte offset from beginning of array to start + * of striding. * - * Failure: abort() -- should never fail + * Failure: abort() -- should never fail * - * Programmer: Robb Matzke - * Saturday, October 11, 1997 + * Programmer: Robb Matzke + * Saturday, October 11, 1997 * * Modifications: * @@ -145,12 +144,12 @@ H5V_stride_optimize2(size_t *np, size_t *elmt_size, size_t *size, */ 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 */ ) + const size_t *total_size, const size_t *offset, + intn *stride/*out*/) { - size_t skip; /*starting point byte offset */ - size_t acc; /*accumulator */ - int i; /*counter */ + size_t skip; /*starting point byte offset */ + size_t acc; /*accumulator */ + int i; /*counter */ FUNC_ENTER(H5V_hyper_stride, (abort(), 0)); @@ -165,32 +164,32 @@ H5V_hyper_stride(size_t n, const size_t *size, /* 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); + 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 + * 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. + * 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) + * Return: Success: TRUE if the hyperslabs are equal (that is, + * both refer to exactly the same elements of an + * array) * - * FALSE otherwise. + * FALSE otherwise. * - * Failure: TRUE the rank is zero or if both hyperslabs - * are of zero size. + * Failure: TRUE the rank is zero or if both hyperslabs + * are of zero size. * - * Programmer: Robb Matzke - * Friday, October 17, 1997 + * Programmer: Robb Matzke + * Friday, October 17, 1997 * * Modifications: * @@ -198,43 +197,41 @@ H5V_hyper_stride(size_t n, const size_t *size, */ hbool_t H5V_hyper_eq(size_t n, - const size_t *offset1, const size_t *size1, - const size_t *offset2, const size_t *size2) + const size_t *offset1, const size_t *size1, + const size_t *offset2, const size_t *size2) { - size_t nelmts1 = 1, nelmts2 = 1; - intn i; + size_t nelmts1 = 1, nelmts2 = 1; + intn i; if (n <= 0) - return TRUE; + 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; + 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 + * Function: H5V_hyper_disjointp * - * Purpose: Determines if two hyperslabs are disjoint. + * Purpose: Determines if two hyperslabs are disjoint. * - * Return: Success: FALSE if they are not disjoint. - * TRUE if they 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. + * Failure: A hyperslab of zero size is disjoint from all + * other hyperslabs. * - * Programmer: Robb Matzke - * Thursday, October 16, 1997 + * Programmer: Robb Matzke + * Thursday, October 16, 1997 * * Modifications: * @@ -242,45 +239,43 @@ H5V_hyper_eq(size_t n, */ hbool_t H5V_hyper_disjointp(size_t n, - const size_t *offset1, const size_t *size1, - const size_t *offset2, const size_t *size2) + const size_t *offset1, const size_t *size1, + const size_t *offset2, const size_t *size2) { - intn i; + intn i; - if (!n || !size1 || !size2) - return TRUE; + 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; - } + 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 + * Function: H5V_hyper_fill * - * Purpose: Similar to memset() except it operates on hyperslabs... + * 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 + * 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 + * Failure: FAIL * - * Programmer: Robb Matzke - * Friday, October 10, 1997 + * Programmer: Robb Matzke + * Friday, October 10, 1997 * * Modifications: * @@ -288,17 +283,17 @@ H5V_hyper_disjointp(size_t n, */ 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) + 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 */ + 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; + int i; #endif FUNC_ENTER(H5V_hyper_fill, FAIL); @@ -310,8 +305,8 @@ H5V_hyper_fill(size_t n, const size_t *_size, assert(dst); #ifndef NDEBUG for (i = 0; i < n; i++) { - assert(_size[i] > 0); - assert(total_size[i] > 0); + assert(_size[i] > 0); + assert(total_size[i] > 0); } #endif @@ -324,39 +319,39 @@ H5V_hyper_fill(size_t n, const size_t *_size, /* Copy */ status = H5V_stride_fill(n, elmt_size, size, dst_stride, dst + dst_start, - fill_value); + fill_value); FUNC_LEAVE(status); } /*------------------------------------------------------------------------- - * Function: H5V_hyper_copy + * Function: H5V_hyper_copy * - * Purpose: Copies a hyperslab from the source to the destination. + * 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). + * 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. + * 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 + * Return: Success: SUCCEED * - * Failure: FAIL + * Failure: FAIL * - * Programmer: Robb Matzke - * Friday, October 10, 1997 + * Programmer: Robb Matzke + * Friday, October 10, 1997 * * Modifications: * @@ -365,24 +360,24 @@ H5V_hyper_fill(size_t n, const size_t *_size, 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, + /*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) + /*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; + 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); @@ -396,9 +391,9 @@ H5V_hyper_copy(size_t n, const size_t *_size, assert(src); #ifndef NDEBUG for (i = 0; i < n; i++) { - assert(_size[i] > 0); - assert(dst_size[i] > 0); - assert(src_size[i] > 0); + assert(_size[i] > 0); + assert(dst_size[i] > 0); + assert(src_size[i] > 0); } #endif @@ -414,24 +409,24 @@ H5V_hyper_copy(size_t n, const size_t *_size, /* 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); + dst_stride, dst + dst_start, + src_stride, src + src_start); FUNC_LEAVE(status); } /*------------------------------------------------------------------------- - * Function: H5V_stride_fill + * Function: H5V_stride_fill * - * Purpose: Fills all bytes of a hyperslab with the same value using - * memset(). + * Purpose: Fills all bytes of a hyperslab with the same value using + * memset(). * - * Return: Success: SUCCEED + * Return: Success: SUCCEED * - * Failure: FAIL + * Failure: FAIL * - * Programmer: Robb Matzke - * Saturday, October 11, 1997 + * Programmer: Robb Matzke + * Saturday, October 11, 1997 * * Modifications: * @@ -439,13 +434,13 @@ H5V_hyper_copy(size_t n, const size_t *_size, */ herr_t H5V_stride_fill(size_t n, size_t elmt_size, const size_t *size, - const intn *stride, void *_dst, uint8 fill_value) + 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 */ + 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); @@ -453,41 +448,41 @@ H5V_stride_fill(size_t n, size_t elmt_size, const size_t *size, nelmts = H5V_vector_reduce_product(n, size); for (i = 0; i < nelmts; i++) { - /* Copy an element */ - HDmemset(dst, fill_value, elmt_size); + /* 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]; + /* 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]; - } + if (--idx[j]) + carry = FALSE; + else + idx[j] = size[j]; + } } FUNC_LEAVE(SUCCEED); } /*------------------------------------------------------------------------- - * Function: H5V_stride_copy + * 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. + * 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. + * 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 + * Return: Success: SUCCEED * - * Failure: FAIL + * Failure: FAIL * - * Programmer: Robb Matzke - * Saturday, October 11, 1997 + * Programmer: Robb Matzke + * Saturday, October 11, 1997 * * Modifications: * @@ -495,16 +490,15 @@ H5V_stride_fill(size_t n, size_t elmt_size, const size_t *size, */ 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) + 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 */ + 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); @@ -512,38 +506,36 @@ H5V_stride_copy(size_t n, size_t elmt_size, const size_t *size, nelmts = H5V_vector_reduce_product(n, size); for (i = 0; i < nelmts; i++) { - /* Copy an element */ - HDmemcpy(dst, src, elmt_size); + /* 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]; + /* 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]; - } + if (--idx[j]) carry = FALSE; + else idx[j] = size[j]; + } } FUNC_LEAVE(SUCCEED); } /*------------------------------------------------------------------------- - * Function: H5V_stride_copy2 + * 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. + * 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 + * Return: Success: SUCCEED * - * Failure: FAIL + * Failure: FAIL * - * Programmer: Robb Matzke - * Saturday, October 11, 1997 + * Programmer: Robb Matzke + * Saturday, October 11, 1997 * * Modifications: * @@ -552,20 +544,20 @@ H5V_stride_copy(size_t n, size_t elmt_size, const size_t *size, 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, + /* 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) + /* 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; + 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); @@ -574,24 +566,20 @@ H5V_stride_copy2(size_t nelmts, size_t elmt_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]; - } + /* 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); |