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-r6055] Purpose:

Browse Source 
New feature

Description:
    Add support for scalar dataspaces in parallel I/O.

Platforms tested:
    Tested h5committest {arabica (fortran), eirene (fortran, C++)
	modi4 (parallel, fortran)}
    Also, FreeBSD 4.7 (sleipnir) serial & parallel
Misc. update:
    Update release_docs/RELEASE for bug fixes, new features, etc.
This commit is contained in:
Quincey Koziol 2002-11-05 11:31:02 -05:00
parent 3ed57b880a
commit 22f38d627e
6 changed files with 251 additions and 18 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
release_docs/RELEASE.txt
View File

@ -35,6 +35,7 @@ Bug Fixes since HDF5-1.4.0
Library
-------
* Allow scalar dataspaces to be used for parallel I/O. QAK - 2002/11/05
* Fixed error condition where "none" selections were not being handled
correctly in parallel. QAK - 2002/10/29
* New functions H5Gget_comment(modification), H5Aget_storage_size,

4
src/H5A.c
View File

@ -1181,7 +1181,7 @@ H5A_rename(H5G_entry_t *ent, char *old_name, char *new_name)
{
int seq, idx=FAIL; /* Index of attribute being querried */
H5A_t *found_attr; /* Attribute with OLD_NAME */
herr_t ret_value; /* Return value */
herr_t ret_value=SUCCEED; /* Return value */
FUNC_ENTER_NOAPI(H5A_rename, FAIL);
@ -1227,7 +1227,7 @@ H5A_rename(H5G_entry_t *ent, char *old_name, char *new_name)
HGOTO_ERROR(H5E_ATTR, H5E_CANTINIT, FAIL, "unable to update attribute header messages");
/* Close the attribute */
if(found_attr) H5A_close(found_attr);
H5A_close(found_attr);
done:
FUNC_LEAVE(ret_value);

9
src/H5Smpio.c
View File

@ -721,10 +721,6 @@ H5S_mpio_space_type( const H5S_t *space, size_t elmt_size, hbool_t prefer_derive
/* Creat MPI type based on the kind of selection */
switch (space->extent.type) {
case H5S_SCALAR:
/* not yet implemented */
ret_value = FAIL;
break;
case H5S_SIMPLE:
switch(space->select.type) {
case H5S_SEL_NONE:
@ -1039,8 +1035,9 @@ H5S_mpio_opt_possible( const H5S_t *mem_space, const H5S_t *file_space, const un
assert(mem_space);
assert(file_space);
/* Check whether these are both simple dataspaces */
if (H5S_SIMPLE!=mem_space->extent.type || H5S_SIMPLE!=file_space->extent.type)
/* Check whether these are both simple or scalar dataspaces */
if (!((H5S_SIMPLE==mem_space->extent.type || H5S_SCALAR==mem_space->extent.type)
&& (H5S_SIMPLE==file_space->extent.type || H5S_SCALAR==file_space->extent.type)))
HGOTO_DONE(FALSE);
/* Check whether both selections are "regular" */

169
test/tselect.c
View File

@ -4969,12 +4969,12 @@ test_select_fill_hyper_irregular(hssize_t *offset)
/****************************************************************
**
** test_zero_none(): Test basic H5S (dataspace) selection code.
** test_select_none(): Test basic H5S (dataspace) selection code.
** Tests I/O on 0-sized point selections
**
****************************************************************/
static void
test_zero_none(void)
test_select_none(void)
{
hid_t fid1; /* HDF5 File IDs */
hid_t dataset; /* Dataset ID */
@ -5046,7 +5046,165 @@ test_zero_none(void)
/* Free memory buffers */
free(wbuf);
} /* test_zero_none() */
} /* test_select_none() */
/****************************************************************
**
** test_scalar_select(): Test basic H5S (dataspace) selection code.
** Tests selections on scalar dataspaces
**
****************************************************************/
static void
test_scalar_select(void)
{
hid_t fid1; /* HDF5 File IDs */
hid_t dataset; /* Dataset ID */
hid_t sid1,sid2; /* Dataspace ID */
hsize_t dims2[] = {SPACE7_DIM1, SPACE7_DIM2};
hssize_t coord1[SPACE7_RANK]; /* Coordinates for point selection */
hssize_t start[SPACE7_RANK]; /* Hyperslab start */
hsize_t count[SPACE7_RANK]; /* Hyperslab block count */
uint8_t *wbuf_uint8, /* buffer to write to disk */
rval_uint8, /* value read back in */
*tbuf_uint8; /* temporary buffer pointer */
unsigned short *wbuf_ushort,/* another buffer to write to disk */
rval_ushort, /* value read back in */
*tbuf_ushort; /* temporary buffer pointer */
int i,j; /* Counters */
herr_t ret; /* Generic return value */
/* Output message about test being performed */
MESSAGE(5, ("Testing I/O on Selections in Scalar Dataspaces\n"));
/* Allocate write & read buffers */
wbuf_uint8=malloc(sizeof(uint8_t)*SPACE7_DIM1*SPACE7_DIM2);
wbuf_ushort=malloc(sizeof(unsigned short)*SPACE7_DIM1*SPACE7_DIM2);
/* Initialize write buffers */
for(i=0, tbuf_uint8=wbuf_uint8, tbuf_ushort=wbuf_ushort; i<SPACE7_DIM1; i++)
for(j=0; j<SPACE7_DIM2; j++) {
*tbuf_uint8++=(uint8_t)((i*SPACE7_DIM2)+j);
*tbuf_ushort++=(unsigned short)((j*SPACE7_DIM2)+i);
} /* end for */
/* Create file */
fid1 = H5Fcreate(FILENAME, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
CHECK(fid1, FAIL, "H5Fcreate");
/* Create dataspace for dataset */
sid1 = H5Screate(H5S_SCALAR);
CHECK(sid1, FAIL, "H5Screate_simple");
/* Create dataspace for writing buffer */
sid2 = H5Screate_simple(SPACE7_RANK, dims2, NULL);
CHECK(sid2, FAIL, "H5Screate_simple");
/* Create a dataset */
dataset=H5Dcreate(fid1,"Dataset1",H5T_NATIVE_UCHAR,sid1,H5P_DEFAULT);
CHECK(dataset, FAIL, "H5Dcreate");
/* Select one element in memory with a point selection */
coord1[0]=0; coord1[1]= 2;
ret = H5Sselect_elements(sid2,H5S_SELECT_SET,1,(const hssize_t **)&coord1);
CHECK(ret, FAIL, "H5Sselect_elements");
/* Write single point to disk */
ret=H5Dwrite(dataset,H5T_NATIVE_UCHAR,sid2,sid1,H5P_DEFAULT,wbuf_uint8);
CHECK(ret, FAIL, "H5Dwrite");
/* Read scalar element from disk */
ret=H5Dread(dataset,H5T_NATIVE_UCHAR,sid1,sid1,H5P_DEFAULT,&rval_uint8);
CHECK(ret, FAIL, "H5Dread");
/* Check value read back in */
if(rval_uint8!=*(wbuf_uint8+2)) {
printf("Error! rval=%u, should be: *(wbuf+2)=%u\n",(unsigned)rval_uint8,(unsigned)*(wbuf_uint8+2));
num_errs++;
} /* end if */
/* Write single point to disk (with a datatype conversion) */
ret=H5Dwrite(dataset,H5T_NATIVE_USHORT,sid2,sid1,H5P_DEFAULT,wbuf_ushort);
CHECK(ret, FAIL, "H5Dwrite");
/* Read scalar element from disk */
ret=H5Dread(dataset,H5T_NATIVE_USHORT,sid1,sid1,H5P_DEFAULT,&rval_ushort);
CHECK(ret, FAIL, "H5Dread");
/* Check value read back in */
if(rval_ushort!=*(wbuf_ushort+2)) {
printf("Error! rval=%u, should be: *(wbuf+2)=%u\n",(unsigned)rval_ushort,(unsigned)*(wbuf_ushort+2));
num_errs++;
} /* end if */
/* Select one element in memory with a hyperslab selection */
start[0]=4; start[1]=3;
count[0]=1; count[1]=1;
ret = H5Sselect_hyperslab(sid2,H5S_SELECT_SET,start,NULL,count,NULL);
CHECK(ret, FAIL, "H5Sselect_hyperslab");
/* Write single hyperslab element to disk */
ret=H5Dwrite(dataset,H5T_NATIVE_UCHAR,sid2,sid1,H5P_DEFAULT,wbuf_uint8);
CHECK(ret, FAIL, "H5Dwrite");
/* Read scalar element from disk */
ret=H5Dread(dataset,H5T_NATIVE_UCHAR,sid1,sid1,H5P_DEFAULT,&rval_uint8);
CHECK(ret, FAIL, "H5Dread");
/* Check value read back in */
if(rval_uint8!=*(wbuf_uint8+(SPACE7_DIM2*4)+3)) {
printf("Error! rval=%u, should be: *(wbuf+(SPACE7_DIM2*4)+3)=%u\n",(unsigned)rval_uint8,(unsigned)*(wbuf_uint8+(SPACE7_DIM2*4)+3));
num_errs++;
} /* end if */
/* Write single hyperslab element to disk (with a datatype conversion) */
ret=H5Dwrite(dataset,H5T_NATIVE_USHORT,sid2,sid1,H5P_DEFAULT,wbuf_ushort);
CHECK(ret, FAIL, "H5Dwrite");
/* Read scalar element from disk */
ret=H5Dread(dataset,H5T_NATIVE_USHORT,sid1,sid1,H5P_DEFAULT,&rval_ushort);
CHECK(ret, FAIL, "H5Dread");
/* Check value read back in */
if(rval_ushort!=*(wbuf_ushort+(SPACE7_DIM2*4)+3)) {
printf("Error! rval=%u, should be: *(wbuf+(SPACE7_DIM2*4)+3)=%u\n",(unsigned)rval_ushort,(unsigned)*(wbuf_ushort+(SPACE7_DIM2*4)+3));
num_errs++;
} /* end if */
/* Select no elements in memory & file with "none" selections */
ret = H5Sselect_none(sid1);
CHECK(ret, FAIL, "H5Sselect_none");
ret = H5Sselect_none(sid2);
CHECK(ret, FAIL, "H5Sselect_none");
/* Write no data to disk */
ret=H5Dwrite(dataset,H5T_NATIVE_UCHAR,sid2,sid1,H5P_DEFAULT,wbuf_uint8);
CHECK(ret, FAIL, "H5Dwrite");
/* Write no data to disk (with a datatype conversion) */
ret=H5Dwrite(dataset,H5T_NATIVE_USHORT,sid2,sid1,H5P_DEFAULT,wbuf_ushort);
CHECK(ret, FAIL, "H5Dwrite");
/* Close memory dataspace */
ret = H5Sclose(sid2);
CHECK(ret, FAIL, "H5Sclose");
/* Close disk dataspace */
ret = H5Sclose(sid1);
CHECK(ret, FAIL, "H5Sclose");
/* Close Dataset */
ret = H5Dclose(dataset);
CHECK(ret, FAIL, "H5Dclose");
/* Close file */
ret = H5Fclose(fid1);
CHECK(ret, FAIL, "H5Fclose");
/* Free memory buffers */
free(wbuf_uint8);
free(wbuf_ushort);
} /* test_scalar_select() */
/****************************************************************
**
@ -5171,7 +5329,10 @@ test_select(void)
test_select_fill_hyper_irregular(offset);
/* Test 0-sized selections */
test_zero_none();
test_select_none();
/* Test selections on scalar dataspaces */
test_scalar_select();
} /* test_select() */

85
testpar/t_dset.c
View File

@ -479,7 +479,7 @@ dataset_writeAll(char *filename)
hid_t sid; /* Dataspace ID */
hid_t file_dataspace; /* File dataspace ID */
hid_t mem_dataspace; /* memory dataspace ID */
hid_t dataset1, dataset2, dataset3; /* Dataset ID */
hid_t dataset1, dataset2, dataset3, dataset4; /* Dataset ID */
hid_t datatype; /* Datatype ID */
hsize_t dims[RANK]; /* dataset dim sizes */
DATATYPE *data_array1 = NULL; /* data buffer */
@ -525,7 +525,7 @@ dataset_writeAll(char *filename)
* Define the dimensions of the overall datasets
* and create the dataset
* ------------------------- */
/* setup dimensionality object */
/* setup 2-D dimensionality object */
dims[0] = dim0;
dims[1] = dim1;
sid = H5Screate_simple (RANK, dims, NULL);
@ -546,7 +546,21 @@ dataset_writeAll(char *filename)
/* create a third dataset collectively */
dataset3 = H5Dcreate(fid, DATASETNAME3, H5T_NATIVE_INT, sid, H5P_DEFAULT);
VRFY((dataset1 >= 0), "H5Dcreate succeeded");
VRFY((dataset3 >= 0), "H5Dcreate succeeded");
/* release 2-D space ID created */
H5Sclose(sid);
/* setup scalar dimensionality object */
sid = H5Screate(H5S_SCALAR);
VRFY((sid >= 0), "H5Screate succeeded");
/* create a fourth dataset collectively */
dataset4 = H5Dcreate(fid, DATASETNAME4, H5T_NATIVE_INT, sid, H5P_DEFAULT);
VRFY((dataset4 >= 0), "H5Dcreate succeeded");
/* release scalar space ID created */
H5Sclose(sid);
/*
* Set up dimensions of the slab this process accesses.
@ -721,6 +735,66 @@ dataset_writeAll(char *filename)
xfer_plist, data_array1);
VRFY((ret >= 0), "H5Dwrite dataset3 succeeded");
/* release all temporary handles. */
/* Could have used them for dataset4 but it is cleaner */
/* to create them again.*/
H5Sclose(file_dataspace);
H5Sclose(mem_dataspace);
H5Pclose(xfer_plist);
/* Dataset4: each process writes no data, except process zero uses "all" selection. */
/* Additionally, these are in a scalar dataspace */
/* create a file dataspace independently */
file_dataspace = H5Dget_space (dataset4);
VRFY((file_dataspace >= 0), "H5Dget_space succeeded");
if (MAINPROCESS) {
ret=H5Sselect_none(file_dataspace);
VRFY((ret >= 0), "H5Sselect_all file_dataspace succeeded");
} /* end if */
else {
ret=H5Sselect_all(file_dataspace);
VRFY((ret >= 0), "H5Sselect_none succeeded");
} /* end else */
/* create a memory dataspace independently */
mem_dataspace = H5Screate(H5S_SCALAR);
VRFY((mem_dataspace >= 0), "");
if (MAINPROCESS) {
ret=H5Sselect_none(mem_dataspace);
VRFY((ret >= 0), "H5Sselect_all mem_dataspace succeeded");
} /* end if */
else {
ret=H5Sselect_all(mem_dataspace);
VRFY((ret >= 0), "H5Sselect_none succeeded");
} /* end else */
/* fill the local slab with some trivial data */
dataset_fill(start, block, data_array1);
MESG("data_array initialized");
if (verbose) {
MESG("data_array created");
dataset_print(start, block, data_array1);
} /* end if */
/* set up the collective transfer properties list */
xfer_plist = H5Pcreate (H5P_DATASET_XFER);
VRFY((xfer_plist >= 0), "");
ret=H5Pset_dxpl_mpio(xfer_plist, H5FD_MPIO_COLLECTIVE);
VRFY((ret >= 0), "H5Pcreate xfer succeeded");
/* write data collectively */
MESG("writeAll with scalar dataspace");
ret = H5Dwrite(dataset4, H5T_NATIVE_INT, mem_dataspace, file_dataspace,
xfer_plist, data_array1);
VRFY((ret >= 0), "H5Dwrite dataset4 succeeded");
/* write data collectively (with datatype conversion) */
MESG("writeAll with scalar dataspace");
ret = H5Dwrite(dataset4, H5T_NATIVE_UCHAR, mem_dataspace, file_dataspace,
xfer_plist, data_array1);
VRFY((ret >= 0), "H5Dwrite dataset4 succeeded");
/* release all temporary handles. */
H5Sclose(file_dataspace);
H5Sclose(mem_dataspace);
@ -735,9 +809,8 @@ dataset_writeAll(char *filename)
VRFY((ret >= 0), "H5Dclose2 succeeded");
ret=H5Dclose(dataset3);
VRFY((ret >= 0), "H5Dclose3 succeeded");
/* release all IDs created */
H5Sclose(sid);
ret=H5Dclose(dataset4);
VRFY((ret >= 0), "H5Dclose3 succeeded");
/* close the file collectively */
H5Fclose(fid);

1
testpar/testphdf5.h
View File

@ -72,6 +72,7 @@
#define DATASETNAME1 "Data1"
#define DATASETNAME2 "Data2"
#define DATASETNAME3 "Data3"
#define DATASETNAME4 "Data4"
/* hyperslab layout styles */
#define BYROW 1 /* divide into slabs of rows */
#define BYCOL 2 /* divide into blocks of columns */