//--------------------------------------------------------------------------
// Function: DSetCreatPropList::setFletcher32
///\brief Sets Fletcher32 checksum of EDC for this property list.
///
///\exception H5::PropListIException
// Programmer Binh-Minh Ribler - 2000
//--------------------------------------------------------------------------
void DSetCreatPropList::setFletcher32() const
{
herr_t ret_value = H5Pset_fletcher32(id);
if( ret_value < 0 )
{
throw PropListIException("DSetCreatPropList::setFletcher32",
"H5Pset_fletcher32 failed");
}
}
/*-------------------------------------------------------------------------
* Function: create_file_with_bogus_filter
*
* Purpose: Create a dataset with the fletcher filter.
* This function is used to create the test file `test_filters.h5'
* which has a dataset with the "fletcher" I/O filter. This dataset
* will be used to verify the correct behavior of the library in
* the test "dsets"
*
* Return: Success: 0
*
* Failure: -1
*
* Programmer: Pedro Vicente <*****@*****.**>
* Thursday, March 25, 2004
*
*-------------------------------------------------------------------------
*/
static herr_t
test_filters_endianess(void)
{
#if defined H5_HAVE_FILTER_FLETCHER32
hid_t fid = -1; /* file ID */
hid_t dsid = -1; /* dataset ID */
hid_t sid = -1; /* dataspace ID */
hid_t dcpl = -1; /* dataset creation property list ID */
hsize_t dims[1] = {20}; /* dataspace dimensions */
hsize_t chunk_dims[1] = {10}; /* chunk dimensions */
int buf[20];
int rank = 1;
int i;
for(i = 0; i < 20; i++)
buf[i] = 1;
/* create a file using default properties */
if((fid = H5Fcreate(TESTFILE1, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT)) < 0) goto error;
/* create a data space */
if((sid = H5Screate_simple(rank, dims, NULL)) < 0) goto error;
/* create dcpl */
if((dcpl = H5Pcreate(H5P_DATASET_CREATE)) < 0) goto error;
if(H5Pset_chunk(dcpl, rank, chunk_dims) < 0) goto error;
if(H5Pset_fletcher32(dcpl) < 0) goto error;
/* create a dataset */
if((dsid = H5Dcreate2(fid, "dset", H5T_NATIVE_INT, sid, H5P_DEFAULT, dcpl, H5P_DEFAULT)) < 0) goto error;
if(H5Dwrite(dsid, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf) < 0) goto error;
/* close */
if(H5Pclose(dcpl) < 0) goto error;
if(H5Dclose(dsid) < 0) goto error;
if(H5Sclose(sid) < 0) goto error;
if(H5Fclose(fid) < 0) goto error;
#endif /* H5_HAVE_FILTER_FLETCHER32 */
return 0;
#if defined H5_HAVE_FILTER_FLETCHER32
error:
H5E_BEGIN_TRY {
H5Pclose(dcpl);
H5Dclose(dsid);
H5Sclose(sid);
H5Fclose(fid);
} H5E_END_TRY;
return -1;
#endif /* H5_HAVE_FILTER_FLETCHER32 */
} /* end test_filters_endianess() */
int FTI_WriteHDF5Var(FTIT_dataset *FTI_DataVar)
{
int j;
hsize_t dimLength[32];
char str[FTI_BUFS];
int res;
hid_t dcpl;
for (j = 0; j < FTI_DataVar->rank; j++) {
dimLength[j] = FTI_DataVar->dimLength[j];
}
dcpl = H5Pcreate (H5P_DATASET_CREATE);
res = H5Pset_fletcher32 (dcpl);
res = H5Pset_chunk (dcpl, FTI_DataVar->rank, dimLength);
hid_t dataspace = H5Screate_simple( FTI_DataVar->rank, dimLength, NULL);
hid_t dataset = H5Dcreate2 ( FTI_DataVar->h5group->h5groupID, FTI_DataVar->name,FTI_DataVar->type->h5datatype, dataspace, H5P_DEFAULT, dcpl , H5P_DEFAULT);
// If my data are stored in the CPU side
// Just store the data to the file and return;
#ifdef GPUSUPPORT
if ( !FTI_DataVar->isDevicePtr ){
#endif
res = H5Dwrite(dataset,FTI_DataVar->type->h5datatype, H5S_ALL, H5S_ALL, H5P_DEFAULT, FTI_DataVar->ptr);
if (res < 0) {
sprintf(str, "Dataset #%d could not be written", FTI_DataVar->id);
FTI_Print(str, FTI_EROR);
return FTI_NSCS;
}
res = H5Pclose (dcpl);
if (res < 0) {
sprintf(str, "Dataset #%d could not be written", FTI_DataVar->id);
FTI_Print(str, FTI_EROR);
return FTI_NSCS;
}
res = H5Dclose(dataset);
if (res < 0) {
sprintf(str, "Dataset #%d could not be written", FTI_DataVar->id);
FTI_Print(str, FTI_EROR);
return FTI_NSCS;
}
res = H5Sclose(dataspace);
if (res < 0) {
sprintf(str, "Dataset #%d could not be written", FTI_DataVar->id);
FTI_Print(str, FTI_EROR);
return FTI_NSCS;
}
return FTI_SCES;
#ifdef GPUSUPPORT
}
// This code is only executed in the GPU case.
hsize_t *count = (hsize_t*) malloc (sizeof(hsize_t)*FTI_DataVar->rank);
hsize_t *offset= (hsize_t*) calloc (FTI_DataVar->rank,sizeof(hsize_t));
if ( !count|| !offset){
sprintf(str, "Could Not allocate count and offset regions");
FTI_Print(str, FTI_EROR);
return FTI_NSCS;
}
hsize_t seperator;
hsize_t fetchBytes = FTI_getHostBuffSize();
fetchBytes = FTI_calculateCountDim(FTI_DataVar->eleSize, fetchBytes ,count, FTI_DataVar->rank, dimLength, &seperator);
sprintf(str,"GPU-Device Message: I Will Fetch %lld Bytes Per Stream Request", fetchBytes);
FTI_Print(str,FTI_DBUG);
FTIT_data_prefetch prefetcher;
prefetcher.fetchSize = fetchBytes;
prefetcher.totalBytesToFetch = FTI_DataVar->size;
prefetcher.isDevice = FTI_DataVar->isDevicePtr;
prefetcher.dptr = FTI_DataVar->devicePtr;
size_t bytesToWrite;
FTI_InitPrefetcher(&prefetcher);
unsigned char *basePtr = NULL;
if ( FTI_Try(FTI_getPrefetchedData(&prefetcher, &bytesToWrite, &basePtr), "Fetch next memory block from GPU to write to HDF5") != FTI_SCES){
return FTI_NSCS;
}
while( basePtr ){
res = FTI_WriteElements( dataspace, FTI_DataVar->type->h5datatype, dataset, count, offset, FTI_DataVar->rank , basePtr);
if (res != FTI_SCES ) {
free(offset);
free(count);
sprintf(str, "Dataset #%d could not be written", FTI_DataVar->id);
FTI_Print(str, FTI_EROR);
return FTI_NSCS;
}
FTI_AdvanceOffset(seperator, offset,count, dimLength, FTI_DataVar->rank);
if ( FTI_Try(FTI_getPrefetchedData(&prefetcher, &bytesToWrite, &basePtr),
"Fetch next memory block from GPU to write to HDF5") != FTI_SCES){
return FTI_NSCS;
}
}
res = H5Dclose(dataset);
if (res < 0) {
free(offset);
free(count);
sprintf(str, "Dataset #%d could not be written", FTI_DataVar->id);
FTI_Print(str, FTI_EROR);
return FTI_NSCS;
}
res = H5Sclose(dataspace);
if (res < 0) {
free(offset);
free(count);
sprintf(str, "Dataset #%d could not be written", FTI_DataVar->id);
FTI_Print(str, FTI_EROR);
return FTI_NSCS;
}
free(offset);
free(count);
return FTI_SCES;
#endif
}
int apply_filters(const char* name, /* object name from traverse list */
int rank, /* rank of dataset */
hsize_t *dims, /* dimensions of dataset */
size_t msize, /* size of type */
hid_t dcpl_id, /* dataset creation property list */
pack_opt_t *options, /* repack options */
int *has_filter) /* (OUT) object NAME has a filter */
{
int nfilters; /* number of filters in DCPL */
hsize_t chsize[64]; /* chunk size in elements */
H5D_layout_t layout;
int i;
pack_info_t obj;
*has_filter = 0;
if (rank==0) /* scalar dataset, do not apply */
return 0;
/*-------------------------------------------------------------------------
* initialize the assigment object
*-------------------------------------------------------------------------
*/
init_packobject(&obj);
/*-------------------------------------------------------------------------
* find options
*-------------------------------------------------------------------------
*/
if (aux_assign_obj(name,options,&obj)==0)
return 0;
/* get information about input filters */
if ((nfilters = H5Pget_nfilters(dcpl_id))<0)
return -1;
/*-------------------------------------------------------------------------
* check if we have filters in the pipeline
* we want to replace them with the input filters
* only remove if we are inserting new ones
*-------------------------------------------------------------------------
*/
if (nfilters && obj.nfilters )
{
*has_filter = 1;
if (H5Premove_filter(dcpl_id,H5Z_FILTER_ALL)<0)
return -1;
}
/*-------------------------------------------------------------------------
* check if there is an existent chunk
* read it only if there is not a requested layout
*-------------------------------------------------------------------------
*/
if (obj.layout == -1 )
{
if ((layout = H5Pget_layout(dcpl_id))<0)
return -1;
if (layout == H5D_CHUNKED)
{
if ((rank = H5Pget_chunk(dcpl_id,NELMTS(chsize),chsize/*out*/))<0)
return -1;
obj.layout = H5D_CHUNKED;
obj.chunk.rank = rank;
for ( i = 0; i < rank; i++)
obj.chunk.chunk_lengths[i] = chsize[i];
}
}
/*-------------------------------------------------------------------------
* the type of filter and additional parameter
* type can be one of the filters
* H5Z_FILTER_NONE 0 , uncompress if compressed
* H5Z_FILTER_DEFLATE 1 , deflation like gzip
* H5Z_FILTER_SHUFFLE 2 , shuffle the data
* H5Z_FILTER_FLETCHER32 3 , fletcher32 checksum of EDC
* H5Z_FILTER_SZIP 4 , szip compression
* H5Z_FILTER_NBIT 5 , nbit compression
* H5Z_FILTER_SCALEOFFSET 6 , scaleoffset compression
*-------------------------------------------------------------------------
*/
if (obj.nfilters)
{
/*-------------------------------------------------------------------------
* filters require CHUNK layout; if we do not have one define a default
*-------------------------------------------------------------------------
*/
if (obj.layout==-1)
{
/* stripmine info */
hsize_t sm_size[H5S_MAX_RANK]; /*stripmine size */
hsize_t sm_nbytes; /*bytes per stripmine */
obj.chunk.rank = rank;
/*
* determine the strip mine size. The strip mine is
* a hyperslab whose size is manageable.
*/
sm_nbytes = msize;
for ( i = rank; i > 0; --i)
{
hsize_t size = H5TOOLS_BUFSIZE / sm_nbytes;
if ( size == 0) /* datum size > H5TOOLS_BUFSIZE */
size = 1;
sm_size[i - 1] = MIN(dims[i - 1], size);
sm_nbytes *= sm_size[i - 1];
assert(sm_nbytes > 0);
}
for ( i = 0; i < rank; i++)
{
obj.chunk.chunk_lengths[i] = sm_size[i];
}
}
for ( i=0; i<obj.nfilters; i++)
{
switch (obj.filter[i].filtn)
{
default:
break;
/*-------------------------------------------------------------------------
* H5Z_FILTER_DEFLATE 1 , deflation like gzip
*-------------------------------------------------------------------------
*/
case H5Z_FILTER_DEFLATE:
{
unsigned aggression; /* the deflate level */
aggression = obj.filter[i].cd_values[0];
/* set up for deflated data */
if(H5Pset_chunk(dcpl_id, obj.chunk.rank, obj.chunk.chunk_lengths)<0)
return -1;
if(H5Pset_deflate(dcpl_id,aggression)<0)
return -1;
}
break;
/*-------------------------------------------------------------------------
* H5Z_FILTER_SZIP 4 , szip compression
*-------------------------------------------------------------------------
*/
case H5Z_FILTER_SZIP:
{
unsigned options_mask;
unsigned pixels_per_block;
options_mask = obj.filter[i].cd_values[0];
pixels_per_block = obj.filter[i].cd_values[1];
/* set up for szip data */
if(H5Pset_chunk(dcpl_id,obj.chunk.rank,obj.chunk.chunk_lengths)<0)
return -1;
if (H5Pset_szip(dcpl_id,options_mask,pixels_per_block)<0)
return -1;
}
break;
/*-------------------------------------------------------------------------
* H5Z_FILTER_SHUFFLE 2 , shuffle the data
*-------------------------------------------------------------------------
*/
case H5Z_FILTER_SHUFFLE:
if(H5Pset_chunk(dcpl_id, obj.chunk.rank, obj.chunk.chunk_lengths)<0)
return -1;
if (H5Pset_shuffle(dcpl_id)<0)
return -1;
break;
/*-------------------------------------------------------------------------
* H5Z_FILTER_FLETCHER32 3 , fletcher32 checksum of EDC
*-------------------------------------------------------------------------
*/
case H5Z_FILTER_FLETCHER32:
if(H5Pset_chunk(dcpl_id, obj.chunk.rank, obj.chunk.chunk_lengths)<0)
return -1;
if (H5Pset_fletcher32(dcpl_id)<0)
return -1;
break;
/*----------- -------------------------------------------------------------
* H5Z_FILTER_NBIT , NBIT compression
*-------------------------------------------------------------------------
*/
case H5Z_FILTER_NBIT:
if(H5Pset_chunk(dcpl_id, obj.chunk.rank, obj.chunk.chunk_lengths)<0)
return -1;
if (H5Pset_nbit(dcpl_id)<0)
return -1;
break;
/*----------- -------------------------------------------------------------
* H5Z_FILTER_SCALEOFFSET , scale+offset compression
*-------------------------------------------------------------------------
*/
case H5Z_FILTER_SCALEOFFSET:
{
H5Z_SO_scale_type_t scale_type;
int scale_factor;
scale_type = (H5Z_SO_scale_type_t)obj.filter[i].cd_values[0];
scale_factor = obj.filter[i].cd_values[1];
if(H5Pset_chunk(dcpl_id, obj.chunk.rank, obj.chunk.chunk_lengths)<0)
return -1;
if (H5Pset_scaleoffset(dcpl_id,scale_type,scale_factor)<0)
return -1;
}
break;
} /* switch */
}/*i*/
}
/*obj.nfilters*/
/*-------------------------------------------------------------------------
* layout
*-------------------------------------------------------------------------
*/
if (obj.layout>=0)
{
/* a layout was defined */
if (H5Pset_layout(dcpl_id, obj.layout)<0)
return -1;
if (H5D_CHUNKED == obj.layout)
{
if(H5Pset_chunk(dcpl_id, obj.chunk.rank, obj.chunk.chunk_lengths)<0)
return -1;
}
else if (H5D_COMPACT == obj.layout)
{
if (H5Pset_alloc_time(dcpl_id, H5D_ALLOC_TIME_EARLY)<0)
return -1;
}
/* remove filters for the H5D_CONTIGUOUS case */
else if (H5D_CONTIGUOUS == obj.layout)
{
if (H5Premove_filter(dcpl_id,H5Z_FILTER_ALL)<0)
return -1;
}
}
return 0;
}
herr_t H5ARRAYmake( hid_t loc_id,
const char *dset_name,
const char *obversion,
const int rank,
const hsize_t *dims,
int extdim,
hid_t type_id,
hsize_t *dims_chunk,
void *fill_data,
int compress,
char *complib,
int shuffle,
int fletcher32,
const void *data)
{
hid_t dataset_id, space_id;
hsize_t *maxdims = NULL;
hid_t plist_id = 0;
unsigned int cd_values[6];
int chunked = 0;
int i;
/* Check whether the array has to be chunked or not */
if (dims_chunk) {
chunked = 1;
}
if(chunked) {
maxdims = malloc(rank*sizeof(hsize_t));
if(!maxdims) return -1;
for(i=0;i<rank;i++) {
if (i == extdim) {
maxdims[i] = H5S_UNLIMITED;
}
else {
maxdims[i] = dims[i] < dims_chunk[i] ? dims_chunk[i] : dims[i];
}
}
}
/* Create the data space for the dataset. */
if ( (space_id = H5Screate_simple( rank, dims, maxdims )) < 0 )
return -1;
if (chunked) {
/* Modify dataset creation properties, i.e. enable chunking */
plist_id = H5Pcreate (H5P_DATASET_CREATE);
if ( H5Pset_chunk ( plist_id, rank, dims_chunk ) < 0 )
return -1;
/* Set the fill value using a struct as the data type. */
if (fill_data) {
if ( H5Pset_fill_value( plist_id, type_id, fill_data ) < 0 )
return -1;
}
else {
if ( H5Pset_fill_time(plist_id, H5D_FILL_TIME_ALLOC) < 0 )
return -1;
}
/*
Dataset creation property list is modified to use
*/
/* Fletcher must be first */
if (fletcher32) {
if ( H5Pset_fletcher32( plist_id) < 0 )
return -1;
}
/* Then shuffle (not if blosc is activated) */
if ((shuffle) && (strcmp(complib, "blosc") != 0)) {
if ( H5Pset_shuffle( plist_id) < 0 )
return -1;
}
/* Finally compression */
if (compress) {
cd_values[0] = compress;
cd_values[1] = (int)(atof(obversion) * 10);
if (extdim <0)
cd_values[2] = CArray;
else
cd_values[2] = EArray;
/* The default compressor in HDF5 (zlib) */
if (strcmp(complib, "zlib") == 0) {
if ( H5Pset_deflate( plist_id, compress) < 0 )
return -1;
}
/* The Blosc compressor does accept parameters */
else if (strcmp(complib, "blosc") == 0) {
cd_values[4] = compress;
cd_values[5] = shuffle;
if ( H5Pset_filter( plist_id, FILTER_BLOSC, H5Z_FLAG_OPTIONAL, 6, cd_values) < 0 )
return -1;
}
/* The LZO compressor does accept parameters */
else if (strcmp(complib, "lzo") == 0) {
if ( H5Pset_filter( plist_id, FILTER_LZO, H5Z_FLAG_OPTIONAL, 3, cd_values) < 0 )
return -1;
}
/* The bzip2 compress does accept parameters */
else if (strcmp(complib, "bzip2") == 0) {
if ( H5Pset_filter( plist_id, FILTER_BZIP2, H5Z_FLAG_OPTIONAL, 3, cd_values) < 0 )
return -1;
}
else {
/* Compression library not supported */
fprintf(stderr, "Compression library not supported\n");
return -1;
}
}
/* Create the (chunked) dataset */
if ((dataset_id = H5Dcreate(loc_id, dset_name, type_id,
space_id, plist_id )) < 0 )
goto out;
}
else { /* Not chunked case */
/* Create the dataset. */
if ((dataset_id = H5Dcreate(loc_id, dset_name, type_id,
space_id, H5P_DEFAULT )) < 0 )
goto out;
}
/* Write the dataset only if there is data to write */
if (data)
{
if ( H5Dwrite( dataset_id, type_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, data ) < 0 )
goto out;
}
/* Terminate access to the data space. */
if ( H5Sclose( space_id ) < 0 )
return -1;
/* End access to the property list */
if (plist_id)
if ( H5Pclose( plist_id ) < 0 )
goto out;
/* Release resources */
if (maxdims)
free(maxdims);
return dataset_id;
out:
H5Dclose( dataset_id );
H5Sclose( space_id );
if (maxdims)
free(maxdims);
if (dims_chunk)
free(dims_chunk);
return -1;
}
/*+++++++++++++++++++++++++
.IDENTifer PYTABLE_make_array
.PURPOSE create extensible HDF5 dataset
.INPUT/OUTPUT
call as stat = PYTABLE_make_array( locID, dset_name, title, rank, dims,
extdim, typeID, dims_chunk, fill_data,
compress, shuffle, fletcher32, buff );
input:
hid_t locID : HDF5 identifier of file or group
char *dset_name : name of dataset
char *title :
int rank : number of dimensions
hsize_t *dims : size of each dimension
int extdim : index of expendable dimension
hid_t typeID : data type (HDF5 identifier)
hsize_t *dims_chunk : chunk sizes
void *fill_data : Fill value for data
unsigned int compress : compression level (zero for no compression)
bool shuffle : shuffel data for better compression
bool fletcher32 :
void *buffer : buffer with data to write (or NULL)
.RETURNS A negative value is returned on failure.
.COMMENTS none
-------------------------*/
herr_t PYTABLE_make_array( hid_t locID, const char *dset_name,
const char *title, const int rank,
const hsize_t *dims, int extdim, hid_t typeID,
const hsize_t *dims_chunk, void *fill_data,
unsigned int compress, bool shuffle,
bool fletcher32, const void *buffer )
{
register int ni;
hid_t dataID = -1, spaceID = -1;
herr_t stat;
/* check if the array has to be chunked or not */
if ( dims_chunk != NULL ) {
hid_t plistID;
hsize_t *maxdims = (hsize_t *) malloc( rank * sizeof(hsize_t) );
if ( maxdims == NULL )
NADC_GOTO_ERROR( NADC_ERR_ALLOC, "maxdims" );
for ( ni = 0; ni < rank; ni++ ) {
if ( ni == extdim )
maxdims[ni] = H5S_UNLIMITED;
else
maxdims[ni] =
dims[ni] < dims_chunk[ni] ? dims_chunk[ni] : dims[ni];
}
spaceID = H5Screate_simple( rank, dims, maxdims );
free( maxdims );
if ( spaceID < 0 ) NADC_GOTO_ERROR( NADC_ERR_HDF_SPACE, "" );
/* Modify dataset creation properties, i.e. enable chunking */
plistID = H5Pcreate( H5P_DATASET_CREATE );
if ( H5Pset_chunk( plistID, rank, dims_chunk ) < 0 ) goto done;
/* set the fill value using a struct as the data type */
if ( fill_data != NULL
&& H5Pset_fill_value( plistID, typeID, fill_data ) < 0 )
goto done;
/* dataset creation property list is modified to use */
/* fletcher must be first */
if ( fletcher32 ) {
if ( H5Pset_fletcher32( plistID ) < 0 ) goto done;
}
/* then shuffle */
if ( shuffle ) {
if ( H5Pset_shuffle( plistID ) < 0 ) goto done;
}
/* finally compression */
if ( compress > 0 ) {
if ( H5Pset_deflate( plistID, compress ) < 0 ) goto done;
}
/* create the (chunked) dataset */
dataID = H5Dcreate( locID, dset_name, typeID, spaceID,
H5P_DEFAULT, plistID, H5P_DEFAULT );
if ( dataID < 0 )
NADC_GOTO_ERROR( NADC_ERR_HDF_DATA, dset_name );
/* end access to the property list */
if ( H5Pclose( plistID ) < 0 ) goto done;
} else {
spaceID = H5Screate_simple( rank, dims, NULL );
if ( spaceID < 0 ) return -1;
/* create the dataset (not chunked) */
dataID = H5Dcreate( locID, dset_name, typeID, spaceID,
H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT );
if ( dataID < 0 )
NADC_GOTO_ERROR( NADC_ERR_HDF_DATA, dset_name );
}
/*
* write the data
*/
stat = H5Dwrite( dataID, typeID, H5S_ALL, H5S_ALL, H5P_DEFAULT, buffer );
if ( stat < 0 ) NADC_GOTO_ERROR( NADC_ERR_HDF_WR, "" );
(void) H5Dclose( dataID );
(void) H5Sclose( spaceID );
/*
* Set the conforming array attributes
*
* attach the CLASS attribute
*/
(void) H5LTset_attribute_string( locID, dset_name, "CLASS",
PY_ARRAY_CLASS );
/* attach the EXTDIM attribute in case of enlargeable arrays */
(void) H5LTset_attribute_int( locID, dset_name, "EXTDIM", &extdim, 1 );
/* attach the FLAVOR attribute */
(void) H5LTset_attribute_string( locID, dset_name, "FLAVOR",
PY_ARRAY_FLAVOR );
/* attach the VERSION attribute */
(void) H5LTset_attribute_string( locID, dset_name, "VERSION",
PY_ARRAY_VERSION );
/* attach the TITLE attribute */
(void) H5LTset_attribute_string( locID, dset_name, "TITLE", title );
return 0;
done:
if ( dataID > 0 ) (void) H5Dclose( dataID );
if ( spaceID > 0 ) (void) H5Sclose( spaceID );
return -1;
}
herr_t H5VLARRAYmake( hid_t loc_id,
const char *dset_name,
const char *obversion,
const int rank,
const hsize_t *dims,
hid_t type_id,
hsize_t chunk_size,
void *fill_data,
int compress,
char *complib,
int shuffle,
int fletcher32,
const void *data)
{
hvl_t vldata;
hid_t dataset_id, space_id, datatype, tid1;
hsize_t dataset_dims[1];
hsize_t maxdims[1] = { H5S_UNLIMITED };
hsize_t dims_chunk[1];
hid_t plist_id;
unsigned int cd_values[6];
if (data)
/* if data, one row will be filled initially */
dataset_dims[0] = 1;
else
/* no data, so no rows on dataset initally */
dataset_dims[0] = 0;
dims_chunk[0] = chunk_size;
/* Fill the vldata estructure with the data to write */
/* This is currectly not used */
vldata.p = (void *)data;
vldata.len = 1; /* Only one array type to save */
/* Create a VL datatype */
if (rank == 0) {
datatype = H5Tvlen_create(type_id);
}
else {
tid1 = H5Tarray_create(type_id, rank, dims);
datatype = H5Tvlen_create(tid1);
H5Tclose( tid1 ); /* Release resources */
}
/* The dataspace */
space_id = H5Screate_simple( 1, dataset_dims, maxdims );
/* Modify dataset creation properties, i.e. enable chunking */
plist_id = H5Pcreate (H5P_DATASET_CREATE);
if ( H5Pset_chunk ( plist_id, 1, dims_chunk ) < 0 )
return -1;
/*
Dataset creation property list is modified to use
*/
/* Fletcher must be first */
if (fletcher32) {
if ( H5Pset_fletcher32( plist_id) < 0 )
return -1;
}
/* Then shuffle (blosc shuffles inplace) */
if (shuffle && (strcmp(complib, "blosc") != 0)) {
if ( H5Pset_shuffle( plist_id) < 0 )
return -1;
}
/* Finally compression */
if (compress) {
cd_values[0] = compress;
cd_values[1] = (int)(atof(obversion) * 10);
cd_values[2] = VLArray;
/* The default compressor in HDF5 (zlib) */
if (strcmp(complib, "zlib") == 0) {
if ( H5Pset_deflate( plist_id, compress) < 0 )
return -1;
}
/* The Blosc compressor does accept parameters */
else if (strcmp(complib, "blosc") == 0) {
cd_values[4] = compress;
cd_values[5] = shuffle;
if ( H5Pset_filter( plist_id, FILTER_BLOSC, H5Z_FLAG_OPTIONAL, 6, cd_values) < 0 )
return -1;
}
/* The LZO compressor does accept parameters */
else if (strcmp(complib, "lzo") == 0) {
if ( H5Pset_filter( plist_id, FILTER_LZO, H5Z_FLAG_OPTIONAL, 3, cd_values) < 0 )
return -1;
}
/* The bzip2 compress does accept parameters */
else if (strcmp(complib, "bzip2") == 0) {
if ( H5Pset_filter( plist_id, FILTER_BZIP2, H5Z_FLAG_OPTIONAL, 3, cd_values) < 0 )
return -1;
}
else {
/* Compression library not supported */
fprintf(stderr, "Compression library not supported\n");
return -1;
}
}
/* Create the dataset. */
if ((dataset_id = H5Dcreate(loc_id, dset_name, datatype, space_id,
H5P_DEFAULT, plist_id, H5P_DEFAULT )) < 0 )
goto out;
/* Write the dataset only if there is data to write */
if (data)
if ( H5Dwrite( dataset_id, datatype, H5S_ALL, H5S_ALL, H5P_DEFAULT, &vldata ) < 0 )
goto out;
/* Terminate access to the data space. */
if ( H5Sclose( space_id ) < 0 )
return -1;
/* Release the datatype in the case that it is not an atomic type */
if ( H5Tclose( datatype ) < 0 )
return -1;
/* End access to the property list */
if ( H5Pclose( plist_id ) < 0 )
goto out;
return dataset_id;
out:
return -1;
}
herr_t H5TBOmake_table( const char *table_title,
hid_t loc_id,
const char *dset_name,
char *version,
const char *class_,
hid_t type_id,
hsize_t nrecords,
hsize_t chunk_size,
void *fill_data,
int compress,
char *complib,
int shuffle,
int fletcher32,
const void *data )
{
hid_t dataset_id;
hid_t space_id;
hid_t plist_id;
hsize_t dims[1];
hsize_t dims_chunk[1];
hsize_t maxdims[1] = { H5S_UNLIMITED };
unsigned int cd_values[7];
int blosc_compcode;
char *blosc_compname = NULL;
dims[0] = nrecords;
dims_chunk[0] = chunk_size;
/* Create a simple data space with unlimited size */
if ( (space_id = H5Screate_simple( 1, dims, maxdims )) < 0 )
return -1;
/* Modify dataset creation properties, i.e. enable chunking */
plist_id = H5Pcreate (H5P_DATASET_CREATE);
if ( H5Pset_chunk ( plist_id, 1, dims_chunk ) < 0 )
return -1;
/* Set the fill value using a struct as the data type. */
if ( fill_data)
{
if ( H5Pset_fill_value( plist_id, type_id, fill_data ) < 0 )
return -1;
}
else {
if ( H5Pset_fill_time(plist_id, H5D_FILL_TIME_ALLOC) < 0 )
return -1;
}
/*
Dataset creation property list is modified to use filters
*/
/* Fletcher must be first */
if (fletcher32) {
if ( H5Pset_fletcher32( plist_id) < 0 )
return -1;
}
/* Then shuffle (blosc shuffles inplace) */
if ((shuffle && compress) && (strncmp(complib, "blosc", 5) != 0)) {
if ( H5Pset_shuffle( plist_id) < 0 )
return -1;
}
/* Finally compression */
if ( compress )
{
cd_values[0] = compress;
cd_values[1] = (int)(atof(version) * 10);
cd_values[2] = Table;
/* The default compressor in HDF5 (zlib) */
if (strcmp(complib, "zlib") == 0) {
if ( H5Pset_deflate( plist_id, compress) < 0 )
return -1;
}
/* The Blosc compressor does accept parameters */
else if (strcmp(complib, "blosc") == 0) {
cd_values[4] = compress;
cd_values[5] = shuffle;
if ( H5Pset_filter( plist_id, FILTER_BLOSC, H5Z_FLAG_OPTIONAL, 6, cd_values) < 0 )
return -1;
}
/* The Blosc compressor can use other compressors */
else if (strncmp(complib, "blosc:", 6) == 0) {
cd_values[4] = compress;
cd_values[5] = shuffle;
blosc_compname = complib + 6;
blosc_compcode = blosc_compname_to_compcode(blosc_compname);
cd_values[6] = blosc_compcode;
if ( H5Pset_filter( plist_id, FILTER_BLOSC, H5Z_FLAG_OPTIONAL, 7, cd_values) < 0 )
return -1;
}
/* The LZO compressor does accept parameters */
else if (strcmp(complib, "lzo") == 0) {
if ( H5Pset_filter( plist_id, FILTER_LZO, H5Z_FLAG_OPTIONAL, 3, cd_values) < 0 )
return -1;
}
/* The bzip2 compress does accept parameters */
else if (strcmp(complib, "bzip2") == 0) {
if ( H5Pset_filter( plist_id, FILTER_BZIP2, H5Z_FLAG_OPTIONAL, 3, cd_values) < 0 )
return -1;
}
else {
/* Compression library not supported */
return -1;
}
}
/* Create the dataset. */
if ( (dataset_id = H5Dcreate( loc_id, dset_name, type_id, space_id,
H5P_DEFAULT, plist_id, H5P_DEFAULT )) < 0 )
goto out;
/* Only write if there is something to write */
if ( data )
{
/* Write data to the dataset. */
if ( H5Dwrite( dataset_id, type_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, data ) < 0 )
goto out;
}
/* Terminate access to the data space. */
if ( H5Sclose( space_id ) < 0 )
goto out;
/* End access to the property list */
if ( H5Pclose( plist_id ) < 0 )
goto out;
/* Return the object unique ID for future references */
return dataset_id;
/* error zone, gracefully close */
out:
H5E_BEGIN_TRY {
H5Dclose(dataset_id);
H5Sclose(space_id);
H5Pclose(plist_id);
} H5E_END_TRY;
return -1;
}