gsell
6a4d711b99
Since MPI-POSIX VFD has been removed from hdf5 > 1.8.12, but a test with stride data should be performed, we use independent IO instead for hdf5 > 1.8.12
505 lines
14 KiB
C
505 lines
14 KiB
C
#include <stdlib.h>
|
|
#include "testframe.h"
|
|
#include "params.h"
|
|
|
|
static void
|
|
test_write_file_attribs(h5_file_t file, int position)
|
|
{
|
|
h5_err_t status;
|
|
char name[ATTR_NAME_SIZE];
|
|
|
|
TEST("Writing file attributes");
|
|
|
|
get_attr_name(name, "str", position);
|
|
status = H5WriteFileAttribString(file, name, ATTR_STR_VAL);
|
|
RETURN(status, H5_SUCCESS, "H5WriteFileAttribString");
|
|
|
|
get_attr_name(name, "i32", position);
|
|
h5_int32_t i32 = ATTR_INT32_VAL;
|
|
status = H5WriteFileAttribInt32(file, name, &i32, 1);
|
|
RETURN(status, H5_SUCCESS, "H5WriteFileAttribInt32");
|
|
|
|
get_attr_name(name, "i64", position);
|
|
h5_int64_t i64 = ATTR_INT64_VAL;
|
|
status = H5WriteFileAttribInt64(file, name, &i64, 1);
|
|
RETURN(status, H5_SUCCESS, "H5WriteFileAttribInt64");
|
|
|
|
get_attr_name(name, "f32", position);
|
|
h5_float32_t f32 = ATTR_FLOAT_VAL;
|
|
status = H5WriteFileAttribFloat32(file, name, &f32, 1);
|
|
RETURN(status, H5_SUCCESS, "H5WriteFileAttribFloat32");
|
|
|
|
get_attr_name(name, "f64", position);
|
|
h5_float64_t f64 = ATTR_FLOAT_VAL;
|
|
status = H5WriteFileAttribFloat64(file, name, &f64, 1);
|
|
RETURN(status, H5_SUCCESS, "H5WriteFileAttribFloat64");
|
|
}
|
|
|
|
static void
|
|
test_write_step_attribs(h5_file_t file, int position)
|
|
{
|
|
h5_err_t status;
|
|
char name[ATTR_NAME_SIZE];
|
|
|
|
TEST("Writing step attributes");
|
|
|
|
get_attr_name(name, "str", position);
|
|
status = H5WriteStepAttribString(file, name, ATTR_STR_VAL);
|
|
RETURN(status, H5_SUCCESS, "H5WriteStepAttribString");
|
|
|
|
get_attr_name(name, "i32", position);
|
|
h5_int32_t i32 = ATTR_INT32_VAL;
|
|
status = H5WriteStepAttribInt32(file, name, &i32, 1);
|
|
RETURN(status, H5_SUCCESS, "H5WriteStepAttribInt32");
|
|
|
|
get_attr_name(name, "i64", position);
|
|
h5_int64_t i64 = ATTR_INT64_VAL;
|
|
status = H5WriteStepAttribInt64(file, name, &i64, 1);
|
|
RETURN(status, H5_SUCCESS, "H5WriteStepAttribInt64");
|
|
|
|
get_attr_name(name, "f32", position);
|
|
h5_float32_t f32 = ATTR_FLOAT_VAL;
|
|
status = H5WriteStepAttribFloat32(file, name, &f32, 1);
|
|
RETURN(status, H5_SUCCESS, "H5WriteStepAttribFloat32");
|
|
|
|
get_attr_name(name, "f64", position);
|
|
h5_float64_t f64 = ATTR_FLOAT_VAL;
|
|
status = H5WriteStepAttribFloat64(file, name, &f64, 1);
|
|
RETURN(status, H5_SUCCESS, "H5WriteStepAttribFloat64");
|
|
}
|
|
|
|
static void
|
|
test_write_data64(h5_file_t file, int nparticles, int step)
|
|
{
|
|
int i,t;
|
|
h5_int64_t status, val;
|
|
|
|
double *x,*y,*z;
|
|
double *px,*py,*pz;
|
|
h5_int64_t *id;
|
|
|
|
x=(double*)malloc(nparticles*sizeof(double));
|
|
y=(double*)malloc(nparticles*sizeof(double));
|
|
z=(double*)malloc(nparticles*sizeof(double));
|
|
px=(double*)malloc(nparticles*sizeof(double));
|
|
py=(double*)malloc(nparticles*sizeof(double));
|
|
pz=(double*)malloc(nparticles*sizeof(double));
|
|
id=(h5_int64_t*)malloc(nparticles*sizeof(h5_int64_t));
|
|
|
|
TEST("Writing 64-bit data");
|
|
|
|
for (t=step; t<step+NTIMESTEPS; t++)
|
|
{
|
|
for (i=0; i<nparticles; i++)
|
|
{
|
|
x[i] = 0.0 + (double)(i+nparticles*t);
|
|
y[i] = 0.1 + (double)(i+nparticles*t);
|
|
z[i] = 0.2 + (double)(i+nparticles*t);
|
|
px[i] = 0.3 + (double)(i+nparticles*t);
|
|
py[i] = 0.4 + (double)(i+nparticles*t);
|
|
pz[i] = 0.5 + (double)(i+nparticles*t);
|
|
id[i] = i + nparticles*t;
|
|
}
|
|
|
|
val = H5HasStep(file, t);
|
|
|
|
status = H5SetStep(file, t);
|
|
RETURN(status, H5_SUCCESS, "H5SetStep");
|
|
|
|
if (val == 0) test_write_step_attribs(file, t);
|
|
|
|
status = H5PartSetNumParticles(file, nparticles);
|
|
RETURN(status, H5_SUCCESS, "H5PartSetNumParticles");
|
|
|
|
status = H5PartWriteDataFloat64(file, "x", x);
|
|
RETURN(status, H5_SUCCESS, "H5PartWriteDataFloat64");
|
|
|
|
status = H5PartWriteDataFloat64(file, "y", y);
|
|
RETURN(status, H5_SUCCESS, "H5PartWriteDataFloat64");
|
|
|
|
status = H5PartWriteDataFloat64(file, "z", z);
|
|
RETURN(status, H5_SUCCESS, "H5PartWriteDataFloat64");
|
|
|
|
status = H5PartWriteDataFloat64(file, "px", px);
|
|
RETURN(status, H5_SUCCESS, "H5PartWriteDataFloat64");
|
|
|
|
status = H5PartWriteDataFloat64(file, "py", py);
|
|
RETURN(status, H5_SUCCESS, "H5PartWriteDataFloat64");
|
|
|
|
status = H5PartWriteDataFloat64(file, "pz", pz);
|
|
RETURN(status, H5_SUCCESS, "H5PartWriteDataFloat64");
|
|
|
|
status = H5PartWriteDataInt64(file, "id", id);
|
|
RETURN(status, H5_SUCCESS, "H5PartWriteDataInt64");
|
|
}
|
|
}
|
|
|
|
static void
|
|
test_write_strided_data64(h5_file_t file, int nparticles, int step)
|
|
{
|
|
int i,t;
|
|
h5_int64_t status;
|
|
|
|
double *data;
|
|
|
|
data=(double*)malloc(6*nparticles*sizeof(double));
|
|
|
|
status = H5PartSetNumParticlesStrided(file, nparticles, 6);
|
|
RETURN(status, H5_SUCCESS, "H5PartSetNumParticlesStrided");
|
|
|
|
TEST("Writing 64-bit strided data");
|
|
|
|
for (t=step; t<step+NTIMESTEPS; t++)
|
|
{
|
|
for (i=0; i<nparticles; i++)
|
|
{
|
|
data[6*i] = 0.0 + (double)(i+nparticles*t);
|
|
data[6*i+1] = 0.1 + (double)(i+nparticles*t);
|
|
data[6*i+2] = 0.2 + (double)(i+nparticles*t);
|
|
data[6*i+3] = 0.3 + (double)(i+nparticles*t);
|
|
data[6*i+4] = 0.4 + (double)(i+nparticles*t);
|
|
data[6*i+5] = 0.5 + (double)(i+nparticles*t);
|
|
}
|
|
|
|
status = H5SetStep(file, t);
|
|
RETURN(status, H5_SUCCESS, "H5SetStep");
|
|
|
|
status = H5PartSetNumParticlesStrided(file, nparticles, 6);
|
|
RETURN(status, H5_SUCCESS, "H5PartSetNumParticlesStrided");
|
|
|
|
status = H5PartWriteDataFloat64(file, "x", data+0);
|
|
RETURN(status, H5_SUCCESS, "H5PartWriteDataFloat64");
|
|
|
|
status = H5PartWriteDataFloat64(file, "y", data+1);
|
|
RETURN(status, H5_SUCCESS, "H5PartWriteDataFloat64");
|
|
|
|
status = H5PartWriteDataFloat64(file, "z", data+2);
|
|
RETURN(status, H5_SUCCESS, "H5PartWriteDataFloat64");
|
|
|
|
status = H5PartWriteDataFloat64(file, "px", data+3);
|
|
RETURN(status, H5_SUCCESS, "H5PartWriteDataFloat64");
|
|
|
|
status = H5PartWriteDataFloat64(file, "py", data+4);
|
|
RETURN(status, H5_SUCCESS, "H5PartWriteDataFloat64");
|
|
|
|
status = H5PartWriteDataFloat64(file, "pz", data+5);
|
|
RETURN(status, H5_SUCCESS, "H5PartWriteDataFloat64");
|
|
|
|
test_write_step_attribs(file, t);
|
|
}
|
|
}
|
|
|
|
static void
|
|
test_write_data32(h5_file_t file, int nparticles, int step)
|
|
{
|
|
int i,t;
|
|
h5_err_t status;
|
|
h5_size_t val;
|
|
|
|
float *x,*y,*z;
|
|
float *px,*py,*pz;
|
|
int *id;
|
|
|
|
x=(float*)malloc(nparticles*sizeof(float));
|
|
y=(float*)malloc(nparticles*sizeof(float));
|
|
z=(float*)malloc(nparticles*sizeof(float));
|
|
px=(float*)malloc(nparticles*sizeof(float));
|
|
py=(float*)malloc(nparticles*sizeof(float));
|
|
pz=(float*)malloc(nparticles*sizeof(float));
|
|
id=(int*)malloc(nparticles*sizeof(int));
|
|
|
|
status = H5PartSetNumParticles(file, nparticles);
|
|
RETURN(status, H5_SUCCESS, "H5PartSetNumParticles");
|
|
|
|
#if defined(H5_HAVE_PARALLEL)
|
|
int rank, nprocs;
|
|
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
|
|
MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
|
|
#else
|
|
int rank = 0;
|
|
#endif
|
|
|
|
TEST("Writing 32-bit data");
|
|
|
|
for (t=step; t<step+NTIMESTEPS; t++)
|
|
{
|
|
for (i=0; i<nparticles; i++)
|
|
{
|
|
x[i] = 0.0F + (float)(i+nparticles*t);
|
|
y[i] = 0.1F + (float)(i+nparticles*t);
|
|
z[i] = 0.2F + (float)(i+nparticles*t);
|
|
px[i] = 0.3F + (float)(i+nparticles*t);
|
|
py[i] = 0.4F + (float)(i+nparticles*t);
|
|
pz[i] = 0.5F + (float)(i+nparticles*t);
|
|
id[i] = i + nparticles*t;
|
|
}
|
|
|
|
val = H5HasStep(file, t);
|
|
if (val == 0) {
|
|
status = H5SetStep(file, t);
|
|
RETURN(status, H5_SUCCESS, "H5SetStep");
|
|
}
|
|
|
|
/* test a two-part write using views */
|
|
status = H5PartSetView(file,
|
|
rank*nparticles,
|
|
rank*nparticles + 31);
|
|
RETURN(status, H5_SUCCESS, "H5PartSetView");
|
|
|
|
status = H5PartWriteDataFloat32(file, "x", x);
|
|
RETURN(status, H5_SUCCESS, "H5PartWriteDataFloat32");
|
|
|
|
test_write_step_attribs(file, t);
|
|
|
|
status = H5PartWriteDataFloat32(file, "y", y);
|
|
RETURN(status, H5_SUCCESS, "H5PartWriteDataFloat32");
|
|
|
|
status = H5PartWriteDataFloat32(file, "z", z);
|
|
RETURN(status, H5_SUCCESS, "H5PartWriteDataFloat32");
|
|
|
|
status = H5PartWriteDataFloat32(file, "px", px);
|
|
RETURN(status, H5_SUCCESS, "H5PartWriteDataFloat32");
|
|
|
|
status = H5PartWriteDataFloat32(file, "py", py);
|
|
RETURN(status, H5_SUCCESS, "H5PartWriteDataFloat32");
|
|
|
|
status = H5PartWriteDataFloat32(file, "pz", pz);
|
|
RETURN(status, H5_SUCCESS, "H5PartWriteDataFloat32");
|
|
|
|
status = H5PartWriteDataInt32(file, "id", id);
|
|
RETURN(status, H5_SUCCESS, "H5PartWriteDataInt32");
|
|
|
|
/* the second write phase... */
|
|
status = H5PartSetView(file,
|
|
rank*nparticles + 32,
|
|
rank*nparticles + nparticles - 1);
|
|
RETURN(status, H5_SUCCESS, "H5PartSetView");
|
|
/* offset the input arrays */
|
|
status = H5PartWriteDataFloat32(file, "x", x+32);
|
|
RETURN(status, H5_SUCCESS, "H5PartWriteDataFloat32");
|
|
|
|
status = H5PartWriteDataFloat32(file, "y", y+32);
|
|
RETURN(status, H5_SUCCESS, "H5PartWriteDataFloat32");
|
|
|
|
status = H5PartWriteDataFloat32(file, "z", z+32);
|
|
RETURN(status, H5_SUCCESS, "H5PartWriteDataFloat32");
|
|
|
|
status = H5PartWriteDataFloat32(file, "px", px+32);
|
|
RETURN(status, H5_SUCCESS, "H5PartWriteDataFloat32");
|
|
|
|
status = H5PartWriteDataFloat32(file, "py", py+32);
|
|
RETURN(status, H5_SUCCESS, "H5PartWriteDataFloat32");
|
|
|
|
status = H5PartWriteDataFloat32(file, "pz", pz+32);
|
|
RETURN(status, H5_SUCCESS, "H5PartWriteDataFloat32");
|
|
|
|
status = H5PartWriteDataInt32(file, "id", id+32);
|
|
RETURN(status, H5_SUCCESS, "H5PartWriteDataInt32");
|
|
}
|
|
}
|
|
|
|
static void
|
|
test_write_strided_data32(h5_file_t file, int nparticles, int step)
|
|
{
|
|
int i,t;
|
|
h5_int64_t status;
|
|
|
|
float *data;
|
|
|
|
data=(float*)malloc(6*nparticles*sizeof(float));
|
|
|
|
TEST("Writing 32-bit strided data");
|
|
|
|
for (t=step; t<step+NTIMESTEPS; t++)
|
|
{
|
|
for (i=0; i<nparticles; i++)
|
|
{
|
|
data[6*i] = 0.0F + (float)(i+nparticles*t);
|
|
data[6*i+1] = 0.1F + (float)(i+nparticles*t);
|
|
data[6*i+2] = 0.2F + (float)(i+nparticles*t);
|
|
data[6*i+3] = 0.3F + (float)(i+nparticles*t);
|
|
data[6*i+4] = 0.4F + (float)(i+nparticles*t);
|
|
data[6*i+5] = 0.5F + (float)(i+nparticles*t);
|
|
}
|
|
|
|
status = H5SetStep(file, t);
|
|
RETURN(status, H5_SUCCESS, "H5SetStep");
|
|
|
|
test_write_step_attribs(file, t);
|
|
|
|
status = H5PartSetNumParticlesStrided(file, nparticles, 6);
|
|
RETURN(status, H5_SUCCESS, "H5PartSetNumParticlesStrided");
|
|
|
|
status = H5PartWriteDataFloat32(file, "x", data+0);
|
|
RETURN(status, H5_SUCCESS, "H5PartWriteDataFloat32");
|
|
|
|
status = H5PartWriteDataFloat32(file, "y", data+1);
|
|
RETURN(status, H5_SUCCESS, "H5PartWriteDataFloat32");
|
|
|
|
status = H5PartWriteDataFloat32(file, "z", data+2);
|
|
RETURN(status, H5_SUCCESS, "H5PartWriteDataFloat32");
|
|
|
|
status = H5PartWriteDataFloat32(file, "px", data+3);
|
|
RETURN(status, H5_SUCCESS, "H5PartWriteDataFloat32");
|
|
|
|
status = H5PartWriteDataFloat32(file, "py", data+4);
|
|
RETURN(status, H5_SUCCESS, "H5PartWriteDataFloat32");
|
|
|
|
status = H5PartWriteDataFloat32(file, "pz", data+5);
|
|
RETURN(status, H5_SUCCESS, "H5PartWriteDataFloat32");
|
|
}
|
|
}
|
|
|
|
void h5u_test_write1(void)
|
|
{
|
|
h5_file_t file1;
|
|
h5_err_t status;
|
|
|
|
TEST("Opening file once, write-truncate");
|
|
h5_prop_t props = H5CreateFileProp ();
|
|
|
|
#if defined(H5_HAVE_PARALLEL)
|
|
MPI_Comm comm = MPI_COMM_WORLD;
|
|
status = H5SetPropFileMPIOCollective (props, &comm);
|
|
RETURN(status, H5_SUCCESS, "H5SetPropFileMPIOCollective");
|
|
#endif
|
|
file1 = H5OpenFile(FILENAME, H5_O_WRONLY, props);
|
|
status = H5CheckFile(file1);
|
|
RETURN(status, H5_SUCCESS, "H5CheckFile");
|
|
|
|
status = H5CloseProp (props);
|
|
RETURN(status, H5_SUCCESS, "H5CloseProp");
|
|
|
|
test_write_data32(file1, NPARTICLES, 1);
|
|
test_write_file_attribs(file1, 0);
|
|
|
|
status = H5CloseFile(file1);
|
|
RETURN(status, H5_SUCCESS, "H5CloseFile");
|
|
}
|
|
|
|
void h5u_test_write2(void)
|
|
{
|
|
h5_file_t file1;
|
|
h5_file_t file2;
|
|
h5_err_t status;
|
|
|
|
TEST("Opening file twice, write-append + read-only");
|
|
h5_prop_t props = H5CreateFileProp ();
|
|
|
|
#if defined(H5_HAVE_PARALLEL)
|
|
MPI_Comm comm = MPI_COMM_WORLD;
|
|
status = H5SetPropFileMPIOCollective (props, &comm);
|
|
RETURN(status, H5_SUCCESS, "H5SetPropFileMPIOCollective");
|
|
#endif
|
|
file1 = H5OpenFile(FILENAME, H5_O_APPENDONLY, props);
|
|
status = H5CheckFile(file1);
|
|
RETURN(status, H5_SUCCESS, "H5CheckFile");
|
|
|
|
file2 = H5OpenFile(FILENAME, H5_O_RDONLY, props);
|
|
status = H5CheckFile(file2);
|
|
RETURN(status, H5_SUCCESS, "H5CheckFile");
|
|
|
|
status = H5CloseProp (props);
|
|
RETURN(status, H5_SUCCESS, "H5CloseProp");
|
|
|
|
test_write_strided_data32(file1, NPARTICLES, NTIMESTEPS+1);
|
|
test_write_file_attribs(file1, 1);
|
|
|
|
status = H5CloseFile(file1);
|
|
RETURN(status, H5_SUCCESS, "H5CloseFile");
|
|
status = H5CloseFile(file2);
|
|
RETURN(status, H5_SUCCESS, "H5CloseFile");
|
|
}
|
|
|
|
void h5u_test_write3(void)
|
|
{
|
|
h5_file_t file1;
|
|
h5_err_t status;
|
|
|
|
#if H5_VERSION_LE(1,8,12)
|
|
TEST("Opening file once, write-truncate, MPI-POSIX VFD");
|
|
#else
|
|
TEST("Opening file once, write-truncate, MPI-IO Independent VFD");
|
|
#endif
|
|
|
|
h5_prop_t props = H5CreateFileProp ();
|
|
|
|
#if defined(H5_HAVE_PARALLEL)
|
|
MPI_Comm comm = MPI_COMM_WORLD;
|
|
|
|
#if H5_VERSION_LE(1,8,12)
|
|
status = H5SetPropFileMPIOPosix (props, &comm);
|
|
RETURN(status, H5_SUCCESS, "H5SetPropFileMPIOPosix");
|
|
#else
|
|
status = H5SetPropFileMPIOIndependent (props, &comm);
|
|
RETURN(status, H5_SUCCESS, "H5SetPropFileMPIOIndependent");
|
|
#endif
|
|
|
|
#endif // H5_HAVE_PARALLEL
|
|
|
|
file1 = H5OpenFile(FILENAME, H5_O_WRONLY, props);
|
|
|
|
status = H5CheckFile(file1);
|
|
RETURN(status, H5_SUCCESS, "H5CheckFile");
|
|
|
|
status = H5CloseProp (props);
|
|
RETURN(status, H5_SUCCESS, "H5CloseProp");
|
|
|
|
TEST("Redefining step name");
|
|
status = H5SetStepNameFormat(file1, "data", 16);
|
|
RETURN(status, H5_SUCCESS, "H5SetStepNameFormat");
|
|
|
|
test_write_strided_data64(file1, NPARTICLES, 0);
|
|
test_write_file_attribs(file1, 0);
|
|
|
|
status = H5CloseFile(file1);
|
|
RETURN(status, H5_SUCCESS, "H5CloseFile");
|
|
}
|
|
|
|
void h5u_test_write4(void)
|
|
{
|
|
h5_file_t file1;
|
|
h5_file_t file2;
|
|
|
|
h5_err_t status;
|
|
h5_prop_t props;
|
|
|
|
TEST("Opening file twice, write-append + read-only, MPI-IO Independent VFD");
|
|
|
|
props = H5CreateFileProp ();
|
|
#if defined(H5_HAVE_PARALLEL)
|
|
MPI_Comm comm = MPI_COMM_WORLD;
|
|
status = H5SetPropFileMPIOIndependent (props, &comm);
|
|
RETURN(status, H5_SUCCESS, "H5SetPropFileMPIOIndependent");
|
|
#endif
|
|
file1 = H5OpenFile(FILENAME, H5_O_APPENDONLY, props);
|
|
status = H5CheckFile(file1);
|
|
RETURN(status, H5_SUCCESS, "H5CheckFile");
|
|
|
|
file2 = H5OpenFile(FILENAME, H5_O_RDONLY, props);
|
|
status = H5CheckFile(file2);
|
|
RETURN(status, H5_SUCCESS, "H5CheckFile");
|
|
|
|
status = H5CloseProp (props);
|
|
RETURN(status, H5_SUCCESS, "H5CloseProp");
|
|
|
|
TEST("Redefining step name");
|
|
status = H5SetStepNameFormat(file1, "data", 16);
|
|
RETURN(status, H5_SUCCESS, "H5SetStepNameFormat");
|
|
|
|
status = H5SetStepNameFormat(file2, "data", 16);
|
|
RETURN(status, H5_SUCCESS, "H5SetStepNameFormat");
|
|
|
|
status = H5PartSetChunkSize(file1, NPARTICLES);
|
|
RETURN(status, H5_SUCCESS, "H5PartSetChunk");
|
|
|
|
test_write_data64(file1, NPARTICLES, NTIMESTEPS-2);
|
|
test_write_file_attribs(file1, 2);
|
|
|
|
status = H5CloseFile(file1);
|
|
RETURN(status, H5_SUCCESS, "H5CloseFile");
|
|
status = H5CloseFile(file2);
|
|
RETURN(status, H5_SUCCESS, "H5CloseFile");
|
|
}
|
|
|