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

[svn-r30189] Description:

Browse Source 
Clean up more warnings: drop the warning count from ~1310 down to ~940,
with only 31 types of warnings in 148 files (down from 38 types in 167 files).

Tested on:
    MacOSX/64 10.11.5 (amazon) w/serial & parallel
    (h5committest forthcoming)
This commit is contained in:
Quincey Koziol 2016-07-17 19:18:42 -05:00
parent c8f4641507
commit bb19817c9f
47 changed files with 1304 additions and 1052 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
hl/test/test_dset_append.c
View File

@ -16,7 +16,6 @@
#include <stdlib.h>
#include <string.h>
#include "h5hltest.h"
#include "H5srcdir.h"
#include "H5DOpublic.h"
#include <math.h>

1
hl/test/test_dset_opt.c
View File

@ -16,7 +16,6 @@
#include <stdlib.h>
#include <string.h>
#include "h5hltest.h"
#include "H5srcdir.h"
#include "H5DOpublic.h"
#include <math.h>

19
src/H5Dchunk.c
View File

@ -364,6 +364,9 @@ H5FL_DEFINE(H5D_chunk_info_t);
/* Declare a free list to manage the chunk sequence information */
H5FL_BLK_DEFINE_STATIC(chunk);
/* Declare extern free list to manage the H5S_sel_iter_t struct */
H5FL_EXTERN(H5S_sel_iter_t);
/*-------------------------------------------------------------------------
* Function: H5D__chunk_direct_write
@ -4557,14 +4560,14 @@ H5D__chunk_prune_fill(H5D_chunk_it_ud1_t *udata, hbool_t new_unfilt_chunk)
const H5O_layout_t *layout = &(dset->shared->layout); /* Dataset's layout */
unsigned rank = udata->common.layout->ndims - 1; /* Dataset rank */
const hsize_t *scaled = udata->common.scaled; /* Scaled chunk offset */
H5S_sel_iter_t chunk_iter; /* Memory selection iteration info */
H5S_sel_iter_t *chunk_iter = NULL; /* Memory selection iteration info */
hbool_t chunk_iter_init = FALSE; /* Whether the chunk iterator has been initialized */
hssize_t sel_nelmts; /* Number of elements in selection */
hsize_t count[H5O_LAYOUT_NDIMS]; /* Element count of hyperslab */
size_t chunk_size; /*size of a chunk */
void *chunk; /* The file chunk */
H5D_chunk_ud_t chk_udata; /* User data for locking chunk */
uint32_t bytes_accessed; /* Bytes accessed in chunk */
hbool_t chunk_iter_init = FALSE; /* Whether the chunk iterator has been initialized */
unsigned u; /* Local index variable */
herr_t ret_value = SUCCEED; /* Return value */
@ -4629,13 +4632,17 @@ H5D__chunk_prune_fill(H5D_chunk_it_ud1_t *udata, hbool_t new_unfilt_chunk)
if(H5D__fill_refill_vl(&udata->fb_info, (size_t)sel_nelmts, io_info->md_dxpl_id) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_CANTCONVERT, FAIL, "can't refill fill value buffer")
/* Allocate the chunk selection iterator */
if(NULL == (chunk_iter = H5FL_MALLOC(H5S_sel_iter_t)))
HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "can't allocate chunk selection iterator")
/* Create a selection iterator for scattering the elements to memory buffer */
if(H5S_select_iter_init(&chunk_iter, udata->chunk_space, layout->u.chunk.dim[rank]) < 0)
if(H5S_select_iter_init(chunk_iter, udata->chunk_space, layout->u.chunk.dim[rank]) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to initialize chunk selection information")
chunk_iter_init = TRUE;
/* Scatter the data into memory */
if(H5D__scatter_mem(udata->fb_info.fill_buf, udata->chunk_space, &chunk_iter, (size_t)sel_nelmts, io_info->dxpl_cache, chunk/*out*/) < 0)
if(H5D__scatter_mem(udata->fb_info.fill_buf, udata->chunk_space, chunk_iter, (size_t)sel_nelmts, io_info->dxpl_cache, chunk/*out*/) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_WRITEERROR, FAIL, "scatter failed")
@ -4650,8 +4657,10 @@ H5D__chunk_prune_fill(H5D_chunk_it_ud1_t *udata, hbool_t new_unfilt_chunk)
done:
/* Release the selection iterator */
if(chunk_iter_init && H5S_SELECT_ITER_RELEASE(&chunk_iter) < 0)
if(chunk_iter_init && H5S_SELECT_ITER_RELEASE(chunk_iter) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release selection iterator")
if(chunk_iter)
chunk_iter = H5FL_FREE(H5S_sel_iter_t, chunk_iter);
FUNC_LEAVE_NOAPI(ret_value)
} /* H5D__chunk_prune_fill */

25
src/H5Dfill.c
View File

@ -88,6 +88,9 @@ H5FL_BLK_DEFINE_STATIC(non_zero_fill);
/* Declare the free list to manage blocks of zero fill-value data */
H5FL_BLK_DEFINE_STATIC(zero_fill);
/* Declare extern free list to manage the H5S_sel_iter_t struct */
H5FL_EXTERN(H5S_sel_iter_t);
/*--------------------------------------------------------------------------
NAME
@ -174,6 +177,8 @@ herr_t
H5D__fill(const void *fill, const H5T_t *fill_type, void *buf,
const H5T_t *buf_type, const H5S_t *space, hid_t dxpl_id)
{
H5S_sel_iter_t *mem_iter = NULL; /* Memory selection iteration info */
hbool_t mem_iter_init = FALSE; /* Whether the memory selection iterator has been initialized */
H5WB_t *elem_wb = NULL; /* Wrapped buffer for element data */
uint8_t elem_buf[H5T_ELEM_BUF_SIZE]; /* Buffer for element data */
H5WB_t *bkg_elem_wb = NULL; /* Wrapped buffer for background data */
@ -246,7 +251,6 @@ H5D__fill(const void *fill, const H5T_t *fill_type, void *buf,
if(TRUE == H5T_detect_class(fill_type, H5T_VLEN, FALSE)) {
H5D_dxpl_cache_t _dxpl_cache; /* Data transfer property cache buffer */
H5D_dxpl_cache_t *dxpl_cache = &_dxpl_cache; /* Data transfer property cache */
H5S_sel_iter_t mem_iter; /* Memory selection iteration info */
hssize_t nelmts; /* Number of data elements */
/* Get the number of elements in the selection */
@ -273,19 +277,18 @@ H5D__fill(const void *fill, const H5T_t *fill_type, void *buf,
if(H5D__get_dxpl_cache(dxpl_id, &dxpl_cache) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't fill dxpl cache")
/* Allocate the chunk selection iterator */
if(NULL == (mem_iter = H5FL_MALLOC(H5S_sel_iter_t)))
HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "can't allocate memory selection iterator")
/* Create a selection iterator for scattering the elements to memory buffer */
if(H5S_select_iter_init(&mem_iter, space, dst_type_size) < 0)
if(H5S_select_iter_init(mem_iter, space, dst_type_size) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to initialize memory selection information")
mem_iter_init = TRUE;
/* Scatter the data into memory */
if(H5D__scatter_mem(tmp_buf, space, &mem_iter, (size_t)nelmts, dxpl_cache, buf/*out*/) < 0) {
H5S_SELECT_ITER_RELEASE(&mem_iter);
if(H5D__scatter_mem(tmp_buf, space, mem_iter, (size_t)nelmts, dxpl_cache, buf/*out*/) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_READERROR, FAIL, "scatter failed")
} /* end if */
/* Release the selection iterator */
if(H5S_SELECT_ITER_RELEASE(&mem_iter) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release selection iterator")
} /* end if */
else {
const uint8_t *fill_buf; /* Buffer to use for writing fill values */
@ -335,6 +338,10 @@ H5D__fill(const void *fill, const H5T_t *fill_type, void *buf,
} /* end else */
done:
if(mem_iter_init && H5S_SELECT_ITER_RELEASE(mem_iter) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release selection iterator")
if(mem_iter)
mem_iter = H5FL_FREE(H5S_sel_iter_t, mem_iter);
if(src_id != (-1) && H5I_dec_ref(src_id) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't decrement temporary datatype ID")
if(dst_id != (-1) && H5I_dec_ref(dst_id) < 0)

37
src/H5Dio.c
View File

@ -87,6 +87,9 @@ static herr_t H5D__typeinfo_term(const H5D_type_info_t *type_info);
/* Declare a free list to manage blocks of type conversion data */
H5FL_BLK_DEFINE(type_conv);
/* Declare a free list to manage the H5D_chunk_map_t struct */
H5FL_DEFINE(H5D_chunk_map_t);
/*-------------------------------------------------------------------------
@ -366,7 +369,7 @@ herr_t
H5D__read(H5D_t *dataset, hid_t mem_type_id, const H5S_t *mem_space,
const H5S_t *file_space, hid_t dxpl_id, void *buf/*out*/)
{
H5D_chunk_map_t fm; /* Chunk file<->memory mapping */
H5D_chunk_map_t *fm = NULL; /* Chunk file<->memory mapping */
H5D_io_info_t io_info; /* Dataset I/O info */
H5D_type_info_t type_info; /* Datatype info for operation */
hbool_t type_info_init = FALSE; /* Whether the datatype info has been initialized */
@ -523,26 +526,31 @@ H5D__read(H5D_t *dataset, hid_t mem_type_id, const H5S_t *mem_space,
|| dataset->shared->dcpl_cache.efl.nused > 0
|| dataset->shared->layout.type == H5D_COMPACT);
/* Allocate the chunk map */
if(NULL == (fm = H5FL_CALLOC(H5D_chunk_map_t)))
HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "can't allocate chunk map")
/* Call storage method's I/O initialization routine */
HDmemset(&fm, 0, sizeof(H5D_chunk_map_t));
if(io_info.layout_ops.io_init && (*io_info.layout_ops.io_init)(&io_info, &type_info, nelmts, file_space, mem_space, &fm) < 0)
if(io_info.layout_ops.io_init && (*io_info.layout_ops.io_init)(&io_info, &type_info, nelmts, file_space, mem_space, fm) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "can't initialize I/O info")
io_op_init = TRUE;
#ifdef H5_HAVE_PARALLEL
/* Adjust I/O info for any parallel I/O */
if(H5D__ioinfo_adjust(&io_info, dataset, dxpl_id, file_space, mem_space, &type_info, &fm) < 0)
if(H5D__ioinfo_adjust(&io_info, dataset, dxpl_id, file_space, mem_space, &type_info, fm) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to adjust I/O info for parallel I/O")
#endif /*H5_HAVE_PARALLEL*/
/* Invoke correct "high level" I/O routine */
if((*io_info.io_ops.multi_read)(&io_info, &type_info, nelmts, file_space, mem_space, &fm) < 0)
if((*io_info.io_ops.multi_read)(&io_info, &type_info, nelmts, file_space, mem_space, fm) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_READERROR, FAIL, "can't read data")
done:
/* Shut down the I/O op information */
if(io_op_init && io_info.layout_ops.io_term && (*io_info.layout_ops.io_term)(&fm) < 0)
if(io_op_init && io_info.layout_ops.io_term && (*io_info.layout_ops.io_term)(fm) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTCLOSEOBJ, FAIL, "unable to shut down I/O op info")
if(fm)
fm = H5FL_FREE(H5D_chunk_map_t, fm);
if(io_info_init) {
#ifdef H5_DEBUG_BUILD
@ -587,7 +595,7 @@ herr_t
H5D__write(H5D_t *dataset, hid_t mem_type_id, const H5S_t *mem_space,
const H5S_t *file_space, hid_t dxpl_id, const void *buf)
{
H5D_chunk_map_t fm; /* Chunk file<->memory mapping */
H5D_chunk_map_t *fm = NULL; /* Chunk file<->memory mapping */
H5D_io_info_t io_info; /* Dataset I/O info */
H5D_type_info_t type_info; /* Datatype info for operation */
hbool_t type_info_init = FALSE; /* Whether the datatype info has been initialized */
@ -765,20 +773,23 @@ H5D__write(H5D_t *dataset, hid_t mem_type_id, const H5S_t *mem_space,
HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to initialize storage")
} /* end if */
/* Allocate the chunk map */
if(NULL == (fm = H5FL_CALLOC(H5D_chunk_map_t)))
HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "can't allocate chunk map")
/* Call storage method's I/O initialization routine */
HDmemset(&fm, 0, sizeof(H5D_chunk_map_t));
if(io_info.layout_ops.io_init && (*io_info.layout_ops.io_init)(&io_info, &type_info, nelmts, file_space, mem_space, &fm) < 0)
if(io_info.layout_ops.io_init && (*io_info.layout_ops.io_init)(&io_info, &type_info, nelmts, file_space, mem_space, fm) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "can't initialize I/O info")
io_op_init = TRUE;
#ifdef H5_HAVE_PARALLEL
/* Adjust I/O info for any parallel I/O */
if(H5D__ioinfo_adjust(&io_info, dataset, dxpl_id, file_space, mem_space, &type_info, &fm) < 0)
if(H5D__ioinfo_adjust(&io_info, dataset, dxpl_id, file_space, mem_space, &type_info, fm) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to adjust I/O info for parallel I/O")
#endif /*H5_HAVE_PARALLEL*/
/* Invoke correct "high level" I/O routine */
if((*io_info.io_ops.multi_write)(&io_info, &type_info, nelmts, file_space, mem_space, &fm) < 0)
if((*io_info.io_ops.multi_write)(&io_info, &type_info, nelmts, file_space, mem_space, fm) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_WRITEERROR, FAIL, "can't write data")
#ifdef OLD_WAY
@ -801,8 +812,10 @@ H5D__write(H5D_t *dataset, hid_t mem_type_id, const H5S_t *mem_space,
done:
/* Shut down the I/O op information */
if(io_op_init && io_info.layout_ops.io_term && (*io_info.layout_ops.io_term)(&fm) < 0)
if(io_op_init && io_info.layout_ops.io_term && (*io_info.layout_ops.io_term)(fm) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTCLOSEOBJ, FAIL, "unable to shut down I/O op info")
if(fm)
fm = H5FL_FREE(H5D_chunk_map_t, fm);
if(io_info_init) {
#ifdef H5_DEBUG_BUILD

333
src/H5Dscatgath.c
View File

@ -67,10 +67,13 @@ static herr_t H5D__compound_opt_write(size_t nelmts, const H5D_type_info_t *type
/* Local Variables */
/*******************/
/* Declare a free list to manage sequences of size_t */
/* Declare extern free list to manage the H5S_sel_iter_t struct */
H5FL_EXTERN(H5S_sel_iter_t);
/* Declare extern free list to manage sequences of size_t */
H5FL_SEQ_EXTERN(size_t);
/* Declare a free list to manage sequences of hsize_t */
/* Declare extern free list to manage sequences of hsize_t */
H5FL_SEQ_EXTERN(hsize_t);
@ -97,17 +100,16 @@ H5D__scatter_file(const H5D_io_info_t *_io_info,
const void *_buf)
{
H5D_io_info_t tmp_io_info; /* Temporary I/O info object */
hsize_t _off[H5D_IO_VECTOR_SIZE]; /* Array to store sequence offsets */
hsize_t *off = NULL; /* Pointer to sequence offsets */
hsize_t mem_off; /* Offset in memory */
size_t mem_curr_seq; /* "Current sequence" in memory */
size_t dset_curr_seq; /* "Current sequence" in dataset */
size_t _len[H5D_IO_VECTOR_SIZE]; /* Array to store sequence lengths */
size_t *len = NULL; /* Array to store sequence lengths */
size_t orig_mem_len, mem_len; /* Length of sequence in memory */
size_t nseq; /* Number of sequences generated */
size_t nelem; /* Number of elements used in sequences */
herr_t ret_value = SUCCEED; /* Return value */
size_t nseq; /* Number of sequences generated */
size_t nelem; /* Number of elements used in sequences */
size_t vec_size; /* Vector length */
herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_STATIC
@ -124,21 +126,19 @@ H5D__scatter_file(const H5D_io_info_t *_io_info,
tmp_io_info.u.wbuf = _buf;
/* Allocate the vector I/O arrays */
if(tmp_io_info.dxpl_cache->vec_size > H5D_IO_VECTOR_SIZE) {
if(NULL == (len = H5FL_SEQ_MALLOC(size_t, tmp_io_info.dxpl_cache->vec_size)))
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate I/O length vector array")
if(NULL == (off = H5FL_SEQ_MALLOC(hsize_t, tmp_io_info.dxpl_cache->vec_size)))
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate I/O offset vector array")
} /* end if */
else {
len = _len;
off = _off;
} /* end else */
if(tmp_io_info.dxpl_cache->vec_size > H5D_IO_VECTOR_SIZE)
vec_size = tmp_io_info.dxpl_cache->vec_size;
else
vec_size = H5D_IO_VECTOR_SIZE;
if(NULL == (len = H5FL_SEQ_MALLOC(size_t, vec_size)))
HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "can't allocate I/O length vector array")
if(NULL == (off = H5FL_SEQ_MALLOC(hsize_t, vec_size)))
HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "can't allocate I/O offset vector array")
/* Loop until all elements are written */
while(nelmts > 0) {
/* Get list of sequences for selection to write */
if(H5S_SELECT_GET_SEQ_LIST(space, H5S_GET_SEQ_LIST_SORTED, iter, tmp_io_info.dxpl_cache->vec_size, nelmts, &nseq, &nelem, off, len) < 0)
if(H5S_SELECT_GET_SEQ_LIST(space, H5S_GET_SEQ_LIST_SORTED, iter, vec_size, nelmts, &nseq, &nelem, off, len) < 0)
HGOTO_ERROR(H5E_INTERNAL, H5E_UNSUPPORTED, FAIL, "sequence length generation failed")
/* Reset the current sequence information */
@ -160,9 +160,9 @@ H5D__scatter_file(const H5D_io_info_t *_io_info,
done:
/* Release resources, if allocated */
if(len && len != _len)
if(len)
len = H5FL_SEQ_FREE(size_t, len);
if(off && off != _off)
if(off)
off = H5FL_SEQ_FREE(hsize_t, off);
FUNC_LEAVE_NOAPI(ret_value)
@ -196,16 +196,15 @@ H5D__gather_file(const H5D_io_info_t *_io_info,
void *_buf/*out*/)
{
H5D_io_info_t tmp_io_info; /* Temporary I/O info object */
hsize_t _off[H5D_IO_VECTOR_SIZE]; /* Array to store sequence offsets */
hsize_t *off = NULL; /* Pointer to sequence offsets */
hsize_t mem_off; /* Offset in memory */
size_t mem_curr_seq; /* "Current sequence" in memory */
size_t dset_curr_seq; /* "Current sequence" in dataset */
size_t _len[H5D_IO_VECTOR_SIZE]; /* Array to store sequence lengths */
size_t *len = NULL; /* Pointer to sequence lengths */
size_t orig_mem_len, mem_len; /* Length of sequence in memory */
size_t nseq; /* Number of sequences generated */
size_t nelem; /* Number of elements used in sequences */
size_t vec_size; /* Vector length */
size_t ret_value = nelmts; /* Return value */
FUNC_ENTER_STATIC
@ -225,21 +224,19 @@ H5D__gather_file(const H5D_io_info_t *_io_info,
tmp_io_info.u.rbuf = _buf;
/* Allocate the vector I/O arrays */
if(tmp_io_info.dxpl_cache->vec_size > H5D_IO_VECTOR_SIZE) {
if(NULL == (len = H5FL_SEQ_MALLOC(size_t, tmp_io_info.dxpl_cache->vec_size)))
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, 0, "can't allocate I/O length vector array")
if(NULL == (off = H5FL_SEQ_MALLOC(hsize_t, tmp_io_info.dxpl_cache->vec_size)))
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, 0, "can't allocate I/O offset vector array")
} /* end if */
else {
len = _len;
off = _off;
} /* end else */
if(tmp_io_info.dxpl_cache->vec_size > H5D_IO_VECTOR_SIZE)
vec_size = tmp_io_info.dxpl_cache->vec_size;
else
vec_size = H5D_IO_VECTOR_SIZE;
if(NULL == (len = H5FL_SEQ_MALLOC(size_t, vec_size)))
HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, 0, "can't allocate I/O length vector array")
if(NULL == (off = H5FL_SEQ_MALLOC(hsize_t, vec_size)))
HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, 0, "can't allocate I/O offset vector array")
/* Loop until all elements are read */
while(nelmts > 0) {
/* Get list of sequences for selection to read */
if(H5S_SELECT_GET_SEQ_LIST(space, H5S_GET_SEQ_LIST_SORTED, iter, tmp_io_info.dxpl_cache->vec_size, nelmts, &nseq, &nelem, off, len) < 0)
if(H5S_SELECT_GET_SEQ_LIST(space, H5S_GET_SEQ_LIST_SORTED, iter, vec_size, nelmts, &nseq, &nelem, off, len) < 0)
HGOTO_ERROR(H5E_INTERNAL, H5E_UNSUPPORTED, 0, "sequence length generation failed")
/* Reset the current sequence information */
@ -261,9 +258,9 @@ H5D__gather_file(const H5D_io_info_t *_io_info,
done:
/* Release resources, if allocated */
if(len && len != _len)
if(len)
len = H5FL_SEQ_FREE(size_t, len);
if(off && off != _off)
if(off)
off = H5FL_SEQ_FREE(hsize_t, off);
FUNC_LEAVE_NOAPI(ret_value)
@ -292,15 +289,14 @@ H5D__scatter_mem (const void *_tscat_buf, const H5S_t *space,
{
uint8_t *buf = (uint8_t *)_buf; /* Get local copies for address arithmetic */
const uint8_t *tscat_buf = (const uint8_t *)_tscat_buf;
hsize_t _off[H5D_IO_VECTOR_SIZE]; /* Array to store sequence offsets */
hsize_t *off = NULL; /* Pointer to sequence offsets */
size_t _len[H5D_IO_VECTOR_SIZE]; /* Array to store sequence lengths */
size_t *len = NULL; /* Pointer to sequence lengths */
hsize_t *off = NULL; /* Pointer to sequence offsets */
size_t *len = NULL; /* Pointer to sequence lengths */
size_t curr_len; /* Length of bytes left to process in sequence */
size_t nseq; /* Number of sequences generated */
size_t curr_seq; /* Current sequence being processed */
size_t nelem; /* Number of elements used in sequences */
herr_t ret_value = SUCCEED; /* Number of elements scattered */
size_t vec_size; /* Vector length */
herr_t ret_value = SUCCEED; /* Number of elements scattered */
FUNC_ENTER_PACKAGE
@ -312,21 +308,19 @@ H5D__scatter_mem (const void *_tscat_buf, const H5S_t *space,
HDassert(buf);
/* Allocate the vector I/O arrays */
if(dxpl_cache->vec_size > H5D_IO_VECTOR_SIZE) {
if(NULL == (len = H5FL_SEQ_MALLOC(size_t, dxpl_cache->vec_size)))
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate I/O length vector array")
if(NULL == (off = H5FL_SEQ_MALLOC(hsize_t, dxpl_cache->vec_size)))
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate I/O offset vector array")
} /* end if */
else {
len = _len;
off = _off;
} /* end else */
if(dxpl_cache->vec_size > H5D_IO_VECTOR_SIZE)
vec_size = dxpl_cache->vec_size;
else
vec_size = H5D_IO_VECTOR_SIZE;
if(NULL == (len = H5FL_SEQ_MALLOC(size_t, vec_size)))
HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "can't allocate I/O length vector array")
if(NULL == (off = H5FL_SEQ_MALLOC(hsize_t, vec_size)))
HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "can't allocate I/O offset vector array")
/* Loop until all elements are written */
while(nelmts > 0) {
/* Get list of sequences for selection to write */
if(H5S_SELECT_GET_SEQ_LIST(space, 0, iter, dxpl_cache->vec_size, nelmts, &nseq, &nelem, off, len) < 0)
if(H5S_SELECT_GET_SEQ_LIST(space, 0, iter, vec_size, nelmts, &nseq, &nelem, off, len) < 0)
HGOTO_ERROR (H5E_INTERNAL, H5E_UNSUPPORTED, 0, "sequence length generation failed")
/* Loop, while sequences left to process */
@ -346,9 +340,9 @@ H5D__scatter_mem (const void *_tscat_buf, const H5S_t *space,
done:
/* Release resources, if allocated */
if(len && len != _len)
if(len)
len = H5FL_SEQ_FREE(size_t, len);
if(off && off != _off)
if(off)
off = H5FL_SEQ_FREE(hsize_t, off);
FUNC_LEAVE_NOAPI(ret_value)
@ -379,15 +373,14 @@ H5D__gather_mem(const void *_buf, const H5S_t *space,
{
const uint8_t *buf = (const uint8_t *)_buf; /* Get local copies for address arithmetic */
uint8_t *tgath_buf = (uint8_t *)_tgath_buf;
hsize_t _off[H5D_IO_VECTOR_SIZE]; /* Array to store sequence offsets */
hsize_t *off = NULL; /* Pointer to sequence offsets */
size_t _len[H5D_IO_VECTOR_SIZE]; /* Array to store sequence lengths */
size_t *len = NULL; /* Pointer to sequence lengths */
size_t *len = NULL; /* Pointer to sequence lengths */
size_t curr_len; /* Length of bytes left to process in sequence */
size_t nseq; /* Number of sequences generated */
size_t curr_seq; /* Current sequence being processed */
size_t nelem; /* Number of elements used in sequences */
size_t ret_value = nelmts; /* Number of elements gathered */
size_t vec_size; /* Vector length */
size_t ret_value = nelmts; /* Number of elements gathered */
FUNC_ENTER_STATIC
@ -399,21 +392,19 @@ H5D__gather_mem(const void *_buf, const H5S_t *space,
HDassert(tgath_buf);
/* Allocate the vector I/O arrays */
if(dxpl_cache->vec_size > H5D_IO_VECTOR_SIZE) {
if(NULL == (len = H5FL_SEQ_MALLOC(size_t, dxpl_cache->vec_size)))
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, 0, "can't allocate I/O length vector array")
if(NULL == (off = H5FL_SEQ_MALLOC(hsize_t, dxpl_cache->vec_size)))
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, 0, "can't allocate I/O offset vector array")
} /* end if */
else {
len = _len;
off = _off;
} /* end else */
if(dxpl_cache->vec_size > H5D_IO_VECTOR_SIZE)
vec_size = dxpl_cache->vec_size;
else
vec_size = H5D_IO_VECTOR_SIZE;
if(NULL == (len = H5FL_SEQ_MALLOC(size_t, vec_size)))
HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, 0, "can't allocate I/O length vector array")
if(NULL == (off = H5FL_SEQ_MALLOC(hsize_t, vec_size)))
HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, 0, "can't allocate I/O offset vector array")
/* Loop until all elements are written */
while(nelmts > 0) {
/* Get list of sequences for selection to write */
if(H5S_SELECT_GET_SEQ_LIST(space, 0, iter, dxpl_cache->vec_size, nelmts, &nseq, &nelem, off, len) < 0)
if(H5S_SELECT_GET_SEQ_LIST(space, 0, iter, vec_size, nelmts, &nseq, &nelem, off, len) < 0)
HGOTO_ERROR (H5E_INTERNAL, H5E_UNSUPPORTED, 0, "sequence length generation failed")
/* Loop, while sequences left to process */
@ -433,9 +424,9 @@ H5D__gather_mem(const void *_buf, const H5S_t *space,
done:
/* Release resources, if allocated */
if(len && len != _len)
if(len)
len = H5FL_SEQ_FREE(size_t, len);
if(off && off != _off)
if(off)
off = H5FL_SEQ_FREE(hsize_t, off);
FUNC_LEAVE_NOAPI(ret_value)
@ -460,15 +451,15 @@ H5D__scatgath_read(const H5D_io_info_t *io_info, const H5D_type_info_t *type_inf
{
const H5D_dxpl_cache_t *dxpl_cache = io_info->dxpl_cache; /* Local pointer to dataset transfer info */
void *buf = io_info->u.rbuf; /* Local pointer to application buffer */
H5S_sel_iter_t mem_iter; /*memory selection iteration info*/
hbool_t mem_iter_init = FALSE; /*memory selection iteration info has been initialized */
H5S_sel_iter_t bkg_iter; /*background iteration info*/
hbool_t bkg_iter_init = FALSE; /*background iteration info has been initialized */
H5S_sel_iter_t file_iter; /*file selection iteration info*/
hbool_t file_iter_init = FALSE; /*file selection iteration info has been initialized */
hsize_t smine_start; /*strip mine start loc */
size_t smine_nelmts; /*elements per strip */
herr_t ret_value = SUCCEED; /*return value */
H5S_sel_iter_t *mem_iter = NULL; /* Memory selection iteration info*/
hbool_t mem_iter_init = FALSE; /* Memory selection iteration info has been initialized */
H5S_sel_iter_t *bkg_iter = NULL; /* Background iteration info*/
hbool_t bkg_iter_init = FALSE; /* Background iteration info has been initialized */
H5S_sel_iter_t *file_iter = NULL; /* File selection iteration info*/
hbool_t file_iter_init = FALSE; /* File selection iteration info has been initialized */
hsize_t smine_start; /* Strip mine start loc */
size_t smine_nelmts; /* Elements per strip */
herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_PACKAGE
@ -483,14 +474,22 @@ H5D__scatgath_read(const H5D_io_info_t *io_info, const H5D_type_info_t *type_inf
if(nelmts == 0)
HGOTO_DONE(SUCCEED)
/* Allocate the iterators */
if(NULL == (mem_iter = H5FL_MALLOC(H5S_sel_iter_t)))
HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "can't allocate memory iterator")
if(NULL == (bkg_iter = H5FL_MALLOC(H5S_sel_iter_t)))
HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "can't allocate background iterator")
if(NULL == (file_iter = H5FL_MALLOC(H5S_sel_iter_t)))
HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "can't allocate file iterator")
/* Figure out the strip mine size. */
if(H5S_select_iter_init(&file_iter, file_space, type_info->src_type_size) < 0)
if(H5S_select_iter_init(file_iter, file_space, type_info->src_type_size) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to initialize file selection information")
file_iter_init = TRUE; /*file selection iteration info has been initialized */
if(H5S_select_iter_init(&mem_iter, mem_space, type_info->dst_type_size) < 0)
if(H5S_select_iter_init(mem_iter, mem_space, type_info->dst_type_size) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to initialize memory selection information")
mem_iter_init = TRUE; /*file selection iteration info has been initialized */
if(H5S_select_iter_init(&bkg_iter, mem_space, type_info->dst_type_size) < 0)
if(H5S_select_iter_init(bkg_iter, mem_space, type_info->dst_type_size) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to initialize background selection information")
bkg_iter_init = TRUE; /*file selection iteration info has been initialized */
@ -499,7 +498,7 @@ H5D__scatgath_read(const H5D_io_info_t *io_info, const H5D_type_info_t *type_inf
size_t n; /* Elements operated on */
/* Go figure out how many elements to read from the file */
HDassert(H5S_SELECT_ITER_NELMTS(&file_iter) == (nelmts - smine_start));
HDassert(H5S_SELECT_ITER_NELMTS(file_iter) == (nelmts - smine_start));
smine_nelmts = (size_t)MIN(type_info->request_nelmts, (nelmts - smine_start));
/*
@ -511,8 +510,7 @@ H5D__scatgath_read(const H5D_io_info_t *io_info, const H5D_type_info_t *type_inf
/*
* Gather data
*/
n = H5D__gather_file(io_info, file_space, &file_iter, smine_nelmts,
type_info->tconv_buf/*out*/);
n = H5D__gather_file(io_info, file_space, file_iter, smine_nelmts, type_info->tconv_buf/*out*/);
if(n != smine_nelmts)
HGOTO_ERROR(H5E_IO, H5E_READERROR, FAIL, "file gather failed")
@ -521,14 +519,12 @@ H5D__scatgath_read(const H5D_io_info_t *io_info, const H5D_type_info_t *type_inf
* bypass the rest of steps.
*/
if(type_info->cmpd_subset && H5T_SUBSET_FALSE != type_info->cmpd_subset->subset) {
if(H5D__compound_opt_read(smine_nelmts, mem_space, &mem_iter, dxpl_cache,
type_info, buf /*out*/) < 0)
if(H5D__compound_opt_read(smine_nelmts, mem_space, mem_iter, dxpl_cache, type_info, buf /*out*/) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "datatype conversion failed")
} /* end if */
else {
if(H5T_BKG_YES == type_info->need_bkg) {
n = H5D__gather_mem(buf, mem_space, &bkg_iter, smine_nelmts,
dxpl_cache, type_info->bkg_buf/*out*/);
n = H5D__gather_mem(buf, mem_space, bkg_iter, smine_nelmts, dxpl_cache, type_info->bkg_buf/*out*/);
if(n != smine_nelmts)
HGOTO_ERROR(H5E_IO, H5E_READERROR, FAIL, "mem gather failed")
} /* end if */
@ -549,26 +545,25 @@ H5D__scatgath_read(const H5D_io_info_t *io_info, const H5D_type_info_t *type_inf
/*
* Scatter the data into memory.
*/
if(H5D__scatter_mem(type_info->tconv_buf, mem_space, &mem_iter,
smine_nelmts, dxpl_cache, buf/*out*/) < 0)
if(H5D__scatter_mem(type_info->tconv_buf, mem_space, mem_iter, smine_nelmts, dxpl_cache, buf/*out*/) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_READERROR, FAIL, "scatter failed")
} /* end else */
} /* end for */
done:
/* Release selection iterators */
if(file_iter_init) {
if(H5S_SELECT_ITER_RELEASE(&file_iter) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release selection iterator")
} /* end if */
if(mem_iter_init) {
if(H5S_SELECT_ITER_RELEASE(&mem_iter) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release selection iterator")
} /* end if */
if(bkg_iter_init) {
if(H5S_SELECT_ITER_RELEASE(&bkg_iter) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release selection iterator")
} /* end if */
if(file_iter_init && H5S_SELECT_ITER_RELEASE(file_iter) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release selection iterator")
if(file_iter)
file_iter = H5FL_FREE(H5S_sel_iter_t, file_iter);
if(mem_iter_init && H5S_SELECT_ITER_RELEASE(mem_iter) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release selection iterator")
if(mem_iter)
mem_iter = H5FL_FREE(H5S_sel_iter_t, mem_iter);
if(bkg_iter_init && H5S_SELECT_ITER_RELEASE(bkg_iter) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release selection iterator")
if(bkg_iter)
bkg_iter = H5FL_FREE(H5S_sel_iter_t, bkg_iter);
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5D__scatgath_read() */
@ -592,15 +587,15 @@ H5D__scatgath_write(const H5D_io_info_t *io_info, const H5D_type_info_t *type_in
{
const H5D_dxpl_cache_t *dxpl_cache = io_info->dxpl_cache; /* Local pointer to dataset transfer info */
const void *buf = io_info->u.wbuf; /* Local pointer to application buffer */
H5S_sel_iter_t mem_iter; /*memory selection iteration info*/
hbool_t mem_iter_init = FALSE; /*memory selection iteration info has been initialized */
H5S_sel_iter_t bkg_iter; /*background iteration info*/
hbool_t bkg_iter_init = FALSE; /*background iteration info has been initialized */
H5S_sel_iter_t file_iter; /*file selection iteration info*/
hbool_t file_iter_init = FALSE; /*file selection iteration info has been initialized */
hsize_t smine_start; /*strip mine start loc */
size_t smine_nelmts; /*elements per strip */
herr_t ret_value = SUCCEED; /*return value */
H5S_sel_iter_t *mem_iter = NULL; /* Memory selection iteration info*/
hbool_t mem_iter_init = FALSE; /* Memory selection iteration info has been initialized */
H5S_sel_iter_t *bkg_iter = NULL; /* Background iteration info*/
hbool_t bkg_iter_init = FALSE; /* Background iteration info has been initialized */
H5S_sel_iter_t *file_iter = NULL; /* File selection iteration info*/
hbool_t file_iter_init = FALSE; /* File selection iteration info has been initialized */
hsize_t smine_start; /* Strip mine start loc */
size_t smine_nelmts; /* Elements per strip */
herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_PACKAGE
@ -615,14 +610,22 @@ H5D__scatgath_write(const H5D_io_info_t *io_info, const H5D_type_info_t *type_in
if(nelmts == 0)
HGOTO_DONE(SUCCEED)
/* Allocate the iterators */
if(NULL == (mem_iter = H5FL_MALLOC(H5S_sel_iter_t)))
HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "can't allocate memory iterator")
if(NULL == (bkg_iter = H5FL_MALLOC(H5S_sel_iter_t)))
HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "can't allocate background iterator")
if(NULL == (file_iter = H5FL_MALLOC(H5S_sel_iter_t)))
HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "can't allocate file iterator")
/* Figure out the strip mine size. */
if(H5S_select_iter_init(&file_iter, file_space, type_info->dst_type_size) < 0)
if(H5S_select_iter_init(file_iter, file_space, type_info->dst_type_size) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to initialize file selection information")
file_iter_init = TRUE; /*file selection iteration info has been initialized */
if(H5S_select_iter_init(&mem_iter, mem_space, type_info->src_type_size) < 0)
if(H5S_select_iter_init(mem_iter, mem_space, type_info->src_type_size) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to initialize memory selection information")
mem_iter_init = TRUE; /*file selection iteration info has been initialized */
if(H5S_select_iter_init(&bkg_iter, file_space, type_info->dst_type_size) < 0)
if(H5S_select_iter_init(bkg_iter, file_space, type_info->dst_type_size) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to initialize background selection information")
bkg_iter_init = TRUE; /*file selection iteration info has been initialized */
@ -631,7 +634,7 @@ H5D__scatgath_write(const H5D_io_info_t *io_info, const H5D_type_info_t *type_in
size_t n; /* Elements operated on */
/* Go figure out how many elements to read from the file */
HDassert(H5S_SELECT_ITER_NELMTS(&file_iter) == (nelmts - smine_start));
HDassert(H5S_SELECT_ITER_NELMTS(file_iter) == (nelmts - smine_start));
smine_nelmts = (size_t)MIN(type_info->request_nelmts, (nelmts - smine_start));
/*
@ -639,8 +642,7 @@ H5D__scatgath_write(const H5D_io_info_t *io_info, const H5D_type_info_t *type_in
* buffer. Also gather data from the file into the background buffer
* if necessary.
*/
n = H5D__gather_mem(buf, mem_space, &mem_iter, smine_nelmts,
dxpl_cache, type_info->tconv_buf/*out*/);
n = H5D__gather_mem(buf, mem_space, mem_iter, smine_nelmts, dxpl_cache, type_info->tconv_buf/*out*/);
if(n != smine_nelmts)
HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "mem gather failed")
@ -657,8 +659,7 @@ H5D__scatgath_write(const H5D_io_info_t *io_info, const H5D_type_info_t *type_in
} /* end if */
else {
if(H5T_BKG_YES == type_info->need_bkg) {
n = H5D__gather_file(io_info, file_space, &bkg_iter, smine_nelmts,
type_info->bkg_buf/*out*/);
n = H5D__gather_file(io_info, file_space, bkg_iter, smine_nelmts, type_info->bkg_buf/*out*/);
if(n != smine_nelmts)
HGOTO_ERROR(H5E_IO, H5E_READERROR, FAIL, "file gather failed")
} /* end if */
@ -681,25 +682,24 @@ H5D__scatgath_write(const H5D_io_info_t *io_info, const H5D_type_info_t *type_in
/*
* Scatter the data out to the file.
*/
if(H5D__scatter_file(io_info, file_space, &file_iter, smine_nelmts,
type_info->tconv_buf) < 0)
if(H5D__scatter_file(io_info, file_space, file_iter, smine_nelmts, type_info->tconv_buf) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_WRITEERROR, FAIL, "scatter failed")
} /* end for */
done:
/* Release selection iterators */
if(file_iter_init) {
if(H5S_SELECT_ITER_RELEASE(&file_iter) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release selection iterator")
} /* end if */
if(mem_iter_init) {
if(H5S_SELECT_ITER_RELEASE(&mem_iter) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release selection iterator")
} /* end if */
if(bkg_iter_init) {
if(H5S_SELECT_ITER_RELEASE(&bkg_iter) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release selection iterator")
} /* end if */
if(file_iter_init && H5S_SELECT_ITER_RELEASE(file_iter) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release selection iterator")
if(file_iter)
file_iter = H5FL_FREE(H5S_sel_iter_t, file_iter);
if(mem_iter_init && H5S_SELECT_ITER_RELEASE(mem_iter) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release selection iterator")
if(mem_iter)
mem_iter = H5FL_FREE(H5S_sel_iter_t, mem_iter);
if(bkg_iter_init && H5S_SELECT_ITER_RELEASE(bkg_iter) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release selection iterator")
if(bkg_iter)
bkg_iter = H5FL_FREE(H5S_sel_iter_t, bkg_iter);
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5D__scatgath_write() */
@ -744,12 +744,11 @@ H5D__compound_opt_read(size_t nelmts, const H5S_t *space,
{
uint8_t *ubuf = (uint8_t *)user_buf; /* Cast for pointer arithmetic */
uint8_t *xdbuf; /* Pointer into dataset buffer */
hsize_t _off[H5D_IO_VECTOR_SIZE]; /* Array to store sequence offsets */
hsize_t *off = NULL; /* Pointer to sequence offsets */
size_t _len[H5D_IO_VECTOR_SIZE]; /* Array to store sequence lengths */
size_t *len = NULL; /* Pointer to sequence lengths */
size_t src_stride, dst_stride, copy_size;
herr_t ret_value = SUCCEED; /*return value */
size_t vec_size; /* Vector length */
herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_STATIC
@ -765,16 +764,14 @@ H5D__compound_opt_read(size_t nelmts, const H5S_t *space,
HDassert(user_buf);
/* Allocate the vector I/O arrays */
if(dxpl_cache->vec_size > H5D_IO_VECTOR_SIZE) {
if(NULL == (len = H5FL_SEQ_MALLOC(size_t, dxpl_cache->vec_size)))
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate I/O length vector array")
if(NULL == (off = H5FL_SEQ_MALLOC(hsize_t, dxpl_cache->vec_size)))
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate I/O offset vector array")
} /* end if */
else {
len = _len;
off = _off;
} /* end else */
if(dxpl_cache->vec_size > H5D_IO_VECTOR_SIZE)
vec_size = dxpl_cache->vec_size;
else
vec_size = H5D_IO_VECTOR_SIZE;
if(NULL == (len = H5FL_SEQ_MALLOC(size_t, vec_size)))
HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "can't allocate I/O length vector array")
if(NULL == (off = H5FL_SEQ_MALLOC(hsize_t, vec_size)))
HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "can't allocate I/O offset vector array")
/* Get source & destination strides */
src_stride = type_info->src_type_size;
@ -791,7 +788,7 @@ H5D__compound_opt_read(size_t nelmts, const H5S_t *space,
size_t elmtno; /* Element counter */
/* Get list of sequences for selection to write */
if(H5S_SELECT_GET_SEQ_LIST(space, 0, iter, dxpl_cache->vec_size, nelmts, &nseq, &elmtno, off, len) < 0)
if(H5S_SELECT_GET_SEQ_LIST(space, 0, iter, vec_size, nelmts, &nseq, &elmtno, off, len) < 0)
HGOTO_ERROR(H5E_INTERNAL, H5E_UNSUPPORTED, 0, "sequence length generation failed")
/* Loop, while sequences left to process */
@ -827,9 +824,9 @@ H5D__compound_opt_read(size_t nelmts, const H5S_t *space,
done:
/* Release resources, if allocated */
if(len && len != _len)
if(len)
len = H5FL_SEQ_FREE(size_t, len);
if(off && off != _off)
if(off)
off = H5FL_SEQ_FREE(hsize_t, off);
FUNC_LEAVE_NOAPI(ret_value)
@ -923,7 +920,7 @@ H5Dscatter(H5D_scatter_func_t op, void *op_data, hid_t type_id,
{
H5T_t *type; /* Datatype */
H5S_t *dst_space; /* Dataspace */
H5S_sel_iter_t iter; /* Selection iteration info*/
H5S_sel_iter_t *iter = NULL; /* Selection iteration info*/
hbool_t iter_init = FALSE; /* Selection iteration info has been initialized */
const void *src_buf = NULL; /* Source (contiguous) data buffer */
size_t src_buf_nbytes = 0; /* Size of src_buf */
@ -959,8 +956,12 @@ H5Dscatter(H5D_scatter_func_t op, void *op_data, hid_t type_id,
if((nelmts = (hssize_t)H5S_GET_SELECT_NPOINTS(dst_space)) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_CANTCOUNT, FAIL, "unable to get number of elements in selection")
/* Allocate the selection iterator */
if(NULL == (iter = H5FL_MALLOC(H5S_sel_iter_t)))
HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "can't allocate selection iterator")
/* Initialize selection iterator */
if(H5S_select_iter_init(&iter, dst_space, type_size) < 0)
if(H5S_select_iter_init(iter, dst_space, type_size) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to initialize selection iterator information")
iter_init = TRUE;
@ -984,7 +985,7 @@ H5Dscatter(H5D_scatter_func_t op, void *op_data, hid_t type_id,
HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "callback returned more elements than in selection")
/* Scatter data */
if(H5D__scatter_mem(src_buf, dst_space, &iter, nelmts_scatter, dxpl_cache, dst_buf) < 0)
if(H5D__scatter_mem(src_buf, dst_space, iter, nelmts_scatter, dxpl_cache, dst_buf) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_CANTCOPY, FAIL, "scatter failed")
nelmts -= (hssize_t)nelmts_scatter;
@ -992,10 +993,10 @@ H5Dscatter(H5D_scatter_func_t op, void *op_data, hid_t type_id,
done:
/* Release selection iterator */
if(iter_init) {
if(H5S_SELECT_ITER_RELEASE(&iter) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release selection iterator")
} /* end if */
if(iter_init && H5S_SELECT_ITER_RELEASE(iter) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release selection iterator")
if(iter)
iter = H5FL_FREE(H5S_sel_iter_t, iter);
FUNC_LEAVE_API(ret_value)
} /* H5Dscatter() */
@ -1023,7 +1024,7 @@ H5Dgather(hid_t src_space_id, const void *src_buf, hid_t type_id,
{
H5T_t *type; /* Datatype */
H5S_t *src_space; /* Dataspace */
H5S_sel_iter_t iter; /* Selection iteration info*/
H5S_sel_iter_t *iter = NULL; /* Selection iteration info*/
hbool_t iter_init = FALSE; /* Selection iteration info has been initialized */
size_t type_size; /* Datatype element size */
hssize_t nelmts; /* Number of remaining elements in selection */
@ -1071,15 +1072,19 @@ H5Dgather(hid_t src_space_id, const void *src_buf, hid_t type_id,
if(((size_t)nelmts > dst_buf_nelmts) && (op == NULL))
HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no callback supplied and destination buffer too small")
/* Allocate the selection iterator */
if(NULL == (iter = H5FL_MALLOC(H5S_sel_iter_t)))
HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "can't allocate selection iterator")
/* Initialize selection iterator */
if(H5S_select_iter_init(&iter, src_space, type_size) < 0)
if(H5S_select_iter_init(iter, src_space, type_size) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to initialize selection iterator information")
iter_init = TRUE;
/* Loop until all data has been scattered */
while(nelmts > 0) {
/* Gather data */
if(0 == (nelmts_gathered = H5D__gather_mem(src_buf, src_space, &iter, MIN(dst_buf_nelmts, (size_t)nelmts), dxpl_cache, dst_buf)))
if(0 == (nelmts_gathered = H5D__gather_mem(src_buf, src_space, iter, MIN(dst_buf_nelmts, (size_t)nelmts), dxpl_cache, dst_buf)))
HGOTO_ERROR(H5E_IO, H5E_CANTCOPY, FAIL, "gather failed")
HDassert(nelmts_gathered == MIN(dst_buf_nelmts, (size_t)nelmts));
@ -1093,10 +1098,10 @@ H5Dgather(hid_t src_space_id, const void *src_buf, hid_t type_id,
done:
/* Release selection iterator */
if(iter_init) {
if(H5S_SELECT_ITER_RELEASE(&iter) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release selection iterator")
} /* end if */
if(iter_init && H5S_SELECT_ITER_RELEASE(iter) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "Can't release selection iterator")
if(iter)
iter = H5FL_FREE(H5S_sel_iter_t, iter);
FUNC_LEAVE_API(ret_value)
} /* H5Dgather() */

84
src/H5Dselect.c
View File

@ -68,6 +68,9 @@ H5FL_SEQ_DEFINE(size_t);
/* Declare a free list to manage sequences of hsize_t */
H5FL_SEQ_DEFINE(hsize_t);
/* Declare extern free list to manage the H5S_sel_iter_t struct */
H5FL_EXTERN(H5S_sel_iter_t);
/*-------------------------------------------------------------------------
@ -86,22 +89,19 @@ static herr_t
H5D__select_io(const H5D_io_info_t *io_info, size_t elmt_size,
size_t nelmts, const H5S_t *file_space, const H5S_t *mem_space)
{
H5S_sel_iter_t mem_iter; /* Memory selection iteration info */
hbool_t mem_iter_init = 0; /* Memory selection iteration info has been initialized */
H5S_sel_iter_t file_iter; /* File selection iteration info */
hbool_t file_iter_init = 0; /* File selection iteration info has been initialized */
hsize_t _mem_off[H5D_IO_VECTOR_SIZE]; /* Array to store sequence offsets in memory */
H5S_sel_iter_t *mem_iter = NULL; /* Memory selection iteration info */
hbool_t mem_iter_init = FALSE; /* Memory selection iteration info has been initialized */
H5S_sel_iter_t *file_iter = NULL; /* File selection iteration info */
hbool_t file_iter_init = FALSE; /* File selection iteration info has been initialized */
hsize_t *mem_off = NULL; /* Pointer to sequence offsets in memory */
hsize_t _file_off[H5D_IO_VECTOR_SIZE]; /* Array to store sequence offsets in the file */
hsize_t *file_off = NULL; /* Pointer to sequence offsets in the file */
size_t _mem_len[H5D_IO_VECTOR_SIZE]; /* Array to store sequence lengths in memory */
size_t *mem_len = NULL; /* Pointer to sequence lengths in memory */
size_t _file_len[H5D_IO_VECTOR_SIZE]; /* Array to store sequence lengths in the file */
size_t *file_len = NULL; /* Pointer to sequence lengths in the file */
size_t curr_mem_seq; /* Current memory sequence to operate on */
size_t curr_file_seq; /* Current file sequence to operate on */
size_t mem_nseq; /* Number of sequences generated in the file */
size_t file_nseq; /* Number of sequences generated in memory */
size_t vec_size; /* Vector length */
ssize_t tmp_file_len; /* Temporary number of bytes in file sequence */
herr_t ret_value = SUCCEED; /* Return value */
@ -115,22 +115,18 @@ H5D__select_io(const H5D_io_info_t *io_info, size_t elmt_size,
HDassert(io_info->u.rbuf);
/* Allocate the vector I/O arrays */
if(io_info->dxpl_cache->vec_size > H5D_IO_VECTOR_SIZE) {
if(NULL == (mem_len = H5FL_SEQ_MALLOC(size_t,io_info->dxpl_cache->vec_size)))
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate I/O length vector array")
if(NULL == (mem_off = H5FL_SEQ_MALLOC(hsize_t,io_info->dxpl_cache->vec_size)))
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate I/O offset vector array")
if(NULL == (file_len = H5FL_SEQ_MALLOC(size_t,io_info->dxpl_cache->vec_size)))
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate I/O length vector array")
if(NULL == (file_off = H5FL_SEQ_MALLOC(hsize_t,io_info->dxpl_cache->vec_size)))
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate I/O offset vector array")
} /* end if */
else {
mem_len = _mem_len;
mem_off = _mem_off;
file_len = _file_len;
file_off = _file_off;
} /* end else */
if(io_info->dxpl_cache->vec_size > H5D_IO_VECTOR_SIZE)
vec_size = io_info->dxpl_cache->vec_size;
else
vec_size = H5D_IO_VECTOR_SIZE;
if(NULL == (mem_len = H5FL_SEQ_MALLOC(size_t, vec_size)))
HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "can't allocate I/O length vector array")
if(NULL == (mem_off = H5FL_SEQ_MALLOC(hsize_t, vec_size)))
HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "can't allocate I/O offset vector array")
if(NULL == (file_len = H5FL_SEQ_MALLOC(size_t, vec_size)))
HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "can't allocate I/O length vector array")
if(NULL == (file_off = H5FL_SEQ_MALLOC(hsize_t, vec_size)))
HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "can't allocate I/O offset vector array")
/* Check for only one element in selection */
if(nelmts == 1) {
@ -169,13 +165,19 @@ H5D__select_io(const H5D_io_info_t *io_info, size_t elmt_size,
size_t mem_nelem; /* Number of elements used in memory sequences */
size_t file_nelem; /* Number of elements used in file sequences */
/* Allocate the iterators */
if(NULL == (mem_iter = H5FL_MALLOC(H5S_sel_iter_t)))
HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "can't allocate memory iterator")
if(NULL == (file_iter = H5FL_MALLOC(H5S_sel_iter_t)))
HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "can't allocate file iterator")
/* Initialize file iterator */
if(H5S_select_iter_init(&file_iter, file_space, elmt_size) < 0)
if(H5S_select_iter_init(file_iter, file_space, elmt_size) < 0)
HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to initialize selection iterator")
file_iter_init = 1; /* File selection iteration info has been initialized */
/* Initialize memory iterator */
if(H5S_select_iter_init(&mem_iter, mem_space, elmt_size) < 0)
if(H5S_select_iter_init(mem_iter, mem_space, elmt_size) < 0)
HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to initialize selection iterator")
mem_iter_init = 1; /* Memory selection iteration info has been initialized */
@ -188,7 +190,7 @@ H5D__select_io(const H5D_io_info_t *io_info, size_t elmt_size,
/* Check if more file sequences are needed */
if(curr_file_seq >= file_nseq) {
/* Get sequences for file selection */
if(H5S_SELECT_GET_SEQ_LIST(file_space, H5S_GET_SEQ_LIST_SORTED, &file_iter, io_info->dxpl_cache->vec_size, nelmts, &file_nseq, &file_nelem, file_off, file_len) < 0)
if(H5S_SELECT_GET_SEQ_LIST(file_space, H5S_GET_SEQ_LIST_SORTED, file_iter, vec_size, nelmts, &file_nseq, &file_nelem, file_off, file_len) < 0)
HGOTO_ERROR(H5E_INTERNAL, H5E_UNSUPPORTED, FAIL, "sequence length generation failed")
/* Start at the beginning of the sequences again */
@ -198,7 +200,7 @@ H5D__select_io(const H5D_io_info_t *io_info, size_t elmt_size,
/* Check if more memory sequences are needed */
if(curr_mem_seq >= mem_nseq) {
/* Get sequences for memory selection */
if(H5S_SELECT_GET_SEQ_LIST(mem_space, 0, &mem_iter, io_info->dxpl_cache->vec_size, nelmts, &mem_nseq, &mem_nelem, mem_off, mem_len) < 0)
if(H5S_SELECT_GET_SEQ_LIST(mem_space, 0, mem_iter, vec_size, nelmts, &mem_nseq, &mem_nelem, mem_off, mem_len) < 0)
HGOTO_ERROR(H5E_INTERNAL, H5E_UNSUPPORTED, FAIL, "sequence length generation failed")
/* Start at the beginning of the sequences again */
@ -227,24 +229,24 @@ H5D__select_io(const H5D_io_info_t *io_info, size_t elmt_size,
} /* end else */
done:
/* Release file selection iterator */
if(file_iter_init)
if(H5S_SELECT_ITER_RELEASE(&file_iter) < 0)
HDONE_ERROR(H5E_DATASPACE, H5E_CANTRELEASE, FAIL, "unable to release selection iterator")
/* Release memory selection iterator */
if(mem_iter_init)
if(H5S_SELECT_ITER_RELEASE(&mem_iter) < 0)
HDONE_ERROR(H5E_DATASPACE, H5E_CANTRELEASE, FAIL, "unable to release selection iterator")
/* Release selection iterators */
if(file_iter_init && H5S_SELECT_ITER_RELEASE(file_iter) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTRELEASE, FAIL, "unable to release selection iterator")
if(file_iter)
file_iter = H5FL_FREE(H5S_sel_iter_t, file_iter);
if(mem_iter_init && H5S_SELECT_ITER_RELEASE(mem_iter) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTRELEASE, FAIL, "unable to release selection iterator")
if(mem_iter)
mem_iter = H5FL_FREE(H5S_sel_iter_t, mem_iter);
/* Release vector arrays, if allocated */
if(file_len && file_len != _file_len)
if(file_len)
file_len = H5FL_SEQ_FREE(size_t, file_len);
if(file_off && file_off != _file_off)
if(file_off)
file_off = H5FL_SEQ_FREE(hsize_t, file_off);
if(mem_len && mem_len != _mem_len)
if(mem_len)
mem_len = H5FL_SEQ_FREE(size_t, mem_len);
if(mem_off && mem_off != _mem_off)
if(mem_off)
mem_off = H5FL_SEQ_FREE(hsize_t, mem_off);
FUNC_LEAVE_NOAPI(ret_value)

44
src/H5FDfamily.c
View File

@ -46,10 +46,8 @@
#include "H5MMprivate.h" /* Memory management */
#include "H5Pprivate.h" /* Property lists */
#undef MAX
#define MAX(X,Y) ((X)>(Y)?(X):(Y))
#undef MIN
#define MIN(X,Y) ((X)<(Y)?(X):(Y))
/* The size of the member name buffers */
#define H5FD_FAM_MEMB_NAME_BUF_SIZE 4096
/* The driver identification number, initialized at runtime */
static hid_t H5FD_FAMILY_g = 0;
@ -623,11 +621,11 @@ static H5FD_t *
H5FD_family_open(const char *name, unsigned flags, hid_t fapl_id,
haddr_t maxaddr)
{
H5FD_family_t *file=NULL;
H5FD_t *ret_value=NULL;
char memb_name[4096], temp[4096];
hsize_t eof=HADDR_UNDEF;
H5FD_family_t *file = NULL;
char *memb_name = NULL, *temp = NULL;
hsize_t eof = HADDR_UNDEF;
unsigned t_flags = flags & ~H5F_ACC_CREAT;
H5FD_t *ret_value = NULL;
FUNC_ENTER_NOAPI_NOINIT
@ -683,15 +681,21 @@ H5FD_family_open(const char *name, unsigned flags, hid_t fapl_id,
file->name = H5MM_strdup(name);
file->flags = flags;
/* Allocate space for the string buffers */
if(NULL == (memb_name = (char *)H5MM_malloc(H5FD_FAM_MEMB_NAME_BUF_SIZE)))
HGOTO_ERROR(H5E_FILE, H5E_CANTALLOC, NULL, "unable to allocate member name")
if(NULL == (temp = (char *)H5MM_malloc(H5FD_FAM_MEMB_NAME_BUF_SIZE)))
HGOTO_ERROR(H5E_FILE, H5E_CANTALLOC, NULL, "unable to allocate temporary member name")
/* Check that names are unique */
HDsnprintf(memb_name, sizeof(memb_name), name, 0);
HDsnprintf(temp, sizeof(temp), name, 1);
HDsnprintf(memb_name, H5FD_FAM_MEMB_NAME_BUF_SIZE, name, 0);
HDsnprintf(temp, H5FD_FAM_MEMB_NAME_BUF_SIZE, name, 1);
if(!HDstrcmp(memb_name, temp))
HGOTO_ERROR(H5E_FILE, H5E_FILEEXISTS, NULL, "file names not unique")
/* Open all the family members */
while(1) {
HDsnprintf(memb_name, sizeof(memb_name), name, file->nmembs);
HDsnprintf(memb_name, H5FD_FAM_MEMB_NAME_BUF_SIZE, name, file->nmembs);
/* Enlarge member array */
if(file->nmembs >= file->amembs) {
@ -732,6 +736,12 @@ H5FD_family_open(const char *name, unsigned flags, hid_t fapl_id,
ret_value=(H5FD_t *)file;
done:
/* Release resources */
if(memb_name)
H5MM_xfree(memb_name);
if(temp)
H5MM_xfree(temp);
/* Cleanup and fail */
if(ret_value == NULL && file != NULL) {
unsigned nerrors = 0; /* Number of errors closing member files */
@ -941,12 +951,16 @@ H5FD_family_set_eoa(H5FD_t *_file, H5FD_mem_t type, haddr_t abs_eoa)
{
H5FD_family_t *file = (H5FD_family_t*)_file;
haddr_t addr = abs_eoa;
char memb_name[4096];
char *memb_name = NULL;
unsigned u; /* Local index variable */
herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_NOAPI_NOINIT
/* Allocate space for the member name buffer */
if(NULL == (memb_name = (char *)H5MM_malloc(H5FD_FAM_MEMB_NAME_BUF_SIZE)))
HGOTO_ERROR(H5E_FILE, H5E_CANTALLOC, FAIL, "unable to allocate member name")
for(u = 0; addr || u < file->nmembs; u++) {
/* Enlarge member array */
@ -964,7 +978,7 @@ H5FD_family_set_eoa(H5FD_t *_file, H5FD_mem_t type, haddr_t abs_eoa)
/* Create another file if necessary */
if(u >= file->nmembs || !file->memb[u]) {
file->nmembs = MAX(file->nmembs, u+1);
HDsnprintf(memb_name, sizeof(memb_name), file->name, u);
HDsnprintf(memb_name, H5FD_FAM_MEMB_NAME_BUF_SIZE, file->name, u);
H5E_BEGIN_TRY {
H5_CHECK_OVERFLOW(file->memb_size, hsize_t, haddr_t);
file->memb[u] = H5FDopen(memb_name, file->flags | H5F_ACC_CREAT,
@ -992,6 +1006,10 @@ H5FD_family_set_eoa(H5FD_t *_file, H5FD_mem_t type, haddr_t abs_eoa)
file->eoa = abs_eoa;
done:
/* Release resources */
if(memb_name)
H5MM_xfree(memb_name);
FUNC_LEAVE_NOAPI(ret_value)
}

18
src/H5FL.c
View File

@ -293,7 +293,7 @@ H5FL_reg_init(H5FL_reg_head_t *head)
H5FL_reg_gc_head.first=new_node;
/* Indicate that the free list is initialized */
head->init=1;
head->init = TRUE;
/* Make certain that the space allocated is large enough to store a free list pointer (eventually) */
if(head->size<sizeof(H5FL_reg_node_t))
@ -655,7 +655,7 @@ printf("%s: head->name = %s, head->allocated = %d\n", FUNC, H5FL_reg_gc_head.fir
/* No allocations left open for list, get rid of it */
else {
/* Reset the "initialized" flag, in case we restart this list somehow (I don't know how..) */
H5FL_reg_gc_head.first->list->init = 0;
H5FL_reg_gc_head.first->list->init = FALSE;
/* Free the node from the garbage collection list */
H5MM_xfree(H5FL_reg_gc_head.first);
@ -822,7 +822,7 @@ H5FL_blk_init(H5FL_blk_head_t *head)
H5FL_blk_gc_head.first=new_node;
/* Indicate that the PQ is initialized */
head->init=1;
head->init = TRUE;
done:
FUNC_LEAVE_NOAPI(ret_value)
@ -1326,7 +1326,7 @@ printf("%s: head->name = %s, head->allocated = %d\n", FUNC, H5FL_blk_gc_head.fir
/* No allocations left open for list, get rid of it */
else {
/* Reset the "initialized" flag, in case we restart this list somehow (I don't know how..) */
H5FL_blk_gc_head.first->pq->init = 0;
H5FL_blk_gc_head.first->pq->init = FALSE;
/* Free the node from the garbage collection list */
H5MM_free(H5FL_blk_gc_head.first);
@ -1379,7 +1379,7 @@ H5FL_arr_init(H5FL_arr_head_t *head)
H5FL_arr_gc_head.first=new_node;
/* Allocate room for the free lists */
if(NULL == (head->list_arr = (H5FL_arr_node_t *)H5MM_calloc((size_t)head->maxelem*sizeof(H5FL_arr_node_t))))
if(NULL == (head->list_arr = (H5FL_arr_node_t *)H5MM_calloc((size_t)head->maxelem * sizeof(H5FL_arr_node_t))))
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed")
/* Initialize the size of each array */
@ -1387,7 +1387,7 @@ H5FL_arr_init(H5FL_arr_head_t *head)
head->list_arr[u].size = head->base_size + (head->elem_size * u);
/* Indicate that the free list is initialized */
head->init = 1;
head->init = TRUE;
done:
FUNC_LEAVE_NOAPI(ret_value)
@ -1795,7 +1795,7 @@ printf("%s: head->name = %s, head->allocated = %d\n", FUNC, H5FL_arr_gc_head.fir
H5MM_xfree(H5FL_arr_gc_head.first->list->list_arr);
/* Reset the "initialized" flag, in case we restart this list somehow (I don't know how..) */
H5FL_arr_gc_head.first->list->init = 0;
H5FL_arr_gc_head.first->list->init = FALSE;
/* Free the node from the garbage collection list */
H5MM_free(H5FL_arr_gc_head.first);
@ -2007,7 +2007,7 @@ H5FL_fac_init(size_t size)
#endif /* H5FL_TRACK */
/* Indicate that the free list is initialized */
factory->init = 1;
factory->init = TRUE;
/* Set return value */
ret_value = factory;
@ -2417,7 +2417,7 @@ printf("%s: head->size = %d, head->allocated = %d\n", FUNC, (int)H5FL_fac_gc_hea
HDassert(H5FL_fac_gc_head.first->list->allocated == 0);
/* Reset the "initialized" flag, in case we restart this list somehow (I don't know how..) */
H5FL_fac_gc_head.first->list->init = 0;
H5FL_fac_gc_head.first->list->init = FALSE;
/* Free the node from the garbage collection list */
H5FL_fac_gc_head.first = H5FL_FREE(H5FL_fac_gc_node_t, H5FL_fac_gc_head.first);

12
src/H5FLprivate.h
View File

@ -97,7 +97,7 @@ typedef struct H5FL_reg_node_t {
/* Data structure for free list of blocks */
typedef struct H5FL_reg_head_t {
unsigned init; /* Whether the free list has been initialized */
hbool_t init; /* Whether the free list has been initialized */
unsigned allocated; /* Number of blocks allocated */
unsigned onlist; /* Number of blocks on free list */
const char *name; /* Name of the type */
@ -166,9 +166,9 @@ typedef struct H5FL_blk_node_t {
/* Data structure for priority queue of native block free lists */
typedef struct H5FL_blk_head_t {
unsigned init; /* Whether the free list has been initialized */
unsigned allocated; /* Number of blocks allocated */
unsigned onlist; /* Number of blocks on free list */
hbool_t init; /* Whether the free list has been initialized */
unsigned allocated; /* Number of blocks allocated */
unsigned onlist; /* Number of blocks on free list */
size_t list_mem; /* Amount of memory in block on free list */
const char *name; /* Name of the type */
H5FL_blk_node_t *head; /* Pointer to first free list in queue */
@ -237,7 +237,7 @@ typedef struct H5FL_arr_node_t {
/* Data structure for free list of array blocks */
typedef struct H5FL_arr_head_t {
unsigned init; /* Whether the free list has been initialized */
hbool_t init; /* Whether the free list has been initialized */
unsigned allocated; /* Number of blocks allocated */
size_t list_mem; /* Amount of memory in block on free list */
const char *name; /* Name of the type */
@ -354,7 +354,7 @@ typedef struct H5FL_fac_node_t H5FL_fac_node_t;
/* Data structure for free list block factory */
typedef struct H5FL_fac_head_t {
unsigned init; /* Whether the free list has been initialized */
hbool_t init; /* Whether the free list has been initialized */
unsigned allocated; /* Number of blocks allocated */
unsigned onlist; /* Number of blocks on free list */
size_t size; /* Size of the blocks in the list */

4
src/H5HFcache.c
View File

@ -618,8 +618,8 @@ H5HF__cache_hdr_image_len(const void *_thing, size_t *image_len,
*-------------------------------------------------------------------------
*/
static herr_t
H5HF__cache_hdr_pre_serialize(const H5F_t *f, hid_t dxpl_id, void *_thing,
haddr_t addr, size_t len, size_t H5_ATTR_UNUSED compressed_len,
H5HF__cache_hdr_pre_serialize(const H5F_t *f, hid_t H5_ATTR_UNUSED dxpl_id,
void *_thing, haddr_t addr, size_t len, size_t H5_ATTR_UNUSED compressed_len,
haddr_t H5_ATTR_UNUSED *new_addr, size_t H5_ATTR_UNUSED *new_len,
size_t H5_ATTR_UNUSED *new_compressed_len, unsigned *flags)
{

5
src/H5Oalloc.c
View File

@ -763,7 +763,7 @@ H5O_alloc_new_chunk(H5F_t *f, hid_t dxpl_id, H5O_t *oh, size_t size, size_t *new
size_t idx; /* Message number */
uint8_t *p = NULL; /*ptr into new chunk */
H5O_cont_t *cont = NULL; /*native continuation message */
size_t chunkno; /* Chunk allocated */
unsigned chunkno; /* Chunk allocated */
haddr_t new_chunk_addr;
unsigned u; /* Local index variable */
herr_t ret_value = SUCCEED; /* Return value */
@ -921,7 +921,8 @@ H5O_alloc_new_chunk(H5F_t *f, hid_t dxpl_id, H5O_t *oh, size_t size, size_t *new
oh->chunk = x;
} /* end if */
chunkno = (unsigned)oh->nchunks++;
H5_CHECKED_ASSIGN(chunkno, unsigned, oh->nchunks, size_t);
oh->nchunks++;
oh->chunk[chunkno].addr = new_chunk_addr;
oh->chunk[chunkno].size = size;
oh->chunk[chunkno].gap = 0;

4
src/H5Ocache.c
View File

@ -770,7 +770,7 @@ H5O__cache_chk_deserialize(const void *image, size_t len, void *_udata,
/* Set the fields for the chunk proxy */
chk_proxy->oh = udata->oh;
chk_proxy->chunkno = udata->oh->nchunks - 1;
H5_CHECKED_ASSIGN(chk_proxy->chunkno, unsigned, udata->oh->nchunks - 1, size_t);
} /* end if */
else {
/* Sanity check */
@ -1324,7 +1324,7 @@ H5O__chunk_deserialize(H5O_t *oh, haddr_t addr, size_t len, const uint8_t *image
/* Decode continuation message */
cont = (H5O_cont_t *)(H5O_MSG_CONT->decode)(udata->f, udata->dxpl_id, NULL, 0, &ioflags, oh->mesg[curmesg].raw);
cont->chunkno = udata->cont_msg_info->nmsgs + 1; /*the next continuation message/chunk */
H5_CHECKED_ASSIGN(cont->chunkno, unsigned, udata->cont_msg_info->nmsgs + 1, size_t); /* the next continuation message/chunk */
/* Save 'native' form of continuation message */
oh->mesg[curmesg].native = cont;

2
src/H5Pfapl.c
View File

@ -778,7 +778,7 @@ done:
const void *
H5P_peek_driver_info(H5P_genplist_t *plist)
{
void *ret_value = NULL; /* Return value */
const void *ret_value = NULL; /* Return value */
FUNC_ENTER_NOAPI(NULL)

60
src/H5Shyper.c
View File

@ -145,6 +145,9 @@ H5FL_DEFINE_STATIC(H5S_hyper_span_t);
/* Declare a free list to manage the H5S_hyper_span_info_t struct */
H5FL_DEFINE_STATIC(H5S_hyper_span_info_t);
/* Declare extern free list to manage the H5S_sel_iter_t struct */
H5FL_EXTERN(H5S_sel_iter_t);
/* #define H5S_HYPER_DEBUG */
#ifdef H5S_HYPER_DEBUG
static herr_t
@ -9288,7 +9291,7 @@ H5S__hyper_project_intersection(const H5S_t *src_space, const H5S_t *dst_space,
size_t ss_nelem; /* Number of elements for src_space */
size_t ss_i = (size_t)0; /* Index into offset/length arrays for src_space */
hbool_t advance_ss = FALSE; /* Whether to advance ss_i on the next iteration */
H5S_sel_iter_t ss_iter; /* Selection iterator for src_space */
H5S_sel_iter_t *ss_iter = NULL; /* Selection iterator for src_space */
hbool_t ss_iter_init = FALSE; /* Whether ss_iter is initialized */
hsize_t ss_sel_off = (hsize_t)0; /* Offset within src_space selection */
hsize_t ds_off[H5S_PROJECT_INTERSECT_NSEQS]; /* Offset array for dst_space */
@ -9296,7 +9299,7 @@ H5S__hyper_project_intersection(const H5S_t *src_space, const H5S_t *dst_space,
size_t ds_nseq; /* Number of sequences for dst_space */
size_t ds_nelem; /* Number of elements for dst_space */
size_t ds_i = (size_t)0; /* Index into offset/length arrays for dst_space */
H5S_sel_iter_t ds_iter; /* Selection iterator for dst_space */
H5S_sel_iter_t *ds_iter = NULL; /* Selection iterator for dst_space */
hbool_t ds_iter_init = FALSE; /* Whether ds_iter is initialized */
hsize_t ds_sel_off = (hsize_t)0; /* Offset within dst_space selection */
hsize_t sis_off[H5S_PROJECT_INTERSECT_NSEQS]; /* Offset array for src_intersect_space */
@ -9305,7 +9308,7 @@ H5S__hyper_project_intersection(const H5S_t *src_space, const H5S_t *dst_space,
size_t sis_nelem; /* Number of elements for src_intersect_space */
size_t sis_i = (size_t)0; /* Index into offset/length arrays for src_intersect_space */
hbool_t advance_sis = FALSE; /* Whether to advance sis_i on the next iteration */
H5S_sel_iter_t sis_iter; /* Selection iterator for src_intersect_space */
H5S_sel_iter_t *sis_iter = NULL; /* Selection iterator for src_intersect_space */
hbool_t sis_iter_init = FALSE; /* Whether sis_iter is initialized */
hsize_t int_sel_off; /* Offset within intersected selections (ss/sis and ds/ps) */
size_t int_len; /* Length of segment in intersected selections */
@ -9384,35 +9387,47 @@ H5S__hyper_project_intersection(const H5S_t *src_space, const H5S_t *dst_space,
/* Set unlim_dim */
proj_space->select.sel_info.hslab->unlim_dim = -1;
/* Allocate the source space iterator */
if(NULL == (ss_iter = H5FL_MALLOC(H5S_sel_iter_t)))
HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, FAIL, "can't allocate source space iterator")
/* Initialize source space iterator */
if(H5S_select_iter_init(&ss_iter, src_space, (size_t)1) < 0)
if(H5S_select_iter_init(ss_iter, src_space, (size_t)1) < 0)
HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to initialize selection iterator")
ss_iter_init = TRUE;
/* Get sequence list for source space */
if(H5S_SELECT_GET_SEQ_LIST(src_space, 0u, &ss_iter, H5S_PROJECT_INTERSECT_NSEQS, ss_nelem, &ss_nseq, &nelem, ss_off, ss_len) < 0)
if(H5S_SELECT_GET_SEQ_LIST(src_space, 0u, ss_iter, H5S_PROJECT_INTERSECT_NSEQS, ss_nelem, &ss_nseq, &nelem, ss_off, ss_len) < 0)
HGOTO_ERROR(H5E_INTERNAL, H5E_UNSUPPORTED, FAIL, "sequence length generation failed")
ss_nelem -= nelem;
HDassert(ss_nseq > 0);
/* Allocate the destination space iterator */
if(NULL == (ds_iter = H5FL_MALLOC(H5S_sel_iter_t)))
HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, FAIL, "can't allocate destination space iterator")
/* Initialize destination space iterator */
if(H5S_select_iter_init(&ds_iter, dst_space, (size_t)1) < 0)
if(H5S_select_iter_init(ds_iter, dst_space, (size_t)1) < 0)
HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to initialize selection iterator")
ds_iter_init = TRUE;
/* Get sequence list for destination space */
if(H5S_SELECT_GET_SEQ_LIST(dst_space, 0u, &ds_iter, H5S_PROJECT_INTERSECT_NSEQS, ds_nelem, &ds_nseq, &nelem, ds_off, ds_len) < 0)
if(H5S_SELECT_GET_SEQ_LIST(dst_space, 0u, ds_iter, H5S_PROJECT_INTERSECT_NSEQS, ds_nelem, &ds_nseq, &nelem, ds_off, ds_len) < 0)
HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to initialize selection iterator")
ds_nelem -= nelem;
HDassert(ds_nseq > 0);
/* Allocate the source intersect space iterator */
if(NULL == (sis_iter = H5FL_MALLOC(H5S_sel_iter_t)))
HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, FAIL, "can't allocate source intersect space iterator")
/* Initialize source intersect space iterator */
if(H5S_select_iter_init(&sis_iter, src_intersect_space, (size_t)1) < 0)
if(H5S_select_iter_init(sis_iter, src_intersect_space, (size_t)1) < 0)
HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to initialize selection iterator")
sis_iter_init = TRUE;
/* Get sequence list for source intersect space */
if(H5S_SELECT_GET_SEQ_LIST(src_intersect_space, 0u, &sis_iter, H5S_PROJECT_INTERSECT_NSEQS, sis_nelem, &sis_nseq, &nelem, sis_off, sis_len) < 0)
if(H5S_SELECT_GET_SEQ_LIST(src_intersect_space, 0u, sis_iter, H5S_PROJECT_INTERSECT_NSEQS, sis_nelem, &sis_nseq, &nelem, sis_off, sis_len) < 0)
HGOTO_ERROR(H5E_INTERNAL, H5E_UNSUPPORTED, FAIL, "sequence length generation failed")
sis_nelem -= nelem;
HDassert(sis_nseq > 0);
@ -9427,7 +9442,7 @@ H5S__hyper_project_intersection(const H5S_t *src_space, const H5S_t *dst_space,
if(++ss_i == ss_nseq) {
if(ss_nelem > 0) {
/* Try to grab more sequences from src_space */
if(H5S_SELECT_GET_SEQ_LIST(src_space, 0u, &ss_iter, H5S_PROJECT_INTERSECT_NSEQS, ss_nelem, &ss_nseq, &nelem, ss_off, ss_len) < 0)
if(H5S_SELECT_GET_SEQ_LIST(src_space, 0u, ss_iter, H5S_PROJECT_INTERSECT_NSEQS, ss_nelem, &ss_nseq, &nelem, ss_off, ss_len) < 0)
HGOTO_ERROR(H5E_INTERNAL, H5E_UNSUPPORTED, FAIL, "sequence length generation failed")
HDassert(ss_len[0] > 0);
@ -9459,7 +9474,7 @@ H5S__hyper_project_intersection(const H5S_t *src_space, const H5S_t *dst_space,
if(sis_nelem > 0) {
/* Try to grab more sequences from src_intersect_space
*/
if(H5S_SELECT_GET_SEQ_LIST(src_intersect_space, 0u, &sis_iter, H5S_PROJECT_INTERSECT_NSEQS, sis_nelem, &sis_nseq, &nelem, sis_off, sis_len) < 0)
if(H5S_SELECT_GET_SEQ_LIST(src_intersect_space, 0u, sis_iter, H5S_PROJECT_INTERSECT_NSEQS, sis_nelem, &sis_nseq, &nelem, sis_off, sis_len) < 0)
HGOTO_ERROR(H5E_INTERNAL, H5E_UNSUPPORTED, FAIL, "sequence length generation failed")
HDassert(sis_len[0] > 0);
@ -9511,7 +9526,7 @@ H5S__hyper_project_intersection(const H5S_t *src_space, const H5S_t *dst_space,
HDassert(ds_nelem > 0);
/* Try to grab more sequences from dst_space */
if(H5S_SELECT_GET_SEQ_LIST(dst_space, 0u, &ds_iter, H5S_PROJECT_INTERSECT_NSEQS, ds_nelem, &ds_nseq, &nelem, ds_off, ds_len) < 0)
if(H5S_SELECT_GET_SEQ_LIST(dst_space, 0u, ds_iter, H5S_PROJECT_INTERSECT_NSEQS, ds_nelem, &ds_nseq, &nelem, ds_off, ds_len) < 0)
HGOTO_ERROR(H5E_INTERNAL, H5E_UNSUPPORTED, FAIL, "sequence length generation failed")
HDassert(ds_len[0] > 0);
@ -9625,19 +9640,22 @@ loop_end:
done:
/* Release source selection iterator */
if(ss_iter_init)
if(H5S_SELECT_ITER_RELEASE(&ss_iter) < 0)
HDONE_ERROR(H5E_DATASPACE, H5E_CANTRELEASE, FAIL, "unable to release selection iterator")
if(ss_iter_init && H5S_SELECT_ITER_RELEASE(ss_iter) < 0)
HDONE_ERROR(H5E_DATASPACE, H5E_CANTRELEASE, FAIL, "unable to release selection iterator")
if(ss_iter)
ss_iter = H5FL_FREE(H5S_sel_iter_t, ss_iter);
/* Release destination selection iterator */
if(ds_iter_init)
if(H5S_SELECT_ITER_RELEASE(&ds_iter) < 0)
HDONE_ERROR(H5E_DATASPACE, H5E_CANTRELEASE, FAIL, "unable to release selection iterator")
if(ds_iter_init && H5S_SELECT_ITER_RELEASE(ds_iter) < 0)
HDONE_ERROR(H5E_DATASPACE, H5E_CANTRELEASE, FAIL, "unable to release selection iterator")
if(ds_iter)
ds_iter = H5FL_FREE(H5S_sel_iter_t, ds_iter);
/* Release source intersect selection iterator */
if(sis_iter_init)
if(H5S_SELECT_ITER_RELEASE(&sis_iter) < 0)
HDONE_ERROR(H5E_DATASPACE, H5E_CANTRELEASE, FAIL, "unable to release selection iterator")
if(sis_iter_init && H5S_SELECT_ITER_RELEASE(sis_iter) < 0)
HDONE_ERROR(H5E_DATASPACE, H5E_CANTRELEASE, FAIL, "unable to release selection iterator")
if(sis_iter)
sis_iter = H5FL_FREE(H5S_sel_iter_t, sis_iter);
/* Cleanup on error */
if(ret_value < 0) {

111
src/H5Sselect.c
View File

@ -39,6 +39,15 @@ static htri_t H5S_select_iter_has_next_block(const H5S_sel_iter_t *iter);
static herr_t H5S_select_iter_next_block(H5S_sel_iter_t *iter);
#endif /* LATER */
/* Declare a free list to manage the H5S_sel_iter_t struct */
H5FL_DEFINE(H5S_sel_iter_t);
/* Declare extern free list to manage sequences of size_t */
H5FL_SEQ_EXTERN(size_t);
/* Declare extern free list to manage sequences of hsize_t */
H5FL_SEQ_EXTERN(hsize_t);
/*--------------------------------------------------------------------------
@ -1364,8 +1373,10 @@ herr_t
H5S_select_iterate(void *buf, const H5T_t *type, const H5S_t *space,
const H5S_sel_iter_op_t *op, void *op_data)
{
H5S_sel_iter_t iter; /* Selection iteration info */
H5S_sel_iter_t *iter = NULL; /* Selection iteration info */
hbool_t iter_init = FALSE; /* Selection iteration info has been initialized */
hsize_t *off = NULL; /* Array to store sequence offsets */
size_t *len = NULL; /* Array to store sequence lengths */
hssize_t nelmts; /* Number of elements in selection */
hsize_t space_size[H5O_LAYOUT_NDIMS]; /* Dataspace size */
size_t max_elem; /* Maximum number of elements allowed in sequences */
@ -1386,8 +1397,12 @@ H5S_select_iterate(void *buf, const H5T_t *type, const H5S_t *space,
if(0 == (elmt_size = H5T_get_size(type)))
HGOTO_ERROR(H5E_DATATYPE, H5E_BADSIZE, FAIL, "datatype size invalid")
/* Allocate the selection iterator */
if(NULL == (iter = H5FL_MALLOC(H5S_sel_iter_t)))
HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, FAIL, "can't allocate selection iterator")
/* Initialize iterator */
if(H5S_select_iter_init(&iter, space, elmt_size) < 0)
if(H5S_select_iter_init(iter, space, elmt_size) < 0)
HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to initialize selection iterator")
iter_init = TRUE; /* Selection iteration info has been initialized */
@ -1408,16 +1423,20 @@ H5S_select_iterate(void *buf, const H5T_t *type, const H5S_t *space,
/* Compute the maximum number of bytes required */
H5_CHECKED_ASSIGN(max_elem, size_t, nelmts, hssize_t);
/* Allocate the offset & length arrays */
if(NULL == (len = H5FL_SEQ_MALLOC(size_t, H5D_IO_VECTOR_SIZE)))
HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, FAIL, "can't allocate length vector array")
if(NULL == (off = H5FL_SEQ_MALLOC(hsize_t, H5D_IO_VECTOR_SIZE)))
HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, FAIL, "can't allocate offset vector array")
/* Loop, while elements left in selection */
while(max_elem > 0 && user_ret == 0) {
hsize_t off[H5D_IO_VECTOR_SIZE]; /* Array to store sequence offsets */
size_t len[H5D_IO_VECTOR_SIZE]; /* Array to store sequence lengths */
size_t nelem; /* Number of elements used in sequences */
size_t nseq; /* Number of sequences generated */
size_t curr_seq; /* Current sequence being worked on */
/* Get the sequences of bytes */
if(H5S_SELECT_GET_SEQ_LIST(space, 0, &iter, (size_t)H5D_IO_VECTOR_SIZE, max_elem, &nseq, &nelem, off, len) < 0)
if(H5S_SELECT_GET_SEQ_LIST(space, 0, iter, (size_t)H5D_IO_VECTOR_SIZE, max_elem, &nseq, &nelem, off, len) < 0)
HGOTO_ERROR(H5E_INTERNAL, H5E_UNSUPPORTED, FAIL, "sequence length generation failed")
/* Loop, while sequences left to process */
@ -1477,9 +1496,17 @@ H5S_select_iterate(void *buf, const H5T_t *type, const H5S_t *space,
ret_value = user_ret;
done:
/* Release resources, if allocated */
if(len)
len = H5FL_SEQ_FREE(size_t, len);
if(off)
off = H5FL_SEQ_FREE(hsize_t, off);
/* Release selection iterator */
if(iter_init && H5S_SELECT_ITER_RELEASE(&iter) < 0)
if(iter_init && H5S_SELECT_ITER_RELEASE(iter) < 0)
HDONE_ERROR(H5E_DATASPACE, H5E_CANTRELEASE, FAIL, "unable to release selection iterator")
if(iter)
iter = H5FL_FREE(H5S_sel_iter_t, iter);
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5S_select_iterate() */
@ -1583,8 +1610,8 @@ H5S_get_select_type(const H5S_t *space)
htri_t
H5S_select_shape_same(const H5S_t *space1, const H5S_t *space2)
{
H5S_sel_iter_t iter_a; /* Selection a iteration info */
H5S_sel_iter_t iter_b; /* Selection b iteration info */
H5S_sel_iter_t *iter_a = NULL; /* Selection a iteration info */
H5S_sel_iter_t *iter_b = NULL; /* Selection b iteration info */
hbool_t iter_a_init = 0; /* Selection a iteration info has been initialized */
hbool_t iter_b_init = 0; /* Selection b iteration info has been initialized */
htri_t ret_value = TRUE; /* Return value */
@ -1729,15 +1756,21 @@ H5S_select_shape_same(const H5S_t *space1, const H5S_t *space2)
hsize_t off_b[H5O_LAYOUT_NDIMS]; /* Offset of selection b blocks */
hbool_t first_block = TRUE; /* Flag to indicate the first block */
/* Allocate the selection iterators */
if(NULL == (iter_a = H5FL_MALLOC(H5S_sel_iter_t)))
HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, FAIL, "can't allocate selection iterator")
if(NULL == (iter_b = H5FL_MALLOC(H5S_sel_iter_t)))
HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, FAIL, "can't allocate selection iterator")
/* Initialize iterator for each dataspace selection
* Use '0' for element size instead of actual element size to indicate
* that the selection iterator shouldn't be "flattened", since we
* aren't actually going to be doing I/O with the iterators.
*/
if(H5S_select_iter_init(&iter_a, space_a, (size_t)0) < 0)
if(H5S_select_iter_init(iter_a, space_a, (size_t)0) < 0)
HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to initialize selection iterator a")
iter_a_init = 1;
if(H5S_select_iter_init(&iter_b, space_b, (size_t)0) < 0)
if(H5S_select_iter_init(iter_b, space_b, (size_t)0) < 0)
HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to initialize selection iterator b")
iter_b_init = 1;
@ -1748,9 +1781,9 @@ H5S_select_shape_same(const H5S_t *space1, const H5S_t *space2)
htri_t status_a, status_b; /* Status from next block checks */
/* Get the current block for each selection iterator */
if(H5S_SELECT_ITER_BLOCK(&iter_a, start_a, end_a) < 0)
if(H5S_SELECT_ITER_BLOCK(iter_a, start_a, end_a) < 0)
HGOTO_ERROR(H5E_DATASPACE, H5E_CANTGET, FAIL, "unable to get iterator block a")
if(H5S_SELECT_ITER_BLOCK(&iter_b, start_b, end_b) < 0)
if(H5S_SELECT_ITER_BLOCK(iter_b, start_b, end_b) < 0)
HGOTO_ERROR(H5E_DATASPACE, H5E_CANTGET, FAIL, "unable to get iterator block b")
space_a_dim = (int)space_a_rank - 1;
@ -1821,10 +1854,10 @@ H5S_select_shape_same(const H5S_t *space1, const H5S_t *space2)
} /* end else */
/* Check if we are able to advance to the next selection block */
if((status_a = H5S_SELECT_ITER_HAS_NEXT_BLOCK(&iter_a)) < 0)
if((status_a = H5S_SELECT_ITER_HAS_NEXT_BLOCK(iter_a)) < 0)
HGOTO_ERROR(H5E_DATASPACE, H5E_CANTNEXT, FAIL, "unable to check iterator block a")
if((status_b = H5S_SELECT_ITER_HAS_NEXT_BLOCK(&iter_b)) < 0)
if((status_b = H5S_SELECT_ITER_HAS_NEXT_BLOCK(iter_b)) < 0)
HGOTO_ERROR(H5E_DATASPACE, H5E_CANTNEXT, FAIL, "unable to check iterator block b")
/* Did we run out of blocks at the same time? */
@ -1834,10 +1867,10 @@ H5S_select_shape_same(const H5S_t *space1, const H5S_t *space2)
HGOTO_DONE(FALSE)
else {
/* Advance to next block in selection iterators */
if(H5S_SELECT_ITER_NEXT_BLOCK(&iter_a) < 0)
if(H5S_SELECT_ITER_NEXT_BLOCK(iter_a) < 0)
HGOTO_ERROR(H5E_DATASPACE, H5E_CANTNEXT, FAIL, "unable to advance to next iterator block a")
if(H5S_SELECT_ITER_NEXT_BLOCK(&iter_b) < 0)
if(H5S_SELECT_ITER_NEXT_BLOCK(iter_b) < 0)
HGOTO_ERROR(H5E_DATASPACE, H5E_CANTNEXT, FAIL, "unable to advance to next iterator block b")
} /* end else */
} /* end while */
@ -1845,12 +1878,14 @@ H5S_select_shape_same(const H5S_t *space1, const H5S_t *space2)
} /* end else */
done:
if(iter_a_init)
if(H5S_SELECT_ITER_RELEASE(&iter_a) < 0)
HDONE_ERROR(H5E_DATASPACE, H5E_CANTRELEASE, FAIL, "unable to release selection iterator a")
if(iter_b_init)
if(H5S_SELECT_ITER_RELEASE(&iter_b) < 0)
HDONE_ERROR(H5E_DATASPACE, H5E_CANTRELEASE, FAIL, "unable to release selection iterator b")
if(iter_a_init && H5S_SELECT_ITER_RELEASE(iter_a) < 0)
HDONE_ERROR(H5E_DATASPACE, H5E_CANTRELEASE, FAIL, "unable to release selection iterator a")
if(iter_a)
iter_a = H5FL_FREE(H5S_sel_iter_t, iter_a);
if(iter_b_init && H5S_SELECT_ITER_RELEASE(iter_b) < 0)
HDONE_ERROR(H5E_DATASPACE, H5E_CANTRELEASE, FAIL, "unable to release selection iterator b")
if(iter_b)
iter_b = H5FL_FREE(H5S_sel_iter_t, iter_b);
FUNC_LEAVE_NOAPI(ret_value)
} /* H5S_select_shape_same() */
@ -2152,8 +2187,10 @@ done:
herr_t
H5S_select_fill(const void *fill, size_t fill_size, const H5S_t *space, void *_buf)
{
H5S_sel_iter_t iter; /* Selection iteration info */
H5S_sel_iter_t *iter = NULL; /* Selection iteration info */
hbool_t iter_init = 0; /* Selection iteration info has been initialized */
hsize_t *off = NULL; /* Array to store sequence offsets */
size_t *len = NULL; /* Array to store sequence lengths */
hssize_t nelmts; /* Number of elements in selection */
size_t max_elem; /* Total number of elements in selection */
herr_t ret_value = SUCCEED; /* Return value */
@ -2166,8 +2203,12 @@ H5S_select_fill(const void *fill, size_t fill_size, const H5S_t *space, void *_b
HDassert(space);
HDassert(_buf);
/* Allocate the selection iterator */
if(NULL == (iter = H5FL_MALLOC(H5S_sel_iter_t)))
HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, FAIL, "can't allocate selection iterator")
/* Initialize iterator */
if(H5S_select_iter_init(&iter, space, fill_size) < 0)
if(H5S_select_iter_init(iter, space, fill_size) < 0)
HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to initialize selection iterator")
iter_init = 1; /* Selection iteration info has been initialized */
@ -2178,16 +2219,20 @@ H5S_select_fill(const void *fill, size_t fill_size, const H5S_t *space, void *_b
/* Compute the number of bytes to process */
H5_CHECKED_ASSIGN(max_elem, size_t, nelmts, hssize_t);
/* Allocate the offset & length arrays */
if(NULL == (len = H5FL_SEQ_MALLOC(size_t, H5D_IO_VECTOR_SIZE)))
HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, FAIL, "can't allocate length vector array")
if(NULL == (off = H5FL_SEQ_MALLOC(hsize_t, H5D_IO_VECTOR_SIZE)))
HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, FAIL, "can't allocate offset vector array")
/* Loop, while elements left in selection */
while(max_elem > 0) {
hsize_t off[H5D_IO_VECTOR_SIZE]; /* Array to store sequence offsets */
size_t len[H5D_IO_VECTOR_SIZE]; /* Array to store sequence lengths */
size_t nseq; /* Number of sequences generated */
size_t curr_seq; /* Current sequnce being worked on */
size_t nelem; /* Number of elements used in sequences */
/* Get the sequences of bytes */
if(H5S_SELECT_GET_SEQ_LIST(space, 0, &iter, (size_t)H5D_IO_VECTOR_SIZE, max_elem, &nseq, &nelem, off, len) < 0)
if(H5S_SELECT_GET_SEQ_LIST(space, 0, iter, (size_t)H5D_IO_VECTOR_SIZE, max_elem, &nseq, &nelem, off, len) < 0)
HGOTO_ERROR(H5E_INTERNAL, H5E_UNSUPPORTED, FAIL, "sequence length generation failed")
/* Loop over sequences */
@ -2207,9 +2252,17 @@ H5S_select_fill(const void *fill, size_t fill_size, const H5S_t *space, void *_b
} /* end while */
done:
/* Release resouces */
if(iter_init && H5S_SELECT_ITER_RELEASE(&iter) < 0)
/* Release resources, if allocated */
if(len)
len = H5FL_SEQ_FREE(size_t, len);
if(off)
off = H5FL_SEQ_FREE(hsize_t, off);
/* Release selection iterator */
if(iter_init && H5S_SELECT_ITER_RELEASE(iter) < 0)
HDONE_ERROR(H5E_DATASPACE, H5E_CANTRELEASE, FAIL, "unable to release selection iterator")
if(iter)
iter = H5FL_FREE(H5S_sel_iter_t, iter);
FUNC_LEAVE_NOAPI(ret_value)
} /* H5S_select_fill() */

29
src/H5system.c
View File

@ -172,7 +172,7 @@ HDfprintf(FILE *stream, const char *fmt, ...)
s = rest;
} /* end if */
else if ('*'==*s) {
fwidth = va_arg (ap, int);
fwidth = va_arg(ap, int);
if(fwidth < 0) {
leftjust = 1;
fwidth = -fwidth;
@ -269,23 +269,22 @@ HDfprintf(FILE *stream, const char *fmt, ...)
len += HDsnprintf(format_templ + len, (sizeof(format_templ) - (size_t)(len + 1)), "%s", modifier);
HDsnprintf(format_templ + len, (sizeof(format_templ) - (size_t)(len + 1)), "%c", conv);
/* Conversion */
switch (conv) {
case 'd':
case 'i':
if(!HDstrcmp(modifier, "h")) {
short x = (short)va_arg (ap, int);
n = fprintf (stream, format_templ, x);
short x = (short)va_arg(ap, int);
n = fprintf(stream, format_templ, x);
} else if(!*modifier) {
int x = va_arg (ap, int);
n = fprintf (stream, format_templ, x);
} else if(!HDstrcmp (modifier, "l")) {
long x = va_arg (ap, long);
n = fprintf (stream, format_templ, x);
int x = va_arg(ap, int);
n = fprintf(stream, format_templ, x);
} else if(!HDstrcmp(modifier, "l")) {
long x = va_arg(ap, long);
n = fprintf(stream, format_templ, x);
} else {
int64_t x = va_arg(ap, int64_t);
n = fprintf (stream, format_templ, x);
n = fprintf(stream, format_templ, x);
}
break;
@ -294,13 +293,13 @@ HDfprintf(FILE *stream, const char *fmt, ...)
case 'x':
case 'X':
if(!HDstrcmp(modifier, "h")) {
unsigned short x = (unsigned short)va_arg (ap, unsigned int);
unsigned short x = (unsigned short)va_arg(ap, unsigned int);
n = fprintf(stream, format_templ, x);
} else if(!*modifier) {
unsigned int x = va_arg (ap, unsigned int); /*lint !e732 Loss of sign not really occuring */
unsigned int x = va_arg(ap, unsigned int); /*lint !e732 Loss of sign not really occuring */
n = fprintf(stream, format_templ, x);
} else if(!HDstrcmp(modifier, "l")) {
unsigned long x = va_arg (ap, unsigned long); /*lint !e732 Loss of sign not really occuring */
unsigned long x = va_arg(ap, unsigned long); /*lint !e732 Loss of sign not really occuring */
n = fprintf(stream, format_templ, x);
} else {
uint64_t x = va_arg(ap, uint64_t); /*lint !e732 Loss of sign not really occuring */
@ -336,7 +335,7 @@ HDfprintf(FILE *stream, const char *fmt, ...)
case 'a':
{
haddr_t x = va_arg (ap, haddr_t); /*lint !e732 Loss of sign not really occuring */
haddr_t x = va_arg(ap, haddr_t); /*lint !e732 Loss of sign not really occuring */
if(H5F_addr_defined(x)) {
len = 0;
@ -405,7 +404,7 @@ HDfprintf(FILE *stream, const char *fmt, ...)
htri_t tri_var = va_arg(ap, htri_t);
if(tri_var > 0)
fprintf (stream, "TRUE");
fprintf(stream, "TRUE");
else if(!tri_var)
fprintf(stream, "FALSE");
else

38
src/H5timer.c
View File

@ -127,16 +127,16 @@ H5_timer_begin (H5_timer_t *timer)
#ifdef H5_HAVE_GETRUSAGE
HDgetrusage (RUSAGE_SELF, &rusage);
timer->utime = (double)rusage.ru_utime.tv_sec +
((double)rusage.ru_utime.tv_usec / 1e6F);
((double)rusage.ru_utime.tv_usec / (double)1e6F);
timer->stime = (double)rusage.ru_stime.tv_sec +
((double)rusage.ru_stime.tv_usec / 1e6F);
((double)rusage.ru_stime.tv_usec / (double)1e6F);
#else
timer->utime = 0.0F;
timer->stime = 0.0F;
#endif
#ifdef H5_HAVE_GETTIMEOFDAY
HDgettimeofday (&etime, NULL);
timer->etime = (double)etime.tv_sec + ((double)etime.tv_usec / 1e6F);
timer->etime = (double)etime.tv_sec + ((double)etime.tv_usec / (double)1e6F);
#else
timer->etime = 0.0F;
#endif
@ -166,9 +166,9 @@ H5_timer_end (H5_timer_t *sum/*in,out*/, H5_timer_t *timer/*in,out*/)
HDassert(timer);
H5_timer_begin(&now);
timer->utime = MAX(0.0F, now.utime - timer->utime);
timer->stime = MAX(0.0F, now.stime - timer->stime);
timer->etime = MAX(0.0F, now.etime - timer->etime);
timer->utime = MAX((double)0.0F, now.utime - timer->utime);
timer->stime = MAX((double)0.0F, now.stime - timer->stime);
timer->etime = MAX((double)0.0F, now.etime - timer->etime);
if (sum) {
sum->utime += timer->utime;
@ -208,28 +208,28 @@ H5_bandwidth(char *buf/*out*/, double nbytes, double nseconds)
{
double bw;
if(nseconds <= 0.0F)
if(nseconds <= (double)0.0F)
HDstrcpy(buf, " NaN");
else {
bw = nbytes/nseconds;
if(H5_DBL_ABS_EQUAL(bw, 0.0F))
HDstrcpy(buf, "0.000 B/s");
else if(bw < 1.0F)
if(H5_DBL_ABS_EQUAL(bw, (double)0.0F))
HDstrcpy(buf, "0.000 B/s");
else if(bw < (double)1.0F)
sprintf(buf, "%10.4e", bw);
else if(bw < H5_KB) {
else if(bw < (double)H5_KB) {
sprintf(buf, "%05.4f", bw);
HDstrcpy(buf+5, " B/s");
} else if(bw < H5_MB) {
sprintf(buf, "%05.4f", bw / H5_KB);
} else if(bw < (double)H5_MB) {
sprintf(buf, "%05.4f", bw / (double)H5_KB);
HDstrcpy(buf+5, " kB/s");
} else if(bw < H5_GB) {
sprintf(buf, "%05.4f", bw / H5_MB);
} else if(bw < (double)H5_GB) {
sprintf(buf, "%05.4f", bw / (double)H5_MB);
HDstrcpy(buf+5, " MB/s");
} else if(bw < H5_TB) {
sprintf(buf, "%05.4f", bw / H5_GB);
} else if(bw < (double)H5_TB) {
sprintf(buf, "%05.4f", bw / (double)H5_GB);
HDstrcpy(buf+5, " GB/s");
} else if(bw < H5_PB) {
sprintf(buf, "%05.4f", bw / H5_TB);
} else if(bw < (double)H5_PB) {
sprintf(buf, "%05.4f", bw / (double)H5_TB);
HDstrcpy(buf+5, " TB/s");
} else {
sprintf(buf, "%10.4e", bw);

167
test/cmpd_dset.c
View File

@ -102,15 +102,18 @@ typedef struct {
float f, g, h[16], i, j;
double k, l, m, n;
} stype1;
typedef struct {
int a, b, c[8], d, e;
float f, g, h[16], i, j;
double k, l, m, n;
long o, p, q;
} stype2;
typedef struct {
int a, b, c[8], d, e;
} stype3;
typedef struct {
int a, b, c[8], d, e;
float f, g, h[16], i, j;
@ -147,7 +150,7 @@ typedef struct {
* Moved this part of code from MAIN to TEST_COMPOUND function.
*-------------------------------------------------------------------------
*/
static int
static unsigned
test_compound (char *filename, hid_t fapl)
{
/* First dataset */
@ -868,31 +871,31 @@ error:
*-------------------------------------------------------------------------
*/
static void
initialize_stype1(unsigned char *buf, const size_t num)
initialize_stype1(unsigned char *buf, size_t num)
{
int i, j;
stype1 *s_ptr;
for (i=0; i<(int)num; i++) {
s_ptr = (stype1*)buf + i;
s_ptr->a = i*8+0;
s_ptr->b = i*8+1;
for(j=0; j<8; j++)
s_ptr->c[j] = i*8+j;
s_ptr->d = i*8+6;
s_ptr->e = i*8+7;
for(i = 0; i < (int)num; i++) {
s_ptr = (stype1 *)buf + i;
s_ptr->a = i * 8 + 0;
s_ptr->b = i * 8 + 1;
for(j = 0; j < 8; j++)
s_ptr->c[j] = i * 8 + j;
s_ptr->d = i * 8 + 6;
s_ptr->e = i * 8 + 7;
s_ptr->f = i*2/3;
s_ptr->g = i*2/3+1;
for(j=0; j<16; j++)
s_ptr->h[j] = i*j/5+j;
s_ptr->i = i*2/3+2;
s_ptr->j = i*2/3+3;
s_ptr->f = (float)(i * 2 / 3);
s_ptr->g = (float)(i * 2 / 3 + 1);
for(j = 0; j < 16; j++)
s_ptr->h[j] = (float)(i * j / 5 + j);
s_ptr->i = (float)(i * 2 / 3 + 2);
s_ptr->j = (float)(i * 2 / 3 + 3);
s_ptr->k = i/7+1;
s_ptr->l = i/7+2;
s_ptr->m = i/7+3;
s_ptr->n = i/7+4;
s_ptr->k = i / 7 + 1;
s_ptr->l = i / 7 + 2;
s_ptr->m = i / 7 + 3;
s_ptr->n = i / 7 + 4;
}
}
@ -911,35 +914,35 @@ initialize_stype1(unsigned char *buf, const size_t num)
*-------------------------------------------------------------------------
*/
static void
initialize_stype2(unsigned char *buf, const size_t num)
initialize_stype2(unsigned char *buf, size_t num)
{
size_t i, j;
stype2 *s_ptr;
for (i=0; i<num; i++) {
s_ptr = (stype2*)buf + i;
s_ptr->a = i*8+0;
s_ptr->b = i*8+1;
for(j=0; j<8; j++)
s_ptr->c[j] = i*8+j;
s_ptr->d = i*8+6;
s_ptr->e = i*8+7;
for(i = 0; i < num; i++) {
s_ptr = (stype2 *)buf + i;
s_ptr->a = (int)(i * 8 + 0);
s_ptr->b = (int)(i * 8 + 1);
for(j = 0; j < 8; j++)
s_ptr->c[j] = (int)(i * 8 + j);
s_ptr->d = (int)(i * 8 + 6);
s_ptr->e = (int)(i * 8 + 7);
s_ptr->f = i*2/3;
s_ptr->g = i*2/3+1;
for(j=0; j<16; j++)
s_ptr->h[j] = i*j/5+j;
s_ptr->i = i*2/3+2;
s_ptr->j = i*2/3+3;
s_ptr->f = (float)(i * 2 / 3);
s_ptr->g = (float)(i * 2 / 3 + 1);
for(j = 0; j < 16; j++)
s_ptr->h[j] = (float)(i * j / 5 + j);
s_ptr->i = (float)(i * 2 / 3 + 2);
s_ptr->j = (float)(i * 2 / 3 + 3);
s_ptr->k = i/7+1;
s_ptr->l = i/7+2;
s_ptr->m = i/7+3;
s_ptr->n = i/7+4;
s_ptr->k = (double)(i / 7 + 1);
s_ptr->l = (double)(i / 7 + 2);
s_ptr->m = (double)(i / 7 + 3);
s_ptr->n = (double)(i / 7 + 4);
s_ptr->o = i*3+0;
s_ptr->p = i*3+1;
s_ptr->q = i*3+2;
s_ptr->o = (long)(i * 3 + 0);
s_ptr->p = (long)(i * 3 + 1);
s_ptr->q = (long)(i * 3 + 2);
}
}
@ -958,19 +961,19 @@ initialize_stype2(unsigned char *buf, const size_t num)
*-------------------------------------------------------------------------
*/
static void
initialize_stype3(unsigned char *buf, const size_t num)
initialize_stype3(unsigned char *buf, size_t num)
{
int i, j;
stype3 *s_ptr;
for (i=0; i<(int)num; i++) {
s_ptr = (stype3*)buf + i;
s_ptr->a = i*8+0;
s_ptr->b = i*8+1;
for(j=0; j<8; j++)
s_ptr->c[j] = i*8+j;
s_ptr->d = i*8+6;
s_ptr->e = i*8+7;
for(i = 0; i < (int)num; i++) {
s_ptr = (stype3 *)buf + i;
s_ptr->a = i * 8 + 0;
s_ptr->b = i * 8 + 1;
for(j = 0; j < 8; j++)
s_ptr->c[j] = i * 8 + j;
s_ptr->d = i * 8 + 6;
s_ptr->e = i * 8 + 7;
}
}
@ -989,39 +992,39 @@ initialize_stype3(unsigned char *buf, const size_t num)
*-------------------------------------------------------------------------
*/
static void
initialize_stype4(unsigned char *buf, const size_t num)
initialize_stype4(unsigned char *buf, size_t num)
{
size_t i, j;
stype4 *s_ptr;
for (i=0; i<num; i++) {
s_ptr = (stype4*)buf + i;
s_ptr->a = i*8+0;
s_ptr->b = i*8+1;
for(j=0; j<8; j++)
s_ptr->c[j] = i*8+j;
s_ptr->d = i*8+6;
s_ptr->e = i*8+7;
for(i = 0; i < num; i++) {
s_ptr = (stype4 *)buf + i;
s_ptr->a = (int)(i * 8 + 0);
s_ptr->b = (int)(i * 8 + 1);
for(j = 0; j < 8; j++)
s_ptr->c[j] = (int)(i * 8 + j);
s_ptr->d = (int)(i * 8 + 6);
s_ptr->e = (int)(i * 8 + 7);
s_ptr->f = i*2/3;
s_ptr->g = i*2/3+1;
for(j=0; j<16; j++)
s_ptr->h[j] = i*j/5+j;
s_ptr->i = i*2/3+2;
s_ptr->j = i*2/3+3;
s_ptr->f = (float)(i * 2 / 3);
s_ptr->g = (float)(i * 2 / 3 + 1);
for(j = 0; j < 16; j++)
s_ptr->h[j] = (float)(i * j / 5 + j);
s_ptr->i = (float)(i * 2 / 3 + 2);
s_ptr->j = (float)(i * 2 / 3 + 3);
s_ptr->k = i/7+1;
s_ptr->l = i/7+2;
s_ptr->m = i/7+3;
s_ptr->n = i/7+4;
s_ptr->k = (double)(i / 7 + 1);
s_ptr->l = (double)(i / 7 + 2);
s_ptr->m = (double)(i / 7 + 3);
s_ptr->n = (double)(i / 7 + 4);
s_ptr->o = i*3+0;
s_ptr->p = i*3+1;
s_ptr->q = i*3+2;
s_ptr->o = (long)(i * 3 + 0);
s_ptr->p = (long)(i * 3 + 1);
s_ptr->q = (long)(i * 3 + 2);
s_ptr->r = i*5+1;
s_ptr->s = i*5+2;
s_ptr->t = i*5+3;
s_ptr->r = (long long)(i * 5 + 1);
s_ptr->s = (long long)(i * 5 + 2);
s_ptr->t = (long long)(i * 5 + 3);
}
}
@ -1349,7 +1352,7 @@ error:
* Modifications:
*-------------------------------------------------------------------------
*/
static int
static unsigned
test_hdf5_src_subset(char *filename, hid_t fapl)
{
hid_t file;
@ -1554,7 +1557,7 @@ error:
* Modifications:
*-------------------------------------------------------------------------
*/
static int
static unsigned
test_hdf5_dst_subset(char *filename, hid_t fapl)
{
hid_t file;
@ -1763,7 +1766,7 @@ error:
* Modifications:
*-------------------------------------------------------------------------
*/
static int
static unsigned
test_pack_ooo(void)
{
hid_t cmpd, sub_cmpd; /* Datatype IDs */
@ -1788,7 +1791,7 @@ test_pack_ooo(void)
for(i=0; i<PACK_NMEMBS; i++) {
/* Generate index into free_order array */
num_free = PACK_NMEMBS - i;
j = HDrand() % num_free;
j = (unsigned)HDrandom() % num_free;
/* Update order array at the randomly generated (but guaranteed to be
* free) location */
@ -1800,7 +1803,7 @@ test_pack_ooo(void)
} /* end for */
/* Generate order to insert inner compound type */
sub_cmpd_order = HDrand() % PACK_NMEMBS;
sub_cmpd_order = (unsigned)HDrandom() % PACK_NMEMBS;
for(extra_space=0; extra_space<2; extra_space ++) {
if(extra_space)
@ -1995,7 +1998,7 @@ error:
* Modifications:
*-------------------------------------------------------------------------
*/
static int
static unsigned
test_ooo_order(char *filename)
{
hid_t file = -1; /* File ID */

653
test/dsets.c
View File

@ -2952,25 +2952,34 @@ test_nbit_float(hid_t file)
/* Define user-defined single-precision floating-point type for dataset */
datatype = H5Tcopy(H5T_IEEE_F32BE);
if(H5Tset_fields(datatype, (size_t)26, (size_t)20, (size_t)6, (size_t)7, (size_t)13) < 0) goto error;
if(H5Tset_fields(datatype, (size_t)26, (size_t)20, (size_t)6, (size_t)7, (size_t)13) < 0)
FAIL_STACK_ERROR
offset = 7;
if(H5Tset_offset(datatype,offset) < 0) goto error;
if(H5Tset_offset(datatype,offset) < 0)
FAIL_STACK_ERROR
precision = 20;
if(H5Tset_precision(datatype,precision) < 0) goto error;
if(H5Tset_size(datatype, (size_t)4) < 0) goto error;
if(H5Tset_ebias(datatype, (size_t)31) < 0) goto error;
if(H5Tset_precision(datatype,precision) < 0)
FAIL_STACK_ERROR
if(H5Tset_size(datatype, (size_t)4) < 0)
FAIL_STACK_ERROR
if(H5Tset_ebias(datatype, (size_t)31) < 0)
FAIL_STACK_ERROR
/* Create the data space */
if((space = H5Screate_simple(2, size, NULL)) < 0) goto error;
if((space = H5Screate_simple(2, size, NULL)) < 0)
FAIL_STACK_ERROR
/* Use nbit filter */
if((dc = H5Pcreate(H5P_DATASET_CREATE)) < 0) goto error;
if(H5Pset_chunk(dc, 2, chunk_size) < 0) goto error;
if(H5Pset_nbit(dc) < 0) goto error;
if((dc = H5Pcreate(H5P_DATASET_CREATE)) < 0)
FAIL_STACK_ERROR
if(H5Pset_chunk(dc, 2, chunk_size) < 0)
FAIL_STACK_ERROR
if(H5Pset_nbit(dc) < 0)
FAIL_STACK_ERROR
/* Create the dataset */
if((dataset = H5Dcreate2(file, DSET_NBIT_FLOAT_NAME, datatype,
space, H5P_DEFAULT, dc, H5P_DEFAULT)) < 0) goto error;
if((dataset = H5Dcreate2(file, DSET_NBIT_FLOAT_NAME, datatype, space, H5P_DEFAULT, dc, H5P_DEFAULT)) < 0)
FAIL_STACK_ERROR
PASSED();
/*----------------------------------------------------------------------
@ -2980,9 +2989,8 @@ test_nbit_float(hid_t file)
*/
TESTING(" nbit float (write)");
if(H5Dwrite(dataset, H5T_NATIVE_FLOAT, H5S_ALL, H5S_ALL, H5P_DEFAULT,
orig_data) < 0)
goto error;
if(H5Dwrite(dataset, H5T_NATIVE_FLOAT, H5S_ALL, H5S_ALL, H5P_DEFAULT, orig_data) < 0)
FAIL_STACK_ERROR
PASSED();
@ -2993,17 +3001,17 @@ test_nbit_float(hid_t file)
TESTING(" nbit float (read)");
/* Read the dataset back */
if(H5Dread(dataset, H5T_NATIVE_FLOAT, H5S_ALL, H5S_ALL, H5P_DEFAULT,
new_data) < 0)
goto error;
if(H5Dread(dataset, H5T_NATIVE_FLOAT, H5S_ALL, H5S_ALL, H5P_DEFAULT, new_data) < 0)
FAIL_STACK_ERROR
/* Check that the values read are the same as the values written
* Assume size of int = size of float
*/
for(i=0; i<(size_t)size[0]; i++) {
for(j=0; j<(size_t)size[1]; j++) {
if(!(orig_data[i][j]==orig_data[i][j])) continue; /* skip if value is NaN */
if(new_data[i][j] != orig_data[i][j]) {
for(i = 0; i < (size_t)size[0]; i++) {
for(j = 0; j < (size_t)size[1]; j++) {
if(!(orig_data[i][j] == orig_data[i][j]))
continue; /* skip if value is NaN */
if(!H5_FLT_ABS_EQUAL(new_data[i][j], orig_data[i][j])) {
H5_FAILED();
printf(" Read different values than written.\n");
printf(" At index %lu,%lu\n", (unsigned long)i, (unsigned long)j);
@ -3016,10 +3024,14 @@ test_nbit_float(hid_t file)
* Cleanup
*----------------------------------------------------------------------
*/
if(H5Tclose(datatype) < 0) goto error;
if(H5Pclose(dc) < 0) goto error;
if(H5Sclose(space) < 0) goto error;
if(H5Dclose(dataset) < 0) goto error;
if(H5Tclose(datatype) < 0)
FAIL_STACK_ERROR
if(H5Pclose(dc) < 0)
FAIL_STACK_ERROR
if(H5Sclose(space) < 0)
FAIL_STACK_ERROR
if(H5Dclose(dataset) < 0)
FAIL_STACK_ERROR
PASSED();
@ -3077,25 +3089,34 @@ test_nbit_double(hid_t file)
/* Define user-defined doule-precision floating-point type for dataset */
datatype = H5Tcopy(H5T_IEEE_F64BE);
if(H5Tset_fields(datatype, (size_t)55, (size_t)46, (size_t)9, (size_t)5, (size_t)41) < 0) goto error;
if(H5Tset_fields(datatype, (size_t)55, (size_t)46, (size_t)9, (size_t)5, (size_t)41) < 0)
FAIL_STACK_ERROR
offset = 5;
if(H5Tset_offset(datatype,offset) < 0) goto error;
if(H5Tset_offset(datatype,offset) < 0)
FAIL_STACK_ERROR
precision = 51;
if(H5Tset_precision(datatype,precision) < 0) goto error;
if(H5Tset_size(datatype, (size_t)8) < 0) goto error;
if(H5Tset_ebias(datatype, (size_t)255) < 0) goto error;
if(H5Tset_precision(datatype,precision) < 0)
FAIL_STACK_ERROR
if(H5Tset_size(datatype, (size_t)8) < 0)
FAIL_STACK_ERROR
if(H5Tset_ebias(datatype, (size_t)255) < 0)
FAIL_STACK_ERROR
/* Create the data space */
if((space = H5Screate_simple(2, size, NULL)) < 0) goto error;
if((space = H5Screate_simple(2, size, NULL)) < 0)
FAIL_STACK_ERROR
/* Use nbit filter */
if((dc = H5Pcreate(H5P_DATASET_CREATE)) < 0) goto error;
if(H5Pset_chunk(dc, 2, chunk_size) < 0) goto error;
if(H5Pset_nbit(dc) < 0) goto error;
if((dc = H5Pcreate(H5P_DATASET_CREATE)) < 0)
FAIL_STACK_ERROR
if(H5Pset_chunk(dc, 2, chunk_size) < 0)
FAIL_STACK_ERROR
if(H5Pset_nbit(dc) < 0)
FAIL_STACK_ERROR
/* Create the dataset */
if((dataset = H5Dcreate2(file, DSET_NBIT_DOUBLE_NAME, datatype,
space, H5P_DEFAULT, dc, H5P_DEFAULT)) < 0) goto error;
if((dataset = H5Dcreate2(file, DSET_NBIT_DOUBLE_NAME, datatype, space, H5P_DEFAULT, dc, H5P_DEFAULT)) < 0)
FAIL_STACK_ERROR
PASSED();
@ -3106,9 +3127,8 @@ test_nbit_double(hid_t file)
*/
TESTING(" nbit double (write)");
if(H5Dwrite(dataset, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL, H5P_DEFAULT,
orig_data) < 0)
goto error;
if(H5Dwrite(dataset, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL, H5P_DEFAULT, orig_data) < 0)
FAIL_STACK_ERROR
PASSED();
/*----------------------------------------------------------------------
@ -3118,17 +3138,17 @@ test_nbit_double(hid_t file)
TESTING(" nbit double (read)");
/* Read the dataset back */
if(H5Dread(dataset, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL, H5P_DEFAULT,
new_data) < 0)
goto error;
if(H5Dread(dataset, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL, H5P_DEFAULT, new_data) < 0)
FAIL_STACK_ERROR
/* Check that the values read are the same as the values written
* Assume size of long long = size of double
*/
for(i=0; i<(size_t)size[0]; i++) {
for(j=0; j<(size_t)size[1]; j++) {
if(!(orig_data[i][j]==orig_data[i][j])) continue; /* skip if value is NaN */
if(new_data[i][j] != orig_data[i][j]) {
for(i = 0; i < (size_t)size[0]; i++) {
for(j = 0; j < (size_t)size[1]; j++) {
if(!(orig_data[i][j] == orig_data[i][j]))
continue; /* skip if value is NaN */
if(!H5_DBL_ABS_EQUAL(new_data[i][j], orig_data[i][j])) {
H5_FAILED();
printf(" Read different values than written.\n");
printf(" At index %lu,%lu\n", (unsigned long)i, (unsigned long)j);
@ -3141,10 +3161,14 @@ test_nbit_double(hid_t file)
* Cleanup
*----------------------------------------------------------------------
*/
if(H5Tclose(datatype) < 0) goto error;
if(H5Pclose(dc) < 0) goto error;
if(H5Sclose(space) < 0) goto error;
if(H5Dclose(dataset) < 0) goto error;
if(H5Tclose(datatype) < 0)
FAIL_STACK_ERROR
if(H5Pclose(dc) < 0)
FAIL_STACK_ERROR
if(H5Sclose(space) < 0)
FAIL_STACK_ERROR
if(H5Dclose(dataset) < 0)
FAIL_STACK_ERROR
PASSED();
@ -3330,73 +3354,103 @@ test_nbit_compound(hid_t file)
TESTING(" nbit compound (setup)");
/* Define datatypes of members of compound datatype */
i_tid=H5Tcopy(H5T_NATIVE_INT);
c_tid=H5Tcopy(H5T_NATIVE_CHAR);
s_tid=H5Tcopy(H5T_NATIVE_SHORT);
f_tid=H5Tcopy(H5T_IEEE_F32BE);
if((i_tid = H5Tcopy(H5T_NATIVE_INT)) < 0)
FAIL_STACK_ERROR
if((c_tid = H5Tcopy(H5T_NATIVE_CHAR)) < 0)
FAIL_STACK_ERROR
if((s_tid = H5Tcopy(H5T_NATIVE_SHORT)) < 0)
FAIL_STACK_ERROR
if((f_tid = H5Tcopy(H5T_IEEE_F32BE)) < 0)
FAIL_STACK_ERROR
/* Set precision and offset etc. */
if(H5Tset_precision(i_tid,precision[0]) < 0) goto error;
if(H5Tset_offset(i_tid,offset[0]) < 0) goto error;
if(H5Tset_precision(i_tid,precision[0]) < 0)
FAIL_STACK_ERROR
if(H5Tset_offset(i_tid,offset[0]) < 0)
FAIL_STACK_ERROR
if(H5Tset_precision(c_tid,precision[1]) < 0) goto error;
if(H5Tset_offset(c_tid,offset[1]) < 0) goto error;
if(H5Tset_precision(c_tid,precision[1]) < 0)
FAIL_STACK_ERROR
if(H5Tset_offset(c_tid,offset[1]) < 0)
FAIL_STACK_ERROR
if(H5Tset_precision(s_tid,precision[2]) < 0) goto error;
if(H5Tset_offset(s_tid,offset[2]) < 0) goto error;
if(H5Tset_precision(s_tid,precision[2]) < 0)
FAIL_STACK_ERROR
if(H5Tset_offset(s_tid,offset[2]) < 0)
FAIL_STACK_ERROR
if(H5Tset_fields(f_tid, (size_t)26, (size_t)20, (size_t)6, (size_t)7, (size_t)13) < 0) goto error;
if(H5Tset_offset(f_tid, (size_t)7) < 0) goto error;
if(H5Tset_precision(f_tid, (size_t)20) < 0) goto error;
if(H5Tset_size(f_tid, (size_t)4) < 0) goto error;
if(H5Tset_ebias(f_tid, (size_t)31) < 0) goto error;
if(H5Tset_fields(f_tid, (size_t)26, (size_t)20, (size_t)6, (size_t)7, (size_t)13) < 0)
FAIL_STACK_ERROR
if(H5Tset_offset(f_tid, (size_t)7) < 0)
FAIL_STACK_ERROR
if(H5Tset_precision(f_tid, (size_t)20) < 0)
FAIL_STACK_ERROR
if(H5Tset_size(f_tid, (size_t)4) < 0)
FAIL_STACK_ERROR
if(H5Tset_ebias(f_tid, (size_t)31) < 0)
FAIL_STACK_ERROR
/* Create a memory compound datatype before setting the order */
mem_cmpd_tid = H5Tcreate(H5T_COMPOUND, sizeof(atomic));
if(H5Tinsert(mem_cmpd_tid, "i", HOFFSET(atomic, i), i_tid) < 0) goto error;
if(H5Tinsert(mem_cmpd_tid, "c", HOFFSET(atomic, c), c_tid) < 0) goto error;
if(H5Tinsert(mem_cmpd_tid, "s", HOFFSET(atomic, s), s_tid) < 0) goto error;
if(H5Tinsert(mem_cmpd_tid, "f", HOFFSET(atomic, f), H5T_NATIVE_FLOAT) < 0) goto error;
if((mem_cmpd_tid = H5Tcreate(H5T_COMPOUND, sizeof(atomic))) < 0)
FAIL_STACK_ERROR
if(H5Tinsert(mem_cmpd_tid, "i", HOFFSET(atomic, i), i_tid) < 0)
FAIL_STACK_ERROR
if(H5Tinsert(mem_cmpd_tid, "c", HOFFSET(atomic, c), c_tid) < 0)
FAIL_STACK_ERROR
if(H5Tinsert(mem_cmpd_tid, "s", HOFFSET(atomic, s), s_tid) < 0)
FAIL_STACK_ERROR
if(H5Tinsert(mem_cmpd_tid, "f", HOFFSET(atomic, f), H5T_NATIVE_FLOAT) < 0)
FAIL_STACK_ERROR
/* Create a dataset compound datatype and insert some atomic types */
cmpd_tid = H5Tcreate(H5T_COMPOUND, sizeof(atomic));
if(H5Tinsert(cmpd_tid, "i", HOFFSET(atomic, i), i_tid) < 0) goto error;
if(H5Tinsert(cmpd_tid, "c", HOFFSET(atomic, c), c_tid) < 0) goto error;
if(H5Tinsert(cmpd_tid, "s", HOFFSET(atomic, s), s_tid) < 0) goto error;
if(H5Tinsert(cmpd_tid, "f", HOFFSET(atomic, f), f_tid) < 0) goto error;
if((cmpd_tid = H5Tcreate(H5T_COMPOUND, sizeof(atomic))) < 0)
FAIL_STACK_ERROR
if(H5Tinsert(cmpd_tid, "i", HOFFSET(atomic, i), i_tid) < 0)
FAIL_STACK_ERROR
if(H5Tinsert(cmpd_tid, "c", HOFFSET(atomic, c), c_tid) < 0)
FAIL_STACK_ERROR
if(H5Tinsert(cmpd_tid, "s", HOFFSET(atomic, s), s_tid) < 0)
FAIL_STACK_ERROR
if(H5Tinsert(cmpd_tid, "f", HOFFSET(atomic, f), f_tid) < 0)
FAIL_STACK_ERROR
/* Set order of dataset compound datatype */
if(H5Tset_order(cmpd_tid, H5T_ORDER_BE) < 0) goto error;
if(H5Tset_order(cmpd_tid, H5T_ORDER_BE) < 0)
FAIL_STACK_ERROR
/* Create the data space */
if((space = H5Screate_simple(2, size, NULL)) < 0) goto error;
if((space = H5Screate_simple(2, size, NULL)) < 0)
FAIL_STACK_ERROR
/* Use nbit filter */
if((dc = H5Pcreate(H5P_DATASET_CREATE)) < 0) goto error;
if(H5Pset_chunk(dc, 2, chunk_size) < 0) goto error;
if(H5Pset_nbit(dc) < 0) goto error;
if((dc = H5Pcreate(H5P_DATASET_CREATE)) < 0)
FAIL_STACK_ERROR
if(H5Pset_chunk(dc, 2, chunk_size) < 0)
FAIL_STACK_ERROR
if(H5Pset_nbit(dc) < 0)
FAIL_STACK_ERROR
/* Create the dataset */
if((dataset = H5Dcreate2(file, DSET_NBIT_COMPOUND_NAME, cmpd_tid,
space, H5P_DEFAULT, dc, H5P_DEFAULT)) < 0) goto error;
if((dataset = H5Dcreate2(file, DSET_NBIT_COMPOUND_NAME, cmpd_tid, space, H5P_DEFAULT, dc, H5P_DEFAULT)) < 0)
FAIL_STACK_ERROR
/* Initialize data, assuming size of long long >= size of member datatypes */
for(i= 0;i< (size_t)size[0]; i++)
for(j = 0; j < (size_t)size[1]; j++) {
power = HDpow(2.0F, (double)(precision[0]-1));
orig_data[i][j].i = (int)(((long long)HDrandom() % (long long)power) << offset[0]);
power = HDpow(2.0F, (double)(precision[1]-1));
orig_data[i][j].c = (char)(((long long)HDrandom() % (long long)power) << offset[1]);
power = HDpow(2.0F, (double)(precision[2]-1));
orig_data[i][j].s = (short)(((long long)HDrandom() % (long long)power) << offset[2]);
orig_data[i][j].f = float_val[i][j];
for(i = 0; i < (size_t)size[0]; i++)
for(j = 0; j < (size_t)size[1]; j++) {
power = HDpow(2.0F, (double)(precision[0]-1));
orig_data[i][j].i = (int)(((long long)HDrandom() % (long long)power) << offset[0]);
power = HDpow(2.0F, (double)(precision[1]-1));
orig_data[i][j].c = (char)(((long long)HDrandom() % (long long)power) << offset[1]);
power = HDpow(2.0F, (double)(precision[2]-1));
orig_data[i][j].s = (short)(((long long)HDrandom() % (long long)power) << offset[2]);
orig_data[i][j].f = float_val[i][j];
/* some even-numbered integer values are negtive */
if((i*size[1]+j+1)%2 == 0) {
orig_data[i][j].i = -orig_data[i][j].i;
orig_data[i][j].s = (short)-orig_data[i][j].s;
/* some even-numbered integer values are negtive */
if((i * size[1] + j + 1) % 2 == 0) {
orig_data[i][j].i = -orig_data[i][j].i;
orig_data[i][j].s = (short)-orig_data[i][j].s;
}
}
}
PASSED();
@ -3407,9 +3461,8 @@ test_nbit_compound(hid_t file)
*/
TESTING(" nbit compound (write)");
if(H5Dwrite(dataset, mem_cmpd_tid, H5S_ALL, H5S_ALL, H5P_DEFAULT,
orig_data) < 0)
goto error;
if(H5Dwrite(dataset, mem_cmpd_tid, H5S_ALL, H5S_ALL, H5P_DEFAULT, orig_data) < 0)
FAIL_STACK_ERROR
PASSED();
/*----------------------------------------------------------------------
@ -3419,9 +3472,8 @@ test_nbit_compound(hid_t file)
TESTING(" nbit compound (read)");
/* Read the dataset back */
if(H5Dread(dataset, mem_cmpd_tid, H5S_ALL, H5S_ALL, H5P_DEFAULT,
new_data) < 0)
goto error;
if(H5Dread(dataset, mem_cmpd_tid, H5S_ALL, H5S_ALL, H5P_DEFAULT, new_data) < 0)
FAIL_STACK_ERROR
/* Check that the values read are the same as the values written
* Use mask for checking the significant bits, ignoring the padding bits
@ -3429,12 +3481,12 @@ test_nbit_compound(hid_t file)
i_mask = ~((unsigned)~0 << (precision[0] + offset[0])) & ((unsigned)~0 << offset[0]);
c_mask = ~((unsigned)~0 << (precision[1] + offset[1])) & ((unsigned)~0 << offset[1]);
s_mask = ~((unsigned)~0 << (precision[2] + offset[2])) & ((unsigned)~0 << offset[2]);
for(i=0; i<size[0]; i++) {
for(j=0; j<size[1]; j++) {
for(i = 0; i < size[0]; i++) {
for(j = 0; j < size[1]; j++) {
if(((unsigned)new_data[i][j].i & i_mask) != ((unsigned)orig_data[i][j].i & i_mask) ||
((unsigned)new_data[i][j].c & c_mask) != ((unsigned)orig_data[i][j].c & c_mask) ||
((unsigned)new_data[i][j].s & s_mask) != ((unsigned)orig_data[i][j].s & s_mask) ||
(orig_data[i][j].f==orig_data[i][j].f && new_data[i][j].f != orig_data[i][j].f))
(orig_data[i][j].f == orig_data[i][j].f && !H5_FLT_ABS_EQUAL(new_data[i][j].f, orig_data[i][j].f)))
{
H5_FAILED();
printf(" Read different values than written.\n");
@ -3448,15 +3500,24 @@ test_nbit_compound(hid_t file)
* Cleanup
*----------------------------------------------------------------------
*/
if(H5Tclose(i_tid) < 0) goto error;
if(H5Tclose(c_tid) < 0) goto error;
if(H5Tclose(s_tid) < 0) goto error;
if(H5Tclose(f_tid) < 0) goto error;
if(H5Tclose(cmpd_tid) < 0) goto error;
if(H5Tclose(mem_cmpd_tid) < 0) goto error;
if(H5Pclose(dc) < 0) goto error;
if(H5Sclose(space) < 0) goto error;
if(H5Dclose(dataset) < 0) goto error;
if(H5Tclose(i_tid) < 0)
FAIL_STACK_ERROR
if(H5Tclose(c_tid) < 0)
FAIL_STACK_ERROR
if(H5Tclose(s_tid) < 0)
FAIL_STACK_ERROR
if(H5Tclose(f_tid) < 0)
FAIL_STACK_ERROR
if(H5Tclose(cmpd_tid) < 0)
FAIL_STACK_ERROR
if(H5Tclose(mem_cmpd_tid) < 0)
FAIL_STACK_ERROR
if(H5Pclose(dc) < 0)
FAIL_STACK_ERROR
if(H5Sclose(space) < 0)
FAIL_STACK_ERROR
if(H5Dclose(dataset) < 0)
FAIL_STACK_ERROR
PASSED();
@ -3525,119 +3586,169 @@ test_nbit_compound_2(hid_t file)
TESTING(" nbit compound complex (setup)");
/* Define datatypes of members of compound datatype */
i_tid=H5Tcopy(H5T_NATIVE_INT);
c_tid=H5Tcopy(H5T_NATIVE_CHAR);
s_tid=H5Tcopy(H5T_NATIVE_SHORT);
v_tid=H5Tcopy(H5T_NATIVE_UINT);
f_tid=H5Tcopy(H5T_IEEE_F32BE);
if((i_tid = H5Tcopy(H5T_NATIVE_INT)) < 0)
FAIL_STACK_ERROR
if((c_tid = H5Tcopy(H5T_NATIVE_CHAR)) < 0)
FAIL_STACK_ERROR
if((s_tid = H5Tcopy(H5T_NATIVE_SHORT)) < 0)
FAIL_STACK_ERROR
if((v_tid = H5Tcopy(H5T_NATIVE_UINT)) < 0)
FAIL_STACK_ERROR
if((f_tid = H5Tcopy(H5T_IEEE_F32BE)) < 0)
FAIL_STACK_ERROR
/* Set precision and offset etc. of atomic compound datatype members */
if(H5Tset_precision(i_tid,precision[0]) < 0) goto error;
if(H5Tset_offset(i_tid,offset[0]) < 0) goto error;
if(H5Tset_precision(i_tid,precision[0]) < 0)
FAIL_STACK_ERROR
if(H5Tset_offset(i_tid,offset[0]) < 0)
FAIL_STACK_ERROR
if(H5Tset_precision(c_tid,precision[1]) < 0) goto error;
if(H5Tset_offset(c_tid,offset[1]) < 0) goto error;
if(H5Tset_precision(c_tid,precision[1]) < 0)
FAIL_STACK_ERROR
if(H5Tset_offset(c_tid,offset[1]) < 0)
FAIL_STACK_ERROR
if(H5Tset_precision(s_tid,precision[2]) < 0) goto error;
if(H5Tset_offset(s_tid,offset[2]) < 0) goto error;
if(H5Tset_precision(s_tid,precision[2]) < 0)
FAIL_STACK_ERROR
if(H5Tset_offset(s_tid,offset[2]) < 0)
FAIL_STACK_ERROR
if(H5Tset_fields(f_tid, (size_t)26, (size_t)20, (size_t)6, (size_t)7, (size_t)13) < 0) goto error;
if(H5Tset_offset(f_tid, (size_t)7) < 0) goto error;
if(H5Tset_precision(f_tid, (size_t)20) < 0) goto error;
if(H5Tset_size(f_tid, (size_t)4) < 0) goto error;
if(H5Tset_ebias(f_tid, (size_t)31) < 0) goto error;
if(H5Tset_fields(f_tid, (size_t)26, (size_t)20, (size_t)6, (size_t)7, (size_t)13) < 0)
FAIL_STACK_ERROR
if(H5Tset_offset(f_tid, (size_t)7) < 0)
FAIL_STACK_ERROR
if(H5Tset_precision(f_tid, (size_t)20) < 0)
FAIL_STACK_ERROR
if(H5Tset_size(f_tid, (size_t)4) < 0)
FAIL_STACK_ERROR
if(H5Tset_ebias(f_tid, (size_t)31) < 0)
FAIL_STACK_ERROR
/* Create a memory atomic compound datatype before setting the order */
mem_cmpd_tid1 = H5Tcreate(H5T_COMPOUND, sizeof(atomic));
if(H5Tinsert(mem_cmpd_tid1, "i", HOFFSET(atomic, i), i_tid) < 0) goto error;
if(H5Tinsert(mem_cmpd_tid1, "c", HOFFSET(atomic, c), c_tid) < 0) goto error;
if(H5Tinsert(mem_cmpd_tid1, "s", HOFFSET(atomic, s), s_tid) < 0) goto error;
if(H5Tinsert(mem_cmpd_tid1, "f", HOFFSET(atomic, f), H5T_NATIVE_FLOAT) < 0) goto error;
if((mem_cmpd_tid1 = H5Tcreate(H5T_COMPOUND, sizeof(atomic))) < 0)
FAIL_STACK_ERROR
if(H5Tinsert(mem_cmpd_tid1, "i", HOFFSET(atomic, i), i_tid) < 0)
FAIL_STACK_ERROR
if(H5Tinsert(mem_cmpd_tid1, "c", HOFFSET(atomic, c), c_tid) < 0)
FAIL_STACK_ERROR
if(H5Tinsert(mem_cmpd_tid1, "s", HOFFSET(atomic, s), s_tid) < 0)
FAIL_STACK_ERROR
if(H5Tinsert(mem_cmpd_tid1, "f", HOFFSET(atomic, f), H5T_NATIVE_FLOAT) < 0)
FAIL_STACK_ERROR
/* Create a dataset atomic compound datatype and insert some atomic types */
cmpd_tid1 = H5Tcreate(H5T_COMPOUND, sizeof(atomic));
if(H5Tinsert(cmpd_tid1, "i", HOFFSET(atomic, i), i_tid) < 0) goto error;
if(H5Tinsert(cmpd_tid1, "c", HOFFSET(atomic, c), c_tid) < 0) goto error;
if(H5Tinsert(cmpd_tid1, "s", HOFFSET(atomic, s), s_tid) < 0) goto error;
if(H5Tinsert(cmpd_tid1, "f", HOFFSET(atomic, f), f_tid) < 0) goto error;
if((cmpd_tid1 = H5Tcreate(H5T_COMPOUND, sizeof(atomic))) < 0)
FAIL_STACK_ERROR
if(H5Tinsert(cmpd_tid1, "i", HOFFSET(atomic, i), i_tid) < 0)
FAIL_STACK_ERROR
if(H5Tinsert(cmpd_tid1, "c", HOFFSET(atomic, c), c_tid) < 0)
FAIL_STACK_ERROR
if(H5Tinsert(cmpd_tid1, "s", HOFFSET(atomic, s), s_tid) < 0)
FAIL_STACK_ERROR
if(H5Tinsert(cmpd_tid1, "f", HOFFSET(atomic, f), f_tid) < 0)
FAIL_STACK_ERROR
/* Set order of dataset compound datatype */
if(H5Tset_order(cmpd_tid1, H5T_ORDER_BE) < 0) goto error;
if(H5Tset_order(cmpd_tid1, H5T_ORDER_BE) < 0)
FAIL_STACK_ERROR
/* Set precision and offset of the other data member */
if(H5Tset_precision(v_tid,precision[3]) < 0) goto error;
if(H5Tset_offset(v_tid,offset[3]) < 0) goto error;
if(H5Tset_precision(v_tid,precision[3]) < 0)
FAIL_STACK_ERROR
if(H5Tset_offset(v_tid,offset[3]) < 0)
FAIL_STACK_ERROR
/* Create the simple array datatype */
base_tid = H5Tcopy(H5T_NATIVE_CHAR);
if(H5Tset_precision(base_tid,precision[4]) < 0) goto error;
if(H5Tset_offset(base_tid,offset[4]) < 0) goto error;
array_tid = H5Tarray_create2(base_tid, 2, array_dims);
if((base_tid = H5Tcopy(H5T_NATIVE_CHAR)) < 0)
FAIL_STACK_ERROR
if(H5Tset_precision(base_tid,precision[4]) < 0)
FAIL_STACK_ERROR
if(H5Tset_offset(base_tid,offset[4]) < 0)
FAIL_STACK_ERROR
if((array_tid = H5Tarray_create2(base_tid, 2, array_dims)) < 0)
FAIL_STACK_ERROR
/* Create the complex memory and dataset array datatype */
array_cmplx_tid = H5Tarray_create2(cmpd_tid1, 2, array_dims);
mem_array_cmplx_tid = H5Tarray_create2(mem_cmpd_tid1, 2, array_dims);
if((array_cmplx_tid = H5Tarray_create2(cmpd_tid1, 2, array_dims)) < 0)
FAIL_STACK_ERROR
if((mem_array_cmplx_tid = H5Tarray_create2(mem_cmpd_tid1, 2, array_dims)) < 0)
FAIL_STACK_ERROR
/* Create a memory complex compound datatype before setting the order */
mem_cmpd_tid2 = H5Tcreate(H5T_COMPOUND, sizeof(complex));
if(H5Tinsert(mem_cmpd_tid2, "a", HOFFSET(complex, a), mem_cmpd_tid1) < 0) goto error;
if(H5Tinsert(mem_cmpd_tid2, "v", HOFFSET(complex, v), v_tid) < 0) goto error;
if(H5Tinsert(mem_cmpd_tid2, "b", HOFFSET(complex, b), array_tid) < 0) goto error;
if(H5Tinsert(mem_cmpd_tid2, "d", HOFFSET(complex, d), mem_array_cmplx_tid) < 0) goto error;
if((mem_cmpd_tid2 = H5Tcreate(H5T_COMPOUND, sizeof(complex))) < 0)
FAIL_STACK_ERROR
if(H5Tinsert(mem_cmpd_tid2, "a", HOFFSET(complex, a), mem_cmpd_tid1) < 0)
FAIL_STACK_ERROR
if(H5Tinsert(mem_cmpd_tid2, "v", HOFFSET(complex, v), v_tid) < 0)
FAIL_STACK_ERROR
if(H5Tinsert(mem_cmpd_tid2, "b", HOFFSET(complex, b), array_tid) < 0)
FAIL_STACK_ERROR
if(H5Tinsert(mem_cmpd_tid2, "d", HOFFSET(complex, d), mem_array_cmplx_tid) < 0)
FAIL_STACK_ERROR
/* Set order of dataset other complex compound member datatype */
if(H5Tset_order(v_tid, H5T_ORDER_BE) < 0) goto error;
if(H5Tset_order(v_tid, H5T_ORDER_BE) < 0)
FAIL_STACK_ERROR
/* Create a dataset complex compound datatype and insert members */
cmpd_tid2 = H5Tcreate(H5T_COMPOUND, sizeof(complex));
if(H5Tinsert(cmpd_tid2, "a", HOFFSET(complex, a), cmpd_tid1) < 0) goto error;
if(H5Tinsert(cmpd_tid2, "v", HOFFSET(complex, v), v_tid) < 0) goto error;
if(H5Tinsert(cmpd_tid2, "b", HOFFSET(complex, b), array_tid) < 0) goto error;
if(H5Tinsert(cmpd_tid2, "d", HOFFSET(complex, d), array_cmplx_tid) < 0) goto error;
if((cmpd_tid2 = H5Tcreate(H5T_COMPOUND, sizeof(complex))) < 0)
FAIL_STACK_ERROR
if(H5Tinsert(cmpd_tid2, "a", HOFFSET(complex, a), cmpd_tid1) < 0)
FAIL_STACK_ERROR
if(H5Tinsert(cmpd_tid2, "v", HOFFSET(complex, v), v_tid) < 0)
FAIL_STACK_ERROR
if(H5Tinsert(cmpd_tid2, "b", HOFFSET(complex, b), array_tid) < 0)
FAIL_STACK_ERROR
if(H5Tinsert(cmpd_tid2, "d", HOFFSET(complex, d), array_cmplx_tid) < 0)
FAIL_STACK_ERROR
/* Create the data space */
if((space = H5Screate_simple(2, size, NULL)) < 0) goto error;
if((space = H5Screate_simple(2, size, NULL)) < 0)
FAIL_STACK_ERROR
/* Use nbit filter */
if((dc = H5Pcreate(H5P_DATASET_CREATE)) < 0) goto error;
if(H5Pset_chunk(dc, 2, chunk_size) < 0) goto error;
if(H5Pset_nbit(dc) < 0) goto error;
if((dc = H5Pcreate(H5P_DATASET_CREATE)) < 0)
FAIL_STACK_ERROR
if(H5Pset_chunk(dc, 2, chunk_size) < 0)
FAIL_STACK_ERROR
if(H5Pset_nbit(dc) < 0)
FAIL_STACK_ERROR
/* Create the dataset */
if((dataset = H5Dcreate2(file, DSET_NBIT_COMPOUND_NAME_2, cmpd_tid2,
space, H5P_DEFAULT, dc, H5P_DEFAULT)) < 0) goto error;
if((dataset = H5Dcreate2(file, DSET_NBIT_COMPOUND_NAME_2, cmpd_tid2, space, H5P_DEFAULT, dc, H5P_DEFAULT)) < 0)
FAIL_STACK_ERROR
/* Initialize data, assuming size of long long >= size of member datatypes */
for(i= 0;i< (size_t)size[0]; i++)
for(j = 0; j < (size_t)size[1]; j++) {
power = HDpow(2.0F, (double)(precision[0]-1));
orig_data[i][j].a.i = (int)(((long long)HDrandom() % (long long)power) << offset[0]);
power = HDpow(2.0F, (double)(precision[1]-1));
orig_data[i][j].a.c = (char)(((long long)HDrandom() % (long long)power) << offset[1]);
power = HDpow(2.0F, (double)(precision[2]-1));
orig_data[i][j].a.s = (short)(-((long long)HDrandom() % (long long)power) << offset[2]);
orig_data[i][j].a.f = float_val[i][j];
power = HDpow(2.0F, (double)precision[3]);
orig_data[i][j].v = (unsigned int)(((long long)HDrandom() % (long long)power) << offset[3]);
for(m = 0; m < (size_t)array_dims[0]; m++)
for(n = 0; n < (size_t)array_dims[1]; n++) {
power = HDpow(2.0F, (double)(precision[4]-1));
orig_data[i][j].b[m][n] = (char)(((long long)HDrandom() % (long long)power) << offset[4]);
} /* end for */
for(m = 0; m < (size_t)array_dims[0]; m++)
for(n = 0; n < (size_t)array_dims[1]; n++) {
for(j = 0; j < (size_t)size[1]; j++) {
power = HDpow(2.0F, (double)(precision[0]-1));
orig_data[i][j].d[m][n].i = (int)(-((long long)HDrandom() % (long long)power) << offset[0]);
orig_data[i][j].a.i = (int)(((long long)HDrandom() % (long long)power) << offset[0]);
power = HDpow(2.0F, (double)(precision[1]-1));
orig_data[i][j].d[m][n].c = (char)(((long long)HDrandom() % (long long)power) << offset[1]);
orig_data[i][j].a.c = (char)(((long long)HDrandom() % (long long)power) << offset[1]);
power = HDpow(2.0F, (double)(precision[2]-1));
orig_data[i][j].d[m][n].s = (short)(((long long)HDrandom() % (long long)power) << offset[2]);
orig_data[i][j].d[m][n].f = float_val[i][j];
} /* end for */
} /* end for */
orig_data[i][j].a.s = (short)(-((long long)HDrandom() % (long long)power) << offset[2]);
orig_data[i][j].a.f = float_val[i][j];
power = HDpow(2.0F, (double)precision[3]);
orig_data[i][j].v = (unsigned int)(((long long)HDrandom() % (long long)power) << offset[3]);
for(m = 0; m < (size_t)array_dims[0]; m++)
for(n = 0; n < (size_t)array_dims[1]; n++) {
power = HDpow(2.0F, (double)(precision[4]-1));
orig_data[i][j].b[m][n] = (char)(((long long)HDrandom() % (long long)power) << offset[4]);
} /* end for */
for(m = 0; m < (size_t)array_dims[0]; m++)
for(n = 0; n < (size_t)array_dims[1]; n++) {
power = HDpow(2.0F, (double)(precision[0]-1));
orig_data[i][j].d[m][n].i = (int)(-((long long)HDrandom() % (long long)power) << offset[0]);
power = HDpow(2.0F, (double)(precision[1]-1));
orig_data[i][j].d[m][n].c = (char)(((long long)HDrandom() % (long long)power) << offset[1]);
power = HDpow(2.0F, (double)(precision[2]-1));
orig_data[i][j].d[m][n].s = (short)(((long long)HDrandom() % (long long)power) << offset[2]);
orig_data[i][j].d[m][n].f = float_val[i][j];
} /* end for */
} /* end for */
PASSED();
@ -3648,9 +3759,8 @@ test_nbit_compound_2(hid_t file)
*/
TESTING(" nbit compound complex (write)");
if(H5Dwrite(dataset, mem_cmpd_tid2, H5S_ALL, H5S_ALL, H5P_DEFAULT,
orig_data) < 0)
goto error;
if(H5Dwrite(dataset, mem_cmpd_tid2, H5S_ALL, H5S_ALL, H5P_DEFAULT, orig_data) < 0)
FAIL_STACK_ERROR
PASSED();
/*----------------------------------------------------------------------
@ -3660,9 +3770,8 @@ test_nbit_compound_2(hid_t file)
TESTING(" nbit compound complex (read)");
/* Read the dataset back */
if(H5Dread(dataset, mem_cmpd_tid2, H5S_ALL, H5S_ALL, H5P_DEFAULT,
new_data) < 0)
goto error;
if(H5Dread(dataset, mem_cmpd_tid2, H5S_ALL, H5S_ALL, H5P_DEFAULT, new_data) < 0)
FAIL_STACK_ERROR
/* Check that the values read are the same as the values written
* Use mask for checking the significant bits, ignoring the padding bits
@ -3683,63 +3792,77 @@ test_nbit_compound_2(hid_t file)
s_mask = ~((unsigned)~0 << (precision[2] + offset[2])) & ((unsigned)~0 << offset[2]);
b_mask = ~((unsigned)~0 << (precision[4] + offset[4])) & ((unsigned)~0 << offset[4]);
for(i=0; i<(size_t)size[0]; i++) {
for(j=0; j<(size_t)size[1]; j++) {
b_failed = 0;
d_failed = 0;
for(j=0; j<(size_t)size[1]; j++) {
b_failed = 0;
d_failed = 0;
for(m = 0; m < (size_t)array_dims[0]; m++)
for(n = 0; n < (size_t)array_dims[1]; n++)
if(((unsigned)new_data[i][j].b[m][n] & b_mask)!=((unsigned)orig_data[i][j].b[m][n] & b_mask)) {
for(m = 0; m < (size_t)array_dims[0]; m++)
for(n = 0; n < (size_t)array_dims[1]; n++)
if(((unsigned)new_data[i][j].b[m][n] & b_mask)!=((unsigned)orig_data[i][j].b[m][n] & b_mask)) {
b_failed = 1;
goto out;
}
}
for(m = 0; m < (size_t)array_dims[0]; m++)
for(n = 0; n < (size_t)array_dims[1]; n++)
if(((unsigned)new_data[i][j].d[m][n].i & i_mask) != ((unsigned)orig_data[i][j].d[m][n].i & i_mask)||
((unsigned)new_data[i][j].d[m][n].c & c_mask) != ((unsigned)orig_data[i][j].d[m][n].c & c_mask)||
((unsigned)new_data[i][j].d[m][n].s & s_mask) != ((unsigned)orig_data[i][j].d[m][n].s & s_mask)||
(new_data[i][j].d[m][n].f==new_data[i][j].d[m][n].f &&
new_data[i][j].d[m][n].f != new_data[i][j].d[m][n].f)) {
d_failed = 1;
goto out;
}
for(m = 0; m < (size_t)array_dims[0]; m++)
for(n = 0; n < (size_t)array_dims[1]; n++)
if(((unsigned)new_data[i][j].d[m][n].i & i_mask) != ((unsigned)orig_data[i][j].d[m][n].i & i_mask)||
((unsigned)new_data[i][j].d[m][n].c & c_mask) != ((unsigned)orig_data[i][j].d[m][n].c & c_mask)||
((unsigned)new_data[i][j].d[m][n].s & s_mask) != ((unsigned)orig_data[i][j].d[m][n].s & s_mask)||
(new_data[i][j].d[m][n].f == new_data[i][j].d[m][n].f && !H5_FLT_ABS_EQUAL(new_data[i][j].d[m][n].f, new_data[i][j].d[m][n].f))) {
d_failed = 1;
goto out;
}
out:
if(((unsigned)new_data[i][j].a.i & i_mask) != ((unsigned)orig_data[i][j].a.i & i_mask)||
((unsigned)new_data[i][j].a.c & c_mask) != ((unsigned)orig_data[i][j].a.c & c_mask)||
((unsigned)new_data[i][j].a.s & s_mask) != ((unsigned)orig_data[i][j].a.s & s_mask)||
(new_data[i][j].a.f==new_data[i][j].a.f &&
new_data[i][j].a.f != new_data[i][j].a.f)||
new_data[i][j].v != orig_data[i][j].v || b_failed || d_failed) {
H5_FAILED();
printf(" Read different values than written.\n");
printf(" At index %lu,%lu\n", (unsigned long)i, (unsigned long)j);
goto error;
out:
if(((unsigned)new_data[i][j].a.i & i_mask) != ((unsigned)orig_data[i][j].a.i & i_mask)||
((unsigned)new_data[i][j].a.c & c_mask) != ((unsigned)orig_data[i][j].a.c & c_mask)||
((unsigned)new_data[i][j].a.s & s_mask) != ((unsigned)orig_data[i][j].a.s & s_mask)||
(new_data[i][j].a.f == new_data[i][j].a.f && !H5_FLT_ABS_EQUAL(new_data[i][j].a.f, new_data[i][j].a.f)) ||
new_data[i][j].v != orig_data[i][j].v || b_failed || d_failed) {
H5_FAILED();
printf(" Read different values than written.\n");
printf(" At index %lu,%lu\n", (unsigned long)i, (unsigned long)j);
goto error;
}
}
}
}
/*----------------------------------------------------------------------
* Cleanup
*----------------------------------------------------------------------
*/
if(H5Tclose(i_tid) < 0) goto error;
if(H5Tclose(c_tid) < 0) goto error;
if(H5Tclose(s_tid) < 0) goto error;
if(H5Tclose(f_tid) < 0) goto error;
if(H5Tclose(v_tid) < 0) goto error;
if(H5Tclose(cmpd_tid2) < 0) goto error;
if(H5Tclose(cmpd_tid1) < 0) goto error;
if(H5Tclose(mem_cmpd_tid2) < 0) goto error;
if(H5Tclose(mem_cmpd_tid1) < 0) goto error;
if(H5Tclose(array_tid) < 0) goto error;
if(H5Tclose(base_tid) < 0) goto error;
if(H5Tclose(array_cmplx_tid) < 0) goto error;
if(H5Tclose(mem_array_cmplx_tid) < 0) goto error;
if(H5Pclose(dc) < 0) goto error;
if(H5Sclose(space) < 0) goto error;
if(H5Dclose(dataset) < 0) goto error;
if(H5Tclose(i_tid) < 0)
FAIL_STACK_ERROR
if(H5Tclose(c_tid) < 0)
FAIL_STACK_ERROR
if(H5Tclose(s_tid) < 0)
FAIL_STACK_ERROR
if(H5Tclose(f_tid) < 0)
FAIL_STACK_ERROR
if(H5Tclose(v_tid) < 0)
FAIL_STACK_ERROR
if(H5Tclose(cmpd_tid2) < 0)
FAIL_STACK_ERROR
if(H5Tclose(cmpd_tid1) < 0)
FAIL_STACK_ERROR
if(H5Tclose(mem_cmpd_tid2) < 0)
FAIL_STACK_ERROR
if(H5Tclose(mem_cmpd_tid1) < 0)
FAIL_STACK_ERROR
if(H5Tclose(array_tid) < 0)
FAIL_STACK_ERROR
if(H5Tclose(base_tid) < 0)
FAIL_STACK_ERROR
if(H5Tclose(array_cmplx_tid) < 0)
FAIL_STACK_ERROR
if(H5Tclose(mem_array_cmplx_tid) < 0)
FAIL_STACK_ERROR
if(H5Pclose(dc) < 0)
FAIL_STACK_ERROR
if(H5Sclose(space) < 0)
FAIL_STACK_ERROR
if(H5Dclose(dataset) < 0)
FAIL_STACK_ERROR
PASSED();
@ -3832,7 +3955,7 @@ test_nbit_compound_3(hid_t file)
for(i = 0; i < (size_t)size[0]; i++) {
power = HDpow(2.0F, 17.0F - 1.0F);
HDmemset(&orig_data[i], 0, sizeof(orig_data[i]));
orig_data[i].i = HDrandom() % (long)power;
orig_data[i].i = (int)(HDrandom() % (long)power);
HDstrcpy(orig_data[i].str, "fixed-length C string");
orig_data[i].vl_str = HDstrdup("variable-length C string");
@ -4203,7 +4326,7 @@ test_nbit_flt_size(hid_t file)
*/
for (i=0; i < DSET_DIM1; i++)
for (j=0; j < DSET_DIM2; j++)
orig_data[i][j] = (rand() % 1234567) / 2;
orig_data[i][j] = (float)(HDrandom() % 1234567) / 2;
/* Describe the dataspace. */
@ -4587,7 +4710,7 @@ test_scaleoffset_float(hid_t file)
/* Initialize data */
for(i= 0;i< (size_t)size[0]; i++)
for(j = 0; j < (size_t)size[1]; j++) {
orig_data[i][j] = (float)((HDrandom() % 100000) / 1000.0F);
orig_data[i][j] = (float)(HDrandom() % 100000) / 1000.0F;
/* even-numbered values are negtive */
if((i*size[1]+j+1)%2 == 0)
@ -4718,10 +4841,10 @@ test_scaleoffset_float_2(hid_t file)
/* Initialize data of hyperslab */
for(j = 0; j < (size_t)size[1]; j++) {
orig_data[0][j] = (float)((HDrandom() % 100000) / 1000.0F);
orig_data[0][j] = (float)(HDrandom() % 100000) / 1000.0F;
/* even-numbered values are negtive */
if((j+1)%2 == 0)
if((j + 1) % 2 == 0)
orig_data[0][j] = -orig_data[0][j];
}
@ -4829,10 +4952,10 @@ test_scaleoffset_double(hid_t file)
/* Initialize data */
for(i= 0;i< (size_t)size[0]; i++)
for(j = 0; j < (size_t)size[1]; j++) {
orig_data[i][j] = (HDrandom() % 10000000) / 10000000.0F;
orig_data[i][j] = (float)(HDrandom() % 10000000) / 10000000.0F;
/* even-numbered values are negtive */
if((i*size[1]+j+1)%2 == 0)
if((i* size[1] + j + 1) % 2 == 0)
orig_data[i][j] = -orig_data[i][j];
}
@ -4960,10 +5083,10 @@ test_scaleoffset_double_2(hid_t file)
/* Initialize data of hyperslab */
for(j = 0; j < (size_t)size[1]; j++) {
orig_data[0][j] = (HDrandom() % 10000000) / 10000000.0F;
orig_data[0][j] = (float)(HDrandom() % 10000000) / 10000000.0F;
/* even-numbered values are negtive */
if((j+1)%2 == 0)
if((j + 1) % 2 == 0)
orig_data[0][j] = -orig_data[0][j];
}
@ -5958,7 +6081,7 @@ test_set_local(hid_t fapl)
for(j=0; j<dims[1]; j++) {
/* If the difference between two values is greater than 0.001%, they're
* considered not equal. */
if(!H5_DBL_REL_EQUAL(points_dbl[i][j],check_dbl[i][j],0.00001F)) {
if(!H5_DBL_REL_EQUAL(points_dbl[i][j], check_dbl[i][j], (double)0.00001F)) {
H5_FAILED();
printf(" Line %d: Read different values than written.\n",__LINE__);
printf(" At index %lu,%lu\n", (unsigned long)(i), (unsigned long)(j));
@ -6717,7 +6840,7 @@ test_missing_chunk(hid_t file)
/* Initialize data for 2-D dataset */
for(i = 0; i < MISSING_CHUNK_DIM; i++) {
for(j = 0; j < MISSING_CHUNK_DIM; j++) {
wdata2[i][j] = (int)j + (i * MISSING_CHUNK_DIM);
wdata2[i][j] = (int)(j + (i * MISSING_CHUNK_DIM));
rdata2[i][j] = 911;
}
} /* end for */
@ -7635,7 +7758,7 @@ test_chunk_cache(hid_t fapl)
/* Set new rdcc settings on fapl */
nslots_2 = nslots_1 * 2;
nbytes_2 = nbytes_1 * 2;
w0_2 = w0_1 / 2.0F;
w0_2 = w0_1 / (double)2.0F;
if (H5Pset_cache(fapl_local, 0, nslots_2, nbytes_2, w0_2) < 0) FAIL_STACK_ERROR
h5_fixname(FILENAME[8], fapl, filename, sizeof filename);
@ -8074,7 +8197,7 @@ error:
*-------------------------------------------------------------------------
*/
static herr_t
test_chunk_fast(const char *env_h5_driver, hid_t fapl)
test_chunk_fast(hid_t fapl)
{
char filename[FILENAME_BUF_SIZE];
hid_t fid = -1; /* File ID */
@ -8135,7 +8258,7 @@ test_chunk_fast(const char *env_h5_driver, hid_t fapl)
H5D_alloc_time_t alloc_time; /* Storage allocation time */
/* Loop over storage allocation time */
for(alloc_time = H5D_ALLOC_TIME_EARLY; alloc_time <= H5D_ALLOC_TIME_INCR; alloc_time++) {
for(alloc_time = H5D_ALLOC_TIME_EARLY; alloc_time <= H5D_ALLOC_TIME_INCR; H5_INC_ENUM(H5D_alloc_time_t, alloc_time)) {
unsigned ndims; /* Current # of dims to test */
/* Loop over dataspace ranks to test */
@ -8435,7 +8558,7 @@ test_reopen_chunk_fast(hid_t fapl)
h5_fixname(FILENAME[10], fapl, filename, sizeof filename);
/* Loop over storage allocation time */
for(alloc_time = H5D_ALLOC_TIME_EARLY; alloc_time <= H5D_ALLOC_TIME_INCR; alloc_time++) {
for(alloc_time = H5D_ALLOC_TIME_EARLY; alloc_time <= H5D_ALLOC_TIME_INCR; H5_INC_ENUM(H5D_alloc_time_t, alloc_time)) {
/* Create file */
if((fid = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl)) < 0) FAIL_STACK_ERROR
@ -8566,7 +8689,7 @@ test_chunk_fast_bug1(hid_t fapl)
if((sid = H5Screate_simple(2, dim, max_dim)) < 0) FAIL_STACK_ERROR
/* Loop over storage allocation time */
for(alloc_time = H5D_ALLOC_TIME_EARLY; alloc_time <= H5D_ALLOC_TIME_INCR; alloc_time++) {
for(alloc_time = H5D_ALLOC_TIME_EARLY; alloc_time <= H5D_ALLOC_TIME_INCR; H5_INC_ENUM(H5D_alloc_time_t, alloc_time)) {
/* Create file */
if((fid = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl)) < 0) FAIL_STACK_ERROR
@ -9192,7 +9315,7 @@ test_fixed_array(hid_t fapl)
#endif /* H5_HAVE_FILTER_DEFLATE */
/* Loop over storage allocation time */
for(alloc_time = H5D_ALLOC_TIME_EARLY; alloc_time <= H5D_ALLOC_TIME_INCR; alloc_time++) {
for(alloc_time = H5D_ALLOC_TIME_EARLY; alloc_time <= H5D_ALLOC_TIME_INCR; H5_INC_ENUM(H5D_alloc_time_t, alloc_time)) {
/* Create file */
if((fid = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl)) < 0) FAIL_STACK_ERROR
@ -9564,10 +9687,10 @@ test_single_chunk(hid_t fapl)
TEST_ERROR
for(i = n = 0; i < (DSET_DIM1 * DSET_DIM2); i++)
wbuf[i] = n++;
wbuf[i] = (int)n++;
for(i = n = 0; i < (50* 100); i++)
t_wbuf[i] = n++;
t_wbuf[i] = (int)n++;
#ifdef H5_HAVE_FILTER_DEFLATE
/* Loop over compressing chunks */
@ -9575,7 +9698,7 @@ test_single_chunk(hid_t fapl)
#endif /* H5_HAVE_FILTER_DEFLATE */
/* Loop over storage allocation time */
for(alloc_time = H5D_ALLOC_TIME_EARLY; alloc_time <= H5D_ALLOC_TIME_INCR; alloc_time++) {
for(alloc_time = H5D_ALLOC_TIME_EARLY; alloc_time <= H5D_ALLOC_TIME_INCR; H5_INC_ENUM(H5D_alloc_time_t, alloc_time)) {
/* Create file */
if((fid = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl)) < 0) FAIL_STACK_ERROR
@ -9866,7 +9989,7 @@ test_unfiltered_edge_chunks(hid_t fapl)
/* Initialize write buffer */
for(i=0; i<dim[0]; i++)
for(j=0; j<dim[1]; j++)
wbuf[i][j] = (char)(2 * i) - (char)j;
wbuf[i][j] = (char)((2 * i) - j);
/* Reset byte counts */
count_nbytes_read = (size_t)0;
@ -11944,7 +12067,7 @@ main(void)
nerrors += (test_huge_chunks(my_fapl) < 0 ? 1 : 0);
nerrors += (test_chunk_cache(my_fapl) < 0 ? 1 : 0);
nerrors += (test_big_chunks_bypass_cache(my_fapl) < 0 ? 1 : 0);
nerrors += (test_chunk_fast(envval, my_fapl) < 0 ? 1 : 0);
nerrors += (test_chunk_fast(my_fapl) < 0 ? 1 : 0);
nerrors += (test_reopen_chunk_fast(my_fapl) < 0 ? 1 : 0);
nerrors += (test_chunk_fast_bug1(my_fapl) < 0 ? 1 : 0);
nerrors += (test_chunk_expand(my_fapl) < 0 ? 1 : 0);

1
test/file_image.c
View File

@ -22,7 +22,6 @@
*************************************************************/
#include "h5test.h"
#include "H5srcdir.h"
#include "H5Fprivate.h" /* required to test property removals */
#define VERIFY(condition, string) do { if (!(condition)) FAIL_PUTS_ERROR(string) } while(0)

1
test/filter_fail.c
View File

@ -22,7 +22,6 @@
*/
#include "h5test.h"
#include "H5srcdir.h"
#define DSET_NAME "dset_fail"
#define H5Z_FILTER_FAIL_TEST 312

16
test/freespace.c
View File

@ -455,7 +455,7 @@ test_fs_create(hid_t fapl)
h5_stat_size_t file_size, empty_size; /* File size */
frspace_state_t state; /* State of free space*/
H5FS_create_t cparam, test_cparam; /* creation parameters */
size_t nclasses;
uint16_t nclasses;
unsigned init_flags=0;
TESTING("the creation/close/reopen/deletion of the free-space manager");
@ -589,7 +589,7 @@ test_fs_sect_add(hid_t fapl)
H5F_t *f = NULL; /* Internal file object pointer */
H5FS_t *frsp = NULL; /* pointer to free space structure */
haddr_t fs_addr=HADDR_UNDEF; /* address of free space */
size_t nclasses;
uint16_t nclasses;
H5FS_create_t cparam; /* creation parameters */
frspace_state_t state; /* State of free space*/
@ -921,7 +921,7 @@ test_fs_sect_find(hid_t fapl)
H5F_t *f = NULL; /* Internal file object pointer */
H5FS_t *frsp = NULL; /* pointer to free space structure */
haddr_t fs_addr=HADDR_UNDEF; /* address of free space */
size_t nclasses;
uint16_t nclasses;
H5FS_create_t cparam; /* creation parameters */
frspace_state_t state; /* State of free space*/
@ -1302,7 +1302,7 @@ test_fs_sect_merge(hid_t fapl)
H5F_t *f = NULL; /* Internal file object pointer */
H5FS_t *frsp = NULL; /* pointer to free space structure */
haddr_t fs_addr=HADDR_UNDEF; /* address of free space */
size_t nclasses;
uint16_t nclasses;
H5FS_create_t cparam; /* creation parameters */
frspace_state_t state; /* State of free space*/
@ -1768,7 +1768,7 @@ test_fs_sect_shrink(hid_t fapl)
H5F_t *f = NULL; /* Internal file object pointer */
H5FS_t *frsp = NULL; /* pointer to free space structure */
haddr_t fs_addr=HADDR_UNDEF; /* address of free space */
size_t nclasses;
uint16_t nclasses;
H5FS_create_t cparam; /* creation parameters */
frspace_state_t state; /* State of free space*/
@ -2106,7 +2106,7 @@ test_fs_sect_change_class(hid_t fapl)
H5F_t *f = NULL; /* Internal file object pointer */
H5FS_t *frsp = NULL; /* pointer to free space structure */
haddr_t fs_addr=HADDR_UNDEF; /* address of free space */
size_t nclasses;
uint16_t nclasses;
H5FS_create_t cparam; /* creation parameters */
frspace_state_t state; /* State of free space*/
@ -2396,7 +2396,7 @@ test_fs_sect_extend(hid_t fapl)
H5F_t *f = NULL; /* Internal file object pointer */
H5FS_t *frsp = NULL; /* pointer to free space structure */
haddr_t fs_addr=HADDR_UNDEF; /* address of free space */
size_t nclasses;
uint16_t nclasses;
H5FS_create_t cparam; /* creation parameters */
frspace_state_t state; /* State of free space*/
TEST_free_section_t *sect_node1=NULL, *sect_node2=NULL;
@ -2744,7 +2744,7 @@ test_fs_sect_iterate(hid_t fapl)
H5F_t *f = NULL; /* Internal file object pointer */
H5FS_t *frsp = NULL; /* pointer to free space structure */
haddr_t fs_addr=HADDR_UNDEF; /* address of free space */
size_t nclasses;
uint16_t nclasses;
H5FS_create_t cparam; /* creation parameters */
TEST_free_section_t *sect_node=NULL;

89
test/getname.c
View File

@ -2433,6 +2433,7 @@ test_obj_ref(hid_t fapl)
hsize_t dims1[] = {SPACE1_DIM1};
hobj_ref_t wbuf[SPACE1_DIM1]; /* Buffer to write to disk */
int tu32[SPACE1_DIM1]; /* Int data */
ssize_t namelen; /* Length of the name */
int i; /* counting variables */
char buf[100];
@ -2575,104 +2576,104 @@ test_obj_ref(hid_t fapl)
TESTING("getting path to normal dataset in root group");
if((dataset2 = H5Rdereference2(dataset, H5P_DEFAULT, H5R_OBJECT, &wbuf[0])) < 0) FAIL_STACK_ERROR
*buf = '\0';
i = H5Iget_name(dataset2, (char*)buf, sizeof(buf));
namelen = H5Iget_name(dataset2, (char*)buf, sizeof(buf));
if(H5Dclose(dataset2) < 0) FAIL_STACK_ERROR
if(!((HDstrcmp(buf, "/Dataset3") == 0) &&(i == 9))) TEST_ERROR
if(!((HDstrcmp(buf, "/Dataset3") == 0) &&(namelen == 9))) TEST_ERROR
*buf = '\0';
/* Check H5Rget_name returns the correct length of the name when name is NULL */
i = H5Rget_name(dataset, H5R_OBJECT, &wbuf[0], NULL, 0);
if(i != 9) TEST_ERROR
namelen = H5Rget_name(dataset, H5R_OBJECT, &wbuf[0], NULL, 0);
if(namelen != 9) TEST_ERROR
/* Make sure size parameter is ignored */
i = H5Rget_name(dataset, H5R_OBJECT, &wbuf[0], NULL, 200);
if(i != 9) TEST_ERROR
namelen = H5Rget_name(dataset, H5R_OBJECT, &wbuf[0], NULL, 200);
if(namelen != 9) TEST_ERROR
i = H5Rget_name(dataset, H5R_OBJECT, &wbuf[0], (char*)buf, sizeof(buf));
if(!((HDstrcmp(buf, "/Dataset3") == 0) &&(i == 9))) TEST_ERROR
namelen = H5Rget_name(dataset, H5R_OBJECT, &wbuf[0], (char*)buf, sizeof(buf));
if(!((HDstrcmp(buf, "/Dataset3") == 0) &&(namelen == 9))) TEST_ERROR
PASSED()
HDmemset(buf, 0, sizeof(buf));
TESTING("getting path to dataset in /Group1");
if((dataset2 = H5Rdereference2(dataset, H5P_DEFAULT, H5R_OBJECT, &wbuf[1])) < 0) FAIL_STACK_ERROR
*buf = '\0';
i = H5Iget_name(dataset2, (char*)buf, sizeof(buf));
namelen = H5Iget_name(dataset2, (char*)buf, sizeof(buf));
if(H5Dclose(dataset2) < 0) FAIL_STACK_ERROR
if(!((HDstrcmp(buf, "/Group1/Dataset2") == 0) &&(i == 16))) TEST_ERROR
if(!((HDstrcmp(buf, "/Group1/Dataset2") == 0) &&(namelen == 16))) TEST_ERROR
*buf = '\0';
i = H5Rget_name(dataset, H5R_OBJECT, &wbuf[1], (char*)buf, sizeof(buf));
if(!((HDstrcmp(buf, "/Group1/Dataset2") == 0) &&(i == 16))) TEST_ERROR
namelen = H5Rget_name(dataset, H5R_OBJECT, &wbuf[1], (char*)buf, sizeof(buf));
if(!((HDstrcmp(buf, "/Group1/Dataset2") == 0) &&(namelen == 16))) TEST_ERROR
PASSED()
HDmemset(buf, 0, sizeof(buf));
TESTING("getting path to /Group1");
if((group = H5Rdereference2(dataset, H5P_DEFAULT, H5R_OBJECT, &wbuf[2])) < 0) FAIL_STACK_ERROR
*buf = '\0';
i = H5Iget_name(group, (char*)buf, sizeof(buf));
namelen = H5Iget_name(group, (char*)buf, sizeof(buf));
if(H5Gclose(group) < 0) FAIL_STACK_ERROR
if(!((HDstrcmp(buf, "/Group1") == 0) &&(i == 7))) TEST_ERROR
if(!((HDstrcmp(buf, "/Group1") == 0) &&(namelen == 7))) TEST_ERROR
*buf = '\0';
i = H5Rget_name(dataset, H5R_OBJECT, &wbuf[2], (char*)buf, sizeof(buf));
if(!((HDstrcmp(buf, "/Group1") == 0) &&(i == 7))) TEST_ERROR
namelen = H5Rget_name(dataset, H5R_OBJECT, &wbuf[2], (char*)buf, sizeof(buf));
if(!((HDstrcmp(buf, "/Group1") == 0) &&(namelen == 7))) TEST_ERROR
PASSED()
HDmemset(buf, 0, sizeof(buf));
TESTING("getting path to datatype in /Group1");
if((tid1 = H5Rdereference2(dataset, H5P_DEFAULT, H5R_OBJECT, &wbuf[3])) < 0) FAIL_STACK_ERROR
*buf = '\0';
i = H5Iget_name(tid1, (char*)buf, sizeof(buf));
namelen = H5Iget_name(tid1, (char*)buf, sizeof(buf));
if(H5Tclose(tid1) < 0) FAIL_STACK_ERROR
if(!((HDstrcmp(buf, "/Group1/Datatype1") == 0) &&(i == 17))) TEST_ERROR
if(!((HDstrcmp(buf, "/Group1/Datatype1") == 0) &&(namelen == 17))) TEST_ERROR
*buf = '\0';
i = H5Rget_name(dataset, H5R_OBJECT, &wbuf[3], (char*)buf, sizeof(buf));
if(!((HDstrcmp(buf, "/Group1/Datatype1") == 0) &&(i == 17))) TEST_ERROR
namelen = H5Rget_name(dataset, H5R_OBJECT, &wbuf[3], (char*)buf, sizeof(buf));
if(!((HDstrcmp(buf, "/Group1/Datatype1") == 0) &&(namelen == 17))) TEST_ERROR
PASSED()
HDmemset(buf, 0, sizeof(buf));
TESTING("getting path to dataset in nested group");
if((dataset2 = H5Rdereference2(dataset, H5P_DEFAULT, H5R_OBJECT, &wbuf[4])) < 0) FAIL_STACK_ERROR
*buf = '\0';
i = H5Iget_name(dataset2, (char*)buf, sizeof(buf));
namelen = H5Iget_name(dataset2, (char*)buf, sizeof(buf));
if(H5Dclose(dataset2) < 0) FAIL_STACK_ERROR
if(!((HDstrcmp(buf, "/Group1/Group2/Dataset4") == 0) &&(i == 23))) TEST_ERROR
if(!((HDstrcmp(buf, "/Group1/Group2/Dataset4") == 0) &&(namelen == 23))) TEST_ERROR
*buf = '\0';
i = H5Rget_name(dataset, H5R_OBJECT, &wbuf[4], (char*)buf, sizeof(buf));
if(!((HDstrcmp(buf, "/Group1/Group2/Dataset4") == 0) &&(i == 23))) TEST_ERROR
namelen = H5Rget_name(dataset, H5R_OBJECT, &wbuf[4], (char*)buf, sizeof(buf));
if(!((HDstrcmp(buf, "/Group1/Group2/Dataset4") == 0) &&(namelen == 23))) TEST_ERROR
PASSED()
HDmemset(buf, 0, sizeof(buf));
TESTING("getting path to nested group");
if((group = H5Rdereference2(dataset, H5P_DEFAULT, H5R_OBJECT, &wbuf[5])) < 0) FAIL_STACK_ERROR
*buf = '\0';
i = H5Iget_name(group, (char*)buf, sizeof(buf));
namelen = H5Iget_name(group, (char*)buf, sizeof(buf));
if(H5Gclose(group) < 0) FAIL_STACK_ERROR
if(!((HDstrcmp(buf, "/Group1/Group2") == 0) &&(i == 14))) TEST_ERROR
if(!((HDstrcmp(buf, "/Group1/Group2") == 0) &&(namelen == 14))) TEST_ERROR
*buf = '\0';
i = H5Rget_name(dataset, H5R_OBJECT, &wbuf[5], (char*)buf, sizeof(buf));
if(!((HDstrcmp(buf, "/Group1/Group2") == 0) &&(i == 14))) TEST_ERROR
namelen = H5Rget_name(dataset, H5R_OBJECT, &wbuf[5], (char*)buf, sizeof(buf));
if(!((HDstrcmp(buf, "/Group1/Group2") == 0) &&(namelen == 14))) TEST_ERROR
PASSED()
HDmemset(buf, 0, sizeof(buf));
TESTING("getting path to dataset created via hard link");
if((dataset2 = H5Rdereference2(dataset, H5P_DEFAULT, H5R_OBJECT, &wbuf[6])) < 0) FAIL_STACK_ERROR
*buf = '\0';
i = H5Iget_name(dataset2, (char*)buf, sizeof(buf));
namelen = H5Iget_name(dataset2, (char*)buf, sizeof(buf));
if(H5Dclose(dataset2) < 0) FAIL_STACK_ERROR
if(!((HDstrcmp(buf, "/Group1/Dataset5") == 0) &&(i == 16))) TEST_ERROR
if(!((HDstrcmp(buf, "/Group1/Dataset5") == 0) &&(namelen == 16))) TEST_ERROR
*buf = '\0';
i = H5Rget_name(dataset, H5R_OBJECT, &wbuf[6], (char*)buf, sizeof(buf));
if(!((HDstrcmp(buf, "/Group1/Dataset5") == 0) &&(i == 16))) TEST_ERROR
namelen = H5Rget_name(dataset, H5R_OBJECT, &wbuf[6], (char*)buf, sizeof(buf));
if(!((HDstrcmp(buf, "/Group1/Dataset5") == 0) &&(namelen == 16))) TEST_ERROR
PASSED()
HDmemset(buf, 0, sizeof(buf));
TESTING("getting path to root group");
if((group = H5Rdereference2(dataset, H5P_DEFAULT, H5R_OBJECT, &wbuf[7])) < 0) FAIL_STACK_ERROR
*buf = '\0';
i = H5Iget_name(group, (char*)buf, sizeof(buf));
namelen = H5Iget_name(group, (char*)buf, sizeof(buf));
if(H5Gclose(group) < 0) FAIL_STACK_ERROR
if(!((HDstrcmp(buf, "/") == 0) &&(i == 1))) TEST_ERROR
if(!((HDstrcmp(buf, "/") == 0) &&(namelen == 1))) TEST_ERROR
*buf = '\0';
i = H5Rget_name(dataset, H5R_OBJECT, &wbuf[7], (char*)buf, sizeof(buf));
if(!((HDstrcmp(buf, "/") == 0) &&(i == 1))) TEST_ERROR
namelen = H5Rget_name(dataset, H5R_OBJECT, &wbuf[7], (char*)buf, sizeof(buf));
if(!((HDstrcmp(buf, "/") == 0) &&(namelen == 1))) TEST_ERROR
PASSED()
/* Now we mount fid2 at /Group2 and look for dataset4. It shouldn't be found */
@ -2682,12 +2683,12 @@ test_obj_ref(hid_t fapl)
TESTING("getting path to dataset hidden by a mounted file");
if((dataset2 = H5Rdereference2(dataset, H5P_DEFAULT, H5R_OBJECT, &wbuf[4])) < 0) FAIL_STACK_ERROR
*buf = '\0';
i = H5Iget_name(dataset2, (char*)buf, sizeof(buf));
namelen = H5Iget_name(dataset2, (char*)buf, sizeof(buf));
if(H5Dclose(dataset2) < 0) FAIL_STACK_ERROR
if(i != 0) TEST_ERROR
if(namelen != 0) TEST_ERROR
*buf = '\0';
i = H5Rget_name(dataset, H5R_OBJECT, &wbuf[4], (char*)buf, sizeof(buf));
if(i != 0) TEST_ERROR
namelen = H5Rget_name(dataset, H5R_OBJECT, &wbuf[4], (char*)buf, sizeof(buf));
if(namelen != 0) TEST_ERROR
PASSED()
/* Now we try unlinking dataset2 from the file and searching for it. It shouldn't be found */
@ -2698,12 +2699,12 @@ test_obj_ref(hid_t fapl)
TESTING("getting path to dataset that has been unlinked");
*buf = '\0';
i = H5Iget_name(dataset2, (char*)buf, sizeof(buf));
namelen = H5Iget_name(dataset2, (char*)buf, sizeof(buf));
if(H5Dclose(dataset2) < 0) FAIL_STACK_ERROR
if(i != 0) TEST_ERROR
if(namelen != 0) TEST_ERROR
*buf = '\0';
i = H5Rget_name(dataset, H5R_OBJECT, &wbuf[1], (char*)buf, sizeof(buf));
if(i != 0) TEST_ERROR
namelen = H5Rget_name(dataset, H5R_OBJECT, &wbuf[1], (char*)buf, sizeof(buf));
if(namelen != 0) TEST_ERROR
PASSED()
/* Close disk dataspace */

1
test/links.c
View File

@ -7335,7 +7335,6 @@ external_link_with_committed_datatype(hid_t fapl, hbool_t new_format)
hid_t dtid = -1; /* Dataset's datatype ID */
hid_t dcpl = -1; /* Dataset creation property list */
int wdata = 99; /* Attribute data written */
int rdata = 0; /* Attribute data read */
int wbuf[60]; /* Data buffer for writing */
int rbuf[60]; /* Data buffer for reading */
int i; /* Local index variable */

2
test/mtime.c
View File

@ -114,7 +114,7 @@ main(void)
puts(" Modification times will be mantained in the file but");
puts(" cannot be queried on this system. See H5O_mtime_decode().");
return 0;
} else if(HDfabs(HDdifftime(now, oi1.ctime)) > 60.0F) {
} else if(HDfabs(HDdifftime(now, oi1.ctime)) > (double)60.0F) {
H5_FAILED();
tm = HDlocaltime(&(oi1.ctime));
HDstrftime((char*)buf1, sizeof buf1, "%Y-%m-%d %H:%M:%S", tm);

1
test/ohdr.c
View File

@ -17,7 +17,6 @@
* Tuesday, November 24, 1998
*/
#include "h5test.h"
#include "H5srcdir.h"
#include "H5Iprivate.h"
/*

6
test/set_extent.c
View File

@ -348,11 +348,9 @@ static int do_ranks( hid_t fapl, hbool_t new_format )
/* Iterate over different index types, but only if using the new format
*/
for(index_type = RANK4_INDEX_BTREE; index_type < RANK4_NINDICES;
index_type++) {
for(index_type = RANK4_INDEX_BTREE; index_type < RANK4_NINDICES; H5_INC_ENUM(rank4_index_t, index_type)) {
/* Standard test */
if(test_random_rank4(fapl, dcpl, do_fillvalue, disable_edge_filters,
FALSE, index_type) < 0) {
if(test_random_rank4(fapl, dcpl, do_fillvalue, disable_edge_filters, FALSE, index_type) < 0) {
DO_RANKS_PRINT_CONFIG("Randomized rank 4")
printf(" Index: %s\n", index_type == RANK4_INDEX_BTREE
? "btree" : (index_type == RANK4_INDEX_FARRAY ? "farray"

4
test/testframe.c
View File

@ -26,9 +26,9 @@
/*
* Definitions for the testing structure.
*/
#define MAXNUMOFTESTS 60
#define MAXNUMOFTESTS 24
#define MAXTESTNAME 16
#define MAXTESTDESC 64
#define MAXTESTDESC 32
typedef struct TestStruct {
int NumErrors;

2
test/tmeta.c
View File

@ -123,7 +123,7 @@ test_metadata(void)
*
*-------------------------------------------------------------------------
*/
H5_ATTR_PURE void
H5_ATTR_PURE H5_ATTR_CONST void
cleanup_metadata(void)
{
/* no file to clean */

94
test/tvltypes.c
View File

@ -169,7 +169,7 @@ static void
test_vltypes_funcs(void)
{
hid_t type; /* Datatype ID */
int size;
size_t size;
H5T_pad_t inpad;
H5T_norm_t norm;
H5T_cset_t cset;
@ -183,16 +183,16 @@ test_vltypes_funcs(void)
type = H5Tvlen_create (H5T_IEEE_F32BE);
CHECK(type, FAIL, "H5Tvlen_create");
size=H5Tget_precision(type);
CHECK(size, FAIL, "H5Tget_precision");
size = H5Tget_precision(type);
CHECK(size, 0, "H5Tget_precision");
size=H5Tget_size(type);
CHECK(size, FAIL, "H5Tget_size");
size = H5Tget_size(type);
CHECK(size, 0, "H5Tget_size");
size=H5Tget_ebias(type);
CHECK(size, FAIL, "H5Tget_ebias");
size = H5Tget_ebias(type);
CHECK(size, 0, "H5Tget_ebias");
ret=H5Tset_pad(type, H5T_PAD_ZERO, H5T_PAD_ONE);
ret = H5Tset_pad(type, H5T_PAD_ZERO, H5T_PAD_ONE);
CHECK(ret, FAIL, "H5Tset_pad");
inpad = H5Tget_inpad(type);
@ -558,7 +558,7 @@ rewrite_vltypes_vlen_atomic(void)
hsize_t size; /* Number of bytes which will be used */
unsigned i,j; /* counting variables */
size_t mem_used=0; /* Memory used during allocation */
int increment=4;
unsigned increment=4;
herr_t ret; /* Generic return value */
/* Output message about test being performed */
@ -730,8 +730,8 @@ test_vltypes_vlen_compound(void)
wdata[i].p=HDmalloc((i+1)*sizeof(s1));
wdata[i].len=i+1;
for(j=0; j<(i+1); j++) {
((s1 *)wdata[i].p)[j].i=i*10+j;
((s1 *)wdata[i].p)[j].f=(float)((i*20+j)/3.0F);
((s1 *)wdata[i].p)[j].i = (int)(i * 10 + j);
((s1 *)wdata[i].p)[j].f = (float)(i * 20 + j) / 3.0F;
} /* end for */
} /* end for */
@ -865,7 +865,7 @@ rewrite_vltypes_vlen_compound(void)
hsize_t size; /* Number of bytes which will be used */
unsigned i,j; /* counting variables */
size_t mem_used=0; /* Memory used during allocation */
int increment=4;
unsigned increment=4;
herr_t ret; /* Generic return value */
/* Output message about test being performed */
@ -876,8 +876,8 @@ rewrite_vltypes_vlen_compound(void)
wdata[i].p = HDmalloc((i + increment) * sizeof(s1));
wdata[i].len = i + increment;
for(j = 0; j < (i + increment); j++) {
((s1 *)wdata[i].p)[j].i = i * 40 + j;
((s1 *)wdata[i].p)[j].f = (float)((i * 60 + j) / 3.0F);
((s1 *)wdata[i].p)[j].i = (int)(i * 40 + j);
((s1 *)wdata[i].p)[j].f = (float)(i * 60 + j) / 3.0F;
} /* end for */
} /* end for */
@ -1016,17 +1016,17 @@ test_vltypes_compound_vlen_vlen(void)
MESSAGE(5, ("Testing Compound Datatypes with VL Atomic Datatype Component Functionality\n"));
/* Allocate and initialize VL data to write */
for(i=0; i<SPACE3_DIM1; i++) {
wdata[i].i=i*10;
wdata[i].f=(float)((i*20)/3.0F);
wdata[i].v.p=HDmalloc((i+L1_INCM)*sizeof(hvl_t));
wdata[i].v.len=i+L1_INCM;
for(t1=(hvl_t *)((wdata[i].v).p),j=0; j<(i+L1_INCM); j++, t1++) {
t1->p=HDmalloc((j+L2_INCM)*sizeof(unsigned int));
t1->len=j+L2_INCM;
for(k=0; k<j+L2_INCM; k++)
((unsigned int*)t1->p)[k] = i*100 + j*10 + k;
}
for(i = 0; i < SPACE3_DIM1; i++) {
wdata[i].i = (int)(i * 10);
wdata[i].f = (float)(i * 20) / 3.0F;
wdata[i].v.p = HDmalloc((i + L1_INCM) * sizeof(hvl_t));
wdata[i].v.len = i + L1_INCM;
for(t1 = (hvl_t *)((wdata[i].v).p), j = 0; j < (i + L1_INCM); j++, t1++) {
t1->p = HDmalloc((j + L2_INCM) * sizeof(unsigned int));
t1->len = j + L2_INCM;
for(k = 0; k < j + L2_INCM; k++)
((unsigned int*)t1->p)[k] = i * 100 + j * 10 + k;
} /* end for */
} /* end for */
/* Create file */
@ -1477,13 +1477,13 @@ test_vltypes_compound_vlen_atomic(void)
MESSAGE(5, ("Testing Compound Datatypes with VL Atomic Datatype Component Functionality\n"));
/* Allocate and initialize VL data to write */
for(i=0; i<SPACE1_DIM1; i++) {
wdata[i].i=i*10;
wdata[i].f=(float)((i*20)/3.0F);
wdata[i].v.p=HDmalloc((i+1)*sizeof(unsigned int));
wdata[i].v.len=i+1;
for(j=0; j<(i+1); j++)
((unsigned int *)wdata[i].v.p)[j]=i*10+j;
for(i = 0; i < SPACE1_DIM1; i++) {
wdata[i].i = (int)(i * 10);
wdata[i].f = (float)(i * 20) / 3.0F;
wdata[i].v.p = HDmalloc((i + 1)*sizeof(unsigned int));
wdata[i].v.len = i + 1;
for(j = 0; j < (i + 1); j++)
((unsigned int *)wdata[i].v.p)[j] = i * 10 + j;
} /* end for */
/* Create file */
@ -1688,7 +1688,7 @@ rewrite_vltypes_compound_vlen_atomic(void)
hsize_t size; /* Number of bytes which will be used */
unsigned i,j; /* counting variables */
size_t mem_used=0; /* Memory used during allocation */
int increment=4;
unsigned increment=4;
herr_t ret; /* Generic return value */
/* Output message about test being performed */
@ -1696,8 +1696,8 @@ rewrite_vltypes_compound_vlen_atomic(void)
/* Allocate and initialize VL data to write */
for(i = 0; i < SPACE1_DIM1; i++) {
wdata[i].i = i * 40;
wdata[i].f = (float)((i * 50) / 3.0F);
wdata[i].i = (int)(i * 40);
wdata[i].f = (float)(i * 50) / 3.0F;
wdata[i].v.p = HDmalloc((i + increment) * sizeof(unsigned int));
wdata[i].v.len = i + increment;
for(j = 0; j < (i + increment); j++)
@ -1960,7 +1960,7 @@ test_vltypes_vlen_vlen_atomic(void)
/* 10 hvl_t elements allocated = 1 + 2 + 3 + 4 elements for each array position */
/* 20 unsigned int elements allocated = 1 + 3 + 6 + 10 elements */
VERIFY(size, ((SPACE1_DIM1 * (SPACE1_DIM1 + 1)) / 2) * sizeof(hvl_t) + vlen_size_func((unsigned long)SPACE1_DIM1) * sizeof(unsigned int), "H5Dvlen_get_buf_size");
VERIFY(size, (hsize_t)(((SPACE1_DIM1 * (SPACE1_DIM1 + 1)) / 2) * sizeof(hvl_t) + vlen_size_func((unsigned long)SPACE1_DIM1) * sizeof(unsigned int)), "H5Dvlen_get_buf_size");
/* Read dataset from disk */
ret = H5Dread(dataset, tid2, H5S_ALL, H5S_ALL, xfer_pid, rdata);
@ -1969,7 +1969,7 @@ test_vltypes_vlen_vlen_atomic(void)
/* Make certain the correct amount of memory has been used */
/* 10 hvl_t elements allocated = 1 + 2 + 3 + 4 elements for each array position */
/* 20 unsigned int elements allocated = 1 + 3 + 6 + 10 elements */
VERIFY(mem_used, ((SPACE1_DIM1 * (SPACE1_DIM1 + 1)) / 2) * sizeof(hvl_t) + vlen_size_func((unsigned long)SPACE1_DIM1) * sizeof(unsigned int), "H5Dread");
VERIFY(mem_used, (size_t)(((SPACE1_DIM1 * (SPACE1_DIM1 + 1)) / 2) * sizeof(hvl_t) + vlen_size_func((unsigned long)SPACE1_DIM1) * sizeof(unsigned int)), "H5Dread");
/* Compare data read in */
for(i=0; i<SPACE1_DIM1; i++) {
@ -2048,7 +2048,7 @@ rewrite_longer_vltypes_vlen_vlen_atomic(void)
hsize_t size; /* Number of bytes which will be used */
unsigned i,j,k; /* counting variables */
size_t mem_used=0; /* Memory used during allocation */
int increment=1;
unsigned increment=1;
herr_t ret; /* Generic return value */
/* Output message about test being performed */
@ -2224,7 +2224,7 @@ rewrite_shorter_vltypes_vlen_vlen_atomic(void)
hsize_t size; /* Number of bytes which will be used */
unsigned i,j,k; /* counting variables */
size_t mem_used=0; /* Memory used during allocation */
int increment=1;
unsigned increment=1;
herr_t ret; /* Generic return value */
/* Output message about test being performed */
@ -2316,7 +2316,7 @@ rewrite_shorter_vltypes_vlen_vlen_atomic(void)
/* 10 hvl_t elements allocated = 1 + 2 + 3 + 4 elements for each array position */
/* 20 unsigned int elements allocated = 1 + 3 + 6 + 10 elements */
VERIFY(size, ((SPACE1_DIM1*(SPACE1_DIM1 + 1)) / 2) * sizeof(hvl_t) + vlen_size_func((unsigned long)SPACE1_DIM1) * sizeof(unsigned int), "H5Dvlen_get_buf_size");
VERIFY(size, (hsize_t)(((SPACE1_DIM1*(SPACE1_DIM1 + 1)) / 2) * sizeof(hvl_t) + vlen_size_func((unsigned long)SPACE1_DIM1) * sizeof(unsigned int)), "H5Dvlen_get_buf_size");
/* Read dataset from disk */
ret=H5Dread(dataset,tid2,H5S_ALL,H5S_ALL,xfer_pid,rdata);
@ -2325,7 +2325,7 @@ rewrite_shorter_vltypes_vlen_vlen_atomic(void)
/* Make certain the correct amount of memory has been used */
/* 10 hvl_t elements allocated = 1 + 2 + 3 + 4 elements for each array position */
/* 20 unsigned int elements allocated = 1 + 3 + 6 + 10 elements */
VERIFY(mem_used,((SPACE1_DIM1*(SPACE1_DIM1+1))/2)*sizeof(hvl_t)+vlen_size_func((unsigned long)SPACE1_DIM1)*sizeof(unsigned int),"H5Dread");
VERIFY(mem_used, (size_t)(((SPACE1_DIM1*(SPACE1_DIM1+1))/2)*sizeof(hvl_t)+vlen_size_func((unsigned long)SPACE1_DIM1)*sizeof(unsigned int)),"H5Dread");
/* Compare data read in */
for(i=0; i<SPACE1_DIM1; i++) {
@ -2597,6 +2597,10 @@ test_vltypes_fill_value(void)
}
break;
case H5D_VIRTUAL:
assert(0 && "Invalid layout type!");
break;
case H5D_LAYOUT_ERROR:
case H5D_NLAYOUTS:
default:
@ -2700,6 +2704,10 @@ test_vltypes_fill_value(void)
dset_elmts = SPACE4_DIM_LARGE;
break;
case H5D_VIRTUAL:
assert(0 && "Invalid layout type!");
break;
case H5D_LAYOUT_ERROR:
case H5D_NLAYOUTS:
default:
@ -2897,6 +2905,10 @@ test_vltypes_fill_value(void)
dset_elmts = SPACE4_DIM_LARGE;
break;
case H5D_VIRTUAL:
assert(0 && "Invalid layout type!");
break;
case H5D_LAYOUT_ERROR:
case H5D_NLAYOUTS:
default:

1
test/vds.c
View File

@ -19,7 +19,6 @@
* Purpose: Tests datasets with virtual layout.
*/
#include "h5test.h"
#include "H5srcdir.h"
#include "H5Dprivate.h" /* For H5D_VIRTUAL_DEF_LIST_SIZE */
typedef enum {

16
testpar/t_shapesame.c
View File

@ -5078,24 +5078,24 @@ int main(int argc, char **argv)
/* Shape Same tests using contigous hyperslab */
#if 1
AddTest("sscontig1", sscontig1, NULL,
"Shape Same, contigous hyperslab, ind IO, contig datasets", PARATESTFILE);
"Cntg hslab, ind IO, cntg dsets", PARATESTFILE);
AddTest("sscontig2", sscontig2, NULL,
"Shape Same, contigous hyperslab, col IO, contig datasets", PARATESTFILE);
"Cntg hslab, col IO, cntg dsets", PARATESTFILE);
AddTest("sscontig3", sscontig3, NULL,
"Shape Same, contigous hyperslab, ind IO, chunked datasets", PARATESTFILE);
"Cntg hslab, ind IO, chnk dsets", PARATESTFILE);
AddTest("sscontig4", sscontig4, NULL,
"Shape Same, contigous hyperslab, col IO, chunked datasets", PARATESTFILE);
"Cntg hslab, col IO, chnk dsets", PARATESTFILE);
#endif
/* Shape Same tests using checker board hyperslab */
AddTest("sschecker1", sschecker1, NULL,
"Shape Same, checker hyperslab, ind IO, contig datasets", PARATESTFILE);
"Check hslab, ind IO, cntg dsets", PARATESTFILE);
AddTest("sschecker2", sschecker2, NULL,
"Shape Same, checker hyperslab, col IO, contig datasets", PARATESTFILE);
"Check hslab, col IO, cntg dsets", PARATESTFILE);
AddTest("sschecker3", sschecker3, NULL,
"Shape Same, checker hyperslab, ind IO, chunked datasets", PARATESTFILE);
"Check hslab, ind IO, chnk dsets", PARATESTFILE);
AddTest("sschecker4", sschecker4, NULL,
"Shape Same, checker hyperslab, col IO, chunked datasets", PARATESTFILE);
"Check hslab, col IO, chnk dsets", PARATESTFILE);
/* Display testing information */
TestInfo(argv[0]);

24
tools/h5copy/h5copy.c
View File

@ -417,19 +417,19 @@ main (int argc, const char *argv[])
/* create property to pass copy options */
if ( (ocpl_id = H5Pcreate(H5P_OBJECT_COPY)) < 0)
HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pcreate failed");
HGOTO_ERROR(EXIT_FAILURE, H5E_tools_min_id_g, "H5Pcreate failed");
/* set options for object copy */
if (flag)
{
if ( H5Pset_copy_object(ocpl_id, flag) < 0)
HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pset_copy_object failed");
HGOTO_ERROR(EXIT_FAILURE, H5E_tools_min_id_g, "H5Pset_copy_object failed");
}
/* Create link creation property list */
if((lcpl_id = H5Pcreate(H5P_LINK_CREATE)) < 0) {
error_msg("Could not create link creation property list\n");
HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pcreate failed");
HGOTO_ERROR(EXIT_FAILURE, H5E_tools_min_id_g, "H5Pcreate failed");
} /* end if */
/* Check for creating intermediate groups */
@ -437,7 +437,7 @@ main (int argc, const char *argv[])
/* Set the intermediate group creation property */
if(H5Pset_create_intermediate_group(lcpl_id, 1) < 0) {
error_msg("Could not set property for creating parent groups\n");
HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pset_create_intermediate_group failed");
HGOTO_ERROR(EXIT_FAILURE, H5E_tools_min_id_g, "H5Pset_create_intermediate_group failed");
} /* end if */
/* Display some output if requested */
@ -464,7 +464,7 @@ main (int argc, const char *argv[])
{
error_msg("group <%s> doesn't exist. Use -p to create parent groups.\n", str_ptr);
HDfree(str_ptr);
HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Lexists failed");
HGOTO_ERROR(EXIT_FAILURE, H5E_tools_min_id_g, "H5Lexists failed");
}
HDfree(str_ptr);
}
@ -484,7 +484,7 @@ main (int argc, const char *argv[])
if(H5Lcopy(fid_src, oname_src,
fid_dst, oname_dst,
H5P_DEFAULT, H5P_DEFAULT) < 0)
HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Lcopy failed");
HGOTO_ERROR(EXIT_FAILURE, H5E_tools_min_id_g, "H5Lcopy failed");
}
else /* valid link */
{
@ -494,7 +494,7 @@ main (int argc, const char *argv[])
oname_dst, /* Name of the destination object */
ocpl_id, /* Object copy property list */
lcpl_id)<0) /* Link creation property list */
HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Ocopy failed");
HGOTO_ERROR(EXIT_FAILURE, H5E_tools_min_id_g, "H5Ocopy failed");
}
/* free link info path */
@ -503,15 +503,15 @@ main (int argc, const char *argv[])
/* close propertis */
if(H5Pclose(ocpl_id)<0)
HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
HGOTO_ERROR(EXIT_FAILURE, H5E_tools_min_id_g, "H5Pclose failed");
if(H5Pclose(lcpl_id)<0)
HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Pclose failed");
HGOTO_ERROR(EXIT_FAILURE, H5E_tools_min_id_g, "H5Pclose failed");
/* close files */
if (H5Fclose(fid_src)<0)
HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Fclose failed");
HGOTO_ERROR(EXIT_FAILURE, H5E_tools_min_id_g, "H5Fclose failed");
if (H5Fclose(fid_dst)<0)
HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Fclose failed");
HGOTO_ERROR(EXIT_FAILURE, H5E_tools_min_id_g, "H5Fclose failed");
leave(EXIT_SUCCESS);
@ -529,6 +529,6 @@ done:
H5Fclose(fid_dst);
} H5E_END_TRY;
leave(EXIT_FAILURE);
leave(ret_value);
}

5
tools/h5diff/h5diff_main.c
View File

@ -16,6 +16,7 @@
#include <stdlib.h>
#include <assert.h>
#include <memory.h>
#include "H5private.h"
#include "h5diff.h"
#include "h5diff_common.h"
#include "h5tools.h"
@ -136,9 +137,9 @@ int main(int argc, const char *argv[])
*
*-------------------------------------------------------------------------
*/
void
H5_ATTR_NORETURN void
h5diff_exit(int status)
{
exit(status);
HDexit(status);
}

217
tools/h5diff/h5diffgentest.c
View File

@ -28,7 +28,7 @@
* NOTE: this value should stay in sync with the value defined in the tools
* library file: h5tools_utils.h
*/
hsize_t H5TOOLS_MALLOCSIZE = (128 * 1024 * 1024);
size_t H5TOOLS_MALLOCSIZE = (128 * 1024 * 1024);
/*-------------------------------------------------------------------------
* Program: h5diffgentest
@ -3745,7 +3745,7 @@ static int test_comp_vlen_strings(const char *fname1, const char *grp_name, int
/* vlen string */
hid_t sid_vlen_str=0; /* dataspace ID */
hid_t tid_vlen_str=0; /* datatype ID */
const char vlen_str_buf[]= {
char vlen_str_buf[]= {
"Variable length string"
};
hsize_t dims_vlen_str[] = {VLEN_STR_DIM};
@ -3762,7 +3762,7 @@ static int test_comp_vlen_strings(const char *fname1, const char *grp_name, int
hid_t sid_vlen_str_array=0; /* dataspace ID */
hid_t tid_vlen_str_array_pre=0; /* datatype ID */
hid_t tid_vlen_str_array=0; /* datatype ID */
const char *vlen_str_array_buf[VLEN_STR_ARRY_DIM]= {
char *vlen_str_array_buf[VLEN_STR_ARRY_DIM]= {
"1 - Variable length string Array",
"2 - Testing variable length string array in compound type",
"3 - Four score and seven\n years ago our forefathers brought forth on this continent a new nation,"
@ -4478,8 +4478,8 @@ static void test_comps_array (const char *fname, const char *dset, const char *a
wdata[i].i1 = i;
for(j=0; j < SDIM_CMPD_ARRAY; j++)
{
wdata[i].cmpd2[j].i2 = i*10 + diff;
wdata[i].cmpd2[j].f2 = (float)(i*10.5F) + diff;
wdata[i].cmpd2[j].i2 = i * 10 + diff;
wdata[i].cmpd2[j].f2 = (float)i * 10.5F + (float)diff;
} /* end for */
}
@ -4588,15 +4588,13 @@ static void test_comps_vlen (const char * fname, const char *dset, const char *a
herr_t ret; /* Generic return value */
/* Allocate and initialize VL data to write */
for(i=0; i<SDIM_DSET; i++)
{
wdata[i].i1 = i;
wdata[i].vl.p = HDmalloc((i+1)*sizeof(cmpd2_t));
wdata[i].vl.len = i+1;
for(j=0; j<(i+1); j++)
{
((cmpd2_t *)wdata[i].vl.p)[j].i2 = i*10 + diff;
((cmpd2_t *)wdata[i].vl.p)[j].f2 = (float)(i*10.5F) + diff;
for(i = 0; i < SDIM_DSET; i++) {
wdata[i].i1 = (int)i;
wdata[i].vl.p = HDmalloc((i + 1) * sizeof(cmpd2_t));
wdata[i].vl.len = i + 1;
for(j = 0; j < (i + 1); j++) {
((cmpd2_t *)wdata[i].vl.p)[j].i2 = (int)(i * 10 + (unsigned)diff);
((cmpd2_t *)wdata[i].vl.p)[j].f2 = (float)i * 10.5F + (float)diff;
} /* end for */
} /* end for */
@ -4703,26 +4701,24 @@ static void test_comps_array_vlen (const char * fname, const char *dset,const ch
hid_t tid_cmpd3; /* Compound3 Datatype ID */
hsize_t sdims_dset[] = {SDIM_DSET};
hsize_t sdims_arry[] = {SDIM_CMPD_ARRAY};
int i,j,k; /* counting variables */
herr_t ret; /* Generic return value */
unsigned i, j, k; /* counting variables */
herr_t ret; /* Generic return value */
/* Initialize array data to write in compound1 */
for(i=0; i < SDIM_DSET; i++)
{
wdata[i].i1 = i;
for(i = 0; i < SDIM_DSET; i++) {
wdata[i].i1 = (int)i;
/* Allocate and initialize VL data to write in compound2 */
for(j=0; j < SDIM_CMPD_ARRAY; j++)
{
wdata[i].cmpd2[j].i2 = j*10;
wdata[i].cmpd2[j].vl.p = HDmalloc((j+1)*sizeof(cmpd3_t));
wdata[i].cmpd2[j].vl.len = j+1;
for(k=0; k<(j+1); k++)
{
for(j = 0; j < SDIM_CMPD_ARRAY; j++) {
wdata[i].cmpd2[j].i2 = (int)(j * 10);
wdata[i].cmpd2[j].vl.p = HDmalloc((j + 1) * sizeof(cmpd3_t));
wdata[i].cmpd2[j].vl.len = j + 1;
for(k = 0; k < (j + 1); k++) {
/* Initialize data of compound3 */
((cmpd3_t *)wdata[i].cmpd2[j].vl.p)[k].i3 = j*10 + diff;
((cmpd3_t *)wdata[i].cmpd2[j].vl.p)[k].f3 = (float)(j*10.5F) + diff;
((cmpd3_t *)wdata[i].cmpd2[j].vl.p)[k].i3 = (int)j * 10 + diff;
((cmpd3_t *)wdata[i].cmpd2[j].vl.p)[k].f3 = (float)j * 10.5F + (float)diff;
} /* end for */
} /* end for */
}
@ -4856,22 +4852,19 @@ static void test_comps_vlen_arry (const char * fname, const char *dset, const ch
herr_t ret; /* Generic return value */
/* Allocate and initialize VL data to write */
for(i=0; i<SDIM_DSET; i++)
{
for(i = 0; i < SDIM_DSET; i++) {
/* compound 1 data */
wdata[i].i1 = i;
wdata[i].vl.p = HDmalloc((i+1)*sizeof(cmpd2_t));
wdata[i].vl.len = i+1;
for(j=0; j<(i+1); j++)
{
wdata[i].i1 = (int)i;
wdata[i].vl.p = HDmalloc((i + 1) * sizeof(cmpd2_t));
wdata[i].vl.len = i + 1;
for(j = 0; j < (i + 1); j++) {
/* compound2 data */
((cmpd2_t *)wdata[i].vl.p)[j].i2 = i*10 + diff;
for (k=0; k < SDIM_CMPD_ARRAY; k++)
{
((cmpd2_t *)wdata[i].vl.p)[j].i2 = (int)i * 10 + diff;
for(k = 0; k < SDIM_CMPD_ARRAY; k++) {
/* compound 3 data */
((cmpd2_t *)(wdata[i].vl.p))[j].cmpd3[k].i3 = k*10.5F + diff;
((cmpd2_t *)(wdata[i].vl.p))[j].cmpd3[k].f3 = (float)(k*10.5F) + diff;
}
((cmpd2_t *)(wdata[i].vl.p))[j].cmpd3[k].i3 = (int)((float)k * 10.5F) + diff;
((cmpd2_t *)(wdata[i].vl.p))[j].cmpd3[k].f3 = (float)k * 10.5F + (float)diff;
} /* end for */
} /* end for */
} /* end for */
@ -5857,13 +5850,15 @@ void write_attr_in(hid_t loc_id,
/* Allocate and initialize VL dataset to write */
n=0;
for (i = 0; i < 3; i++) {
for (j = 0; j < 2; j++) {
buf52[i][j].p = HDmalloc((i + 1) * sizeof(int));
buf52[i][j].len = i + 1;
for (l = 0; l < i + 1; l++)
if (make_diffs)((int *)buf52[i][j].p)[l] = 0;
else ((int *)buf52[i][j].p)[l] = n++;
for(i = 0; i < 3; i++) {
for(j = 0; j < 2; j++) {
buf52[i][j].p = HDmalloc((size_t)(i + 1) * sizeof(int));
buf52[i][j].len = (size_t)(i + 1);
for(l = 0; l < i + 1; l++)
if(make_diffs)
((int *)buf52[i][j].p)[l] = 0;
else
((int *)buf52[i][j].p)[l] = n++;
}
}
@ -6074,8 +6069,10 @@ void write_attr_in(hid_t loc_id,
for (i = 0; i < 4; i++) {
for (j = 0; j < 3; j++) {
for (k = 0; k < 2; k++) {
if (make_diffs) buf23[i][j][k]=0;
else buf23[i][j][k]=n++;
if(make_diffs)
buf23[i][j][k] = 0;
else
buf23[i][j][k] = (char)n++;
}
}
}
@ -6132,12 +6129,12 @@ void write_attr_in(hid_t loc_id,
for (j = 0; j < 3; j++) {
for (k = 0; k < 2; k++) {
if (make_diffs) {
buf33[i][j][k].a=0;
buf33[i][j][k].b=0.0F;
buf33[i][j][k].a = 0;
buf33[i][j][k].b = 0.0F;
}
else {
buf33[i][j][k].a=n++;
buf33[i][j][k].b=n++;
buf33[i][j][k].a = (char)n++;
buf33[i][j][k].b = n++;
}
}
}
@ -6275,11 +6272,13 @@ void write_attr_in(hid_t loc_id,
for (i = 0; i < 4; i++) {
for (j = 0; j < 3; j++) {
for (k = 0; k < 2; k++) {
buf53[i][j][k].p = HDmalloc((i + 1) * sizeof(int));
buf53[i][j][k].len = i + 1;
buf53[i][j][k].p = HDmalloc((size_t)(i + 1) * sizeof(int));
buf53[i][j][k].len = (size_t)(i + 1);
for (l = 0; l < i + 1; l++)
if (make_diffs)((int *)buf53[i][j][k].p)[l] = 0;
else ((int *)buf53[i][j][k].p)[l] = n++;
if(make_diffs)
((int *)buf53[i][j][k].p)[l] = 0;
else
((int *)buf53[i][j][k].p)[l] = n++;
}
}
}
@ -6649,22 +6648,21 @@ void write_dset_in(hid_t loc_id,
status = H5Tclose(tid);
{
double *dbuf; /* information to write */
hid_t did; /* dataset ID */
hid_t sid; /* dataspace ID */
hid_t tid; /* datatype ID */
hid_t ldid; /* dataset ID */
hid_t lsid; /* dataspace ID */
hid_t ltid; /* datatype ID */
size_t size;
hsize_t sdims[] = {1};
hsize_t tdims[] = {H5TOOLS_MALLOCSIZE / sizeof(double) + 1};
int j;
size_t jj;
/* allocate and initialize array data to write */
size = ( H5TOOLS_MALLOCSIZE / sizeof(double) + 1 ) * sizeof(double);
dbuf = (double *)HDmalloc( size );
dbuf = (double *)HDmalloc(size);
for( j = 0; j < H5TOOLS_MALLOCSIZE / sizeof(double) + 1; j++)
dbuf[j] = j;
for(jj = 0; jj < (H5TOOLS_MALLOCSIZE / sizeof(double) + 1); jj++)
dbuf[jj] = (double)jj;
if (make_diffs)
{
@ -6673,19 +6671,19 @@ void write_dset_in(hid_t loc_id,
}
/* create a type larger than H5TOOLS_MALLOCSIZE */
tid = H5Tarray_create2(H5T_NATIVE_DOUBLE, 1, tdims);
size = H5Tget_size(tid);
sid = H5Screate_simple(1, sdims, NULL);
did = H5Dcreate2(loc_id, "arrayd", tid, sid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
ltid = H5Tarray_create2(H5T_NATIVE_DOUBLE, 1, tdims);
size = H5Tget_size(ltid);
lsid = H5Screate_simple(1, sdims, NULL);
ldid = H5Dcreate2(loc_id, "arrayd", ltid, lsid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
#if defined(WRITE_ARRAY)
H5Dwrite(did, tid, H5S_ALL, H5S_ALL, H5P_DEFAULT, dbuf);
H5Dwrite(ldid, ltid, H5S_ALL, H5S_ALL, H5P_DEFAULT, dbuf);
#endif
/* close */
H5Dclose(did);
H5Tclose(tid);
H5Sclose(sid);
HDfree( dbuf );
H5Dclose(ldid);
H5Tclose(ltid);
H5Sclose(lsid);
HDfree(dbuf);
}
/*-------------------------------------------------------------------------
@ -6815,15 +6813,12 @@ void write_dset_in(hid_t loc_id,
/* Allocate and initialize VL dataset to write */
n = 0;
for(i = 0; i < 3; i++)
{
for(j = 0; j < 2; j++)
{
buf52[i][j].p = HDmalloc((i + 1) * sizeof(int));
buf52[i][j].len = i + 1;
for(l = 0; l < i + 1; l++)
{
if (make_diffs)
for(i = 0; i < 3; i++) {
for(j = 0; j < 2; j++) {
buf52[i][j].p = HDmalloc((size_t)(i + 1) * sizeof(int));
buf52[i][j].len = (size_t)(i + 1);
for(l = 0; l < i + 1; l++) {
if(make_diffs)
((int *)buf52[i][j].p)[l] = 0;
else
((int *)buf52[i][j].p)[l] = n++;
@ -6933,15 +6928,13 @@ void write_dset_in(hid_t loc_id,
n=1;
for (i = 0; i < 4; i++)
{
for (j = 0; j < 3; j++)
{
for (k = 0; k < 2; k++)
{
if (make_diffs)
buf23[i][j][k]=0;
else buf23[i][j][k]=n++;
for (i = 0; i < 4; i++) {
for (j = 0; j < 3; j++) {
for (k = 0; k < 2; k++) {
if(make_diffs)
buf23[i][j][k] = 0;
else
buf23[i][j][k] = (char)n++;
}
}
}
@ -6966,20 +6959,16 @@ void write_dset_in(hid_t loc_id,
*/
n=1;
for (i = 0; i < 4; i++)
{
for (j = 0; j < 3; j++)
{
for (k = 0; k < 2; k++)
{
if (make_diffs)
{
buf33[i][j][k].a=0;
buf33[i][j][k].b=0.0F;
for (i = 0; i < 4; i++) {
for (j = 0; j < 3; j++) {
for (k = 0; k < 2; k++) {
if (make_diffs) {
buf33[i][j][k].a = 0;
buf33[i][j][k].b = 0.0F;
}
else {
buf33[i][j][k].a=n++;
buf33[i][j][k].b=n++;
buf33[i][j][k].a = (char)n++;
buf33[i][j][k].b = n++;
}
}
}
@ -7026,16 +7015,12 @@ void write_dset_in(hid_t loc_id,
/* Allocate and initialize VL dataset to write */
n=0;
for(i = 0; i < 4; i++)
{
for(j = 0; j < 3; j++)
{
for(k = 0; k < 2; k++)
{
buf53[i][j][k].p = HDmalloc((i + 1) * sizeof(int));
buf53[i][j][k].len = i + 1;
for(l = 0; l < i + 1; l++)
{
for(i = 0; i < 4; i++) {
for(j = 0; j < 3; j++) {
for(k = 0; k < 2; k++) {
buf53[i][j][k].p = HDmalloc((size_t)(i + 1) * sizeof(int));
buf53[i][j][k].len = (size_t)(i + 1);
for(l = 0; l < i + 1; l++) {
if(make_diffs)
((int *)buf53[i][j][k].p)[l] = 0;
else
@ -7265,7 +7250,7 @@ int test_hyperslab(const char *fname,
if(make_diffs && i == 512 * 512)
HDmemset(buf, 0, nelmts);
hs_start[0] = i * GBLL/(1024*1024);
hs_start[0] = (unsigned long long)i * GBLL / (1024 * 1024);
if (H5Sselect_hyperslab (f_sid,H5S_SELECT_SET,hs_start,NULL,hs_size, NULL) < 0)
goto out;

4
tools/h5format_convert/h5fc_gentest.c
View File

@ -471,9 +471,9 @@ gen_err_level(const char *fname)
hsize_t extent[2] = {0, 0};
start[0] = 0;
start[1] = n;
start[1] = (hsize_t)n;
extent[0] = 1;
extent[1] = n+1;
extent[1] = (hsize_t)(n + 1);
/* Set current dimension sizes for the dataset */
if(H5Dset_extent(did, extent) < 0)

10
tools/h5jam/h5unjam.c
View File

@ -347,17 +347,19 @@ done:
* Returns 0 on success, -1 on failure.
*/
herr_t
copy_to_file( FILE *infid, FILE *ofid, ssize_t _where, ssize_t how_much )
copy_to_file( FILE *infid, FILE *ofid, ssize_t _where, ssize_t show_much )
{
static char buf[COPY_BUF_SIZE];
size_t how_much;
off_t where = (off_t)_where;
off_t to;
off_t from;
herr_t ret_value = 0;
/* nothing to copy */
if(how_much <= 0)
if(show_much <= 0)
goto done;
how_much = (size_t)show_much;
/* rewind */
HDfseek(infid, 0L, 0);
@ -392,8 +394,8 @@ copy_to_file( FILE *infid, FILE *ofid, ssize_t _where, ssize_t how_much )
/* Update positions/size */
how_much -= bytes_read;
from += bytes_read;
to += bytes_read;
from += (off_t)bytes_read;
to += (off_t)bytes_read;
/* Write nchars bytes to output file */
bytes_wrote = HDfwrite(buf, (size_t)1, bytes_read, ofid);

10
tools/h5ls/h5ls.c
View File

@ -196,7 +196,9 @@ usage: %s [OPTIONS] file[/OBJECT] [file[/[OBJECT]...]\n\
as a soft link or external link and prints the value\n\
assigned to the symbolic link; it does not provide any\n\
information regarding the target object or determine\n\
whether the link is a dangling link.\n\
whether the link is a dangling link.\n",
h5tools_getprogname());
HDfprintf(rawerrorstream, "\
--no-dangling-links\n\
Must be used with --follow-symlinks option;\n\
otherwise, h5ls shows error message and returns an exit\n\
@ -216,7 +218,8 @@ usage: %s [OPTIONS] file[/OBJECT] [file[/[OBJECT]...]\n\
-v, --verbose Generate more verbose output\n\
-V, --version Print version number and exit\n\
--vfd=DRIVER Use the specified virtual file driver\n\
-x, --hexdump Show raw data in hexadecimal format\n\
-x, --hexdump Show raw data in hexadecimal format\n");
HDfprintf(rawerrorstream, "\
\n\
file/OBJECT\n\
Each object consists of an HDF5 file name optionally followed by a\n\
@ -235,8 +238,7 @@ usage: %s [OPTIONS] file[/OBJECT] [file[/[OBJECT]...]\n\
-E or --external Follow external links.\n\
Replaced by --follow-symlinks.\n\
-e, --errors Show all HDF5 error reporting\n\
Replaced by --enable-error-stack.\n",
h5tools_getprogname());
Replaced by --enable-error-stack.\n");
}

5
tools/h5repack/h5repack.c
View File

@ -564,7 +564,7 @@ done:
H5Aclose(attr_out);
} H5E_END_TRY;
return -1;
return ret_value;
} /* end copy_attr() */
/*-------------------------------------------------------------------------
@ -606,6 +606,9 @@ static int check_options(pack_opt_t *options) {
case H5D_CHUNKED:
strcpy(slayout, "chunked");
break;
case H5D_VIRTUAL:
strcpy(slayout, "virtual");
break;
case H5D_LAYOUT_ERROR:
case H5D_NLAYOUTS:
error_msg("invalid layout\n");

17
tools/h5repack/h5repack_filters.c
View File

@ -34,8 +34,8 @@
*
*-------------------------------------------------------------------------
*/
static
int aux_find_obj(const char* name, /* object name from traverse list */
static int
aux_find_obj(const char* name, /* object name from traverse list */
pack_opt_t *options, /* repack options */
pack_info_t *obj /*OUT*/) /* info about object to filter */
{
@ -48,7 +48,7 @@ int aux_find_obj(const char* name, /* object name from traverse list */
if (HDstrcmp(options->op_tbl->objs[i].path,name)==0)
{
*obj = options->op_tbl->objs[i];
return i;
return (int)i;
}
pdest = HDstrstr(name,options->op_tbl->objs[i].path);
@ -58,7 +58,7 @@ int aux_find_obj(const char* name, /* object name from traverse list */
if( pdest != NULL && result==1 )
{
*obj = options->op_tbl->objs[i];
return i;
return (int)i;
}
}/*i*/
@ -76,8 +76,8 @@ int aux_find_obj(const char* name, /* object name from traverse list */
*
*-------------------------------------------------------------------------
*/
static
int aux_assign_obj(const char* name, /* object name from traverse list */
static int
aux_assign_obj(const char* name, /* object name from traverse list */
pack_opt_t *options, /* repack options */
pack_info_t *obj /*OUT*/) /* info about object to filter */
{
@ -109,6 +109,7 @@ int aux_assign_obj(const char* name, /* object name from traverse lis
case H5D_LAYOUT_ERROR:
case H5D_COMPACT:
case H5D_CONTIGUOUS:
case H5D_VIRTUAL:
case H5D_NLAYOUTS:
break;
default:
@ -128,6 +129,7 @@ int aux_assign_obj(const char* name, /* object name from traverse lis
case H5D_LAYOUT_ERROR:
case H5D_COMPACT:
case H5D_CONTIGUOUS:
case H5D_VIRTUAL:
case H5D_NLAYOUTS:
break;
default:
@ -184,6 +186,7 @@ int aux_assign_obj(const char* name, /* object name from traverse lis
case H5D_LAYOUT_ERROR:
case H5D_COMPACT:
case H5D_CONTIGUOUS:
case H5D_VIRTUAL:
case H5D_NLAYOUTS:
break;
default:
@ -433,7 +436,7 @@ int apply_filters(const char* name, /* object name from traverse list */
int scale_factor;
scale_type = (H5Z_SO_scale_type_t)obj.filter[i].cd_values[0];
scale_factor = obj.filter[i].cd_values[1];
scale_factor = (int)obj.filter[i].cd_values[1];
if(H5Pset_chunk(dcpl_id, obj.chunk.rank, obj.chunk.chunk_lengths)<0)
return -1;

4
tools/lib/h5tools_filters.c
View File

@ -13,7 +13,7 @@
* access to either file, you may request a copy from help@hdfgroup.org. *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#include "hdf5.h"
#include "H5private.h"
#include "h5tools.h"
/*-------------------------------------------------------------------------
@ -147,7 +147,7 @@ int h5tools_canreadf(const char* name, /* object name, serves also as boolean pr
*
*-------------------------------------------------------------------------
*/
int
H5_ATTR_CONST int
h5tools_can_encode(H5Z_filter_t filtn) {
switch (filtn) {
/* user defined filter */

2
tools/lib/h5tools_ref.c
View File

@ -39,7 +39,7 @@
typedef struct {
haddr_t objno; /* Object ID (i.e. address) */
const char *path; /* Object path */
char *path; /* Object path */
} ref_path_node_t;
static H5SL_t *ref_path_table = NULL; /* the "table" (implemented with a skip list) */

32
tools/perform/sio_engine.c
View File

@ -123,8 +123,8 @@ static hid_t h5dxpl = -1; /* Dataset transfer property list */
* Programmer: Christian Chilan, April, 2008
* Modifications:
*/
results
do_sio(parameters param)
void
do_sio(parameters param, results *res)
{
char *buffer = NULL; /*data buffer pointer */
size_t buf_size[MAX_DIMS]; /* general buffer size in bytes */
@ -133,7 +133,6 @@ do_sio(parameters param)
char base_name[256]; /* test file base name */
/* return codes */
herr_t ret_code = 0; /*return code */
results res;
char fname[FILENAME_MAX]; /* test file name */
int i;
@ -148,11 +147,11 @@ do_sio(parameters param)
switch (iot) {
case POSIXIO:
fd.posixfd = -1;
res.timers = io_time_new(SYS_CLOCK);
res->timers = io_time_new(SYS_CLOCK);
break;
case HDF5:
fd.h5fd = -1;
res.timers = io_time_new(SYS_CLOCK);
res->timers = io_time_new(SYS_CLOCK);
break;
default:
/* unknown request */
@ -209,18 +208,18 @@ do_sio(parameters param)
HDfprintf(output, "data filename=%s\n",
fname);
set_time(res.timers, HDF5_GROSS_WRITE_FIXED_DIMS, TSTART);
set_time(res->timers, HDF5_GROSS_WRITE_FIXED_DIMS, TSTART);
hrc = do_fopen(&param, fname, &fd, SIO_CREATE | SIO_WRITE);
VRFY((hrc == SUCCESS), "do_fopen failed");
set_time(res.timers, HDF5_FINE_WRITE_FIXED_DIMS, TSTART);
hrc = do_write(&res, &fd, &param, buffer);
set_time(res.timers, HDF5_FINE_WRITE_FIXED_DIMS, TSTOP);
set_time(res->timers, HDF5_FINE_WRITE_FIXED_DIMS, TSTART);
hrc = do_write(res, &fd, &param, buffer);
set_time(res->timers, HDF5_FINE_WRITE_FIXED_DIMS, TSTOP);
VRFY((hrc == SUCCESS), "do_write failed");
/* Close file for write */
hrc = do_fclose(iot, &fd);
set_time(res.timers, HDF5_GROSS_WRITE_FIXED_DIMS, TSTOP);
set_time(res->timers, HDF5_GROSS_WRITE_FIXED_DIMS, TSTOP);
VRFY((hrc == SUCCESS), "do_fclose failed");
if (!param.h5_write_only) {
@ -229,19 +228,19 @@ do_sio(parameters param)
*/
/* Open file for read */
set_time(res.timers, HDF5_GROSS_READ_FIXED_DIMS, TSTART);
set_time(res->timers, HDF5_GROSS_READ_FIXED_DIMS, TSTART);
hrc = do_fopen(&param, fname, &fd, SIO_READ);
VRFY((hrc == SUCCESS), "do_fopen failed");
set_time(res.timers, HDF5_FINE_READ_FIXED_DIMS, TSTART);
hrc = do_read(&res, &fd, &param, buffer);
set_time(res.timers, HDF5_FINE_READ_FIXED_DIMS, TSTOP);
set_time(res->timers, HDF5_FINE_READ_FIXED_DIMS, TSTART);
hrc = do_read(res, &fd, &param, buffer);
set_time(res->timers, HDF5_FINE_READ_FIXED_DIMS, TSTOP);
VRFY((hrc == SUCCESS), "do_read failed");
/* Close file for read */
hrc = do_fclose(iot, &fd);
set_time(res.timers, HDF5_GROSS_READ_FIXED_DIMS, TSTOP);
set_time(res->timers, HDF5_GROSS_READ_FIXED_DIMS, TSTOP);
VRFY((hrc == SUCCESS), "do_fclose failed");
}
@ -272,8 +271,7 @@ done:
if (buffer)
free(buffer);
res.ret_code = ret_code;
return res;
res->ret_code = ret_code;
}
/*

89
tools/perform/sio_perf.c
View File

@ -68,7 +68,7 @@
#define SIO_HDF5 0x4
/* report 0.0 in case t is zero too */
#define MB_PER_SEC(bytes,t) (((t)==0.0F) ? 0.0F : ((((double)bytes) / ONE_MB) / (t)))
#define MB_PER_SEC(bytes,t) (H5_DBL_ABS_EQUAL(t, (double)0.0F) ? (double)0.0F : ((((double)bytes) / (double)ONE_MB) / (t)))
#ifndef TRUE
#define TRUE 1
@ -279,18 +279,18 @@ struct options {
long num_files; /* number of files */
off_t num_bpp; /* number of bytes per proc per dset */
int num_iters; /* number of iterations */
off_t dset_size[MAX_DIMS]; /* Dataset size */
hsize_t dset_size[MAX_DIMS]; /* Dataset size */
size_t buf_size[MAX_DIMS]; /* Buffer size */
size_t chk_size[MAX_DIMS]; /* Chunk size */
int order[MAX_DIMS]; /* Dimension access order */
int dset_rank; /* Rank */
int buf_rank; /* Rank */
int order[MAX_DIMS]; /* Dimension access order */
int dset_rank; /* Rank */
int buf_rank; /* Rank */
int order_rank; /* Rank */
int chk_rank; /* Rank */
int chk_rank; /* Rank */
int print_times; /* print times as well as throughputs */
int print_raw; /* print raw data throughput info */
off_t h5_alignment; /* alignment in HDF5 file */
off_t h5_threshold; /* threshold for alignment in HDF5 file */
hsize_t h5_alignment; /* alignment in HDF5 file */
hsize_t h5_threshold; /* threshold for alignment in HDF5 file */
int h5_use_chunks; /* Make HDF5 dataset chunked */
int h5_write_only; /* Perform the write tests only */
int h5_extendable; /* Perform the write tests only */
@ -307,13 +307,13 @@ typedef struct _minmax {
} minmax;
/* local functions */
static off_t parse_size_directive(const char *size);
static hsize_t parse_size_directive(const char *size);
static struct options *parse_command_line(int argc, char *argv[]);
static void run_test_loop(struct options *options);
static int run_test(iotype iot, parameters parms, struct options *opts);
static void output_all_info(minmax *mm, int count, int indent_level);
static void get_minmax(minmax *mm, double val);
static minmax accumulate_minmax_stuff(minmax *mm, int count);
static void accumulate_minmax_stuff(const minmax *mm, int count, minmax *total_mm);
static void output_results(const struct options *options, const char *name,
minmax *table, int table_size, off_t data_size);
static void output_report(const char *fmt, ...);
@ -392,6 +392,7 @@ run_test_loop(struct options *opts)
parameters parms;
int i;
size_t buf_bytes;
/* load options into parameter structure */
parms.num_files = opts->num_files;
parms.num_dsets = opts->num_dsets;
@ -496,7 +497,8 @@ run_test(iotype iot, parameters parms, struct options *opts)
/* Do IO iteration times, collecting statistics each time */
for (i = 0; i < parms.num_iters; ++i) {
double t;
res = do_sio(parms);
do_sio(parms, &res);
/* gather all of the "sys write" times */
t = get_time(res.timers, HDF5_MPI_WRITE);
@ -711,30 +713,27 @@ get_minmax(minmax *mm, double val)
* Modifications:
* Changed to use seconds instead of MB/s - QAK, 5/9/02
*/
static minmax
accumulate_minmax_stuff(minmax *mm, int count)
static void
accumulate_minmax_stuff(const minmax *mm, int count, minmax *total_mm)
{
int i;
minmax total_mm;
total_mm.sum = 0.0F;
total_mm.max = -DBL_MAX;
total_mm.min = DBL_MAX;
total_mm.num = count;
total_mm->sum = 0.0F;
total_mm->max = -DBL_MAX;
total_mm->min = DBL_MAX;
total_mm->num = count;
for (i = 0; i < count; ++i) {
double m = mm[i].max;
total_mm.sum += m;
total_mm->sum += m;
if (m < total_mm.min)
total_mm.min = m;
if (m < total_mm->min)
total_mm->min = m;
if (m > total_mm.max)
total_mm.max = m;
if (m > total_mm->max)
total_mm->max = m;
}
return total_mm;
}
@ -752,7 +751,7 @@ output_results(const struct options *opts, const char *name, minmax *table,
{
minmax total_mm;
total_mm = accumulate_minmax_stuff(table, table_size);
accumulate_minmax_stuff(table, table_size, &total_mm);
print_indent(3);
output_report("%s (%d iteration(s)):\n", name,table_size);
@ -940,10 +939,11 @@ report_parameters(struct options *opts)
static struct options *
parse_command_line(int argc, char *argv[])
{
register int opt;
int opt;
struct options *cl_opts;
int i, default_rank, actual_rank, ranks[4];
cl_opts = (struct options *)malloc(sizeof(struct options));
cl_opts = (struct options *)HDmalloc(sizeof(struct options));
cl_opts->output_file = NULL;
cl_opts->io_types = 0; /* will set default after parsing options */
@ -956,11 +956,11 @@ parse_command_line(int argc, char *argv[])
cl_opts->chk_rank = 0;
cl_opts->order_rank = 0;
for (i=0; i<MAX_DIMS; i++){
cl_opts->buf_size[i]=(i+1)*10;
cl_opts->dset_size[i]=(i+1)*100;
cl_opts->chk_size[i]=(i+1)*10;
cl_opts->order[i]=i+1;
for(i = 0; i < MAX_DIMS; i++) {
cl_opts->buf_size[i] = (size_t)((i + 1) * 10);
cl_opts->dset_size[i] = (hsize_t)((i + 1) * 100);
cl_opts->chk_size[i] = (size_t)((i + 1) * 10);
cl_opts->order[i] = i + 1;
}
cl_opts->vfd = sec2;
@ -985,7 +985,7 @@ parse_command_line(int argc, char *argv[])
while (end && *end != '\0') {
char buf[10];
memset(buf, '\0', sizeof(buf));
HDmemset(buf, '\0', sizeof(buf));
for (i = 0; *end != '\0' && *end != ','; ++end)
if (isalnum(*end) && i < 10)
@ -1024,7 +1024,7 @@ parse_command_line(int argc, char *argv[])
while (end && *end != '\0') {
char buf[10];
memset(buf, '\0', sizeof(buf));
HDmemset(buf, '\0', sizeof(buf));
for (i = 0; *end != '\0' && *end != ','; ++end)
if (isalnum(*end) && i < 10)
@ -1052,7 +1052,7 @@ parse_command_line(int argc, char *argv[])
while (end && *end != '\0') {
char buf[10];
memset(buf, '\0', sizeof(buf));
HDmemset(buf, '\0', sizeof(buf));
for (i = 0; *end != '\0' && *end != ','; ++end)
if (isalnum(*end) && i < 10)
@ -1110,7 +1110,7 @@ parse_command_line(int argc, char *argv[])
while (end && *end != '\0') {
char buf[10];
memset(buf, '\0', sizeof(buf));
HDmemset(buf, '\0', sizeof(buf));
for (i = 0; *end != '\0' && *end != ','; ++end)
if (isalnum(*end) && i < 10)
@ -1174,7 +1174,7 @@ parse_command_line(int argc, char *argv[])
while (end && *end != '\0') {
char buf[10];
memset(buf, '\0', sizeof(buf));
HDmemset(buf, '\0', sizeof(buf));
for (i = 0; *end != '\0' && *end != ','; ++end)
if (isalnum(*end) && i < 10)
@ -1202,13 +1202,13 @@ parse_command_line(int argc, char *argv[])
while (end && *end != '\0') {
char buf[10];
memset(buf, '\0', sizeof(buf));
HDmemset(buf, '\0', sizeof(buf));
for (i = 0; *end != '\0' && *end != ','; ++end)
if (isalnum(*end) && i < 10)
buf[i++] = *end;
cl_opts->order[j] = parse_size_directive(buf);
cl_opts->order[j] = (int)parse_size_directive(buf);
j++;
@ -1294,13 +1294,13 @@ parse_command_line(int argc, char *argv[])
* Modifications:
*/
static off_t
static hsize_t
parse_size_directive(const char *size)
{
off_t s;
hsize_t s;
char *endptr;
s = strtol(size, &endptr, 10);
s = HDstrtoull(size, &endptr, 10);
if (endptr && *endptr) {
while (*endptr != '\0' && (*endptr == ' ' || *endptr == '\t'))
@ -1311,14 +1311,17 @@ parse_size_directive(const char *size)
case 'k':
s *= ONE_KB;
break;
case 'M':
case 'm':
s *= ONE_MB;
break;
case 'G':
case 'g':
s *= ONE_GB;
break;
default:
fprintf(stderr, "Illegal size specifier '%c'\n", *endptr);
exit(EXIT_FAILURE);

32
tools/perform/sio_perf.h
View File

@ -52,21 +52,21 @@ typedef enum vfdtype_ {
typedef struct parameters_ {
iotype io_type; /* The type of IO test to perform */
vfdtype vfd;
long num_files; /* Number of files to create */
long num_dsets; /* Number of datasets to create */
off_t num_bytes; /* Number of bytes in each dset */
int num_iters; /* Number of times to loop doing the IO */
int rank; /* Rank of dataset */
off_t dset_size[MAX_DIMS]; /* Dataset size */
size_t buf_size[MAX_DIMS]; /* Buffer size */
size_t chk_size[MAX_DIMS]; /* Chunk size */
int order[MAX_DIMS]; /* Buffer size */
hsize_t h5_align; /* HDF5 object alignment */
hsize_t h5_thresh; /* HDF5 object alignment threshold */
int h5_use_chunks; /* Make HDF5 dataset chunked */
int h5_extendable; /* Make HDF5 dataset chunked */
int h5_write_only; /* Perform the write tests only */
int verify; /* Verify data correctness */
long num_files; /* Number of files to create */
long num_dsets; /* Number of datasets to create */
hsize_t num_bytes; /* Number of bytes in each dset */
int num_iters; /* Number of times to loop doing the IO */
int rank; /* Rank of dataset */
hsize_t dset_size[MAX_DIMS]; /* Dataset size */
size_t buf_size[MAX_DIMS]; /* Buffer size */
size_t chk_size[MAX_DIMS]; /* Chunk size */
int order[MAX_DIMS]; /* Buffer size */
hsize_t h5_align; /* HDF5 object alignment */
hsize_t h5_thresh; /* HDF5 object alignment threshold */
int h5_use_chunks; /* Make HDF5 dataset chunked */
int h5_extendable; /* Make HDF5 dataset chunked */
int h5_write_only; /* Perform the write tests only */
int verify; /* Verify data correctness */
} parameters;
typedef struct results_ {
@ -95,7 +95,7 @@ extern int sio_debug_level; /* The debug level:
extern "C" {
#endif /* __cplusplus */
extern results do_sio(parameters param);
extern void do_sio(parameters param, results *res);
#ifdef __cplusplus
}

24
tools/perform/zip_perf.c
View File

@ -37,7 +37,7 @@
#define MICROSECOND 1000000.0F
/* report 0.0 in case t is zero too */
#define MB_PER_SEC(bytes,t) ((fabs(t)<0.0000000001F) ? 0.0F : ((((double)bytes) / ONE_MB) / (t)))
#define MB_PER_SEC(bytes,t) ((fabs(t) < (double)0.0000000001F) ? (double)0.0F : ((((double)bytes) / (double)ONE_MB) / (t)))
#ifndef TRUE
#define TRUE 1
@ -173,7 +173,7 @@ write_file(Bytef *source, uLongf sourceLen)
/* destination buffer needs to be at least 0.1% larger than sourceLen
* plus 12 bytes */
destLen = (uLongf)((double)sourceLen + ((double)sourceLen * 0.1F)) + 12;
destLen = (uLongf)((double)sourceLen + ((double)sourceLen * (double)0.1F)) + 12;
dest = (Bytef *)HDmalloc(destLen);
if (!dest)
@ -184,9 +184,9 @@ write_file(Bytef *source, uLongf sourceLen)
HDgettimeofday(&timer_stop, NULL);
compression_time += ((double)timer_stop.tv_sec +
((double)timer_stop.tv_usec) / MICROSECOND) -
((double)timer_stop.tv_usec) / (double)MICROSECOND) -
((double)timer_start.tv_sec +
((double)timer_start.tv_usec) / MICROSECOND);
((double)timer_start.tv_usec) / (double)MICROSECOND);
if (report_once_flag) {
HDfprintf(stdout, "\tCompression Ratio: %g\n", ((double)destLen) / (double)sourceLen);
@ -206,7 +206,7 @@ write_file(Bytef *source, uLongf sourceLen)
if (rc == (int)d_len)
break;
d_len -= rc;
d_len -= (size_t)rc;
d_ptr += rc;
}
@ -419,7 +419,7 @@ fill_with_random_data(Bytef *src, uLongf src_len)
break;
buf += rc;
len -= rc;
len -= (size_t)rc;
}
} else {
HDfprintf(stdout, "Using random() for random data\n");
@ -429,7 +429,7 @@ fill_with_random_data(Bytef *src, uLongf src_len)
}
if (compress_percent) {
unsigned long s = src_len * compress_percent / 100;
size_t s = (size_t)((src_len * (uLongf)compress_percent) / 100);
HDmemset(src, '\0', s);
}
@ -495,7 +495,7 @@ do_write_test(unsigned long file_size, unsigned long min_buf_size,
if (rc == (ssize_t)s_len)
break;
s_len -= rc;
s_len -= (size_t)rc;
s_ptr += rc;
}
}
@ -504,9 +504,9 @@ do_write_test(unsigned long file_size, unsigned long min_buf_size,
HDgettimeofday(&timer_stop, NULL);
total_time = ((double)timer_stop.tv_sec +
((double)timer_stop.tv_usec) / MICROSECOND) -
((double)timer_stop.tv_usec) / (double)MICROSECOND) -
((double)timer_start.tv_sec +
((double)timer_start.tv_usec) / MICROSECOND);
((double)timer_start.tv_usec) / (double)MICROSECOND);
HDfprintf(stdout, "\tUncompressed Write Time: %.2fs\n", total_time);
HDfprintf(stdout, "\tUncompressed Write Throughput: %.2fMB/s\n",
@ -530,9 +530,9 @@ do_write_test(unsigned long file_size, unsigned long min_buf_size,
HDgettimeofday(&timer_stop, NULL);
total_time = ((double)timer_stop.tv_sec +
((double)timer_stop.tv_usec) / MICROSECOND) -
((double)timer_stop.tv_usec) / (double)MICROSECOND) -
((double)timer_start.tv_sec +
((double)timer_start.tv_usec) / MICROSECOND);
((double)timer_start.tv_usec) / (double)MICROSECOND);
HDfprintf(stdout, "\tCompressed Write Time: %.2fs\n", total_time);
HDfprintf(stdout, "\tCompressed Write Throughput: %.2fMB/s\n",