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

Merge pull request in HDFFV/hdf5 from ~BYRN/hdf5_adb:develop to develop

Browse Source 
* commit '1efd23ff02b9bc1a3d303d53395245d1366588be':
  Whitespace and HD prefix changes
  fix get gethostname for windows
  OESS-29 Fix HD prefix in perform and enable test compile
  HDFFV-10876 h5dump OPAQUE size should be optional
This commit is contained in:
Allen Byrne 2019-08-28 15:18:02 -05:00
commit 37532a3688
17 changed files with 713 additions and 709 deletions

6
java/src/hdf/hdf5lib/structs/H5FD_hdfs_fapl_t.java

@ -17,7 +17,7 @@ package hdf.hdf5lib.structs;
import java.io.Serializable;
/*
* Java representation of the HDFS VFD file access property list (fapl)
* Java representation of the HDFS VFD file access property list (fapl)
* structure.
*
* Used for the access of files hosted on the Hadoop Distributed File System.
@ -33,7 +33,7 @@ public class H5FD_hdfs_fapl_t implements Serializable {
private int namenode_port;
private int stream_buffer_size;
/**
/*
* Create a fapl_t structure with the specified components.
*/
public H5FD_hdfs_fapl_t(
@ -91,7 +91,7 @@ public class H5FD_hdfs_fapl_t implements Serializable {
public String toString() {
return "H5FD_hdfs_fapl_t (Version: " + this.version + ") {" +
"\n namenode_name: '" + this.namenode_name +
"'\n namenode_port: " + this.namenode_port +
"'\n namenode_port: " + this.namenode_port +
"\n user_name: '" + this.user_name +
"'\n kerberos_ticket_cache: '" + this.kerberos_ticket_cache +
"'\n stream_buffer_size: " + this.stream_buffer_size +

2
test/h5test.c

@ -1193,7 +1193,7 @@ h5_show_hostname(void)
#endif
#ifdef H5_HAVE_GETHOSTNAME
if (gethostname(hostname, (size_t)80) < 0)
if (HDgethostname(hostname, (size_t)80) < 0)
HDprintf(" gethostname failed\n");
else
HDprintf(" hostname=%s\n", hostname);

4
testpar/CMakeLists.txt

@ -47,11 +47,13 @@ MACRO (ADD_H5P_EXE file)
TARGET_C_PROPERTIES (${file} STATIC)
target_link_libraries (${file}
PRIVATE ${HDF5_TEST_LIB_TARGET} ${HDF5_LIB_TARGET} "$<$<BOOL:${HDF5_ENABLE_PARALLEL}>:${MPI_C_LIBRARIES}>"
$<$<OR:$<PLATFORM_ID:Windows>,$<PLATFORM_ID:MinGW>>:ws2_32.lib>
)
else ()
TARGET_C_PROPERTIES (${file} SHARED)
target_link_libraries (${file}
PRIVATE ${HDF5_TEST_LIBSH_TARGET} ${HDF5_LIBSH_TARGET} "$<$<BOOL:${HDF5_ENABLE_PARALLEL}>:${MPI_C_LIBRARIES}>"
$<$<OR:$<PLATFORM_ID:Windows>,$<PLATFORM_ID:MinGW>>:ws2_32.lib>
)
endif ()
set_target_properties (${file} PROPERTIES FOLDER test/par)
@ -61,7 +63,7 @@ set (H5P_TESTS
t_mpi
t_bigio
t_cache
#t_cache_image
t_cache_image
t_pflush1
t_pflush2
t_pread

3
testpar/CMakeTests.cmake

@ -72,6 +72,9 @@ endforeach ()
# list (REMOVE_ITEM H5P_TESTS t_shapesame)
#endif ()
# do not test until new version is added
list (REMOVE_ITEM H5P_TESTS t_cache_image)
set (test_par_CLEANFILES
t_cache_image_00.h5
t_cache_image_01.h5

630
testpar/t_mdset.c

@ -852,18 +852,18 @@ void collective_group_write_independent_group_read(void)
*/
void collective_group_write(void)
{
int mpi_rank, mpi_size, size;
int i, j, m;
char gname[64], dname[32];
int mpi_rank, mpi_size, size;
int i, j, m;
char gname[64], dname[32];
hid_t fid, gid, did, plist, dcpl, memspace, filespace;
DATATYPE * outme = NULL;
hsize_t chunk_origin[DIM];
hsize_t chunk_dims[DIM], file_dims[DIM], count[DIM];
hsize_t chunk_size[2]; /* Chunk dimensions - computed shortly */
herr_t ret1, ret2;
DATATYPE *outme = NULL;
hsize_t chunk_origin[DIM];
hsize_t chunk_dims[DIM], file_dims[DIM], count[DIM];
hsize_t chunk_size[2]; /* Chunk dimensions - computed shortly */
herr_t ret1, ret2;
const H5Ptest_param_t *pt;
char *filename;
int ngroups;
char *filename;
int ngroups;
pt = GetTestParameters();
filename = pt->name;
@ -920,8 +920,7 @@ void collective_group_write(void)
for(j = 0; j < size; j++)
outme[(i * size) + j] =(i + j) * 1000 + mpi_rank;
H5Dwrite(did, H5T_NATIVE_INT, memspace, filespace, H5P_DEFAULT,
outme);
H5Dwrite(did, H5T_NATIVE_INT, memspace, filespace, H5P_DEFAULT, outme);
H5Dclose(did);
H5Gclose(gid);
@ -951,7 +950,7 @@ void independent_group_read(void)
hid_t plist, fid;
const H5Ptest_param_t *pt;
char *filename;
int ngroups;
int ngroups;
pt = GetTestParameters();
filename = pt->name;
@ -1071,16 +1070,16 @@ group_dataset_read(hid_t fid, int mpi_rank, int m)
*/
void multiple_group_write(void)
{
int mpi_rank, mpi_size, size;
int m;
char gname[64];
hid_t fid, gid, plist, memspace, filespace;
int mpi_rank, mpi_size, size;
int m;
char gname[64];
hid_t fid, gid, plist, memspace, filespace;
hsize_t chunk_origin[DIM];
hsize_t chunk_dims[DIM], file_dims[DIM], count[DIM];
herr_t ret;
herr_t ret;
const H5Ptest_param_t *pt;
char *filename;
int ngroups;
char *filename;
int ngroups;
pt = GetTestParameters();
filename = pt->name;
@ -1162,11 +1161,11 @@ void multiple_group_write(void)
static void
write_dataset(hid_t memspace, hid_t filespace, hid_t gid)
{
int i, j, n, size;
int mpi_rank, mpi_size;
char dname[32];
DATATYPE * outme = NULL;
hid_t did;
int i, j, n, size;
int mpi_rank, mpi_size;
char dname[32];
DATATYPE *outme = NULL;
hid_t did;
MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
MPI_Comm_size(MPI_COMM_WORLD, &mpi_size);
@ -1248,7 +1247,7 @@ void multiple_group_read(void)
hsize_t chunk_dims[DIM], file_dims[DIM], count[DIM];
const H5Ptest_param_t *pt;
char *filename;
int ngroups;
int ngroups;
pt = GetTestParameters();
filename = pt->name;
@ -1323,10 +1322,10 @@ void multiple_group_read(void)
static int
read_dataset(hid_t memspace, hid_t filespace, hid_t gid)
{
int i, j, n, mpi_rank, mpi_size, size, attr_errors=0, vrfy_errors=0;
char dname[32];
int i, j, n, mpi_rank, mpi_size, size, attr_errors=0, vrfy_errors=0;
char dname[32];
DATATYPE *outdata = NULL, *indata = NULL;
hid_t did;
hid_t did;
MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
MPI_Comm_size(MPI_COMM_WORLD, &mpi_size);
@ -1344,8 +1343,7 @@ read_dataset(hid_t memspace, hid_t filespace, hid_t gid)
did = H5Dopen2(gid, dname, H5P_DEFAULT);
VRFY((did>0), dname);
H5Dread(did, H5T_NATIVE_INT, memspace, filespace, H5P_DEFAULT,
indata);
H5Dread(did, H5T_NATIVE_INT, memspace, filespace, H5P_DEFAULT, indata);
/* this is the original value */
for(i=0; i<size; i++)
@ -1451,7 +1449,7 @@ read_attribute(hid_t obj_id, int this_type, int num)
if(MAINPROCESS) {
H5Aread(aid, H5T_NATIVE_INT, &in_num);
vrfy_errors = dataset_vrfy(NULL, NULL, NULL, group_block, &in_num, &num);
}
}
H5Aclose(aid);
}
else if(this_type == is_dset) {
@ -1462,7 +1460,7 @@ read_attribute(hid_t obj_id, int this_type, int num)
if(MAINPROCESS) {
H5Aread(aid, H5T_NATIVE_INT, in_data);
vrfy_errors = dataset_vrfy(NULL, NULL, NULL, dset_block, in_data, out_data);
}
}
H5Aclose(aid);
}
@ -1481,9 +1479,9 @@ read_attribute(hid_t obj_id, int this_type, int num)
static int
check_value(DATATYPE *indata, DATATYPE *outdata, int size)
{
int mpi_rank, mpi_size, err_num=0;
hsize_t i, j;
hsize_t chunk_origin[DIM];
int mpi_rank, mpi_size, err_num=0;
hsize_t i, j;
hsize_t chunk_origin[DIM];
hsize_t chunk_dims[DIM], count[DIM];
MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
@ -1494,11 +1492,11 @@ check_value(DATATYPE *indata, DATATYPE *outdata, int size)
indata += chunk_origin[0]*size;
outdata += chunk_origin[0]*size;
for(i=chunk_origin[0]; i<(chunk_origin[0]+chunk_dims[0]); i++)
for(j=chunk_origin[1]; j<(chunk_origin[1]+chunk_dims[1]); j++) {
if(*indata != *outdata )
if(err_num++ < MAX_ERR_REPORT || VERBOSE_MED)
HDprintf("Dataset Verify failed at [%lu][%lu](row %lu, col%lu): expect %d, got %d\n",(unsigned long)i,(unsigned long)j,(unsigned long)i,(unsigned long)j, *outdata, *indata);
}
for(j=chunk_origin[1]; j<(chunk_origin[1]+chunk_dims[1]); j++) {
if(*indata != *outdata )
if(err_num++ < MAX_ERR_REPORT || VERBOSE_MED)
HDprintf("Dataset Verify failed at [%lu][%lu](row %lu, col%lu): expect %d, got %d\n",(unsigned long)i,(unsigned long)j,(unsigned long)i,(unsigned long)j, *outdata, *indata);
}
if(err_num > MAX_ERR_REPORT && !VERBOSE_MED)
HDprintf("[more errors ...]\n");
if(err_num)
@ -1740,8 +1738,8 @@ void io_mode_confusion(void)
status = H5Pset_dxpl_mpio(plist_id, H5FD_MPIO_COLLECTIVE);
VRFY((status >= 0 ), "H5Pset_dxpl_mpio() failed");
if(dxfer_coll_type == DXFER_INDEPENDENT_IO) {
status = H5Pset_dxpl_mpio_collective_opt(plist_id, H5FD_MPIO_INDIVIDUAL_IO);
VRFY((status>= 0),"set independent IO collectively succeeded");
status = H5Pset_dxpl_mpio_collective_opt(plist_id, H5FD_MPIO_INDIVIDUAL_IO);
VRFY((status>= 0),"set independent IO collectively succeeded");
}
@ -1967,10 +1965,10 @@ void rr_obj_hdr_flush_confusion_writer(MPI_Comm comm)
int steps_done = 0;
/* test bed related variables */
const char * fcn_name = "rr_obj_hdr_flush_confusion_writer";
const hbool_t verbose = FALSE;
const H5Ptest_param_t * pt;
char * filename;
const char *fcn_name = "rr_obj_hdr_flush_confusion_writer";
const hbool_t verbose = FALSE;
const H5Ptest_param_t *pt;
char *filename;
/*
* setup test bed related variables:
@ -2067,19 +2065,19 @@ void rr_obj_hdr_flush_confusion_writer(MPI_Comm comm)
}
for ( i = 0; i < NUM_DATA_SETS; i++ ) {
err = H5Sselect_hyperslab(disk_space[i], H5S_SELECT_SET, disk_start,
NULL, disk_count, NULL);
err = H5Sselect_hyperslab(disk_space[i], H5S_SELECT_SET, disk_start,
NULL, disk_count, NULL);
VRFY((err >= 0), "H5Sselect_hyperslab(1) failed.\n");
mem_space[i] = H5Screate_simple(1, mem_size, NULL);
VRFY((mem_space[i] >= 0), "H5Screate_simple(2) failed.\n");
err = H5Sselect_hyperslab(mem_space[i], H5S_SELECT_SET,
mem_start, NULL, mem_count, NULL);
VRFY((mem_space[i] >= 0), "H5Screate_simple(2) failed.\n");
err = H5Sselect_hyperslab(mem_space[i], H5S_SELECT_SET,
mem_start, NULL, mem_count, NULL);
VRFY((err >= 0), "H5Sselect_hyperslab(2) failed.\n");
err = H5Dwrite(dataset[i], H5T_NATIVE_DOUBLE, mem_space[i],
disk_space[i], dxpl_id, data);
err = H5Dwrite(dataset[i], H5T_NATIVE_DOUBLE, mem_space[i],
disk_space[i], dxpl_id, data);
VRFY((err >= 0), "H5Dwrite(1) failed.\n");
for ( j = 0; j < LOCAL_DATA_SIZE; j++ )
data[j] *= 10.0;
data[j] *= 10.0;
}
/*
@ -2127,7 +2125,7 @@ void rr_obj_hdr_flush_confusion_writer(MPI_Comm comm)
for ( i = 0; i < NUM_DATA_SETS; i++ ) {
att_space[i] = H5Screate_simple(1, att_size, NULL);
VRFY((att_space[i] >= 0), "H5Screate_simple(3) failed.\n");
att_id[i] = H5Acreate2(dataset[i], att_name[i], H5T_NATIVE_DOUBLE,
att_id[i] = H5Acreate2(dataset[i], att_name[i], H5T_NATIVE_DOUBLE,
att_space[i], H5P_DEFAULT, H5P_DEFAULT);
VRFY((att_id[i] >= 0), "H5Acreate(1) failed.\n");
err = H5Awrite(att_id[i], H5T_NATIVE_DOUBLE, att);
@ -2146,7 +2144,6 @@ void rr_obj_hdr_flush_confusion_writer(MPI_Comm comm)
mpi_rank, fcn_name);
for ( i = 0; i < NUM_DATA_SETS; i++ ) {
err = H5Sclose(att_space[i]);
VRFY((err >= 0), "H5Sclose(att_space[i]) failed.\n");
err = H5Aclose(att_id[i]);
@ -2350,20 +2347,20 @@ void rr_obj_hdr_flush_confusion_reader(MPI_Comm comm)
/* MPI variables */
/* world communication size and rank */
int mpi_world_size;
int mpi_world_rank;
int mpi_world_size;
int mpi_world_rank;
/* private communicator size and rank */
int mpi_size;
int mpi_rank;
int mrc; /* mpi error code */
int mpi_size;
int mpi_rank;
int mrc; /* mpi error code */
int steps = -1; /* How far (steps) to verify the file */
int steps_done = -1; /* How far (steps) have been verified */
/* test bed related variables */
const char * fcn_name = "rr_obj_hdr_flush_confusion_reader";
const hbool_t verbose = FALSE;
const H5Ptest_param_t * pt;
char * filename;
const char *fcn_name = "rr_obj_hdr_flush_confusion_reader";
const hbool_t verbose = FALSE;
const H5Ptest_param_t *pt;
char *filename;
/*
* setup test bed related variables:
@ -2380,291 +2377,290 @@ void rr_obj_hdr_flush_confusion_reader(MPI_Comm comm)
/* Repeatedly re-open the file and verify its contents until it is */
/* told to end (when steps=0). */
while (steps_done != 0){
Reader_wait(mrc, steps);
VRFY((mrc >= 0), "Reader_wait failed");
steps_done = 0;
Reader_wait(mrc, steps);
VRFY((mrc >= 0), "Reader_wait failed");
steps_done = 0;
if (steps > 0 ){
/*
* Set up file access property list with parallel I/O access
*/
if (steps > 0 ){
/*
* Set up file access property list with parallel I/O access
*/
if(verbose )
HDfprintf(stdout, "%0d:%s: Setting up property list.\n",
mpi_rank, fcn_name);
if(verbose )
HDfprintf(stdout, "%0d:%s: Setting up property list.\n",
mpi_rank, fcn_name);
fapl_id = H5Pcreate(H5P_FILE_ACCESS);
VRFY((fapl_id != -1), "H5Pcreate(H5P_FILE_ACCESS) failed");
err = H5Pset_fapl_mpio(fapl_id, comm, MPI_INFO_NULL);
VRFY((err >= 0 ), "H5Pset_fapl_mpio() failed");
fapl_id = H5Pcreate(H5P_FILE_ACCESS);
VRFY((fapl_id != -1), "H5Pcreate(H5P_FILE_ACCESS) failed");
err = H5Pset_fapl_mpio(fapl_id, comm, MPI_INFO_NULL);
VRFY((err >= 0 ), "H5Pset_fapl_mpio() failed");
/*
* Create a new file collectively and release property list identifier.
*/
/*
* Create a new file collectively and release property list identifier.
*/
if(verbose )
HDfprintf(stdout, "%0d:%s: Re-open file \"%s\".\n",
mpi_rank, fcn_name, filename);
if(verbose )
HDfprintf(stdout, "%0d:%s: Re-open file \"%s\".\n",
mpi_rank, fcn_name, filename);
file_id = H5Fopen(filename, H5F_ACC_RDONLY, fapl_id);
VRFY((file_id >= 0 ), "H5Fopen() failed");
err = H5Pclose(fapl_id);
VRFY((err >= 0 ), "H5Pclose(fapl_id) failed");
file_id = H5Fopen(filename, H5F_ACC_RDONLY, fapl_id);
VRFY((file_id >= 0 ), "H5Fopen() failed");
err = H5Pclose(fapl_id);
VRFY((err >= 0 ), "H5Pclose(fapl_id) failed");
#if 1
if (steps >= 1){
/*=====================================================*
* Step 1: open the data sets and read data.
*=====================================================*/
if(verbose )
HDfprintf(stdout, "%0d:%s: opening the datasets.\n",
mpi_rank, fcn_name);
for ( i = 0; i < NUM_DATA_SETS; i++ ) {
dataset[i] = -1;
}
for ( i = 0; i < NUM_DATA_SETS; i++ ) {
dataset[i] = H5Dopen2(file_id, dataset_name[i], H5P_DEFAULT);
VRFY((dataset[i] >= 0), "H5Dopen(1) failed.\n");
disk_space[i] = H5Dget_space(dataset[i]);
VRFY((disk_space[i] >= 0), "H5Dget_space failed.\n");
}
/*
* setup data transfer property list
*/
if(verbose )
HDfprintf(stdout, "%0d:%s: Setting up dxpl.\n", mpi_rank, fcn_name);
dxpl_id = H5Pcreate(H5P_DATASET_XFER);
VRFY((dxpl_id != -1), "H5Pcreate(H5P_DATASET_XFER) failed.\n");
err = H5Pset_dxpl_mpio(dxpl_id, H5FD_MPIO_COLLECTIVE);
VRFY((err >= 0),
"H5Pset_dxpl_mpio(dxpl_id, H5FD_MPIO_COLLECTIVE) failed.\n");
/*
* read data from the data sets
*/
if(verbose )
HDfprintf(stdout, "%0d:%s: Reading datasets.\n", mpi_rank, fcn_name);
disk_count[0] = (hsize_t)(LOCAL_DATA_SIZE);
disk_start[0] = (hsize_t)(LOCAL_DATA_SIZE * mpi_rank);
mem_size[0] = (hsize_t)(LOCAL_DATA_SIZE);
mem_count[0] = (hsize_t)(LOCAL_DATA_SIZE);
mem_start[0] = (hsize_t)(0);
/* set up expected data for verification */
for ( j = 0; j < LOCAL_DATA_SIZE; j++ ) {
data[j] = (double)(mpi_rank + 1);
}
for ( i = 0; i < NUM_DATA_SETS; i++ ) {
err = H5Sselect_hyperslab(disk_space[i], H5S_SELECT_SET, disk_start,
NULL, disk_count, NULL);
VRFY((err >= 0), "H5Sselect_hyperslab(1) failed.\n");
mem_space[i] = H5Screate_simple(1, mem_size, NULL);
VRFY((mem_space[i] >= 0), "H5Screate_simple(2) failed.\n");
err = H5Sselect_hyperslab(mem_space[i], H5S_SELECT_SET,
mem_start, NULL, mem_count, NULL);
VRFY((err >= 0), "H5Sselect_hyperslab(2) failed.\n");
err = H5Dread(dataset[i], H5T_NATIVE_DOUBLE, mem_space[i],
disk_space[i], dxpl_id, data_read);
VRFY((err >= 0), "H5Dread(1) failed.\n");
/* compare read data with expected data */
for ( j = 0; j < LOCAL_DATA_SIZE; j++ )
if (data_read[j] != data[j]){
HDfprintf(stdout,
"%0d:%s: Reading datasets value failed in "
"Dataset %d, at position %d: expect %f, got %f.\n",
mpi_rank, fcn_name, i, j, data[j], data_read[j]);
nerrors++;
}
for ( j = 0; j < LOCAL_DATA_SIZE; j++ )
data[j] *= 10.0;
}
/*
* close the data spaces
*/
if(verbose )
HDfprintf(stdout, "%0d:%s: closing dataspaces.\n", mpi_rank, fcn_name);
for ( i = 0; i < NUM_DATA_SETS; i++ ) {
err = H5Sclose(disk_space[i]);
VRFY((err >= 0), "H5Sclose(disk_space[i]) failed.\n");
err = H5Sclose(mem_space[i]);
VRFY((err >= 0), "H5Sclose(mem_space[i]) failed.\n");
}
steps_done++;
}
/* End of Step 1: open the data sets and read data. */
#endif
#if 1
if (steps >= 1){
/*=====================================================*
* Step 1: open the data sets and read data.
*=====================================================*/
* Step 2: reading attributes from each dataset
*=====================================================*/
if(verbose )
HDfprintf(stdout, "%0d:%s: opening the datasets.\n",
mpi_rank, fcn_name);
if (steps >= 2){
if(verbose )
HDfprintf(stdout, "%0d:%s: reading attributes.\n", mpi_rank, fcn_name);
for ( i = 0; i < NUM_DATA_SETS; i++ ) {
dataset[i] = -1;
}
for ( i = 0; i < NUM_DATA_SETS; i++ ) {
dataset[i] = H5Dopen2(file_id, dataset_name[i], H5P_DEFAULT);
VRFY((dataset[i] >= 0), "H5Dopen(1) failed.\n");
disk_space[i] = H5Dget_space(dataset[i]);
VRFY((disk_space[i] >= 0), "H5Dget_space failed.\n");
}
/*
* setup data transfer property list
*/
if(verbose )
HDfprintf(stdout, "%0d:%s: Setting up dxpl.\n", mpi_rank, fcn_name);
dxpl_id = H5Pcreate(H5P_DATASET_XFER);
VRFY((dxpl_id != -1), "H5Pcreate(H5P_DATASET_XFER) failed.\n");
err = H5Pset_dxpl_mpio(dxpl_id, H5FD_MPIO_COLLECTIVE);
VRFY((err >= 0),
"H5Pset_dxpl_mpio(dxpl_id, H5FD_MPIO_COLLECTIVE) failed.\n");
/*
* read data from the data sets
*/
if(verbose )
HDfprintf(stdout, "%0d:%s: Reading datasets.\n", mpi_rank, fcn_name);
disk_count[0] = (hsize_t)(LOCAL_DATA_SIZE);
disk_start[0] = (hsize_t)(LOCAL_DATA_SIZE * mpi_rank);
mem_size[0] = (hsize_t)(LOCAL_DATA_SIZE);
mem_count[0] = (hsize_t)(LOCAL_DATA_SIZE);
mem_start[0] = (hsize_t)(0);
/* set up expected data for verification */
for ( j = 0; j < LOCAL_DATA_SIZE; j++ ) {
data[j] = (double)(mpi_rank + 1);
}
for ( i = 0; i < NUM_DATA_SETS; i++ ) {
err = H5Sselect_hyperslab(disk_space[i], H5S_SELECT_SET, disk_start,
NULL, disk_count, NULL);
VRFY((err >= 0), "H5Sselect_hyperslab(1) failed.\n");
mem_space[i] = H5Screate_simple(1, mem_size, NULL);
VRFY((mem_space[i] >= 0), "H5Screate_simple(2) failed.\n");
err = H5Sselect_hyperslab(mem_space[i], H5S_SELECT_SET,
mem_start, NULL, mem_count, NULL);
VRFY((err >= 0), "H5Sselect_hyperslab(2) failed.\n");
err = H5Dread(dataset[i], H5T_NATIVE_DOUBLE, mem_space[i],
disk_space[i], dxpl_id, data_read);
VRFY((err >= 0), "H5Dread(1) failed.\n");
/* compare read data with expected data */
for ( j = 0; j < LOCAL_DATA_SIZE; j++ )
if (data_read[j] != data[j]){
HDfprintf(stdout,
"%0d:%s: Reading datasets value failed in "
"Dataset %d, at position %d: expect %f, got %f.\n",
mpi_rank, fcn_name, i, j, data[j], data_read[j]);
nerrors++;
}
for ( j = 0; j < LOCAL_DATA_SIZE; j++ )
data[j] *= 10.0;
}
/*
* close the data spaces
*/
if(verbose )
HDfprintf(stdout, "%0d:%s: closing dataspaces.\n", mpi_rank, fcn_name);
for ( i = 0; i < NUM_DATA_SETS; i++ ) {
err = H5Sclose(disk_space[i]);
VRFY((err >= 0), "H5Sclose(disk_space[i]) failed.\n");
err = H5Sclose(mem_space[i]);
VRFY((err >= 0), "H5Sclose(mem_space[i]) failed.\n");
}
steps_done++;
}
/* End of Step 1: open the data sets and read data. */
#endif
#if 1
/*=====================================================*
* Step 2: reading attributes from each dataset
*=====================================================*/
if (steps >= 2){
if(verbose )
HDfprintf(stdout, "%0d:%s: reading attributes.\n", mpi_rank, fcn_name);
for ( j = 0; j < LOCAL_DATA_SIZE; j++ ) {
att[j] = (double)(j + 1);
}
for ( i = 0; i < NUM_DATA_SETS; i++ ) {
hid_t att_id, att_type;
att_id = H5Aopen(dataset[i], att_name[i], H5P_DEFAULT);
VRFY((att_id >= 0), "H5Aopen failed.\n");
att_type = H5Aget_type(att_id);
VRFY((att_type >= 0), "H5Aget_type failed.\n");
tri_err = H5Tequal(att_type, H5T_NATIVE_DOUBLE);
VRFY((tri_err >= 0), "H5Tequal failed.\n");
if (tri_err==0){
HDfprintf(stdout,
"%0d:%s: Mismatched Attribute type of Dataset %d.\n",
mpi_rank, fcn_name, i);
nerrors++;
}else{
/* should verify attribute size before H5Aread */
err = H5Aread(att_id, H5T_NATIVE_DOUBLE, att_read);
VRFY((err >= 0), "H5Aread failed.\n");
/* compare read attribute data with expected data */
for ( j = 0; j < LOCAL_DATA_SIZE; j++ )
if (att_read[j] != att[j]){
HDfprintf(stdout,
"%0d:%s: Mismatched attribute data read in Dataset %d, at position %d: expect %f, got %f.\n",
mpi_rank, fcn_name, i, j, att[j], att_read[j]);
nerrors++;
for ( j = 0; j < LOCAL_DATA_SIZE; j++ ) {
att[j] = (double)(j + 1);
}
for ( j = 0; j < LOCAL_DATA_SIZE; j++ ) {
att[j] /= 10.0;
for ( i = 0; i < NUM_DATA_SETS; i++ ) {
hid_t att_id, att_type;
att_id = H5Aopen(dataset[i], att_name[i], H5P_DEFAULT);
VRFY((att_id >= 0), "H5Aopen failed.\n");
att_type = H5Aget_type(att_id);
VRFY((att_type >= 0), "H5Aget_type failed.\n");
tri_err = H5Tequal(att_type, H5T_NATIVE_DOUBLE);
VRFY((tri_err >= 0), "H5Tequal failed.\n");
if (tri_err==0){
HDfprintf(stdout,
"%0d:%s: Mismatched Attribute type of Dataset %d.\n",
mpi_rank, fcn_name, i);
nerrors++;
}
else {
/* should verify attribute size before H5Aread */
err = H5Aread(att_id, H5T_NATIVE_DOUBLE, att_read);
VRFY((err >= 0), "H5Aread failed.\n");
/* compare read attribute data with expected data */
for ( j = 0; j < LOCAL_DATA_SIZE; j++ )
if (att_read[j] != att[j]){
HDfprintf(stdout,
"%0d:%s: Mismatched attribute data read in Dataset %d, at position %d: expect %f, got %f.\n",
mpi_rank, fcn_name, i, j, att[j], att_read[j]);
nerrors++;
}
for ( j = 0; j < LOCAL_DATA_SIZE; j++ ) {
att[j] /= 10.0;
}
}
err = H5Aclose(att_id);
VRFY((err >= 0), "H5Aclose failed.\n");
}
steps_done++;
}
}
err = H5Aclose(att_id);
VRFY((err >= 0), "H5Aclose failed.\n");
}
steps_done++;
}
/* End of Step 2: reading attributes from each dataset */
/* End of Step 2: reading attributes from each dataset */
#endif
#if 1
/*=====================================================*
* Step 3 or 4: read large attributes from each dataset.
* Step 4 has different attribute value from step 3.
*=====================================================*/
/*=====================================================*
* Step 3 or 4: read large attributes from each dataset.
* Step 4 has different attribute value from step 3.
*=====================================================*/
if (steps >= 3){
if(verbose )
HDfprintf(stdout, "%0d:%s: reading large attributes.\n", mpi_rank, fcn_name);
if (steps >= 3){
if(verbose )
HDfprintf(stdout, "%0d:%s: reading large attributes.\n", mpi_rank, fcn_name);
for ( j = 0; j < LARGE_ATTR_SIZE; j++ ) {
lg_att[j] = (steps==3) ? (double)(j + 1) : (double)(j+2);
}
for ( i = 0; i < NUM_DATA_SETS; i++ ) {
lg_att_id[i] = H5Aopen(dataset[i], lg_att_name[i], H5P_DEFAULT);
VRFY((lg_att_id[i] >= 0), "H5Aopen(2) failed.\n");
lg_att_type[i] = H5Aget_type(lg_att_id[i]);
VRFY((err >= 0), "H5Aget_type failed.\n");
tri_err = H5Tequal(lg_att_type[i], H5T_NATIVE_DOUBLE);
VRFY((tri_err >= 0), "H5Tequal failed.\n");
if (tri_err==0){
HDfprintf(stdout,
"%0d:%s: Mismatched Large attribute type of Dataset %d.\n",
mpi_rank, fcn_name, i);
nerrors++;
}else{
/* should verify large attribute size before H5Aread */
err = H5Aread(lg_att_id[i], H5T_NATIVE_DOUBLE, lg_att_read);
VRFY((err >= 0), "H5Aread failed.\n");
/* compare read attribute data with expected data */
for ( j = 0; j < LARGE_ATTR_SIZE; j++ )
if (lg_att_read[j] != lg_att[j]){
HDfprintf(stdout,
"%0d:%s: Mismatched large attribute data read in Dataset %d, at position %d: expect %f, got %f.\n",
mpi_rank, fcn_name, i, j, lg_att[j], lg_att_read[j]);
nerrors++;
for ( j = 0; j < LARGE_ATTR_SIZE; j++ ) {
lg_att[j] = (steps==3) ? (double)(j + 1) : (double)(j+2);
}
for ( j = 0; j < LARGE_ATTR_SIZE; j++ ) {
lg_att[j] /= 10.0;
}
}
err = H5Tclose(lg_att_type[i]);
VRFY((err >= 0), "H5Tclose failed.\n");
err = H5Aclose(lg_att_id[i]);
VRFY((err >= 0), "H5Aclose failed.\n");
}
/* Both step 3 and 4 use this same read checking code. */
steps_done = (steps==3) ? 3 : 4;
}
for ( i = 0; i < NUM_DATA_SETS; i++ ) {
lg_att_id[i] = H5Aopen(dataset[i], lg_att_name[i], H5P_DEFAULT);
VRFY((lg_att_id[i] >= 0), "H5Aopen(2) failed.\n");
lg_att_type[i] = H5Aget_type(lg_att_id[i]);
VRFY((err >= 0), "H5Aget_type failed.\n");
tri_err = H5Tequal(lg_att_type[i], H5T_NATIVE_DOUBLE);
VRFY((tri_err >= 0), "H5Tequal failed.\n");
if (tri_err==0){
HDfprintf(stdout,
"%0d:%s: Mismatched Large attribute type of Dataset %d.\n",
mpi_rank, fcn_name, i);
nerrors++;
}
else{
/* should verify large attribute size before H5Aread */
err = H5Aread(lg_att_id[i], H5T_NATIVE_DOUBLE, lg_att_read);
VRFY((err >= 0), "H5Aread failed.\n");
/* compare read attribute data with expected data */
for ( j = 0; j < LARGE_ATTR_SIZE; j++ )
if (lg_att_read[j] != lg_att[j]){
HDfprintf(stdout,
"%0d:%s: Mismatched large attribute data read in Dataset %d, at position %d: expect %f, got %f.\n",
mpi_rank, fcn_name, i, j, lg_att[j], lg_att_read[j]);
nerrors++;
}
for ( j = 0; j < LARGE_ATTR_SIZE; j++ ) {
/* End of Step 3 or 4: read large attributes from each dataset */
lg_att[j] /= 10.0;
}
}
err = H5Tclose(lg_att_type[i]);
VRFY((err >= 0), "H5Tclose failed.\n");
err = H5Aclose(lg_att_id[i]);
VRFY((err >= 0), "H5Aclose failed.\n");
}
/* Both step 3 and 4 use this same read checking code. */
steps_done = (steps==3) ? 3 : 4;
}
/* End of Step 3 or 4: read large attributes from each dataset */
#endif
/*=====================================================*
* Step 5: read all objects from the file
*=====================================================*/
if (steps>=5){
/* nothing extra to verify. The file is closed normally. */
/* Just increment steps_done */
steps_done++;
}
/*=====================================================*
* Step 5: read all objects from the file
*=====================================================*/
if (steps>=5){
/* nothing extra to verify. The file is closed normally. */
/* Just increment steps_done */
steps_done++;
}
/*
* Close the data sets
*/
/*
* Close the data sets
*/
if(verbose )
HDfprintf(stdout, "%0d:%s: closing datasets again.\n",
mpi_rank, fcn_name);
if(verbose )
HDfprintf(stdout, "%0d:%s: closing datasets again.\n",
mpi_rank, fcn_name);
for ( i = 0; i < NUM_DATA_SETS; i++ ) {
if ( dataset[i] >= 0 ) {
err = H5Dclose(dataset[i]);
VRFY((err >= 0), "H5Dclose(dataset[i])1 failed.\n");
}
}
for ( i = 0; i < NUM_DATA_SETS; i++ ) {
if ( dataset[i] >= 0 ) {
err = H5Dclose(dataset[i]);
VRFY((err >= 0), "H5Dclose(dataset[i])1 failed.\n");
}
}
/*
* close the data transfer property list.
*/
/*
* close the data transfer property list.
*/
if(verbose )
HDfprintf(stdout, "%0d:%s: closing dxpl .\n", mpi_rank, fcn_name);
if(verbose )
HDfprintf(stdout, "%0d:%s: closing dxpl .\n", mpi_rank, fcn_name);
err = H5Pclose(dxpl_id);
VRFY((err >= 0), "H5Pclose(dxpl_id) failed.\n");
err = H5Pclose(dxpl_id);
VRFY((err >= 0), "H5Pclose(dxpl_id) failed.\n");
/*
* Close the file
*/
if(verbose)
HDfprintf(stdout, "%0d:%s: closing file again.\n",
mpi_rank, fcn_name);
err = H5Fclose(file_id);
VRFY((err >= 0 ), "H5Fclose(1) failed");
/*
* Close the file
*/
if(verbose)
HDfprintf(stdout, "%0d:%s: closing file again.\n",
mpi_rank, fcn_name);
err = H5Fclose(file_id);
VRFY((err >= 0 ), "H5Fclose(1) failed");
} /* else if (steps_done==0) */
Reader_result(mrc, steps_done);
} /* else if (steps_done==0) */
Reader_result(mrc, steps_done);
} /* end while(1) */
if(verbose )

26
tools/lib/h5tools_dump.c

@ -94,7 +94,7 @@ h5tool_format_t h5tools_dataformat = {
const h5tools_dump_header_t h5tools_standardformat = {
"standardformat", /*name */
"HDF5", /*fileebgin */
"HDF5", /*filebegin */
"", /*fileend */
SUPER_BLOCK, /*bootblockbegin */
"", /*bootblockend */
@ -2277,18 +2277,26 @@ h5tools_print_datatype(FILE *stream, h5tools_str_t *buffer, const h5tool_format_
h5tools_render_element(stream, info, ctx, buffer, &curr_pos, (size_t)ncols, (hsize_t)0, (hsize_t)0);
ctx->indent_level++;
{
char *ttag;
char *ttag;
if(NULL == (ttag = H5Tget_tag(type)))
H5E_THROW(FAIL, H5E_tools_min_id_g, "H5Tget_tag failed")
if(NULL == (ttag = H5Tget_tag(type)))
H5E_THROW(FAIL, H5E_tools_min_id_g, "H5Tget_tag failed")
ctx->need_prefix = TRUE;
ctx->need_prefix = TRUE;
h5tools_str_reset(buffer);
h5tools_str_append(buffer, "OPAQUE_TAG \"%s\";", ttag);
h5tools_render_element(stream, info, ctx, buffer, &curr_pos, (size_t)ncols, (hsize_t)0, (hsize_t)0);
h5tools_str_reset(buffer);
h5tools_str_append(buffer, "OPAQUE_TAG \"%s\";", ttag);
h5tools_render_element(stream, info, ctx, buffer, &curr_pos, (size_t)ncols, (hsize_t)0, (hsize_t)0);
H5free_memory(ttag);
H5free_memory(ttag);
if((size = H5Tget_size(type)) <= 0) {
ctx->need_prefix = TRUE;
h5tools_str_reset(buffer);
h5tools_str_append(buffer, "OPAQUE_SIZE \"%s\";", size);
h5tools_render_element(stream, info, ctx, buffer, &curr_pos, (size_t)ncols, (hsize_t)0, (hsize_t)0);
}
}
ctx->indent_level--;

8
tools/src/h5dump/h5dump_ddl.c

@ -1943,9 +1943,6 @@ handle_links(hid_t fid, const char *links, void H5_ATTR_UNUSED * data, int H5_AT
break;
case H5L_TYPE_EXTERNAL:
begin_obj(h5tools_dump_header_format->udlinkbegin, links, h5tools_dump_header_format->udlinkblockbegin);
PRINTVALSTREAM(rawoutstream, "\n");
indentation(COL);
begin_obj(h5tools_dump_header_format->extlinkbegin, links, h5tools_dump_header_format->extlinkblockbegin);
PRINTVALSTREAM(rawoutstream, "\n");
if(H5Lget_val(fid, links, buf, linfo.u.val_size, H5P_DEFAULT) >= 0) {
@ -1953,8 +1950,6 @@ handle_links(hid_t fid, const char *links, void H5_ATTR_UNUSED * data, int H5_AT
const char *elink_path;
if(H5Lunpack_elink_val(buf, linfo.u.val_size, NULL, &elink_file, &elink_path)>=0) {
indentation(COL);
PRINTSTREAM(rawoutstream, "LINKCLASS %d\n", linfo.type);
indentation(COL);
PRINTSTREAM(rawoutstream, "TARGETFILE \"%s\"\n", elink_file);
indentation(COL);
@ -1976,9 +1971,6 @@ handle_links(hid_t fid, const char *links, void H5_ATTR_UNUSED * data, int H5_AT
case H5L_TYPE_MAX:
case H5L_TYPE_HARD:
default:
begin_obj(h5tools_dump_header_format->udlinkbegin, links, h5tools_dump_header_format->udlinkblockbegin);
PRINTVALSTREAM(rawoutstream, "\n");
indentation(COL);
begin_obj(h5tools_dump_header_format->udlinkbegin, links, h5tools_dump_header_format->udlinkblockbegin);
PRINTVALSTREAM(rawoutstream, "\n");
indentation(COL);

14
tools/test/perform/iopipe.c

@ -224,7 +224,7 @@ main (void)
_ftime(tbstart);
#endif
#endif
fprintf (stderr, HEADING, "fill raw");
HDfprintf (stderr, HEADING, "fill raw");
for(u = 0; u < nwrite; u++) {
putc (PROGRESS, stderr);
HDfflush(stderr);
@ -262,7 +262,7 @@ main (void)
_ftime(tbstart);
#endif
#endif
fprintf (stderr, HEADING, "fill hdf5");
HDfprintf (stderr, HEADING, "fill hdf5");
for(u = 0; u < nread; u++) {
putc (PROGRESS, stderr);
HDfflush(stderr);
@ -301,7 +301,7 @@ main (void)
_ftime(tbstart);
#endif
#endif
fprintf (stderr, HEADING, "out raw");
HDfprintf (stderr, HEADING, "out raw");
for(u = 0; u < nwrite; u++) {
putc (PROGRESS, stderr);
HDfflush(stderr);
@ -341,7 +341,7 @@ main (void)
_ftime(tbstart);
#endif
#endif
fprintf (stderr, HEADING, "out hdf5");
HDfprintf (stderr, HEADING, "out hdf5");
for(u = 0; u < nwrite; u++) {
putc (PROGRESS, stderr);
HDfflush(stderr);
@ -380,7 +380,7 @@ main (void)
_ftime(tbstart);
#endif
#endif
fprintf (stderr, HEADING, "in raw");
HDfprintf (stderr, HEADING, "in raw");
for(u = 0; u < nread; u++) {
putc (PROGRESS, stderr);
HDfflush(stderr);
@ -421,7 +421,7 @@ main (void)
_ftime(tbstart);
#endif
#endif
fprintf (stderr, HEADING, "in hdf5");
HDfprintf (stderr, HEADING, "in hdf5");
for(u = 0; u < nread; u++) {
putc (PROGRESS, stderr);
HDfflush(stderr);
@ -465,7 +465,7 @@ main (void)
_ftime(tbstart);
#endif
#endif
fprintf (stderr, HEADING, "in hdf5 partial");
HDfprintf (stderr, HEADING, "in hdf5 partial");
for(u = 0; u < nread; u++) {
putc (PROGRESS, stderr);
HDfflush(stderr);

6
tools/test/perform/overhead.c

@ -84,9 +84,9 @@ typedef enum fill_t {
static void
usage(const char *prog)
{
fprintf(stderr, "usage: %s [STYLE|cache] [LEFT [MIDDLE [RIGHT]]]\n",
HDfprintf(stderr, "usage: %s [STYLE|cache] [LEFT [MIDDLE [RIGHT]]]\n",
prog);
fprintf(stderr, "\
HDfprintf(stderr, "\
STYLE is the order that the dataset is filled and should be one of:\n\
forward -- Fill the dataset from lowest address to highest\n\
address. This style tests the right split ratio.\n\
@ -401,6 +401,6 @@ main(int argc, char *argv[])
return 0;
error:
fprintf(stderr, "*** ERRORS DETECTED ***\n");
HDfprintf(stderr, "*** ERRORS DETECTED ***\n");
return 1;
}

28
tools/test/perform/perf_meta.c

@ -313,7 +313,7 @@ create_dsets(hid_t file)
* Create a dataset using the default dataset creation properties.
*/
for(i = 0; i < NUM_DSETS; i++) {
sprintf(dset_name, "dataset %d", i);
HDsprintf(dset_name, "dataset %d", i);
if((dataset = H5Dcreate2(file, dset_name, H5T_NATIVE_DOUBLE, space,
H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
goto error;
@ -378,14 +378,14 @@ create_attrs_1(void)
* Create all(user specifies the number) attributes for each dataset
*/
for(i = 0; i < NUM_DSETS; i++) {
sprintf(dset_name, "dataset %d", i);
HDsprintf(dset_name, "dataset %d", i);
open_t.start = retrieve_time();
if((dataset = H5Dopen2(file, dset_name, H5P_DEFAULT)) < 0)
goto error;
perf(&open_t, open_t.start, retrieve_time());
for(j = 0; j < NUM_ATTRS; j++) {
sprintf(attr_name, "all attrs for each dset %d", j);
HDsprintf(attr_name, "all attrs for each dset %d", j);
attr_t.start = retrieve_time();
if((attr = H5Acreate2(dataset, attr_name, H5T_NATIVE_DOUBLE,
small_space, H5P_DEFAULT, H5P_DEFAULT)) < 0)
@ -422,7 +422,7 @@ create_attrs_1(void)
attr_t.avg = attr_t.total / (NUM_ATTRS*NUM_DSETS);
/* Print out the performance result */
fprintf(stderr, "1. Create %d attributes for each of %d existing datasets\n",
HDfprintf(stderr, "1. Create %d attributes for each of %d existing datasets\n",
NUM_ATTRS, NUM_DSETS);
print_perf(open_t, close_t, attr_t);
}
@ -480,7 +480,7 @@ create_attrs_2(void)
* Create all(user specifies the number) attributes for each new dataset
*/
for(i = 0; i < NUM_DSETS; i++) {
sprintf(dset_name, "dataset %d", i);
HDsprintf(dset_name, "dataset %d", i);
create_t.start = retrieve_time();
if((dataset = H5Dcreate2(file, dset_name, H5T_NATIVE_DOUBLE,
space, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
@ -488,7 +488,7 @@ create_attrs_2(void)
perf(&create_t, create_t.start, retrieve_time());
for(j = 0; j < NUM_ATTRS; j++) {
sprintf(attr_name, "all attrs for each dset %d", j);
HDsprintf(attr_name, "all attrs for each dset %d", j);
attr_t.start = retrieve_time();
if((attr = H5Acreate2(dataset, attr_name, H5T_NATIVE_DOUBLE,
small_space, H5P_DEFAULT, H5P_DEFAULT)) < 0)
@ -525,7 +525,7 @@ create_attrs_2(void)
attr_t.avg = attr_t.total / (NUM_ATTRS*NUM_DSETS);
/* Print out the performance result */
fprintf(stderr, "2. Create %d attributes for each of %d new datasets\n",
HDfprintf(stderr, "2. Create %d attributes for each of %d new datasets\n",
NUM_ATTRS, NUM_DSETS);
print_perf(create_t, close_t, attr_t);
}
@ -593,14 +593,14 @@ create_attrs_3(void)
for(i = 0; i < loop_num; i++) {
for(j = 0; j < NUM_DSETS; j++) {
sprintf(dset_name, "dataset %d", j);
HDsprintf(dset_name, "dataset %d", j);
open_t.start = retrieve_time();
if((dataset = H5Dopen2(file, dset_name, H5P_DEFAULT)) < 0)
goto error;
perf(&open_t, open_t.start, retrieve_time());
for(k = 0; k < BATCH_ATTRS; k++) {
sprintf(attr_name, "some attrs for each dset %d %d", i, k);
HDsprintf(attr_name, "some attrs for each dset %d %d", i, k);
attr_t.start = retrieve_time();
if((attr = H5Acreate2(dataset, attr_name, H5T_NATIVE_DOUBLE,
small_space, H5P_DEFAULT, H5P_DEFAULT)) < 0)
@ -637,7 +637,7 @@ create_attrs_3(void)
attr_t.avg = attr_t.total / (NUM_ATTRS*NUM_DSETS);
/* Print out the performance result */
fprintf(stderr, "3. Create %d attributes for each of %d existing datasets for %d times\n",
HDfprintf(stderr, "3. Create %d attributes for each of %d existing datasets for %d times\n",
BATCH_ATTRS, NUM_DSETS, loop_num);
print_perf(open_t, close_t, attr_t);
}
@ -750,12 +750,12 @@ void perf(p_time *perf_t, double start_t, double end_t)
*/
void print_perf(p_time open_t, p_time close_t, p_time attr_t)
{
fprintf(stderr, "\t%s:\t\tavg=%.6fs;\tmax=%.6fs;\tmin=%.6fs\n",
HDfprintf(stderr, "\t%s:\t\tavg=%.6fs;\tmax=%.6fs;\tmin=%.6fs\n",
open_t.func, open_t.avg, open_t.max, open_t.min);
fprintf(stderr, "\tH5Dclose:\t\tavg=%.6fs;\tmax=%.6fs;\tmin=%.6fs\n",
HDfprintf(stderr, "\tH5Dclose:\t\tavg=%.6fs;\tmax=%.6fs;\tmin=%.6fs\n",
close_t.avg, close_t.max, close_t.min);
if(NUM_ATTRS)
fprintf(stderr, "\tH5A(create & close):\tavg=%.6fs;\tmax=%.6fs;\tmin=%.6fs\n",
HDfprintf(stderr, "\tH5A(create & close):\tavg=%.6fs;\tmax=%.6fs;\tmin=%.6fs\n",
attr_t.avg, attr_t.max, attr_t.min);
}
@ -799,7 +799,7 @@ main(int argc, char **argv)
#ifdef H5_HAVE_PARALLEL
if (facc_type == FACC_DEFAULT || (facc_type != FACC_DEFAULT && MAINPROCESS))
#endif /*H5_HAVE_PARALLEL*/
fprintf(stderr, "\t\tPerformance result of metadata for datasets and attributes\n\n");
HDfprintf(stderr, "\t\tPerformance result of metadata for datasets and attributes\n\n");
fapl = H5Pcreate (H5P_FILE_ACCESS);
#ifdef H5_HAVE_PARALLEL

90
tools/test/perform/pio_engine.c

@ -61,14 +61,14 @@
#define GOTOERROR(errcode) { ret_code = errcode; goto done; }
#define GOTODONE { goto done; }
#define ERRMSG(mesg) { \
fprintf(stderr, "Proc %d: ", pio_mpi_rank_g); \
fprintf(stderr, "*** Assertion failed (%s) at line %4d in %s\n", \
HDfprintf(stderr, "Proc %d: ", pio_mpi_rank_g); \
HDfprintf(stderr, "*** Assertion failed (%s) at line %4d in %s\n", \
mesg, (int)__LINE__, __FILE__); \
}
#define MSG(mesg) { \
fprintf(stderr, "Proc %d: ", pio_mpi_rank_g); \
fprintf(stderr, "(%s) at line %4d in %s\n", \
HDfprintf(stderr, "Proc %d: ", pio_mpi_rank_g); \
HDfprintf(stderr, "(%s) at line %4d in %s\n", \
mesg, (int)__LINE__, __FILE__); \
}
@ -194,7 +194,7 @@ do_pio(parameters param)
break;
default:
/* unknown request */
fprintf(stderr, "Unknown IO type request (%d)\n", iot);
HDfprintf(stderr, "Unknown IO type request (%d)\n", iot);
GOTOERROR(FAIL);
}
@ -213,21 +213,21 @@ do_pio(parameters param)
}
if (param.num_files < 0 ) {
fprintf(stderr,
HDfprintf(stderr,
"number of files must be >= 0 (%ld)\n",
param.num_files);
GOTOERROR(FAIL);
}
if (ndsets < 0 ) {
fprintf(stderr,
HDfprintf(stderr,
"number of datasets per file must be >= 0 (%ld)\n",
ndsets);
GOTOERROR(FAIL);
}
if (param.num_procs <= 0 ) {
fprintf(stderr,
HDfprintf(stderr,
"maximum number of process to use must be > 0 (%d)\n",
param.num_procs);
GOTOERROR(FAIL);
@ -292,7 +292,7 @@ do_pio(parameters param)
/* output all of the times for all iterations */
if (myrank == 0)
fprintf(output, "Timer details:\n");
HDfprintf(output, "Timer details:\n");
}
for (nf = 1; nf <= param.num_files; nf++) {
@ -302,7 +302,7 @@ do_pio(parameters param)
/* Open file for write */
char base_name[256];
sprintf(base_name, "#pio_tmp_%lu", nf);
HDsprintf(base_name, "#pio_tmp_%lu", nf);
pio_create_filename(iot, base_name, fname, sizeof(fname));
if (pio_debug_level > 0)
HDfprintf(output, "rank %d: data filename=%s\n",
@ -385,7 +385,7 @@ done:
/* release generic resources */
if(buffer)
free(buffer);
HDfree(buffer);
res.ret_code = ret_code;
return res;
}
@ -620,7 +620,7 @@ do_write(results *res, file_descr *fd, parameters *parms, long ndsets,
/* Prepare buffer for verifying data */
if (parms->verify)
memset(buffer,pio_mpi_rank_g+1,buf_size*blk_size);
HDmemset(buffer,pio_mpi_rank_g+1,buf_size*blk_size);
} /* end else */
@ -853,7 +853,7 @@ do_write(results *res, file_descr *fd, parameters *parms, long ndsets,
/* Create the dataset transfer property list */
h5dxpl = H5Pcreate(H5P_DATASET_XFER);
if (h5dxpl < 0) {
fprintf(stderr, "HDF5 Property List Create failed\n");
HDfprintf(stderr, "HDF5 Property List Create failed\n");
GOTOERROR(FAIL);
}
@ -861,7 +861,7 @@ do_write(results *res, file_descr *fd, parameters *parms, long ndsets,
if(parms->collective) {
hrc = H5Pset_dxpl_mpio(h5dxpl, H5FD_MPIO_COLLECTIVE);
if (hrc < 0) {
fprintf(stderr, "HDF5 Property List Set failed\n");
HDfprintf(stderr, "HDF5 Property List Set failed\n");
GOTOERROR(FAIL);
} /* end if */
} /* end if */
@ -883,7 +883,7 @@ do_write(results *res, file_descr *fd, parameters *parms, long ndsets,
case PHDF5:
h5dcpl = H5Pcreate(H5P_DATASET_CREATE);
if (h5dcpl < 0) {
fprintf(stderr, "HDF5 Property List Create failed\n");
HDfprintf(stderr, "HDF5 Property List Create failed\n");
GOTOERROR(FAIL);
}
/* 1D dataspace */
@ -894,7 +894,7 @@ do_write(results *res, file_descr *fd, parameters *parms, long ndsets,
h5dims[0] = blk_size;
hrc = H5Pset_chunk(h5dcpl, 1, h5dims);
if (hrc < 0) {
fprintf(stderr, "HDF5 Property List Set failed\n");
HDfprintf(stderr, "HDF5 Property List Set failed\n");
GOTOERROR(FAIL);
} /* end if */
} /* end if */
@ -907,25 +907,25 @@ do_write(results *res, file_descr *fd, parameters *parms, long ndsets,
h5dims[1] = blk_size;
hrc = H5Pset_chunk(h5dcpl, 2, h5dims);
if (hrc < 0) {
fprintf(stderr, "HDF5 Property List Set failed\n");
HDfprintf(stderr, "HDF5 Property List Set failed\n");
GOTOERROR(FAIL);
} /* end if */
} /* end if */
}/* end else */
sprintf(dname, "Dataset_%ld", ndset);
HDsprintf(dname, "Dataset_%ld", ndset);
h5ds_id = H5DCREATE(fd->h5fd, dname, ELMT_H5_TYPE,
h5dset_space_id, h5dcpl);
if (h5ds_id < 0) {
fprintf(stderr, "HDF5 Dataset Create failed\n");
HDfprintf(stderr, "HDF5 Dataset Create failed\n");
GOTOERROR(FAIL);
}
hrc = H5Pclose(h5dcpl);
/* verifying the close of the dcpl */
if (hrc < 0) {
fprintf(stderr, "HDF5 Property List Close failed\n");
HDfprintf(stderr, "HDF5 Property List Close failed\n");
GOTOERROR(FAIL);
}
break;
@ -1398,7 +1398,7 @@ do_write(results *res, file_descr *fd, parameters *parms, long ndsets,
hrc = H5Dclose(h5ds_id);
if (hrc < 0) {
fprintf(stderr, "HDF5 Dataset Close failed\n");
HDfprintf(stderr, "HDF5 Dataset Close failed\n");
GOTOERROR(FAIL);
}
@ -1455,7 +1455,7 @@ done:
if (h5dset_space_id != -1) {
hrc = H5Sclose(h5dset_space_id);
if (hrc < 0){
fprintf(stderr, "HDF5 Dataset Space Close failed\n");
HDfprintf(stderr, "HDF5 Dataset Space Close failed\n");
ret_code = FAIL;
} else {
h5dset_space_id = -1;
@ -1465,7 +1465,7 @@ done:
if (h5mem_space_id != -1) {
hrc = H5Sclose(h5mem_space_id);
if (hrc < 0) {
fprintf(stderr, "HDF5 Memory Space Close failed\n");
HDfprintf(stderr, "HDF5 Memory Space Close failed\n");
ret_code = FAIL;
} else {
h5mem_space_id = -1;
@ -1475,7 +1475,7 @@ done:
if (h5dxpl != -1) {
hrc = H5Pclose(h5dxpl);
if (hrc < 0) {
fprintf(stderr, "HDF5 Dataset Transfer Property List Close failed\n");
HDfprintf(stderr, "HDF5 Dataset Transfer Property List Close failed\n");
ret_code = FAIL;
} else {
h5dxpl = -1;
@ -1824,7 +1824,7 @@ do_read(results *res, file_descr *fd, parameters *parms, long ndsets,
/* Create the dataset transfer property list */
h5dxpl = H5Pcreate(H5P_DATASET_XFER);
if (h5dxpl < 0) {
fprintf(stderr, "HDF5 Property List Create failed\n");
HDfprintf(stderr, "HDF5 Property List Create failed\n");
GOTOERROR(FAIL);
}
@ -1832,7 +1832,7 @@ do_read(results *res, file_descr *fd, parameters *parms, long ndsets,
if(parms->collective) {
hrc = H5Pset_dxpl_mpio(h5dxpl, H5FD_MPIO_COLLECTIVE);
if (hrc < 0) {
fprintf(stderr, "HDF5 Property List Set failed\n");
HDfprintf(stderr, "HDF5 Property List Set failed\n");
GOTOERROR(FAIL);
} /* end if */
} /* end if */
@ -1852,10 +1852,10 @@ do_read(results *res, file_descr *fd, parameters *parms, long ndsets,
break;
case PHDF5:
sprintf(dname, "Dataset_%ld", ndset);
HDsprintf(dname, "Dataset_%ld", ndset);
h5ds_id = H5DOPEN(fd->h5fd, dname);
if (h5ds_id < 0) {
fprintf(stderr, "HDF5 Dataset open failed\n");
HDfprintf(stderr, "HDF5 Dataset open failed\n");
GOTOERROR(FAIL);
}
@ -2353,7 +2353,7 @@ do_read(results *res, file_descr *fd, parameters *parms, long ndsets,
hrc = H5Dclose(h5ds_id);
if (hrc < 0) {
fprintf(stderr, "HDF5 Dataset Close failed\n");
HDfprintf(stderr, "HDF5 Dataset Close failed\n");
GOTOERROR(FAIL);
}
@ -2410,7 +2410,7 @@ done:
if (h5dset_space_id != -1) {
hrc = H5Sclose(h5dset_space_id);
if (hrc < 0){
fprintf(stderr, "HDF5 Dataset Space Close failed\n");
HDfprintf(stderr, "HDF5 Dataset Space Close failed\n");
ret_code = FAIL;
} else {
h5dset_space_id = -1;
@ -2420,7 +2420,7 @@ done:
if (h5mem_space_id != -1) {
hrc = H5Sclose(h5mem_space_id);
if (hrc < 0) {
fprintf(stderr, "HDF5 Memory Space Close failed\n");
HDfprintf(stderr, "HDF5 Memory Space Close failed\n");
ret_code = FAIL;
} else {
h5mem_space_id = -1;
@ -2430,7 +2430,7 @@ done:
if (h5dxpl != -1) {
hrc = H5Pclose(h5dxpl);
if (hrc < 0) {
fprintf(stderr, "HDF5 Dataset Transfer Property List Close failed\n");
HDfprintf(stderr, "HDF5 Dataset Transfer Property List Close failed\n");
ret_code = FAIL;
} else {
h5dxpl = -1;
@ -2461,7 +2461,7 @@ do_fopen(parameters *param, char *fname, file_descr *fd /*out*/, int flags)
fd->posixfd = POSIXOPEN(fname, O_RDONLY);
if (fd->posixfd < 0 ) {
fprintf(stderr, "POSIX File Open failed(%s)\n", fname);
HDfprintf(stderr, "POSIX File Open failed(%s)\n", fname);
GOTOERROR(FAIL);
}
@ -2485,7 +2485,7 @@ do_fopen(parameters *param, char *fname, file_descr *fd /*out*/, int flags)
h5_io_info_g, &fd->mpifd);
if (mrc != MPI_SUCCESS) {
fprintf(stderr, "MPI File Open failed(%s)\n", fname);
HDfprintf(stderr, "MPI File Open failed(%s)\n", fname);
GOTOERROR(FAIL);
}
@ -2493,13 +2493,13 @@ do_fopen(parameters *param, char *fname, file_descr *fd /*out*/, int flags)
/*filesize , set size to 0 explicitedly. */
mrc = MPI_File_set_size(fd->mpifd, (MPI_Offset)0);
if (mrc != MPI_SUCCESS) {
fprintf(stderr, "MPI_File_set_size failed\n");
HDfprintf(stderr, "MPI_File_set_size failed\n");
GOTOERROR(FAIL);
}
} else {
mrc = MPI_File_open(pio_comm_g, fname, MPI_MODE_RDONLY, h5_io_info_g, &fd->mpifd);
if (mrc != MPI_SUCCESS) {
fprintf(stderr, "MPI File Open failed(%s)\n", fname);
HDfprintf(stderr, "MPI File Open failed(%s)\n", fname);
GOTOERROR(FAIL);
}
}
@ -2508,19 +2508,19 @@ do_fopen(parameters *param, char *fname, file_descr *fd /*out*/, int flags)
case PHDF5:
if ((acc_tpl = H5Pcreate(H5P_FILE_ACCESS)) < 0) {
fprintf(stderr, "HDF5 Property List Create failed\n");
HDfprintf(stderr, "HDF5 Property List Create failed\n");
GOTOERROR(FAIL);
}
/* Set the file driver to the MPI-IO driver */
if (H5Pset_fapl_mpio(acc_tpl, pio_comm_g, h5_io_info_g) < 0) {
fprintf(stderr, "HDF5 Property List Set failed\n");
HDfprintf(stderr, "HDF5 Property List Set failed\n");
GOTOERROR(FAIL);
}
/* Set the alignment of objects in HDF5 file */
if (H5Pset_alignment(acc_tpl, param->h5_thresh, param->h5_align) < 0) {
fprintf(stderr, "HDF5 Property List Set failed\n");
HDfprintf(stderr, "HDF5 Property List Set failed\n");
GOTOERROR(FAIL);
}
@ -2530,13 +2530,13 @@ do_fopen(parameters *param, char *fname, file_descr *fd /*out*/, int flags)
else
fd->h5fd = H5Fopen(fname, H5F_ACC_RDONLY, acc_tpl);
if (fd->h5fd < 0) {
fprintf(stderr, "HDF5 File Create failed(%s)\n", fname);
HDfprintf(stderr, "HDF5 File Create failed(%s)\n", fname);
GOTOERROR(FAIL);
}
/* verifying the close of the acc_tpl */
if (H5Pclose(acc_tpl) < 0) {
fprintf(stderr, "HDF5 Property List Close failed\n");
HDfprintf(stderr, "HDF5 Property List Close failed\n");
GOTOERROR(FAIL);
}
@ -2565,7 +2565,7 @@ do_fclose(iotype iot, file_descr *fd /*out*/)
rc = POSIXCLOSE(fd->posixfd);
if (rc != 0){
fprintf(stderr, "POSIX File Close failed\n");
HDfprintf(stderr, "POSIX File Close failed\n");
GOTOERROR(FAIL);
}
@ -2576,7 +2576,7 @@ do_fclose(iotype iot, file_descr *fd /*out*/)
mrc = MPI_File_close(&fd->mpifd);
if (mrc != MPI_SUCCESS){
fprintf(stderr, "MPI File close failed\n");
HDfprintf(stderr, "MPI File close failed\n");
GOTOERROR(FAIL);
}
@ -2587,7 +2587,7 @@ do_fclose(iotype iot, file_descr *fd /*out*/)
hrc = H5Fclose(fd->h5fd);
if (hrc < 0) {
fprintf(stderr, "HDF5 File Close failed\n");
HDfprintf(stderr, "HDF5 File Close failed\n");
GOTOERROR(FAIL);
}
@ -2621,7 +2621,7 @@ do_cleanupfile(iotype iot, char *fname)
if (clean_file_g){
switch (iot){
case POSIXIO:
remove(fname);
HDremove(fname);
break;
case MPIO:
case PHDF5:

320
tools/test/perform/pio_perf.c

@ -277,13 +277,13 @@ struct options {
unsigned interleaved; /* Interleaved vs. contiguous blocks */
unsigned collective; /* Collective vs. independent I/O */
unsigned dim2d; /* 1D vs. 2D geometry */
int print_times; /* print times as well as throughputs */
int print_raw; /* print raw data throughput info */
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 */
int h5_use_chunks; /* Make HDF5 dataset chunked */
int h5_write_only; /* Perform the write tests only */
int verify; /* Verify data correctness */
int h5_use_chunks; /* Make HDF5 dataset chunked */
int h5_write_only; /* Perform the write tests only */
int verify; /* Verify data correctness */
};
typedef struct _minmax {
@ -339,12 +339,12 @@ main(int argc, char **argv)
ret = MPI_Comm_size(MPI_COMM_WORLD, &comm_world_nprocs_g);
if (ret != MPI_SUCCESS) {
fprintf(stderr, "%s: MPI_Comm_size call failed\n", progname);
HDfprintf(stderr, "%s: MPI_Comm_size call failed\n", progname);
if (ret == MPI_ERR_COMM)
fprintf(stderr, "invalid MPI communicator\n");
HDfprintf(stderr, "invalid MPI communicator\n");
else
fprintf(stderr, "invalid argument\n");
HDfprintf(stderr, "invalid argument\n");
exit_value = EXIT_FAILURE;
goto finish;
@ -353,12 +353,12 @@ main(int argc, char **argv)
ret = MPI_Comm_rank(MPI_COMM_WORLD, &comm_world_rank_g);
if (ret != MPI_SUCCESS) {
fprintf(stderr, "%s: MPI_Comm_rank call failed\n", progname);
HDfprintf(stderr, "%s: MPI_Comm_rank call failed\n", progname);
if (ret == MPI_ERR_COMM)
fprintf(stderr, "invalid MPI communicator\n");
HDfprintf(stderr, "invalid MPI communicator\n");
else
fprintf(stderr, "invalid argument\n");
HDfprintf(stderr, "invalid argument\n");
exit_value = EXIT_FAILURE;
goto finish;
@ -376,7 +376,7 @@ main(int argc, char **argv)
if (opts->output_file) {
if ((output = HDfopen(opts->output_file, "w")) == NULL) {
fprintf(stderr, "%s: cannot open output file\n", progname);
HDfprintf(stderr, "%s: cannot open output file\n", progname);
perror(opts->output_file);
goto finish;
}
@ -667,7 +667,7 @@ run_test(iotype iot, parameters parms, struct options *opts)
/*
* Show various statistics
*/
/* Write statistics */
/* Write statistics */
/* Print the raw data throughput if desired */
if (opts->print_raw) {
/* accumulate and output the max, min, and average "raw write" times */
@ -733,7 +733,7 @@ run_test(iotype iot, parameters parms, struct options *opts)
}
if (!parms.h5_write_only) {
/* Read statistics */
/* Read statistics */
/* Print the raw data throughput if desired */
if (opts->print_raw) {
/* accumulate and output the max, min, and average "raw read" times */
@ -925,7 +925,7 @@ create_comm_world(int num_procs, int *doing_pio)
MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
if (num_procs > nprocs) {
fprintf(stderr,
HDfprintf(stderr,
"number of process(%d) must be <= number of processes in MPI_COMM_WORLD(%d)\n",
num_procs, nprocs);
goto error_done;
@ -936,7 +936,7 @@ create_comm_world(int num_procs, int *doing_pio)
mrc = MPI_Comm_split(MPI_COMM_WORLD, color, myrank, &pio_comm_g);
if (mrc != MPI_SUCCESS) {
fprintf(stderr, "MPI_Comm_split failed\n");
HDfprintf(stderr, "MPI_Comm_split failed\n");
goto error_done;
}
@ -1065,9 +1065,9 @@ output_report(const char *fmt, ...)
if (myrank == 0) {
va_list ap;
va_start(ap, fmt);
vfprintf(output, fmt, ap);
va_end(ap);
HDva_start(ap, fmt);
HDvfprintf(output, fmt, ap);
HDva_end(ap);
}
}
@ -1087,10 +1087,10 @@ print_indent(register int indent)
MPI_Comm_rank(pio_comm_g, &myrank);
if (myrank == 0) {
indent *= TAB_SPACE;
indent *= TAB_SPACE;
for (; indent > 0; --indent)
fputc(' ', output);
for (; indent > 0; --indent)
HDfputc(' ', output);
}
}
@ -1115,11 +1115,11 @@ static void
print_io_api(long io_types)
{
if (io_types & PIO_POSIX)
HDfprintf(output, "posix ");
HDfprintf(output, "posix ");
if (io_types & PIO_MPI)
HDfprintf(output, "mpiio ");
HDfprintf(output, "mpiio ");
if (io_types & PIO_HDF5)
HDfprintf(output, "phdf5 ");
HDfprintf(output, "phdf5 ");
HDfprintf(output, "\n");
}
@ -1128,7 +1128,7 @@ report_parameters(struct options *opts)
{
int rank = comm_world_rank_g;
print_version("HDF5 Library"); /* print library version */
print_version("HDF5 Library"); /* print library version */
HDfprintf(output, "rank %d: ==== Parameters ====\n", rank);
HDfprintf(output, "rank %d: IO API=", rank);
@ -1303,9 +1303,9 @@ parse_command_line(int argc, char *argv[])
} else if (!HDstrcasecmp(buf, "posix")) {
cl_opts->io_types |= PIO_POSIX;
} else {
fprintf(stderr, "pio_perf: invalid --api option %s\n",
HDfprintf(stderr, "pio_perf: invalid --api option %s\n",
buf);
exit(EXIT_FAILURE);
HDexit(EXIT_FAILURE);
}
if (*end == '\0')
@ -1345,17 +1345,17 @@ parse_command_line(int argc, char *argv[])
HDmemset(buf, '\0', sizeof(buf));
for (i = 0; *end != '\0' && *end != ','; ++end)
if (isalnum(*end) && i < 10)
if (HDisalnum(*end) && i < 10)
buf[i++] = *end;
if (strlen(buf) > 1 || isdigit(buf[0])) {
if (HDstrlen(buf) > 1 || HDisdigit(buf[0])) {
size_t j;
for (j = 0; j < 10 && buf[j] != '\0'; ++j)
if (!isdigit(buf[j])) {
fprintf(stderr, "pio_perf: invalid --debug option %s\n",
HDfprintf(stderr, "pio_perf: invalid --debug option %s\n",
buf);
exit(EXIT_FAILURE);
HDexit(EXIT_FAILURE);
}
pio_debug_level = atoi(buf);
@ -1379,8 +1379,8 @@ parse_command_line(int argc, char *argv[])
cl_opts->verify = TRUE;
break;
default:
fprintf(stderr, "pio_perf: invalid --debug option %s\n", buf);
exit(EXIT_FAILURE);
HDfprintf(stderr, "pio_perf: invalid --debug option %s\n", buf);
HDexit(EXIT_FAILURE);
}
}
@ -1396,13 +1396,13 @@ parse_command_line(int argc, char *argv[])
cl_opts->num_bpp = parse_size_directive(opt_arg);
break;
case 'F':
cl_opts->num_files = atoi(opt_arg);
cl_opts->num_files = HDatoi(opt_arg);
break;
case 'g':
cl_opts->dim2d = 1;
break;
case 'i':
cl_opts->num_iters = atoi(opt_arg);
cl_opts->num_iters = HDatoi(opt_arg);
break;
case 'I':
cl_opts->interleaved = 1;
@ -1411,10 +1411,10 @@ parse_command_line(int argc, char *argv[])
cl_opts->output_file = opt_arg;
break;
case 'p':
cl_opts->min_num_procs = atoi(opt_arg);
cl_opts->min_num_procs = HDatoi(opt_arg);
break;
case 'P':
cl_opts->max_num_procs = atoi(opt_arg);
cl_opts->max_num_procs = HDatoi(opt_arg);
break;
case 'T':
cl_opts->h5_threshold = parse_size_directive(opt_arg);
@ -1432,7 +1432,7 @@ parse_command_line(int argc, char *argv[])
case '?':
default:
usage(progname);
free(cl_opts);
HDfree(cl_opts);
return NULL;
}
}
@ -1526,8 +1526,8 @@ parse_size_directive(const char *size)
s *= ONE_GB;
break;
default:
fprintf(stderr, "Illegal size specifier '%c'\n", *endptr);
exit(EXIT_FAILURE);
HDfprintf(stderr, "Illegal size specifier '%c'\n", *endptr);
HDexit(EXIT_FAILURE);
}
}
@ -1540,7 +1540,7 @@ parse_size_directive(const char *size)
* Return: Nothing
* Programmer: Bill Wendling, 31. October 2001
* Modifications:
* Added 2D testing (Christian Chilan, 10. August 2005)
* Added 2D testing (Christian Chilan, 10. August 2005)
*/
static void
usage(const char *prog)
@ -1550,125 +1550,125 @@ usage(const char *prog)
MPI_Comm_rank(pio_comm_g, &myrank);
if (myrank == 0) {
print_version(prog);
printf("usage: %s [OPTIONS]\n", prog);
printf(" OPTIONS\n");
printf(" -h, --help Print a usage message and exit\n");
printf(" -a S, --align=S Alignment of objects in HDF5 file [default: 1]\n");
printf(" -A AL, --api=AL Which APIs to test [default: all of them]\n");
print_version(prog);
HDprintf("usage: %s [OPTIONS]\n", prog);
HDprintf(" OPTIONS\n");
HDprintf(" -h, --help Print a usage message and exit\n");
HDprintf(" -a S, --align=S Alignment of objects in HDF5 file [default: 1]\n");
HDprintf(" -A AL, --api=AL Which APIs to test [default: all of them]\n");
#if 0
printf(" -b, --binary The elusive binary option\n");
HDprintf(" -b, --binary The elusive binary option\n");
#endif /* 0 */
printf(" -B S, --block-size=S Block size within transfer buffer\n");
printf(" (see below for description)\n");
printf(" [default: half the number of bytes per process\n");
printf(" per dataset]\n");
printf(" -c, --chunk Create HDF5 datasets using chunked storage\n");
printf(" [default: contiguous storage]\n");
printf(" -C, --collective Use collective I/O for MPI and HDF5 APIs\n");
printf(" [default: independent I/O)\n");
printf(" -d N, --num-dsets=N Number of datasets per file [default: 1]\n");
printf(" -D DL, --debug=DL Indicate the debugging level\n");
printf(" [default: no debugging]\n");
printf(" -e S, --num-bytes=S Number of bytes per process per dataset\n");
printf(" (see below for description)\n");
printf(" [default: 256K for 1D, 8K for 2D]\n");
printf(" -F N, --num-files=N Number of files [default: 1]\n");
printf(" -g, --geometry Use 2D geometry [default: 1D geometry]\n");
printf(" -i N, --num-iterations=N Number of iterations to perform [default: 1]\n");
printf(" -I, --interleaved Interleaved access pattern\n");
printf(" (see below for example)\n");
printf(" [default: Contiguous access pattern]\n");
printf(" -o F, --output=F Output raw data into file F [default: none]\n");
printf(" -p N, --min-num-processes=N Minimum number of processes to use [default: 1]\n");
printf(" -P N, --max-num-processes=N Maximum number of processes to use\n");
printf(" [default: all MPI_COMM_WORLD processes ]\n");
printf(" -T S, --threshold=S Threshold for alignment of objects in HDF5 file\n");
printf(" [default: 1]\n");
printf(" -w, --write-only Perform write tests not the read tests\n");
printf(" -x S, --min-xfer-size=S Minimum transfer buffer size\n");
printf(" (see below for description)\n");
printf(" [default: half the number of bytes per process\n");
printf(" per dataset]\n");
printf(" -X S, --max-xfer-size=S Maximum transfer buffer size\n");
printf(" [default: the number of bytes per process per\n");
printf(" dataset]\n");
printf("\n");
printf(" F - is a filename.\n");
printf(" N - is an integer >=0.\n");
printf(" S - is a size specifier, an integer >=0 followed by a size indicator:\n");
printf(" K - Kilobyte (%d)\n", ONE_KB);
printf(" M - Megabyte (%d)\n", ONE_MB);
printf(" G - Gigabyte (%d)\n", ONE_GB);
printf("\n");
printf(" Example: '37M' is 37 megabytes or %d bytes\n", 37*ONE_MB);
printf("\n");
printf(" AL - is an API list. Valid values are:\n");
printf(" phdf5 - Parallel HDF5\n");
printf(" mpiio - MPI-I/O\n");
printf(" posix - POSIX\n");
printf("\n");
printf(" Example: --api=mpiio,phdf5\n");
printf("\n");
printf(" Dataset size:\n");
printf(" Depending on the selected geometry, each test dataset is either a linear\n");
printf(" array of size bytes-per-process * num-processes, or a square array of size\n");
printf(" (bytes-per-process * num-processes) x (bytes-per-process * num-processes).\n");
printf("\n");
printf(" Block size vs. Transfer buffer size:\n");
printf(" buffer-size controls the size of the memory buffer, which is broken into\n");
printf(" blocks and written to the file. Depending on the selected geometry, each\n");
printf(" block can be a linear array of size block-size or a square array of size\n");
printf(" block-size x block-size. The arrangement in which blocks are written is\n");
printf(" determined by the access pattern.\n");
printf("\n");
printf(" In 1D geometry, the transfer buffer is a linear array of size buffer-size.\n");
printf(" In 2D geometry, it is a rectangular array of size block-size x buffer-size\n");
printf(" or buffer-size x block-size if interleaved pattern is selected.\n");
printf("\n");
printf(" Interleaved and Contiguous patterns in 1D geometry:\n");
printf(" When contiguous access pattern is chosen, the dataset is evenly divided\n");
printf(" into num-processes regions and each process writes data to its own region.\n");
printf(" When interleaved blocks are written to a dataset, space for the first\n");
printf(" block of the first process is allocated in the dataset, then space is\n");
printf(" allocated for the first block of the second process, etc. until space is\n");
printf(" allocated for the first block of each process, then space is allocated for\n");
printf(" the second block of the first process, the second block of the second\n");
printf(" process, etc.\n");
printf("\n");
printf(" For example, with a 3 process run, 512KB bytes-per-process, 256KB transfer\n");
printf(" buffer size, and 64KB block size, each process must issue 2 transfer\n");
printf(" requests to complete access to the dataset.\n");
printf(" Contiguous blocks of the first transfer request are written like so:\n");
printf(" 1111----2222----3333----\n");
printf(" Interleaved blocks of the first transfer request are written like so:\n");
printf(" 123123123123------------\n");
printf(" The actual number of I/O operations involved in a transfer request\n");
printf(" depends on the access pattern and communication mode.\n");
printf(" When using independent I/O with interleaved pattern, each process\n");
printf(" performs 4 small non-contiguous I/O operations per transfer request.\n");
printf(" If collective I/O is turned on, the combined content of the buffers of\n");
printf(" the 3 processes will be written using one collective I/O operation\n");
printf(" per transfer request.\n");
printf("\n");
printf(" For information about access patterns in 2D geometry, please refer to the\n");
printf(" HDF5 Reference Manual.\n");
printf("\n");
printf(" DL - is a list of debugging flags. Valid values are:\n");
printf(" 1 - Minimal\n");
printf(" 2 - Not quite everything\n");
printf(" 3 - Everything\n");
printf(" 4 - The kitchen sink\n");
printf(" r - Raw data I/O throughput information\n");
printf(" t - Times as well as throughputs\n");
printf(" v - Verify data correctness\n");
printf("\n");
printf(" Example: --debug=2,r,t\n");
printf("\n");
printf(" Environment variables:\n");
printf(" HDF5_NOCLEANUP Do not remove data files if set [default remove]\n");
printf(" HDF5_MPI_INFO MPI INFO object key=value separated by ;\n");
printf(" HDF5_PARAPREFIX Paralllel data files prefix\n");
HDprintf(" -B S, --block-size=S Block size within transfer buffer\n");
HDprintf(" (see below for description)\n");
HDprintf(" [default: half the number of bytes per process\n");
HDprintf(" per dataset]\n");
HDprintf(" -c, --chunk Create HDF5 datasets using chunked storage\n");
HDprintf(" [default: contiguous storage]\n");
HDprintf(" -C, --collective Use collective I/O for MPI and HDF5 APIs\n");
HDprintf(" [default: independent I/O)\n");
HDprintf(" -d N, --num-dsets=N Number of datasets per file [default: 1]\n");
HDprintf(" -D DL, --debug=DL Indicate the debugging level\n");
HDprintf(" [default: no debugging]\n");
HDprintf(" -e S, --num-bytes=S Number of bytes per process per dataset\n");
HDprintf(" (see below for description)\n");
HDprintf(" [default: 256K for 1D, 8K for 2D]\n");
HDprintf(" -F N, --num-files=N Number of files [default: 1]\n");
HDprintf(" -g, --geometry Use 2D geometry [default: 1D geometry]\n");
HDprintf(" -i N, --num-iterations=N Number of iterations to perform [default: 1]\n");
HDprintf(" -I, --interleaved Interleaved access pattern\n");
HDprintf(" (see below for example)\n");
HDprintf(" [default: Contiguous access pattern]\n");
HDprintf(" -o F, --output=F Output raw data into file F [default: none]\n");
HDprintf(" -p N, --min-num-processes=N Minimum number of processes to use [default: 1]\n");
HDprintf(" -P N, --max-num-processes=N Maximum number of processes to use\n");
HDprintf(" [default: all MPI_COMM_WORLD processes ]\n");
HDprintf(" -T S, --threshold=S Threshold for alignment of objects in HDF5 file\n");
HDprintf(" [default: 1]\n");
HDprintf(" -w, --write-only Perform write tests not the read tests\n");
HDprintf(" -x S, --min-xfer-size=S Minimum transfer buffer size\n");
HDprintf(" (see below for description)\n");
HDprintf(" [default: half the number of bytes per process\n");
HDprintf(" per dataset]\n");
HDprintf(" -X S, --max-xfer-size=S Maximum transfer buffer size\n");
HDprintf(" [default: the number of bytes per process per\n");
HDprintf(" dataset]\n");
HDprintf("\n");
HDprintf(" F - is a filename.\n");
HDprintf(" N - is an integer >=0.\n");
HDprintf(" S - is a size specifier, an integer >=0 followed by a size indicator:\n");
HDprintf(" K - Kilobyte (%d)\n", ONE_KB);
HDprintf(" M - Megabyte (%d)\n", ONE_MB);
HDprintf(" G - Gigabyte (%d)\n", ONE_GB);
HDprintf("\n");
HDprintf(" Example: '37M' is 37 megabytes or %d bytes\n", 37*ONE_MB);
HDprintf("\n");
HDprintf(" AL - is an API list. Valid values are:\n");
HDprintf(" phdf5 - Parallel HDF5\n");
HDprintf(" mpiio - MPI-I/O\n");
HDprintf(" posix - POSIX\n");
HDprintf("\n");
HDprintf(" Example: --api=mpiio,phdf5\n");
HDprintf("\n");
HDprintf(" Dataset size:\n");
HDprintf(" Depending on the selected geometry, each test dataset is either a linear\n");
HDprintf(" array of size bytes-per-process * num-processes, or a square array of size\n");
HDprintf(" (bytes-per-process * num-processes) x (bytes-per-process * num-processes).\n");
HDprintf("\n");
HDprintf(" Block size vs. Transfer buffer size:\n");
HDprintf(" buffer-size controls the size of the memory buffer, which is broken into\n");
HDprintf(" blocks and written to the file. Depending on the selected geometry, each\n");
HDprintf(" block can be a linear array of size block-size or a square array of size\n");
HDprintf(" block-size x block-size. The arrangement in which blocks are written is\n");
HDprintf(" determined by the access pattern.\n");
HDprintf("\n");
HDprintf(" In 1D geometry, the transfer buffer is a linear array of size buffer-size.\n");
HDprintf(" In 2D geometry, it is a rectangular array of size block-size x buffer-size\n");
HDprintf(" or buffer-size x block-size if interleaved pattern is selected.\n");
HDprintf("\n");
HDprintf(" Interleaved and Contiguous patterns in 1D geometry:\n");
HDprintf(" When contiguous access pattern is chosen, the dataset is evenly divided\n");
HDprintf(" into num-processes regions and each process writes data to its own region.\n");
HDprintf(" When interleaved blocks are written to a dataset, space for the first\n");
HDprintf(" block of the first process is allocated in the dataset, then space is\n");
HDprintf(" allocated for the first block of the second process, etc. until space is\n");
HDprintf(" allocated for the first block of each process, then space is allocated for\n");
HDprintf(" the second block of the first process, the second block of the second\n");
HDprintf(" process, etc.\n");
HDprintf("\n");
HDprintf(" For example, with a 3 process run, 512KB bytes-per-process, 256KB transfer\n");
HDprintf(" buffer size, and 64KB block size, each process must issue 2 transfer\n");
HDprintf(" requests to complete access to the dataset.\n");
HDprintf(" Contiguous blocks of the first transfer request are written like so:\n");
HDprintf(" 1111----2222----3333----\n");
HDprintf(" Interleaved blocks of the first transfer request are written like so:\n");
HDprintf(" 123123123123------------\n");
HDprintf(" The actual number of I/O operations involved in a transfer request\n");
HDprintf(" depends on the access pattern and communication mode.\n");
HDprintf(" When using independent I/O with interleaved pattern, each process\n");
HDprintf(" performs 4 small non-contiguous I/O operations per transfer request.\n");
HDprintf(" If collective I/O is turned on, the combined content of the buffers of\n");
HDprintf(" the 3 processes will be written using one collective I/O operation\n");
HDprintf(" per transfer request.\n");
HDprintf("\n");
HDprintf(" For information about access patterns in 2D geometry, please refer to the\n");
HDprintf(" HDF5 Reference Manual.\n");
HDprintf("\n");
HDprintf(" DL - is a list of debugging flags. Valid values are:\n");
HDprintf(" 1 - Minimal\n");
HDprintf(" 2 - Not quite everything\n");
HDprintf(" 3 - Everything\n");
HDprintf(" 4 - The kitchen sink\n");
HDprintf(" r - Raw data I/O throughput information\n");
HDprintf(" t - Times as well as throughputs\n");
HDprintf(" v - Verify data correctness\n");
HDprintf("\n");
HDprintf(" Example: --debug=2,r,t\n");
HDprintf("\n");
HDprintf(" Environment variables:\n");
HDprintf(" HDF5_NOCLEANUP Do not remove data files if set [default remove]\n");
HDprintf(" HDF5_MPI_INFO MPI INFO object key=value separated by ;\n");
HDprintf(" HDF5_PARAPREFIX Paralllel data files prefix\n");
fflush(stdout);
} /* end if */
} /* end usage() */
@ -1685,7 +1685,7 @@ usage(const char *prog)
int
main(void)
{
printf("No parallel IO performance because parallel is not configured\n");
HDprintf("No parallel IO performance because parallel is not configured\n");
return EXIT_SUCCESS;
} /* end main */

2
tools/test/perform/pio_standalone.h

@ -294,6 +294,7 @@ H5_DLL int HDfprintf (FILE *stream, const char *fmt, ...);
#define HDpipe(F) pipe(F)
#define HDpow(X,Y) pow(X,Y)
/* printf() variable arguments */
#define HDprintf(...) HDfprintf(stdout, __VA_ARGS__)
#define HDputc(C,F) putc(C,F)
#define HDputchar(C) putchar(C)
#define HDputs(S) puts(S)
@ -355,6 +356,7 @@ H5_DLL int c99_snprintf(char* str, size_t size, const char* format, ...);
#define HDsnprintf snprintf /*varargs*/
#endif
/* sprintf() variable arguments */
#define HDsprintf sprintf /*varargs*/
#define HDsqrt(X) sqrt(X)
#ifdef H5_HAVE_RAND_R
H5_DLL void HDsrand(unsigned int seed);

46
tools/test/perform/sio_engine.c

@ -41,7 +41,7 @@
#define GOTOERROR(errcode) { ret_code = errcode; goto done; }
#define ERRMSG(mesg) { \
fprintf(stderr, "*** Assertion failed (%s) at line %4d in %s\n", \
HDfprintf(stderr, "*** Assertion failed (%s) at line %4d in %s\n", \
mesg, (int)__LINE__, __FILE__); \
}
@ -198,7 +198,7 @@ do_sio(parameters param, results *res)
if (sio_debug_level >= 4)
/* output all of the times for all iterations */
fprintf(output, "Timer details:\n");
HDfprintf(output, "Timer details:\n");
/*
* Write performance measurement
@ -490,7 +490,7 @@ do_write(results *res, file_descr *fd, parameters *parms, void *buffer)
/* Create the dataset transfer property list */
h5dxpl = H5Pcreate(H5P_DATASET_XFER);
if (h5dxpl < 0) {
fprintf(stderr, "HDF5 Property List Create failed\n");
HDfprintf(stderr, "HDF5 Property List Create failed\n");
GOTOERROR(FAIL);
}
@ -512,7 +512,7 @@ do_write(results *res, file_descr *fd, parameters *parms, void *buffer)
h5dcpl = H5Pcreate(H5P_DATASET_CREATE);
if (h5dcpl < 0) {
fprintf(stderr, "HDF5 Property List Create failed\n");
HDfprintf(stderr, "HDF5 Property List Create failed\n");
GOTOERROR(FAIL);
}
@ -520,12 +520,12 @@ do_write(results *res, file_descr *fd, parameters *parms, void *buffer)
/* Set the chunk size to be the same as the buffer size */
hrc = H5Pset_chunk(h5dcpl, rank, h5chunk);
if (hrc < 0) {
fprintf(stderr, "HDF5 Property List Set failed\n");
HDfprintf(stderr, "HDF5 Property List Set failed\n");
GOTOERROR(FAIL);
} /* end if */
} /* end if */
sprintf(dname, "Dataset_%ld", (unsigned long)parms->num_bytes);
HDsprintf(dname, "Dataset_%ld", (unsigned long)parms->num_bytes);
h5ds_id = H5Dcreate2(fd->h5fd, dname, ELMT_H5_TYPE,
h5dset_space_id, H5P_DEFAULT, h5dcpl, H5P_DEFAULT);
@ -556,7 +556,7 @@ do_write(results *res, file_descr *fd, parameters *parms, void *buffer)
hrc = dset_write(rank-1, fd, parms, buffer);
if (hrc < 0) {
fprintf(stderr, "Error in dataset write\n");
HDfprintf(stderr, "Error in dataset write\n");
GOTOERROR(FAIL);
}
@ -571,7 +571,7 @@ do_write(results *res, file_descr *fd, parameters *parms, void *buffer)
hrc = H5Dclose(h5ds_id);
if (hrc < 0) {
fprintf(stderr, "HDF5 Dataset Close failed\n");
HDfprintf(stderr, "HDF5 Dataset Close failed\n");
GOTOERROR(FAIL);
}
@ -584,7 +584,7 @@ done:
if (h5dset_space_id != -1) {
hrc = H5Sclose(h5dset_space_id);
if (hrc < 0){
fprintf(stderr, "HDF5 Dataset Space Close failed\n");
HDfprintf(stderr, "HDF5 Dataset Space Close failed\n");
ret_code = FAIL;
} else {
h5dset_space_id = -1;
@ -594,7 +594,7 @@ done:
if (h5mem_space_id != -1) {
hrc = H5Sclose(h5mem_space_id);
if (hrc < 0) {
fprintf(stderr, "HDF5 Memory Space Close failed\n");
HDfprintf(stderr, "HDF5 Memory Space Close failed\n");
ret_code = FAIL;
} else {
h5mem_space_id = -1;
@ -604,7 +604,7 @@ done:
if (h5dxpl != -1) {
hrc = H5Pclose(h5dxpl);
if (hrc < 0) {
fprintf(stderr, "HDF5 Dataset Transfer Property List Close failed\n");
HDfprintf(stderr, "HDF5 Dataset Transfer Property List Close failed\n");
ret_code = FAIL;
} else {
h5dxpl = -1;
@ -837,7 +837,7 @@ do_read(results *res, file_descr *fd, parameters *parms, void *buffer)
/* Create the dataset transfer property list */
h5dxpl = H5Pcreate(H5P_DATASET_XFER);
if (h5dxpl < 0) {
fprintf(stderr, "HDF5 Property List Create failed\n");
HDfprintf(stderr, "HDF5 Property List Create failed\n");
GOTOERROR(FAIL);
}
break;
@ -856,7 +856,7 @@ do_read(results *res, file_descr *fd, parameters *parms, void *buffer)
break;
case HDF5:
sprintf(dname, "Dataset_%ld", (long)parms->num_bytes);
HDsprintf(dname, "Dataset_%ld", (long)parms->num_bytes);
h5ds_id = H5Dopen2(fd->h5fd, dname, H5P_DEFAULT);
if (h5ds_id < 0) {
HDfprintf(stderr, "HDF5 Dataset open failed\n");
@ -876,7 +876,7 @@ do_read(results *res, file_descr *fd, parameters *parms, void *buffer)
hrc = dset_read(rank-1, fd, parms, buffer, buffer2);
if (hrc < 0) {
fprintf(stderr, "Error in dataset read\n");
HDfprintf(stderr, "Error in dataset read\n");
GOTOERROR(FAIL);
}
@ -890,7 +890,7 @@ do_read(results *res, file_descr *fd, parameters *parms, void *buffer)
hrc = H5Dclose(h5ds_id);
if (hrc < 0) {
fprintf(stderr, "HDF5 Dataset Close failed\n");
HDfprintf(stderr, "HDF5 Dataset Close failed\n");
GOTOERROR(FAIL);
}
@ -903,7 +903,7 @@ done:
if (h5dset_space_id != -1) {
hrc = H5Sclose(h5dset_space_id);
if (hrc < 0){
fprintf(stderr, "HDF5 Dataset Space Close failed\n");
HDfprintf(stderr, "HDF5 Dataset Space Close failed\n");
ret_code = FAIL;
} else {
h5dset_space_id = -1;
@ -913,7 +913,7 @@ done:
if (h5mem_space_id != -1) {
hrc = H5Sclose(h5mem_space_id);
if (hrc < 0) {
fprintf(stderr, "HDF5 Memory Space Close failed\n");
HDfprintf(stderr, "HDF5 Memory Space Close failed\n");
ret_code = FAIL;
} else {
h5mem_space_id = -1;
@ -923,7 +923,7 @@ done:
if (h5dxpl != -1) {
hrc = H5Pclose(h5dxpl);
if (hrc < 0) {
fprintf(stderr, "HDF5 Dataset Transfer Property List Close failed\n");
HDfprintf(stderr, "HDF5 Dataset Transfer Property List Close failed\n");
ret_code = FAIL;
} else {
h5dxpl = -1;
@ -1089,7 +1089,7 @@ do_fopen(parameters *param, char *fname, file_descr *fd /*out*/, int flags)
fapl = set_vfd(param);
if (fapl < 0) {
fprintf(stderr, "HDF5 Property List Create failed\n");
HDfprintf(stderr, "HDF5 Property List Create failed\n");
GOTOERROR(FAIL);
}
@ -1110,7 +1110,7 @@ do_fopen(parameters *param, char *fname, file_descr *fd /*out*/, int flags)
if (fd->h5fd < 0) {
fprintf(stderr, "HDF5 File Create failed(%s)\n", fname);
HDfprintf(stderr, "HDF5 File Create failed(%s)\n", fname);
GOTOERROR(FAIL);
}
break;
@ -1176,7 +1176,7 @@ set_vfd(parameters *param)
HDassert(HDstrlen(multi_letters)==H5FD_MEM_NTYPES);
for (mt=H5FD_MEM_DEFAULT; mt<H5FD_MEM_NTYPES; H5_INC_ENUM(H5FD_mem_t,mt)) {
memb_fapl[mt] = H5P_DEFAULT;
sprintf(sv[mt], "%%s-%c.h5", multi_letters[mt]);
HDsprintf(sv[mt], "%%s-%c.h5", multi_letters[mt]);
memb_name[mt] = sv[mt];
memb_addr[mt] = (haddr_t)MAX(mt - 1,0) * (HADDR_MAX / 10);
}
@ -1225,7 +1225,7 @@ do_fclose(iotype iot, file_descr *fd /*out*/)
rc = POSIXCLOSE(fd->posixfd);
if (rc != 0){
fprintf(stderr, "POSIX File Close failed\n");
HDfprintf(stderr, "POSIX File Close failed\n");
GOTOERROR(FAIL);
}
@ -1236,7 +1236,7 @@ do_fclose(iotype iot, file_descr *fd /*out*/)
hrc = H5Fclose(fd->h5fd);
if (hrc < 0) {
fprintf(stderr, "HDF5 File Close failed\n");
HDfprintf(stderr, "HDF5 File Close failed\n");
GOTOERROR(FAIL);
}

234
tools/test/perform/sio_perf.c

@ -281,14 +281,14 @@ struct options {
int buf_rank; /* Rank */
int order_rank; /* Rank */
int chk_rank; /* Rank */
int print_times; /* print times as well as throughputs */
int print_raw; /* print raw data throughput info */
int print_times; /* print times as well as throughputs */
int print_raw; /* print raw data throughput info */
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 */
int verify; /* Verify data correctness */
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 */
int verify; /* Verify data correctness */
vfdtype vfd; /* File driver */
size_t page_buffer_size;
size_t page_size;
@ -333,7 +333,7 @@ main(int argc, char **argv)
/* Initialize h5tools lib */
h5tools_init();
#endif
output = stdout;
opts = parse_command_line(argc, argv);
@ -345,8 +345,8 @@ main(int argc, char **argv)
if (opts->output_file) {
if ((output = HDfopen(opts->output_file, "w")) == NULL) {
fprintf(stderr, "%s: cannot open output file\n", progname);
perror(opts->output_file);
HDfprintf(stderr, "%s: cannot open output file\n", progname);
HDperror(opts->output_file);
goto finish;
}
}
@ -356,7 +356,7 @@ main(int argc, char **argv)
run_test_loop(opts);
finish:
free(opts);
HDfree(opts);
return exit_value;
}
@ -385,8 +385,8 @@ static void
run_test_loop(struct options *opts)
{
parameters parms;
int i;
size_t buf_bytes;
int i;
size_t buf_bytes;
/* load options into parameter structure */
parms.num_files = opts->num_files;
@ -552,7 +552,7 @@ run_test(iotype iot, parameters parms, struct options *opts)
/*
* Show various statistics
*/
/* Write statistics */
/* Write statistics */
/* Print the raw data throughput if desired */
if (opts->print_raw) {
/* accumulate and output the max, min, and average "raw write" times */
@ -598,7 +598,7 @@ run_test(iotype iot, parameters parms, struct options *opts)
output_results(opts,"Write Open-Close",write_gross_mm_table,parms.num_iters,raw_size);
if (!parms.h5_write_only) {
/* Read statistics */
/* Read statistics */
/* Print the raw data throughput if desired */
if (opts->print_raw) {
/* accumulate and output the max, min, and average "raw read" times */
@ -647,16 +647,16 @@ run_test(iotype iot, parameters parms, struct options *opts)
}
/* clean up our mess */
free(write_sys_mm_table);
free(write_mm_table);
free(write_gross_mm_table);
free(write_raw_mm_table);
HDfree(write_sys_mm_table);
HDfree(write_mm_table);
HDfree(write_gross_mm_table);
HDfree(write_raw_mm_table);
if (!parms.h5_write_only) {
free(read_sys_mm_table);
free(read_mm_table);
free(read_gross_mm_table);
free(read_raw_mm_table);
HDfree(read_sys_mm_table);
HDfree(read_mm_table);
HDfree(read_gross_mm_table);
HDfree(read_raw_mm_table);
}
return ret_value;
@ -790,9 +790,9 @@ output_report(const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
vfprintf(output, fmt, ap);
va_end(ap);
HDva_start(ap, fmt);
HDvfprintf(output, fmt, ap);
HDva_end(ap);
}
/*
@ -806,10 +806,10 @@ output_report(const char *fmt, ...)
static void
print_indent(register int indent)
{
indent *= TAB_SPACE;
indent *= TAB_SPACE;
for (; indent > 0; --indent)
fputc(' ', output);
for (; indent > 0; --indent)
HDfputc(' ', output);
}
static void
@ -833,9 +833,9 @@ static void
print_io_api(long io_types)
{
if (io_types & SIO_POSIX)
HDfprintf(output, "posix ");
HDfprintf(output, "posix ");
if (io_types & SIO_HDF5)
HDfprintf(output, "hdf5 ");
HDfprintf(output, "hdf5 ");
HDfprintf(output, "\n");
}
@ -845,7 +845,7 @@ report_parameters(struct options *opts)
int i, rank;
rank = opts->dset_rank;
print_version("HDF5 Library"); /* print library version */
print_version("HDF5 Library"); /* print library version */
HDfprintf(output, "==== Parameters ====\n");
HDfprintf(output, "IO API=");
@ -1004,7 +1004,7 @@ parse_command_line(int argc, char *argv[])
HDmemset(buf, '\0', sizeof(buf));
for (i = 0; *end != '\0' && *end != ','; ++end)
if (isalnum(*end) && i < 10)
if (HDisalnum(*end) && i < 10)
buf[i++] = *end;
if (!HDstrcasecmp(buf, "hdf5")) {
@ -1012,9 +1012,9 @@ parse_command_line(int argc, char *argv[])
} else if (!HDstrcasecmp(buf, "posix")) {
cl_opts->io_types |= SIO_POSIX;
} else {
fprintf(stderr, "sio_perf: invalid --api option %s\n",
HDfprintf(stderr, "sio_perf: invalid --api option %s\n",
buf);
exit(EXIT_FAILURE);
HDexit(EXIT_FAILURE);
}
if (*end == '\0')
@ -1043,7 +1043,7 @@ parse_command_line(int argc, char *argv[])
HDmemset(buf, '\0', sizeof(buf));
for (i = 0; *end != '\0' && *end != ','; ++end)
if (isalnum(*end) && i < 10)
if (HDisalnum(*end) && i < 10)
buf[i++] = *end;
cl_opts->chk_size[j] = parse_size_directive(buf);
@ -1071,17 +1071,17 @@ parse_command_line(int argc, char *argv[])
HDmemset(buf, '\0', sizeof(buf));
for (i = 0; *end != '\0' && *end != ','; ++end)
if (isalnum(*end) && i < 10)
if (HDisalnum(*end) && i < 10)
buf[i++] = *end;
if (strlen(buf) > 1 || isdigit(buf[0])) {
if (HDstrlen(buf) > 1 || HDisdigit(buf[0])) {
size_t j;
for (j = 0; j < 10 && buf[j] != '\0'; ++j)
if (!isdigit(buf[j])) {
fprintf(stderr, "sio_perf: invalid --debug option %s\n",
if (!HDisdigit(buf[j])) {
HDfprintf(stderr, "sio_perf: invalid --debug option %s\n",
buf);
exit(EXIT_FAILURE);
HDexit(EXIT_FAILURE);
}
sio_debug_level = atoi(buf);
@ -1105,8 +1105,8 @@ parse_command_line(int argc, char *argv[])
cl_opts->verify = TRUE;
break;
default:
fprintf(stderr, "sio_perf: invalid --debug option %s\n", buf);
exit(EXIT_FAILURE);
HDfprintf(stderr, "sio_perf: invalid --debug option %s\n", buf);
HDexit(EXIT_FAILURE);
}
}
@ -1129,7 +1129,7 @@ parse_command_line(int argc, char *argv[])
HDmemset(buf, '\0', sizeof(buf));
for (i = 0; *end != '\0' && *end != ','; ++end)
if (isalnum(*end) && i < 10)
if (HDisalnum(*end) && i < 10)
buf[i++] = *end;
cl_opts->dset_size[j] = parse_size_directive(buf);
@ -1147,7 +1147,7 @@ parse_command_line(int argc, char *argv[])
break;
case 'i':
cl_opts->num_iters = atoi(opt_arg);
cl_opts->num_iters = HDatoi(opt_arg);
break;
case 'o':
cl_opts->output_file = opt_arg;
@ -1171,9 +1171,9 @@ parse_command_line(int argc, char *argv[])
} else if (!HDstrcasecmp(opt_arg, "direct")) {
cl_opts->vfd=direct;
} else {
fprintf(stderr, "sio_perf: invalid --api option %s\n",
HDfprintf(stderr, "sio_perf: invalid --api option %s\n",
opt_arg);
exit(EXIT_FAILURE);
HDexit(EXIT_FAILURE);
}
break;
case 'w':
@ -1193,7 +1193,7 @@ parse_command_line(int argc, char *argv[])
HDmemset(buf, '\0', sizeof(buf));
for (i = 0; *end != '\0' && *end != ','; ++end)
if (isalnum(*end) && i < 10)
if (HDisalnum(*end) && i < 10)
buf[i++] = *end;
cl_opts->buf_size[j] = parse_size_directive(buf);
@ -1221,7 +1221,7 @@ parse_command_line(int argc, char *argv[])
HDmemset(buf, '\0', sizeof(buf));
for (i = 0; *end != '\0' && *end != ','; ++end)
if (isalnum(*end) && i < 10)
if (HDisalnum(*end) && i < 10)
buf[i++] = *end;
cl_opts->order[j] = (int)parse_size_directive(buf);
@ -1243,7 +1243,7 @@ parse_command_line(int argc, char *argv[])
case '?':
default:
usage(progname);
free(cl_opts);
HDfree(cl_opts);
return NULL;
}
}
@ -1339,8 +1339,8 @@ parse_size_directive(const char *size)
break;
default:
fprintf(stderr, "Illegal size specifier '%c'\n", *endptr);
exit(EXIT_FAILURE);
HDfprintf(stderr, "Illegal size specifier '%c'\n", *endptr);
HDexit(EXIT_FAILURE);
}
}
@ -1357,72 +1357,72 @@ parse_size_directive(const char *size)
static void
usage(const char *prog)
{
print_version(prog);
printf("usage: %s [OPTIONS]\n", prog);
printf(" OPTIONS\n");
printf(" -h Print an usage message and exit\n");
printf(" -A AL Which APIs to test\n");
printf(" [default: all of them]\n");
printf(" -c SL Selects chunked storage and defines chunks dimensions\n");
printf(" and sizes\n");
printf(" [default: Off]\n");
printf(" -e SL Dimensions and sizes of dataset\n");
printf(" [default: 100,200]\n");
printf(" -i N Number of iterations to perform\n");
printf(" [default: 1]\n");
printf(" -r NL Dimension access order (see below for description)\n");
printf(" [default: 1,2]\n");
printf(" -t Selects extendable dimensions for HDF5 dataset\n");
printf(" [default: Off]\n");
printf(" -v VFD Selects file driver for HDF5 access\n");
printf(" [default: sec2]\n");
printf(" -w Perform write tests, not the read tests\n");
printf(" [default: Off]\n");
printf(" -x SL Dimensions and sizes of the transfer buffer\n");
printf(" [default: 10,20]\n");
printf("\n");
printf(" N - is an integer > 0.\n");
printf("\n");
printf(" S - is a size specifier, an integer > 0 followed by a size indicator:\n");
printf(" K - Kilobyte (%d)\n", ONE_KB);
printf(" M - Megabyte (%d)\n", ONE_MB);
printf(" G - Gigabyte (%d)\n", ONE_GB);
printf("\n");
printf(" Example: '37M' is 37 megabytes or %d bytes\n", 37*ONE_MB);
printf("\n");
printf(" AL - is an API list. Valid values are:\n");
printf(" hdf5 - HDF5\n");
printf(" posix - POSIX\n");
printf("\n");
printf(" Example: -A posix,hdf5\n");
printf("\n");
printf(" NL - is list of integers (N) separated by commas.\n");
printf("\n");
printf(" Example: 1,2,3\n");
printf("\n");
printf(" SL - is list of size specifiers (S) separated by commas.\n");
printf("\n");
printf(" Example: 2K,2K,3K\n");
printf("\n");
printf(" The example defines an object (dataset, tranfer buffer) with three\n");
printf(" dimensions. Be aware that as the number of dimensions increases, the\n");
printf(" the total size of the object increases exponentially.\n");
printf("\n");
printf(" VFD - is an HDF5 file driver specifier. Valid values are:\n");
printf(" sec2, stdio, core, split, multi, family, direct\n");
printf("\n");
printf(" Dimension access order:\n");
printf(" Data access starts at the cardinal origin of the dataset using the\n");
printf(" transfer buffer. The next access occurs on a dataset region next to\n");
printf(" the previous one. For a multidimensional dataset, there are several\n");
printf(" directions as to where to proceed. This can be specified in the dimension\n");
printf(" access order. For example, -r 1,2 states that the tool should traverse\n");
printf(" dimension 1 first, and then dimension 2.\n");
printf("\n");
printf(" Environment variables:\n");
printf(" HDF5_NOCLEANUP Do not remove data files if set [default remove]\n");
printf(" HDF5_PREFIX Data file prefix\n");
printf("\n");
print_version(prog);
HDprintf("usage: %s [OPTIONS]\n", prog);
HDprintf(" OPTIONS\n");
HDprintf(" -h Print an usage message and exit\n");
HDprintf(" -A AL Which APIs to test\n");
HDprintf(" [default: all of them]\n");
HDprintf(" -c SL Selects chunked storage and defines chunks dimensions\n");
HDprintf(" and sizes\n");
HDprintf(" [default: Off]\n");
HDprintf(" -e SL Dimensions and sizes of dataset\n");
HDprintf(" [default: 100,200]\n");
HDprintf(" -i N Number of iterations to perform\n");
HDprintf(" [default: 1]\n");
HDprintf(" -r NL Dimension access order (see below for description)\n");
HDprintf(" [default: 1,2]\n");
HDprintf(" -t Selects extendable dimensions for HDF5 dataset\n");
HDprintf(" [default: Off]\n");
HDprintf(" -v VFD Selects file driver for HDF5 access\n");
HDprintf(" [default: sec2]\n");
HDprintf(" -w Perform write tests, not the read tests\n");
HDprintf(" [default: Off]\n");
HDprintf(" -x SL Dimensions and sizes of the transfer buffer\n");
HDprintf(" [default: 10,20]\n");
HDprintf("\n");
HDprintf(" N - is an integer > 0.\n");
HDprintf("\n");
HDprintf(" S - is a size specifier, an integer > 0 followed by a size indicator:\n");
HDprintf(" K - Kilobyte (%d)\n", ONE_KB);
HDprintf(" M - Megabyte (%d)\n", ONE_MB);
HDprintf(" G - Gigabyte (%d)\n", ONE_GB);
HDprintf("\n");
HDprintf(" Example: '37M' is 37 megabytes or %d bytes\n", 37*ONE_MB);
HDprintf("\n");
HDprintf(" AL - is an API list. Valid values are:\n");
HDprintf(" hdf5 - HDF5\n");
HDprintf(" posix - POSIX\n");
HDprintf("\n");
HDprintf(" Example: -A posix,hdf5\n");
HDprintf("\n");
HDprintf(" NL - is list of integers (N) separated by commas.\n");
HDprintf("\n");
HDprintf(" Example: 1,2,3\n");
HDprintf("\n");
HDprintf(" SL - is list of size specifiers (S) separated by commas.\n");
HDprintf("\n");
HDprintf(" Example: 2K,2K,3K\n");
HDprintf("\n");
HDprintf(" The example defines an object (dataset, tranfer buffer) with three\n");
HDprintf(" dimensions. Be aware that as the number of dimensions increases, the\n");
HDprintf(" the total size of the object increases exponentially.\n");
HDprintf("\n");
HDprintf(" VFD - is an HDF5 file driver specifier. Valid values are:\n");
HDprintf(" sec2, stdio, core, split, multi, family, direct\n");
HDprintf("\n");
HDprintf(" Dimension access order:\n");
HDprintf(" Data access starts at the cardinal origin of the dataset using the\n");
HDprintf(" transfer buffer. The next access occurs on a dataset region next to\n");
HDprintf(" the previous one. For a multidimensional dataset, there are several\n");
HDprintf(" directions as to where to proceed. This can be specified in the dimension\n");
HDprintf(" access order. For example, -r 1,2 states that the tool should traverse\n");
HDprintf(" dimension 1 first, and then dimension 2.\n");
HDprintf("\n");
HDprintf(" Environment variables:\n");
HDprintf(" HDF5_NOCLEANUP Do not remove data files if set [default remove]\n");
HDprintf(" HDF5_PREFIX Data file prefix\n");
HDprintf("\n");
fflush(stdout);
} /* end usage() */

2
tools/test/perform/sio_standalone.h

@ -316,6 +316,7 @@ H5_DLL int HDfprintf (FILE *stream, const char *fmt, ...);
#define HDpipe(F) pipe(F)
#define HDpow(X,Y) pow(X,Y)
/* printf() variable arguments */
#define HDprintf(...) HDfprintf(stdout, __VA_ARGS__)
#define HDputc(C,F) putc(C,F)
#define HDputchar(C) putchar(C)
#define HDputs(S) puts(S)
@ -377,6 +378,7 @@ H5_DLL int c99_snprintf(char* str, size_t size, const char* format, ...);
#define HDsnprintf snprintf /*varargs*/
#endif
/* sprintf() variable arguments */
#define HDsprintf sprintf /*varargs*/
#define HDsqrt(X) sqrt(X)
#ifdef H5_HAVE_RAND_R
H5_DLL void HDsrand(unsigned int seed);

1
tools/testfiles/tudlink-2.ddl

@ -1,6 +1,5 @@
HDF5 "tudlink.h5" {
USERDEFINED_LINK "udlink2" {
USERDEFINED_LINK "udlink2" {
LINKCLASS 187
}
}