mirror/hdf5
2
0
Fork 0
mirror of https://github.com/HDFGroup/hdf5.git synced 2025-03-31 17:10:47 +08:00
Code Issues Packages Projects Releases Wiki Activity

Purges UFAIL from the library (#637)

Browse Source 
* Committing clang-format changes

* Purges UFAIL from the library

* H5HL_insert change requested in PR

Co-authored-by: github-actions <41898282+github-actions[bot]@users.noreply.github.com>
This commit is contained in:
Dana Robinson 2021-05-11 09:05:03 -07:00 committed by GitHub
parent 9023e98940
commit 7d140b97fb
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
17 changed files with 274 additions and 305 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/H5Dchunk.c
View File

@ -711,10 +711,8 @@ H5D__chunk_set_info_real(H5O_layout_chunk_t *layout, unsigned ndims, const hsize
} /* end for */
/* Get the "down" sizes for each dimension */
if (H5VM_array_down(ndims, layout->chunks, layout->down_chunks) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_CANTSET, FAIL, "can't compute 'down' chunk size value")
if (H5VM_array_down(ndims, layout->max_chunks, layout->max_down_chunks) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_CANTSET, FAIL, "can't compute 'down' chunk size value")
H5VM_array_down(ndims, layout->chunks, layout->down_chunks);
H5VM_array_down(ndims, layout->max_chunks, layout->max_down_chunks);
done:
FUNC_LEAVE_NOAPI(ret_value)

16
src/H5Dearray.c
View File

@ -1160,9 +1160,7 @@ done:
static herr_t
H5D__earray_idx_resize(H5O_layout_chunk_t *layout)
{
herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_STATIC
FUNC_ENTER_STATIC_NOERR
/* Check args */
HDassert(layout);
@ -1182,8 +1180,7 @@ H5D__earray_idx_resize(H5O_layout_chunk_t *layout)
H5VM_swizzle_coords(hsize_t, swizzled_chunks, layout->u.earray.unlim_dim);
/* Get the swizzled "down" sizes for each dimension */
if (H5VM_array_down((layout->ndims - 1), swizzled_chunks, layout->u.earray.swizzled_down_chunks) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_CANTSET, FAIL, "can't compute swizzled 'down' chunk size value")
H5VM_array_down((layout->ndims - 1), swizzled_chunks, layout->u.earray.swizzled_down_chunks);
/* Get the swizzled max number of chunks in each dimension */
H5MM_memcpy(swizzled_max_chunks, layout->max_chunks,
@ -1191,13 +1188,10 @@ H5D__earray_idx_resize(H5O_layout_chunk_t *layout)
H5VM_swizzle_coords(hsize_t, swizzled_max_chunks, layout->u.earray.unlim_dim);
/* Get the swizzled max "down" sizes for each dimension */
if (H5VM_array_down((layout->ndims - 1), swizzled_max_chunks,
layout->u.earray.swizzled_max_down_chunks) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_CANTSET, FAIL, "can't compute swizzled 'down' chunk size value")
} /* end if */
H5VM_array_down((layout->ndims - 1), swizzled_max_chunks, layout->u.earray.swizzled_max_down_chunks);
}
done:
FUNC_LEAVE_NOAPI(ret_value)
FUNC_LEAVE_NOAPI(SUCCEED)
} /* end H5D__earray_idx_resize() */
/*-------------------------------------------------------------------------

17
src/H5Dlayout.c
View File

@ -504,6 +504,7 @@ H5D__layout_oh_create(H5F_t *file, H5O_t *oh, H5D_t *dset, hid_t dapl_id)
H5HL_t * heap; /* Pointer to local heap for EFL file names */
size_t heap_size = H5HL_ALIGN(1);
size_t u;
size_t name_offset;
/* Determine size of heap needed to stored the file names */
for (u = 0; u < efl->nused; ++u)
@ -518,24 +519,22 @@ H5D__layout_oh_create(H5F_t *file, H5O_t *oh, H5D_t *dset, hid_t dapl_id)
HGOTO_ERROR(H5E_DATASET, H5E_CANTPROTECT, FAIL, "unable to protect EFL file name heap")
/* Insert "empty" name first */
if (UFAIL == H5HL_insert(file, heap, (size_t)1, "")) {
if (H5HL_insert(file, heap, (size_t)1, "", &name_offset) < 0) {
H5HL_unprotect(heap);
HGOTO_ERROR(H5E_DATASET, H5E_CANTINSERT, FAIL, "unable to insert file name into heap")
} /* end if */
}
for (u = 0; u < efl->nused; ++u) {
size_t offset; /* Offset of file name in heap */
/* Insert file name into heap */
if (UFAIL ==
(offset = H5HL_insert(file, heap, HDstrlen(efl->slot[u].name) + 1, efl->slot[u].name))) {
if (H5HL_insert(file, heap, HDstrlen(efl->slot[u].name) + 1, efl->slot[u].name, &name_offset) <
0) {
H5HL_unprotect(heap);
HGOTO_ERROR(H5E_DATASET, H5E_CANTINSERT, FAIL, "unable to insert file name into heap")
} /* end if */
}
/* Store EFL file name offset */
efl->slot[u].name_offset = offset;
} /* end for */
efl->slot[u].name_offset = name_offset;
}
/* Release the heap */
if (H5HL_unprotect(heap) < 0)

13
src/H5Gent.c
View File

@ -384,11 +384,8 @@ H5G__ent_convert(H5F_t *f, H5HL_t *heap, const char *name, const H5O_link_t *lnk
/* Reset the new entry */
H5G__ent_reset(ent);
/*
* Add the new name to the heap.
*/
name_offset = H5HL_insert(f, heap, HDstrlen(name) + 1, name);
if (0 == name_offset || UFAIL == name_offset)
/* Add the new name to the heap */
if (H5HL_insert(f, heap, HDstrlen(name) + 1, name, &name_offset) < 0)
HGOTO_ERROR(H5E_SYM, H5E_CANTINSERT, FAIL, "unable to insert symbol name into heap")
ent->name_off = name_offset;
@ -476,14 +473,12 @@ H5G__ent_convert(H5F_t *f, H5HL_t *heap, const char *name, const H5O_link_t *lnk
size_t lnk_offset; /* Offset to sym-link value */
/* Insert link value into local heap */
if (UFAIL ==
(lnk_offset = H5HL_insert(f, heap, HDstrlen(lnk->u.soft.name) + 1, lnk->u.soft.name)))
if (H5HL_insert(f, heap, HDstrlen(lnk->u.soft.name) + 1, lnk->u.soft.name, &lnk_offset) < 0)
HGOTO_ERROR(H5E_SYM, H5E_CANTINIT, FAIL, "unable to write link value to local heap")
ent->type = H5G_CACHED_SLINK;
ent->cache.slink.lval_offset = lnk_offset;
} /* end case */
break;
} break;
case H5L_TYPE_ERROR:
case H5L_TYPE_EXTERNAL:

5
src/H5Gstab.c
View File

@ -150,11 +150,10 @@ H5G__stab_create_components(H5F_t *f, H5O_stab_t *stab, size_t size_hint)
HGOTO_ERROR(H5E_SYM, H5E_PROTECT, FAIL, "unable to protect symbol table heap")
/* Insert name into the heap */
if (UFAIL == (name_offset = H5HL_insert(f, heap, (size_t)1, "")))
if (H5HL_insert(f, heap, (size_t)1, "", &name_offset) < 0)
HGOTO_ERROR(H5E_SYM, H5E_CANTINSERT, FAIL, "can't insert name into heap")
/*
* B-tree's won't work if the first name isn't at the beginning
/* B-trees won't work if the first name isn't at the beginning
* of the heap.
*/
HDassert(0 == name_offset);

42
src/H5HL.c
View File

@ -508,27 +508,31 @@ END_FUNC(STATIC) /* end H5HL__dirty() */
*
* Purpose: Inserts a new item into the heap.
*
* Return: Success: Offset of new item within heap.
* Failure: UFAIL
* Return: Success: SUCCEED
* Offset set to location of new item within heap
*
* Failure: FAIL
* Offset set to SIZE_MAX
*
* Programmer: Robb Matzke
* Jul 17 1997
*
*-------------------------------------------------------------------------
*/
BEGIN_FUNC(PRIV, ERR, size_t, UFAIL, UFAIL,
H5HL_insert(H5F_t *f, H5HL_t *heap, size_t buf_size, const void *buf))
BEGIN_FUNC(PRIV, ERR, herr_t, SUCCEED, FAIL,
H5HL_insert(H5F_t *f, H5HL_t *heap, size_t buf_size, const void *buf, size_t *offset_out))
H5HL_free_t *fl = NULL, *last_fl = NULL;
size_t offset = 0;
size_t need_size;
size_t offset = 0;
hbool_t found;
/* check arguments */
/* Check arguments */
HDassert(f);
HDassert(heap);
HDassert(buf_size > 0);
HDassert(buf);
HDassert(offset_out);
/* Mark heap as dirty in cache */
/* (A bit early in the process, but it's difficult to determine in the
@ -539,20 +543,18 @@ BEGIN_FUNC(PRIV, ERR, size_t, UFAIL, UFAIL,
if (FAIL == H5HL__dirty(heap))
H5E_THROW(H5E_CANTMARKDIRTY, "unable to mark heap as dirty");
/*
* In order to keep the free list descriptors aligned on word boundaries,
/* In order to keep the free list descriptors aligned on word boundaries,
* whatever that might mean, we round the size up to the next multiple of
* a word.
*/
need_size = H5HL_ALIGN(buf_size);
/*
* Look for a free slot large enough for this object and which would
/* Look for a free slot large enough for this object and which would
* leave zero or at least H5G_SIZEOF_FREE bytes left over.
*/
for (fl = heap->freelist, found = FALSE; fl; fl = fl->next) {
if (fl->size > need_size && fl->size - need_size >= H5HL_SIZEOF_FREE(f)) {
/* a big enough free block was found */
/* A big enough free block was found */
offset = fl->offset;
fl->offset += need_size;
fl->size -= need_size;
@ -562,20 +564,19 @@ BEGIN_FUNC(PRIV, ERR, size_t, UFAIL, UFAIL,
break;
}
else if (fl->size == need_size) {
/* free block of exact size found */
/* Free block of exact size found */
offset = fl->offset;
fl = H5HL__remove_free(heap, fl);
found = TRUE;
break;
}
else if (!last_fl || last_fl->offset < fl->offset) {
/* track free space that's closest to end of heap */
/* Track free space that's closest to end of heap */
last_fl = fl;
}
} /* end for */
/*
* If no free chunk was large enough, then allocate more space and
/* If no free chunk was large enough, then allocate more space and
* add it to the free list. If the heap ends with a free chunk, we
* can extend that free chunk. Otherwise we'll have to make another
* free chunk. If the heap must expand, we double its size.
@ -587,7 +588,8 @@ BEGIN_FUNC(PRIV, ERR, size_t, UFAIL, UFAIL,
htri_t was_extended; /* Whether the local heap's data segment on disk was extended */
/* At least double the heap's size, making certain there's enough room
* for the new object */
* for the new object
*/
need_more = MAX(need_size, heap->dblk_size);
/* If there is no last free block or it's not at the end of the heap,
@ -657,8 +659,7 @@ BEGIN_FUNC(PRIV, ERR, size_t, UFAIL, UFAIL,
}
} /* end if */
else {
/*
* Create a new free list element large enough that we can
/* Create a new free list element large enough that we can
* take some space out of it right away.
*/
offset = old_dblk_size;
@ -700,11 +701,10 @@ BEGIN_FUNC(PRIV, ERR, size_t, UFAIL, UFAIL,
/* Copy the data into the heap */
H5MM_memcpy(heap->dblk_image + offset, buf, buf_size);
/* Set return value */
ret_value = offset;
*offset_out = offset;
CATCH
/* No special processing on errors */
/* No special processing on exit */
END_FUNC(PRIV) /* H5HL_insert() */

2
src/H5HLprivate.h
View File

@ -57,7 +57,7 @@ H5_DLL herr_t H5HL_create(H5F_t *f, size_t size_hint, haddr_t *addr /*out*/);
H5_DLL herr_t H5HL_delete(H5F_t *f, haddr_t addr);
H5_DLL herr_t H5HL_get_size(H5F_t *f, haddr_t addr, size_t *size);
H5_DLL herr_t H5HL_heapsize(H5F_t *f, haddr_t addr, hsize_t *heap_size);
H5_DLL size_t H5HL_insert(H5F_t *f, H5HL_t *heap, size_t size, const void *buf);
H5_DLL herr_t H5HL_insert(H5F_t *f, H5HL_t *heap, size_t size, const void *buf, size_t *offset);
H5_DLL void * H5HL_offset_into(const H5HL_t *heap, size_t offset);
H5_DLL H5HL_t *H5HL_protect(H5F_t *f, haddr_t addr, unsigned flags);
H5_DLL herr_t H5HL_remove(H5F_t *f, H5HL_t *heap, size_t offset, size_t size);

8
src/H5Oefl.c
View File

@ -466,7 +466,7 @@ H5O__efl_copy_file(H5F_t H5_ATTR_UNUSED *file_src, void *mesg_src, H5F_t *file_d
HGOTO_ERROR(H5E_EFL, H5E_PROTECT, NULL, "unable to protect EFL file name heap")
/* Insert "empty" name first */
if (UFAIL == (name_offset = H5HL_insert(file_dst, heap, (size_t)1, "")))
if (H5HL_insert(file_dst, heap, (size_t)1, "", &name_offset) < 0)
HGOTO_ERROR(H5E_EFL, H5E_CANTINSERT, NULL, "can't insert file name into heap")
HDassert(0 == name_offset);
@ -483,10 +483,10 @@ H5O__efl_copy_file(H5F_t H5_ATTR_UNUSED *file_src, void *mesg_src, H5F_t *file_d
/* copy the name from the source */
for (idx = 0; idx < efl_src->nused; idx++) {
efl_dst->slot[idx].name = H5MM_xstrdup(efl_src->slot[idx].name);
if (UFAIL == (efl_dst->slot[idx].name_offset = H5HL_insert(
file_dst, heap, HDstrlen(efl_dst->slot[idx].name) + 1, efl_dst->slot[idx].name)))
if (H5HL_insert(file_dst, heap, HDstrlen(efl_dst->slot[idx].name) + 1, efl_dst->slot[idx].name,
&(efl_dst->slot[idx].name_offset)) < 0)
HGOTO_ERROR(H5E_EFL, H5E_CANTINSERT, NULL, "can't insert file name into heap")
} /* end for */
}
/* Set return value */
ret_value = efl_dst;

59
src/H5SM.c
View File

@ -1262,16 +1262,16 @@ static herr_t
H5SM__write_mesg(H5F_t *f, H5O_t *open_oh, H5SM_index_header_t *header, hbool_t defer, unsigned type_id,
void *mesg, unsigned *cache_flags_ptr)
{
H5SM_list_t * list = NULL; /* List index */
H5SM_mesg_key_t key; /* Key used to search the index */
H5SM_list_cache_ud_t cache_udata; /* User-data for metadata cache callback */
H5O_shared_t shared; /* Shared H5O message */
hbool_t found = FALSE; /* Was the message in the index? */
H5HF_t * fheap = NULL; /* Fractal heap handle */
H5B2_t * bt2 = NULL; /* v2 B-tree handle for index */
size_t buf_size; /* Size of the encoded message */
void * encoding_buf = NULL; /* Buffer for encoded message */
size_t empty_pos = UFAIL; /* Empty entry in list */
H5SM_list_t * list = NULL; /* List index */
H5SM_mesg_key_t key; /* Key used to search the index */
H5SM_list_cache_ud_t cache_udata; /* User-data for metadata cache callback */
H5O_shared_t shared; /* Shared H5O message */
hbool_t found = FALSE; /* Was the message in the index? */
H5HF_t * fheap = NULL; /* Fractal heap handle */
H5B2_t * bt2 = NULL; /* v2 B-tree handle for index */
size_t buf_size; /* Size of the encoded message */
void * encoding_buf = NULL; /* Buffer for encoded message */
size_t empty_pos = SIZE_MAX; /* Empty entry in list */
herr_t ret_value = SUCCEED;
FUNC_ENTER_STATIC
@ -1325,11 +1325,11 @@ H5SM__write_mesg(H5F_t *f, H5O_t *open_oh, H5SM_index_header_t *header, hbool_t
HGOTO_ERROR(H5E_SOHM, H5E_CANTINSERT, FAIL, "unable to search for message in list")
if (defer) {
if (list_pos != UFAIL)
if (list_pos != SIZE_MAX)
found = TRUE;
} /* end if */
else {
if (list_pos != UFAIL) {
if (list_pos != SIZE_MAX) {
/* If the message was previously shared in an object header, share
* it in the heap now.
*/
@ -1481,13 +1481,13 @@ H5SM__write_mesg(H5F_t *f, H5O_t *open_oh, H5SM_index_header_t *header, hbool_t
/* Insert the new message into the SOHM index */
if (header->index_type == H5SM_LIST) {
/* Index is a list. Find an empty spot if we haven't already */
if (empty_pos == UFAIL) {
if (empty_pos == SIZE_MAX) {
size_t pos;
if (H5SM__find_in_list(list, NULL, &empty_pos, &pos) < 0)
HGOTO_ERROR(H5E_SOHM, H5E_CANTINSERT, FAIL, "unable to search for message in list")
if (pos == UFAIL || empty_pos == UFAIL)
if (pos == SIZE_MAX || empty_pos == SIZE_MAX)
HGOTO_ERROR(H5E_SOHM, H5E_CANTINSERT, FAIL, "unable to find empty entry in list")
}
/* Insert message into list */
@ -1647,9 +1647,14 @@ done:
*
* If EMPTY_POS is NULL, don't store anything in it.
*
* Return: Message's position in the list on success
* UFAIL if message couldn't be found
* empty_pos set to position of empty message or UFAIL.
* Return: Success: SUCCEED
* pos = position (if found)
* pos = SIZE_MAX (if not found)
* empty_pos = indeterminate (if found)
* empty_pos = 1st empty position (if not found)
*
* Failure: FAIL
* pos & empty_pos indeterminate
*
* Programmer: James Laird
* Tuesday, May 2, 2006
@ -1670,7 +1675,7 @@ H5SM__find_in_list(const H5SM_list_t *list, const H5SM_mesg_key_t *key, size_t *
/* Initialize empty_pos to an invalid value */
if (empty_pos)
*empty_pos = UFAIL;
*empty_pos = SIZE_MAX;
/* Find the first (only) message equal to the key passed in.
* Also record the first empty position we find.
@ -1693,11 +1698,11 @@ H5SM__find_in_list(const H5SM_list_t *list, const H5SM_mesg_key_t *key, size_t *
/* Found earlier position possible, don't check any more */
empty_pos = NULL;
} /* end if */
} /* end for */
}
}
/* If we reached this point, we didn't find the message */
*pos = UFAIL;
*pos = SIZE_MAX;
done:
FUNC_LEAVE_NOAPI(ret_value)
@ -1839,7 +1844,7 @@ H5SM__delete_from_index(H5F_t *f, H5O_t *open_oh, H5SM_index_header_t *header, c
/* Find the message in the list */
if (H5SM__find_in_list(list, &key, NULL, &list_pos) < 0)
HGOTO_ERROR(H5E_SOHM, H5E_NOTFOUND, FAIL, "unable to search for message in list")
if (list_pos == UFAIL)
if (list_pos == SIZE_MAX)
HGOTO_ERROR(H5E_SOHM, H5E_NOTFOUND, FAIL, "message not in index")
if (list->messages[list_pos].location == H5SM_IN_HEAP)
@ -2221,7 +2226,7 @@ H5SM_get_refcount(H5F_t *f, unsigned type_id, const H5O_shared_t *sh_mesg, hsize
/* Find the message in the list */
if (H5SM__find_in_list(list, &key, NULL, &list_pos) < 0)
HGOTO_ERROR(H5E_SOHM, H5E_NOTFOUND, FAIL, "unable to search for message in list")
if (list_pos == UFAIL)
if (list_pos == SIZE_MAX)
HGOTO_ERROR(H5E_SOHM, H5E_NOTFOUND, FAIL, "message not in index")
/* Copy the message */
@ -2519,7 +2524,7 @@ H5SM__list_free(H5SM_list_t *list)
*
* Purpose: Print debugging information for the master table.
*
* If table_vers and num_indexes are not UFAIL, they are used
* If table_vers and num_indexes are not UINT_MAX, they are used
* instead of the values in the superblock.
*
* Return: Non-negative on success/Negative on failure
@ -2546,14 +2551,14 @@ H5SM_table_debug(H5F_t *f, haddr_t table_addr, FILE *stream, int indent, int fwi
HDassert(indent >= 0);
HDassert(fwidth >= 0);
/* If table_vers and num_indexes are UFAIL, replace them with values from
/* If table_vers and num_indexes are UINT_MAX, replace them with values from
* userblock
*/
if (table_vers == UFAIL)
if (table_vers == UINT_MAX)
table_vers = H5F_SOHM_VERS(f);
else if (table_vers != H5F_SOHM_VERS(f))
HDfprintf(stream, "*** SOHM TABLE VERSION DOESN'T MATCH VERSION IN SUPERBLOCK!\n");
if (num_indexes == UFAIL)
if (num_indexes == UINT_MAX)
num_indexes = H5F_SOHM_NINDEXES(f);
else if (num_indexes != H5F_SOHM_NINDEXES(f))
HDfprintf(stream, "*** NUMBER OF SOHM INDEXES DOESN'T MATCH VALUE IN SUPERBLOCK!\n");

3
src/H5Smpio.c
View File

@ -1014,8 +1014,7 @@ H5S__mpio_span_hyper_type(const H5S_t *space, size_t elmt_size, MPI_Datatype *ne
elmt_type_is_derived = TRUE;
/* Compute 'down' sizes for each dimension */
if (H5VM_array_down(space->extent.rank, space->extent.size, down) < 0)
HGOTO_ERROR(H5E_DATASPACE, H5E_CANTGETSIZE, FAIL, "couldn't compute 'down' dimension sizes")
H5VM_array_down(space->extent.rank, space->extent.size, down);
/* Acquire an operation generation value for creating MPI datatypes */
op_gen = H5S__hyper_get_op_gen();

9
src/H5Tbit.c
View File

@ -228,10 +228,7 @@ done:
* Purpose: Return a small bit sequence as a number. Bit vector starts
* at OFFSET and is SIZE bits long.
*
* Return: Success: The bit sequence interpretted as an unsigned
* integer.
*
* Failure: 0
* Return: The bit sequence interpretted as an unsigned integer
*
*-------------------------------------------------------------------------
*/
@ -264,8 +261,8 @@ H5T__bit_get_d(uint8_t *buf, size_t offset, size_t size)
case H5T_ORDER_NONE:
case H5T_ORDER_MIXED:
default:
/* Unknown endianness. Bail out. */
HGOTO_DONE(UFAIL)
/* This function can't return errors */
HDassert(0 && "unknown byte order");
}
/* Set return value */

386
src/H5VM.c
View File

@ -43,20 +43,20 @@ static void H5VM__stride_copy2(hsize_t nelmts, hsize_t elmt_size, unsigned dst_n
#endif /* LATER */
/*-------------------------------------------------------------------------
* Function: H5VM__stride_optimize1
* Function: H5VM__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: None
* Return: void
*
* Programmer: Robb Matzke
* Saturday, October 11, 1997
* Programmer: Robb Matzke
* Saturday, October 11, 1997
*
*-------------------------------------------------------------------------
*/
@ -66,15 +66,12 @@ H5VM__stride_optimize1(unsigned *np /*in,out*/, hsize_t *elmt_size /*in,out*/, c
{
FUNC_ENTER_STATIC_NOERR
/*
* This has to be true because if we optimize the dimensionality down to
/* This has to be true because if we optimize the dimensionality down to
* zero we still must make one reference.
*/
HDassert(1 == H5VM_vector_reduce_product(0, NULL));
/*
* Combine adjacent memory accesses
*/
/* Combine adjacent memory accesses */
while (*np && stride1[*np - 1] > 0 && (hsize_t)(stride1[*np - 1]) == *elmt_size) {
*elmt_size *= size[*np - 1];
if (--*np)
@ -85,20 +82,20 @@ H5VM__stride_optimize1(unsigned *np /*in,out*/, hsize_t *elmt_size /*in,out*/, c
}
/*-------------------------------------------------------------------------
* Function: H5VM__stride_optimize2
* Function: H5VM__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: Non-negative on success/Negative on failure
* Return: Non-negative on success/Negative on failure
*
* Programmer: Robb Matzke
* Saturday, October 11, 1997
* Programmer: Robb Matzke
* Saturday, October 11, 1997
*
*-------------------------------------------------------------------------
*/
@ -108,16 +105,13 @@ H5VM__stride_optimize2(unsigned *np /*in,out*/, hsize_t *elmt_size /*in,out*/, c
{
FUNC_ENTER_STATIC_NOERR
/*
* This has to be true because if we optimize the dimensionality down to
/* This has to be true because if we optimize the dimensionality down to
* zero we still must make one reference.
*/
HDassert(1 == H5VM_vector_reduce_product(0, NULL));
HDassert(*elmt_size > 0);
/*
* Combine adjacent memory accesses
*/
/* Combine adjacent memory accesses */
/* Unroll loop for common cases */
switch (*np) {
@ -206,29 +200,26 @@ H5VM__stride_optimize2(unsigned *np /*in,out*/, hsize_t *elmt_size /*in,out*/, c
}
/*-------------------------------------------------------------------------
* Function: H5VM_hyper_stride
* Function: H5VM_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 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: Byte offset from beginning of array to start of striding.
*
* Failure: abort() -- should never fail
*
* Programmer: Robb Matzke
* Saturday, October 11, 1997
* Programmer: Robb Matzke
* Saturday, October 11, 1997
*
*-------------------------------------------------------------------------
*/
@ -308,23 +299,22 @@ H5VM_hyper_stride(unsigned n, const hsize_t *size, const hsize_t *total_size, co
}
/*-------------------------------------------------------------------------
* Function: H5VM_hyper_eq
* Function: H5VM_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: 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.
* Never returns FAIL
*
* Programmer: Robb Matzke
* Friday, October 17, 1997
* Programmer: Robb Matzke
* Friday, October 17, 1997
*
*-------------------------------------------------------------------------
*/
@ -360,19 +350,19 @@ done:
/*-------------------------------------------------------------------------
* Function: H5VM_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.
* 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: Non-negative on success/Negative on failure
* Return: Non-negative on success/Negative on failure
*
* Programmer: Robb Matzke
* Friday, October 10, 1997
* Programmer: Robb Matzke
* Friday, October 10, 1997
*
*-------------------------------------------------------------------------
*/
@ -418,31 +408,31 @@ H5VM_hyper_fill(unsigned n, const hsize_t *_size, const hsize_t *total_size, con
}
/*-------------------------------------------------------------------------
* Function: H5VM_hyper_copy
* Function: H5VM_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: Non-negative on success/Negative on failure
* Return: Non-negative on success/Negative on failure
*
* Programmer: Robb Matzke
* Friday, October 10, 1997
* Programmer: Robb Matzke
* Friday, October 10, 1997
*
*-------------------------------------------------------------------------
*/
@ -592,13 +582,13 @@ H5VM_hyper_copy(unsigned n, const hsize_t *_size, const hsize_t *dst_size, const
/*-------------------------------------------------------------------------
* Function: H5VM_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: Non-negative on success/Negative on failure
* Return: Non-negative on success/Negative on failure
*
* Programmer: Robb Matzke
* Saturday, October 11, 1997
* Programmer: Robb Matzke
* Saturday, October 11, 1997
*
*-------------------------------------------------------------------------
*/
@ -643,19 +633,19 @@ H5VM_stride_fill(unsigned n, hsize_t elmt_size, const hsize_t *size, const hsize
/*-------------------------------------------------------------------------
* Function: H5VM_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 H5VM_stride_fill() instead.
* Note: If the src_stride is all zero and elmt_size is one, then it's
* probably more efficient to use H5VM_stride_fill() instead.
*
* Return: Non-negative on success/Negative on failure
* Return: Non-negative on success/Negative on failure
*
* Programmer: Robb Matzke
* Saturday, October 11, 1997
* Programmer: Robb Matzke
* Saturday, October 11, 1997
*
*-------------------------------------------------------------------------
*/
@ -709,19 +699,19 @@ H5VM_stride_copy(unsigned n, hsize_t elmt_size, const hsize_t *size, const hsize
/*-------------------------------------------------------------------------
* Function: H5VM_stride_copy_s
*
* 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 H5VM_stride_fill() instead.
* Note: If the src_stride is all zero and elmt_size is one, then it's
* probably more efficient to use H5VM_stride_fill() instead.
*
* Return: Non-negative on success/Negative on failure
* Return: Non-negative on success/Negative on failure
*
* Programmer: Robb Matzke
* Saturday, October 11, 1997
* Programmer: Robb Matzke
* Saturday, October 11, 1997
*
*-------------------------------------------------------------------------
*/
@ -775,17 +765,17 @@ H5VM_stride_copy_s(unsigned n, hsize_t elmt_size, const hsize_t *size, const hss
#ifdef LATER
/*-------------------------------------------------------------------------
* Function: H5VM__stride_copy2
* Function: H5VM__stride_copy2
*
* Purpose: Similar to H5VM_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 H5VM_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: None
* Return: void
*
* Programmer: Robb Matzke
* Saturday, October 11, 1997
* Programmer: Robb Matzke
* Saturday, October 11, 1997
*
*-------------------------------------------------------------------------
*/
@ -843,16 +833,16 @@ H5VM__stride_copy2(hsize_t nelmts, hsize_t elmt_size, unsigned dst_n, const hsiz
#endif /* LATER */
/*-------------------------------------------------------------------------
* Function: H5VM_array_fill
* Function: H5VM_array_fill
*
* Purpose: Fills all bytes of an array with the same value using
* memset(). Increases amount copied by power of two until the
* halfway point is crossed, then copies the rest in one swoop.
* Purpose: Fills all bytes of an array with the same value using
* memset(). Increases amount copied by power of two until the
* halfway point is crossed, then copies the rest in one swoop.
*
* Return: Non-negative on success/Negative on failure
* Return: Non-negative on success/Negative on failure
*
* Programmer: Quincey Koziol
* Thursday, June 18, 1998
* Programmer: Quincey Koziol
* Thursday, June 18, 1998
*
*-------------------------------------------------------------------------
*/
@ -895,25 +885,25 @@ H5VM_array_fill(void *_dst, const void *src, size_t size, size_t count)
} /* H5VM_array_fill() */
/*-------------------------------------------------------------------------
* Function: H5VM_array_down
* Function: H5VM_array_down
*
* Purpose: Given a set of dimension sizes, calculate the size of each
* Purpose: Given a set of dimension sizes, calculate the size of each
* "down" slice. This is the size of the dimensions for all the
* dimensions below the current one, which is used for indexing
* offsets in this dimension.
*
* Return: Non-negative on success/Negative on failure
* Return: void
*
* Programmer: Quincey Koziol
* Monday, April 28, 2003
* Programmer: Quincey Koziol
* Monday, April 28, 2003
*
*-------------------------------------------------------------------------
*/
herr_t
void
H5VM_array_down(unsigned n, const hsize_t *total_size, hsize_t *down)
{
hsize_t acc; /*accumulator */
int i; /*counter */
hsize_t acc; /* Accumulator */
int i; /* Counter */
FUNC_ENTER_NOAPI_NOINIT_NOERR
@ -921,31 +911,31 @@ H5VM_array_down(unsigned n, const hsize_t *total_size, hsize_t *down)
HDassert(total_size);
HDassert(down);
/* Build the sizes of each dimension in the array */
/* (From fastest to slowest) */
/* Build the sizes of each dimension in the array
* (From fastest to slowest)
*/
for (i = (int)(n - 1), acc = 1; i >= 0; i--) {
down[i] = acc;
acc *= total_size[i];
} /* end for */
}
FUNC_LEAVE_NOAPI(SUCCEED)
FUNC_LEAVE_NOAPI_VOID
} /* end H5VM_array_down() */
/*-------------------------------------------------------------------------
* Function: H5VM_array_offset_pre
*
* Purpose: Given a coordinate description of a location in an array, this
* function returns the byte offset of the coordinate.
* Purpose: Given a coordinate description of a location in an array, this
* function returns the byte offset of the coordinate.
*
* The dimensionality of the whole array, and the offset is N.
* The dimensionality of the whole array, and the offset is N.
* The whole array dimensions are TOTAL_SIZE and the coordinate
* is at offset OFFSET.
*
* Return: Success: Byte offset from beginning of array to element offset
* Failure: abort() -- should never fail
* Return: Byte offset from beginning of array to element offset
*
* Programmer: Quincey Koziol
* Tuesday, June 22, 1999
* Tuesday, June 22, 1999
*
*-------------------------------------------------------------------------
*/
@ -971,18 +961,17 @@ H5VM_array_offset_pre(unsigned n, const hsize_t *acc, const hsize_t *offset)
/*-------------------------------------------------------------------------
* Function: H5VM_array_offset
*
* Purpose: Given a coordinate description of a location in an array, this
* function returns the byte offset of the coordinate.
* Purpose: Given a coordinate description of a location in an array,
* this function returns the byte offset of the coordinate.
*
* The dimensionality of the whole array, and the offset is N.
* The dimensionality of the whole array, and the offset is N.
* The whole array dimensions are TOTAL_SIZE and the coordinate
* is at offset OFFSET.
*
* Return: Success: Byte offset from beginning of array to element offset
* Failure: abort() -- should never fail
* Return: Byte offset from beginning of array to element offset
*
* Programmer: Quincey Koziol
* Tuesday, June 22, 1999
* Tuesday, June 22, 1999
*
*-------------------------------------------------------------------------
*/
@ -992,38 +981,36 @@ H5VM_array_offset(unsigned n, const hsize_t *total_size, const hsize_t *offset)
hsize_t acc_arr[H5VM_HYPER_NDIMS]; /* Accumulated size of down dimensions */
hsize_t ret_value; /* Return value */
FUNC_ENTER_NOAPI((HDabort(), 0)) /*lint !e527 Don't worry about unreachable statement */
FUNC_ENTER_NOAPI_NOERR
HDassert(n <= H5VM_HYPER_NDIMS);
HDassert(total_size);
HDassert(offset);
/* Build the sizes of each dimension in the array */
if (H5VM_array_down(n, total_size, acc_arr) < 0)
HGOTO_ERROR(H5E_INTERNAL, H5E_BADVALUE, UFAIL, "can't compute down sizes")
H5VM_array_down(n, total_size, acc_arr);
/* Set return value */
ret_value = H5VM_array_offset_pre(n, acc_arr, offset);
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5VM_array_offset() */
/*-------------------------------------------------------------------------
* Function: H5VM_array_calc_pre
*
* Purpose: Given a linear offset in an array, the dimensions of that
* Purpose: Given a linear offset in an array, the dimensions of that
* array and the pre-computed 'down' (accumulator) sizes, this
* function computes the coordinates of that offset in the array.
*
* The dimensionality of the whole array, and the coordinates is N.
* The dimensionality of the whole array, and the coordinates is N.
* The array dimensions are TOTAL_SIZE and the coordinates
* are returned in COORD. The linear offset is in OFFSET.
*
* Return: Non-negative on success/Negative on failure
* Return: Non-negative on success/Negative on failure
*
* Programmer: Quincey Koziol
* Thursday, July 16, 2009
* Programmer: Quincey Koziol
* Thursday, July 16, 2009
*
*-------------------------------------------------------------------------
*/
@ -1050,18 +1037,18 @@ H5VM_array_calc_pre(hsize_t offset, unsigned n, const hsize_t *down, hsize_t *co
/*-------------------------------------------------------------------------
* Function: H5VM_array_calc
*
* Purpose: Given a linear offset in an array and the dimensions of that
* Purpose: Given a linear offset in an array and the dimensions of that
* array, this function computes the coordinates of that offset
* in the array.
*
* The dimensionality of the whole array, and the coordinates is N.
* The dimensionality of the whole array, and the coordinates is N.
* The array dimensions are TOTAL_SIZE and the coordinates
* are returned in COORD. The linear offset is in OFFSET.
*
* Return: Non-negative on success/Negative on failure
* Return: Non-negative on success/Negative on failure
*
* Programmer: Quincey Koziol
* Wednesday, April 16, 2003
* Programmer: Quincey Koziol
* Wednesday, April 16, 2003
*
*-------------------------------------------------------------------------
*/
@ -1079,8 +1066,7 @@ H5VM_array_calc(hsize_t offset, unsigned n, const hsize_t *total_size, hsize_t *
HDassert(coords);
/* Build the sizes of each dimension in the array */
if (H5VM_array_down(n, total_size, idx) < 0)
HGOTO_ERROR(H5E_INTERNAL, H5E_BADVALUE, FAIL, "can't compute down sizes")
H5VM_array_down(n, total_size, idx);
/* Compute the coordinates from the offset */
if (H5VM_array_calc_pre(offset, n, idx, coords) < 0)
@ -1093,7 +1079,7 @@ done:
/*-------------------------------------------------------------------------
* Function: H5VM_chunk_index
*
* Purpose: Given a coordinate offset (COORD), the size of each chunk
* Purpose: Given a coordinate offset (COORD), the size of each chunk
* (CHUNK), the number of chunks in each dimension (NCHUNKS)
* and the number of dimensions of all of these (NDIMS), calculate
* a "chunk index" for the chunk that the coordinate offset is
@ -1123,10 +1109,10 @@ done:
* The chunk index is placed in the CHUNK_IDX location for return
* from this function
*
* Return: Chunk index on success (can't fail)
* Return: Chunk index on success (can't fail)
*
* Programmer: Quincey Koziol
* Monday, April 21, 2003
* Programmer: Quincey Koziol
* Monday, April 21, 2003
*
*-------------------------------------------------------------------------
*/
@ -1151,14 +1137,14 @@ H5VM_chunk_index(unsigned ndims, const hsize_t *coord, const uint32_t *chunk, co
} /* end H5VM_chunk_index() */
/*-------------------------------------------------------------------------
* Function: H5VM_chunk_scaled
* Function: H5VM_chunk_scaled
*
* Purpose: Compute the scaled coordinates for a chunk offset
* Purpose: Compute the scaled coordinates for a chunk offset
*
* Return: <none>
* Return: void
*
* Programmer: Quincey Koziol
* Wednesday, November 19, 2014
* Programmer: Quincey Koziol
* Wednesday, November 19, 2014
*
*-------------------------------------------------------------------------
*/
@ -1186,7 +1172,7 @@ H5VM_chunk_scaled(unsigned ndims, const hsize_t *coord, const uint32_t *chunk, h
/*-------------------------------------------------------------------------
* Function: H5VM_chunk_index_scaled
*
* Purpose: Given a coordinate offset (COORD), the size of each chunk
* Purpose: Given a coordinate offset (COORD), the size of each chunk
* (CHUNK), the number of chunks in each dimension (NCHUNKS)
* and the number of dimensions of all of these (NDIMS), calculate
* a "chunk index" for the chunk that the coordinate offset is
@ -1216,13 +1202,13 @@ H5VM_chunk_scaled(unsigned ndims, const hsize_t *coord, const uint32_t *chunk, h
* The chunk index is placed in the CHUNK_IDX location for return
* from this function
*
* Note: This routine is identical to H5VM_chunk_index(), except for
* caching the scaled information. Make changes in both places.
* Note: This routine is identical to H5VM_chunk_index(), except for
* caching the scaled information. Make changes in both places.
*
* Return: Chunk index on success (can't fail)
* Return: Chunk index on success (can't fail)
*
* Programmer: Vailin Choi
* Monday, February 9, 2015
* Programmer: Vailin Choi
* Monday, February 9, 2015
*
*-------------------------------------------------------------------------
*/
@ -1257,22 +1243,22 @@ H5VM_chunk_index_scaled(unsigned ndims, const hsize_t *coord, const uint32_t *ch
/*-------------------------------------------------------------------------
* Function: H5VM_opvv
*
* Purpose: Perform an operation on a source & destination sequences
* of offset/length pairs. Each set of sequnces has an array
* of lengths, an array of offsets, the maximum number of
* sequences and the current sequence to start at in the sequence.
* Purpose: Perform an operation on a source & destination sequences
* of offset/length pairs. Each set of sequnces has an array
* of lengths, an array of offsets, the maximum number of
* sequences and the current sequence to start at in the sequence.
*
* There may be different numbers of bytes in the source and
* destination sequences, the operation stops when either the
* source or destination sequence runs out of information.
*
* Note: The algorithm in this routine is [basically] the same as for
* H5VM_memcpyvv(). Changes should be made to both!
* Note: The algorithm in this routine is [basically] the same as for
* H5VM_memcpyvv(). Changes should be made to both!
*
* Return: Non-negative # of bytes operated on, on success/Negative on failure
* Return: Non-negative # of bytes operated on, on success/Negative on failure
*
* Programmer: Quincey Koziol
* Thursday, September 30, 2010
* Programmer: Quincey Koziol
* Thursday, September 30, 2010
*
*-------------------------------------------------------------------------
*/
@ -1460,7 +1446,7 @@ done:
/*-------------------------------------------------------------------------
* Function: H5VM_memcpyvv
*
* Purpose: Given source and destination buffers in memory (SRC & DST)
* Purpose: Given source and destination buffers in memory (SRC & DST)
* copy sequences of from the source buffer into the destination
* buffer. Each set of sequences has an array of lengths, an
* array of offsets, the maximum number of sequences and the
@ -1470,13 +1456,13 @@ done:
* destination sequences, data copying stops when either the
* source or destination buffer runs out of sequence information.
*
* Note: The algorithm in this routine is [basically] the same as for
* H5VM_opvv(). Changes should be made to both!
* Note: The algorithm in this routine is [basically] the same as for
* H5VM_opvv(). Changes should be made to both!
*
* Return: Non-negative # of bytes copied on success/Negative on failure
* Return: Non-negative # of bytes copied on success/Negative on failure
*
* Programmer: Quincey Koziol
* Friday, May 2, 2003
* Programmer: Quincey Koziol
* Friday, May 2, 2003
*
*-------------------------------------------------------------------------
*/

2
src/H5VMprivate.h
View File

@ -105,7 +105,7 @@ H5_DLL herr_t H5VM_stride_copy_s(unsigned n, hsize_t elmt_size, const hsize_t *_
const hssize_t *dst_stride, void *_dst, const hssize_t *src_stride,
const void *_src);
H5_DLL herr_t H5VM_array_fill(void *_dst, const void *src, size_t size, size_t count);
H5_DLL herr_t H5VM_array_down(unsigned n, const hsize_t *total_size, hsize_t *down);
H5_DLL void H5VM_array_down(unsigned n, const hsize_t *total_size, hsize_t *down);
H5_DLL hsize_t H5VM_array_offset_pre(unsigned n, const hsize_t *acc, const hsize_t *offset);
H5_DLL hsize_t H5VM_array_offset(unsigned n, const hsize_t *total_size, const hsize_t *offset);
H5_DLL herr_t H5VM_array_calc_pre(hsize_t offset, unsigned n, const hsize_t *down, hsize_t *coords);

1
src/H5private.h
View File

@ -363,7 +363,6 @@
*/
#define SUCCEED 0
#define FAIL (-1)
#define UFAIL (unsigned)(-1)
/* The HDF5 library uses the symbol `ERR` frequently. So do
* header files for libraries such as curses(3), terminfo(3), etc.

6
test/dsets.c
View File

@ -9525,8 +9525,7 @@ test_chunk_fast(const char *env_h5_driver, hid_t fapl)
npoints = (hsize_t)snpoints;
/* Compute the "down" dimension values */
if (H5VM_array_down(ndims, dim, down) < 0)
FAIL_STACK_ERROR
H5VM_array_down(ndims, dim, down);
/* Create chunked dataset */
if ((dsid = H5Dcreate2(fid, "dset", H5T_NATIVE_UINT, sid, H5P_DEFAULT, dcpl,
@ -9708,8 +9707,7 @@ test_chunk_fast(const char *env_h5_driver, hid_t fapl)
H5VM_swizzle_coords(hsize_t, swizzled_dim, unlim_dim);
/* Compute the "down" dimension values */
if (H5VM_array_down(ndims, swizzled_dim, down) < 0)
FAIL_STACK_ERROR
H5VM_array_down(ndims, swizzled_dim, down);
/* Read elements */
for (u = 0; u < npoints; u++) {

2
test/lheap.c
View File

@ -103,7 +103,7 @@ main(void)
if (j > 4)
buf[j] = '\0';
if (UFAIL == (obj[i] = H5HL_insert(f, heap, HDstrlen(buf) + 1, buf))) {
if (H5HL_insert(f, heap, HDstrlen(buf) + 1, buf, &obj[i]) < 0) {
H5_FAILED();
H5Eprint2(H5E_DEFAULT, stdout);
goto error;

2
tools/src/misc/h5debug.c
View File

@ -626,7 +626,7 @@ main(int argc, char *argv[])
* Debug shared message master table.
*/
status = H5SM_table_debug(f, addr, stdout, 0, VCOL, (unsigned)UFAIL, (unsigned)UFAIL);
status = H5SM_table_debug(f, addr, stdout, 0, VCOL, UINT_MAX, UINT_MAX);
}
else if (!HDmemcmp(sig, H5SM_LIST_MAGIC, (size_t)H5_SIZEOF_MAGIC)) {
/*