mirror/hdf5
2
0
Fork 0
mirror of https://github.com/HDFGroup/hdf5.git synced 2025-01-30 15:32:37 +08:00
Code Issues Packages Projects Releases Wiki Activity
f1031738ef
hdf5/testpar/t_fphdf5.c
Bill Wendling ce045b62d2 [svn-r7848] Purpose: 
Update

Description:
    This completes Phase I of the FPHDF5 testing. This test does the
    following:

        - Creates a file
        - Creates multiple non-root groups
        - For each process:
            For each non-root group:
                Create multiple datasets
            Access all datasets created above
            Write to all datasets created above
        - Close the file
        - Reopen the file and verify the data is correct

Platforms tested:
    AIX (w/ FPHDF5)
    Linux (w/ FPHDF5)
    Solaris (w/ Fortran & C++)

Misc. update:
2003-11-13 15:08:43 -05:00

743 lines
25 KiB
C
Raw Blame History

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Copyright by the Board of Trustees of the University of Illinois. *
* All rights reserved. *
* *
* This file is part of HDF5. The full HDF5 copyright notice, including *
* terms governing use, modification, and redistribution, is contained in *
* the files COPYING and Copyright.html. COPYING can be found at the root *
* of the source code distribution tree; Copyright.html can be found at the *
* root level of an installed copy of the electronic HDF5 document set and *
* is linked from the top-level documents page. It can also be found at *
* http://hdf.ncsa.uiuc.edu/HDF5/doc/Copyright.html. If you do not have *
* access to either file, you may request a copy from hdfhelp@ncsa.uiuc.edu. *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/*
* Flexible Parallel HDF5 test: Create a file using the FPHDF5 file
* driver. Populate it with groups and datasets to make sure that FPHDF5
* can handle it.
*
* Author:
* Bill Wendling (wendling@ncsa.uiuc.edu)
* 20. February 2003
*/
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "testphdf5.h"
#ifdef H5_HAVE_FPHDF5
/*===----------------------------------------------------------------------===
* Local Functions
*===----------------------------------------------------------------------===
*/
static hid_t create_file(const char *filename);
static hid_t create_group(hid_t loc, const char *grp_name, size_t size_hint);
static hid_t create_dset(hid_t loc, const char *dset_name);
static void access_dset(hid_t loc, const char *dset_name);
static void slab_set(hssize_t start[], hsize_t count[],
hsize_t stride[], hsize_t block[]);
static void fill_data(hssize_t start[], hsize_t count[]);
static void write_data(hid_t loc, const char *dset_name,
hssize_t start[], hsize_t count[],
hsize_t stride[], hsize_t block[]);
static void verify_dataset(hid_t loc, const char *dset_name, hssize_t start[],
hsize_t count[], hsize_t stride[], hsize_t block[]);
static void test_group_creation(hid_t loc);
static void test_dataset_creation(hid_t loc);
static void test_dataset_access(hid_t loc);
static void test_dataset_write(hid_t loc);
static void usage(const char *prog);
/*===----------------------------------------------------------------------===
* Filenames
*===----------------------------------------------------------------------===
* The names of the test files for
*/
static const char *FILENAME[2] = { /* List of files we want to create */
"FPHDF5Test",
NULL
};
static char filenames[2][PATH_MAX]; /* "Fixed" filenames */
/*===----------------------------------------------------------------------===
* Global Variables
*===----------------------------------------------------------------------===
*/
#ifdef RANK
#undef RANK
#endif /* RANK */
#ifdef DIM0
#undef DIM0
#endif /* !DIM0 */
#ifdef DIM1
#undef DIM1
#endif /* !DIM1 */
enum {
SAP_RANK = 1, /* The rank acting as the SAP */
RANK = 2,
DIM0 = 6,
DIM1 = 12
};
int nerrors = 0; /* Errors count */
int verbose = 0; /* Verbose, default is no */
static MPI_Comm SAP_Comm = MPI_COMM_NULL; /* COMM for FPHDF5 */
static MPI_Comm SAP_Barrier_Comm = MPI_COMM_NULL; /* COMM used in barriers*/
static hid_t fapl = -1; /* FPHDF5 file access property list */
static int mpi_rank; /* Rank of this process */
static int mpi_size; /* Size of the COMM passed to FPHDF5 */
static int *orig_data = NULL; /* Data that's written to datasets */
/* Hyperslab settings */
static hssize_t start[RANK];
static hsize_t count[RANK];
static hsize_t stride[RANK];
static hsize_t block[RANK];
static const char *progname = "t_fphdf5";
/* Dataset Name Template */
static const char *dset_tmpl = "Dataset %d";
static char dset_name[128];
/* Group Name Template */
static const char *grp_tmpl = "Process %d's Datasets";
static char grp_name[128];
/*-------------------------------------------------------------------------
* Function: create_file
* Purpose: Create a new file with the given filename.
* Return: Success: Valid file ID
* Failure: -1
* Programmer: Bill Wendling
* 29. October 2003
* Modifications:
*-------------------------------------------------------------------------
*/
static hid_t
create_file(const char *filename)
{
hid_t fid = -1;
fid = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl);
VRFY((fid >= 0), "H5Fcreate");
printf("%d: Created file %s\n", mpi_rank, filename);
return fid;
}
/*-------------------------------------------------------------------------
* Function: create_group
* Purpose: Helper function that creates a group at the given
* location with the given name and size_hint.
* Return: Success: The handle to the new group
* Failure: Aborts
* Programmer: Bill Wendling
* 29. October 2003
* Modifications:
*-------------------------------------------------------------------------
*/
static hid_t
create_group(hid_t loc, const char *grp_name, size_t size_hint)
{
hid_t group;
VRFY(((group = H5Gcreate(loc, grp_name, size_hint)) >= 0), "H5Gcreate");
printf("%d: Created group \"%s\"\n", mpi_rank, grp_name);
return group;
}
/*-------------------------------------------------------------------------
* Function: create_dset
* Purpose: Helper function that creates a dataset at the given
* location with the given name and dimensions
* Return: Success: The handle to the new dataset
* Failure: Aborts
* Programmer: Bill Wendling
* 29. October 2003
* Modifications:
*-------------------------------------------------------------------------
*/
static hid_t
create_dset(hid_t loc, const char *dset_name)
{
hsize_t dims[RANK] = { DIM0, DIM1 };
hid_t dset, sid;
VRFY(((sid = H5Screate_simple(RANK, dims, NULL)) >= 0), "H5Screate_simple");
printf("%d: Created simple dataspace\n", mpi_rank);
dset = H5Dcreate(loc, dset_name, H5T_NATIVE_INT, sid, H5P_DEFAULT);
VRFY((dset >= 0), "H5Dcreate");
printf("%d: Created dataset \"%s\"\n", mpi_rank, dset_name);
VRFY((H5Sclose(sid) >= 0), "H5Sclose");
return dset;
}
/*-------------------------------------------------------------------------
* Function: access_dset
* Purpose: Quickly check to see if we can access this dataset.
* Return: Nothing, but aborts if an error occurs.
* Programmer: Bill Wendling
* 03. November 2003
* Modifications:
*-------------------------------------------------------------------------
*/
static void
access_dset(hid_t loc, const char *dset_name)
{
hid_t dataset;
VRFY(((dataset = H5Dopen(loc, dset_name)) >= 0), "H5Dopen");
VRFY((H5Dclose(dataset) >= 0), "H5Dclose");
}
/*-------------------------------------------------------------------------
* Function: slab_set
* Purpose: Setup the dimensions of the hyperslab.
* Return: Nothing
* Programmer: Bill Wendling
* 05. November 2003
* Modifications:
*-------------------------------------------------------------------------
*/
static void
slab_set(hssize_t start[], hsize_t count[], hsize_t stride[], hsize_t block[])
{
/* Each process takes a slab of rows. */
block[0] = DIM0 / mpi_size;
block[1] = DIM1;
stride[0] = block[0];
stride[1] = block[1];
count[0] = 1;
count[1] = 1;
start[0] = mpi_rank * block[0];
start[1] = 0;
}
/*-------------------------------------------------------------------------
* Function: fill_data
* Purpose: Fill data buffer with some data.
* Return: Nothing
* Programmer: Bill Wendling
* 13. November 2003
* Modifications:
*-------------------------------------------------------------------------
*/
static void
fill_data(hssize_t start[], hsize_t count[])
{
int *dataptr = orig_data;
int i, j;
/* put some trivial data in the buffer */
for (i = 0; i < block[0]; ++i)
for (j = 0; j < block[1]; ++j)
*dataptr++ = (j + start[0]) * 100 + j + start[1] + 1;
}
/*-------------------------------------------------------------------------
* Function: write_data
* Purpose: Writes data to a dataset.
* Return: Nothing, but aborts if an error occurs.
* Programmer: Bill Wendling
* 29. October 2003
* Modifications:
*-------------------------------------------------------------------------
*/
static void
write_data(hid_t loc, const char *dset_name, hssize_t start[], hsize_t count[],
hsize_t stride[], hsize_t block[])
{
herr_t hrc;
hid_t file_dataspace, mem_dataspace;
hid_t dataset, xfer;
hsize_t j, k;
int *dataptr = orig_data;
/* See if dataset is there */
VRFY(((dataset = H5Dopen(loc, dset_name)) >= 0), "H5Dopen");
xfer = H5Pcreate(H5P_DATASET_XFER);
VRFY((xfer >= 0), "H5Pcreate");
file_dataspace = H5Dget_space(dataset);
VRFY((file_dataspace >= 0), "H5Dget_space");
/* put some trivial data in the buffer */
for (j = 0; j < block[0]; ++j)
for (k = 0; k < block[1]; ++k)
*dataptr++ = (k + start[0]) * 100 + k + start[1] + 1;
hrc = H5Sselect_hyperslab(file_dataspace, H5S_SELECT_SET,
start, stride, count, block);
VRFY((hrc >= 0), "H5Sselect_hyperslab");
/* create a memory dataspace independently */
mem_dataspace = H5Screate_simple(RANK, block, NULL);
VRFY((mem_dataspace >= 0), "H5Screate_simple");
hrc = H5Dwrite(dataset, H5T_NATIVE_INT, mem_dataspace,
file_dataspace, H5P_DEFAULT, orig_data);
VRFY((hrc >= 0), "H5Dwrite");
VRFY((H5Sclose(mem_dataspace) >= 0), "H5Sclose");
VRFY((H5Sclose(file_dataspace) >= 0), "H5Sclose");
VRFY((H5Pclose(xfer) >= 0), "H5Pclose");
VRFY((H5Dclose(dataset) >= 0), "H5Dclose");
}
/*-------------------------------------------------------------------------
* Function: verify_dataset
* Purpose: Verify the data in the dataset is correct.
* Return: Nothing
* Programmer: Bill Wendling
* 10. November 2003
* Modifications:
*-------------------------------------------------------------------------
*/
static void
verify_dataset(hid_t loc, const char *dset_name, hssize_t start[], hsize_t count[],
hsize_t stride[], hsize_t block[])
{
hid_t dataset, file_dataspace, mem_dataspace;
hsize_t i, j;
int *data_array;
int vrfyerrs = 0;
/* Open the dataset */
VRFY(((dataset = H5Dopen(loc, dset_name)) >= 0), "H5Dopen");
/* Create a file dataspace */
file_dataspace = H5Dget_space(dataset);
VRFY((file_dataspace >= 0), "H5Dget_space");
VRFY((H5Sselect_hyperslab(file_dataspace, H5S_SELECT_SET,
start, stride, count, block) >= 0), "H5Sselect_hyperslab");
/* Create a memory dataspace */
mem_dataspace = H5Screate_simple(RANK, block, NULL);
VRFY((mem_dataspace >= 0), "H5Screate_simple");
/* Read the dataset */
data_array = (int *)malloc(DIM0 * DIM1 * sizeof(int));
VRFY((H5Dread(dataset, H5T_NATIVE_INT, mem_dataspace, file_dataspace,
H5P_DEFAULT, data_array) >= 0), "H5Dread");
/* Verify the contents of the dataset */
for (i = 0; i < block[0]; ++i)
for (j = 0; j < block[1]; ++j)
if (*data_array != *orig_data) {
if (vrfyerrs++ < MAX_ERR_REPORT)
fprintf(stderr,
"Dataset Verify failed at "
"[%ld][%ld](row %ld, col %ld): expect %d, got %d\n",
(long)i, (long)j, (long)(i + start[0]),
(long)(j + start[1]), *orig_data, *data_array);
++data_array;
++orig_data;
}
if (vrfyerrs) {
fprintf(stderr, "%d errors found in verify_dataset\n", vrfyerrs);
++nerrors;
}
VRFY((H5Sclose(mem_dataspace) >= 0), "H5Sclose");
VRFY((H5Sclose(file_dataspace) >= 0), "H5Sclose");
VRFY((H5Dclose(dataset) >= 0), "H5Dclose");
free(data_array);
}
/*-------------------------------------------------------------------------
* Function: test_group_creation
* Purpose: Test creation of multiple groups in the file.
* Return: Nothing
* Programmer: Bill Wendling
* 11. November 2003
* Modifications:
*-------------------------------------------------------------------------
*/
static void
test_group_creation(hid_t loc)
{
if (mpi_rank == 0) {
int i;
for (i = 0; i < mpi_size; ++i)
if (i != SAP_RANK) {
hid_t group;
sprintf(grp_name, grp_tmpl, i);
group = create_group(loc, grp_name, 4);
VRFY((H5Gclose(group) >= 0), "H5Gclose");
}
}
SYNC(SAP_Barrier_Comm);
}
/*-------------------------------------------------------------------------
* Function: test_dataset_creation
* Purpose: Test simultaneous creation of multiple datasets in a
* non-root group.
* Return: Nothing
* Programmer: Bill Wendling
* 11. November 2003
* Modifications:
*-------------------------------------------------------------------------
*/
static void
test_dataset_creation(hid_t loc)
{
hid_t dataset, group;
sprintf(grp_name, grp_tmpl, mpi_rank);
group = H5Gopen(loc, grp_name);
VRFY((group >= 0), "H5Gopen");
sprintf(dset_name, dset_tmpl, 0);
dataset = create_dset(group, dset_name);
VRFY((H5Dclose(dataset) >= 0), "H5Dclose");
/* Create 3x5x(mpi_size) dataset */
sprintf(dset_name, dset_tmpl, 1);
dataset = create_dset(group, dset_name);
VRFY((H5Dclose(dataset) >= 0), "H5Dclose");
/* Create 2x4x(mpi_size) dataset */
sprintf(dset_name, dset_tmpl, 2);
dataset = create_dset(group, dset_name);
VRFY((H5Dclose(dataset) >= 0), "H5Dclose");
/* Create 5x7x(mpi_size) dataset */
sprintf(dset_name, dset_tmpl, 3);
dataset = create_dset(group, dset_name);
VRFY((H5Dclose(dataset) >= 0), "H5Dclose");
VRFY((H5Gclose(group) >= 0), "H5Gclose");
SYNC(SAP_Barrier_Comm);
}
/*-------------------------------------------------------------------------
* Function: test_dataset_access
* Purpose: Test that we can access the datasets in the file from all
* processes.
* Return: Nothing
* Programmer: Bill Wendling
* 11. November 2003
* Modifications:
*-------------------------------------------------------------------------
*/
static void
test_dataset_access(hid_t loc)
{
int i;
for (i = 0; i < mpi_size; ++i)
if (i != SAP_RANK) {
hid_t group;
sprintf(grp_name, grp_tmpl, i);
VRFY(((group = H5Gopen(loc, grp_name)) >= 0), "H5Gopen");
sprintf(dset_name, dset_tmpl, 0);
printf("%d: Accessing dataset \"%s/%s\"\n", mpi_rank, grp_name, dset_name);
access_dset(group, dset_name);
sprintf(dset_name, dset_tmpl, 1);
printf("%d: Accessing dataset \"%s/%s\"\n", mpi_rank, grp_name, dset_name);
access_dset(group, dset_name);
sprintf(dset_name, dset_tmpl, 2);
printf("%d: Accessing dataset \"%s/%s\"\n", mpi_rank, grp_name, dset_name);
access_dset(group, dset_name);
sprintf(dset_name, dset_tmpl, 3);
printf("%d: Accessing dataset \"%s/%s\"\n", mpi_rank, grp_name, dset_name);
access_dset(group, dset_name);
VRFY((H5Gclose(group) >= 0), "H5Gclose");
}
SYNC(SAP_Barrier_Comm);
}
/*-------------------------------------------------------------------------
* Function: test_dataset_write
* Purpose: Test that we can write to the datasets in the file from
* all processes simultaneously.
* Return: Nothing
* Programmer: Bill Wendling
* 11. November 2003
* Modifications:
*-------------------------------------------------------------------------
*/
static void
test_dataset_write(hid_t loc)
{
int i;
/*===-------------------------------------------------------------------===
* All processes write to each dataset.
*===-------------------------------------------------------------------===
*/
for (i = 0; i < mpi_size; ++i)
if (i != SAP_RANK) {
hid_t group;
sprintf(grp_name, grp_tmpl, i);
VRFY(((group = H5Gopen(loc, grp_name)) >= 0), "H5Gopen");
/* Write to this dataset */
sprintf(dset_name, dset_tmpl, 0);
printf("%d: Writing to \"/%s/%s\"\n", mpi_rank, grp_name, dset_name);
write_data(group, dset_name, start, count, stride, block);
printf("%d: Verifying dataset \"/%s/%s\"\n", mpi_rank, grp_name, dset_name);
verify_dataset(group, dset_name, start, count, stride, block);
sprintf(dset_name, dset_tmpl, 1);
printf("%d: Writing to \"/%s/%s\"\n", mpi_rank, grp_name, dset_name);
write_data(group, dset_name, start, count, stride, block);
printf("%d: Verifying dataset \"/%s/%s\"\n", mpi_rank, grp_name, dset_name);
verify_dataset(group, dset_name, start, count, stride, block);
sprintf(dset_name, dset_tmpl, 2);
printf("%d: Writing to \"/%s/%s\"\n", mpi_rank, grp_name, dset_name);
write_data(group, dset_name, start, count, stride, block);
printf("%d: Verifying dataset \"/%s/%s\"\n", mpi_rank, grp_name, dset_name);
verify_dataset(group, dset_name, start, count, stride, block);
sprintf(dset_name, dset_tmpl, 3);
printf("%d: Writing to \"/%s/%s\"\n", mpi_rank, grp_name, dset_name);
write_data(group, dset_name, start, count, stride, block);
printf("%d: Verifying dataset \"/%s/%s\"\n", mpi_rank, grp_name, dset_name);
verify_dataset(group, dset_name, start, count, stride, block);
/* Close the group */
VRFY((H5Gclose(group) >= 0), "H5Gclose");
}
}
/*-------------------------------------------------------------------------
* Function: usage
* Purpose: Print a usage message.
* Return: Nothing
* Programmer: Bill Wendling
* 11. November 2003
* Modifications:
*-------------------------------------------------------------------------
*/
static void
usage(const char *prog)
{
if (mpi_rank == 0) {
fprintf(stderr, "usage: %s [OPTIONS]\n", prog);
fprintf(stderr, " OPTIONS\n");
fprintf(stderr, " -h, --help Print a usage message and exit\n");
fprintf(stderr, " -v, --verbose Verbose output [default: no]\n");
fprintf(stderr, "\n");
fflush(stdout);
}
}
/*-------------------------------------------------------------------------
* Function: main
* Purpose: Parse the command line variables and run the test
* program.
* Return: Success: 0
* Failure: >0
* Programmer: Bill Wendling
* 11. November 2003
* Modifications:
*-------------------------------------------------------------------------
*/
int
main(int argc, char *argv[])
{
hid_t fid, fapl2;
herr_t hrc;
int nargs;
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
MPI_Comm_size(MPI_COMM_WORLD, &mpi_size);
H5open();
for (nargs = argc; nargs > 1; --nargs)
if (strcmp(argv[nargs - 1], "-v") == 0 ||
strcmp(argv[nargs - 1], "--verbose") == 0 ||
strcmp(argv[nargs - 1], "--verbos") == 0 ||
strcmp(argv[nargs - 1], "--verbo") == 0 ||
strcmp(argv[nargs - 1], "--verb") == 0 ||
strcmp(argv[nargs - 1], "--ver") == 0 ||
strcmp(argv[nargs - 1], "--ve") == 0) {
verbose = 1;
} else if (strcmp(argv[nargs - 1], "-h") == 0 ||
strcmp(argv[nargs - 1], "--help") == 0 ||
strcmp(argv[nargs - 1], "--hel") == 0 ||
strcmp(argv[nargs - 1], "--he") == 0) {
usage(progname);
return 0;
} else {
fprintf(stderr, "Unknown option: %s\n", argv[nargs - 1]);
usage(progname);
return 1;
}
h5_show_hostname();
if (MAINPROCESS) {
printf("===================================\n");
printf("FPHDF5 functionality tests\n");
printf("===================================\n");
}
hrc = H5FPinit(MPI_COMM_WORLD, SAP_RANK, &SAP_Comm, &SAP_Barrier_Comm);
VRFY((hrc == MPI_SUCCESS), "H5FP_init");
printf("%d: Initialized FPHDF5\n", mpi_rank);
if (mpi_rank != SAP_RANK) {
/*
* Setup the file access property list that's used to create the
* file.
*/
unsigned i;
fapl = H5Pcreate(H5P_FILE_ACCESS);
VRFY((fapl >= 0), "H5Pcreate");
printf("%d: Created access property list\n", mpi_rank);
hrc = H5Pset_fapl_fphdf5(fapl, SAP_Comm, SAP_Barrier_Comm,
MPI_INFO_NULL, (unsigned)SAP_RANK);
VRFY((fapl >= 0), "H5Pset_fapl_fphdf5");
printf("%d: Set access property list\n", mpi_rank);
orig_data = (int *)malloc(DIM0 * DIM1 * sizeof(int));
VRFY((orig_data != NULL), "orig_data malloc succeeded");
slab_set(start, count, stride, block);
fill_data(start, count);
for (i = 0; i < sizeof(FILENAME) / sizeof(FILENAME[0]) - 1; ++i) {
if (h5_fixname(FILENAME[i], fapl, filenames[i], sizeof(filenames[i])) == NULL) {
fprintf(stderr, "h5_fixname failed\n");
++nerrors;
break;
}
fid = create_file(filenames[i]);
if (fid < 0)
break;
test_group_creation(fid);
test_dataset_creation(fid);
test_dataset_access(fid);
test_dataset_write(fid);
VRFY((H5Fclose(fid) >= 0), "H5Fclose");
SYNC(SAP_Barrier_Comm);
printf("%d: Closed file\n", mpi_rank);
fid = H5Fopen(filenames[i], H5F_ACC_RDONLY, fapl);
VRFY((fid >= 0), "H5Fopen");
SYNC(SAP_Barrier_Comm);
/*===------------------------------------------------------------===
* Reverify that the data is still "correct"
*===------------------------------------------------------------===
*/
for (i = 0; i < mpi_size; ++i)
if (i != SAP_RANK) {
hid_t group;
sprintf(grp_name, grp_tmpl, i);
VRFY(((group = H5Gopen(fid, grp_name)) >= 0), "H5Gopen");
/* Write to this dataset */
sprintf(dset_name, dset_tmpl, 0);
printf("%d: Reverifying dataset \"/%s/%s\"\n", mpi_rank,
grp_name, dset_name);
verify_dataset(group, dset_name, start, count, stride, block);
sprintf(dset_name, dset_tmpl, 1);
printf("%d: Reverifying dataset \"/%s/%s\"\n", mpi_rank,
grp_name, dset_name);
verify_dataset(group, dset_name, start, count, stride, block);
sprintf(dset_name, dset_tmpl, 2);
printf("%d: Reverifying dataset \"/%s/%s\"\n", mpi_rank,
grp_name, dset_name);
verify_dataset(group, dset_name, start, count, stride, block);
sprintf(dset_name, dset_tmpl, 3);
printf("%d: Reverifying dataset \"/%s/%s\"\n", mpi_rank,
grp_name, dset_name);
verify_dataset(group, dset_name, start, count, stride, block);
/* Close the group */
VRFY((H5Gclose(group) >= 0), "H5Gclose");
}
SYNC(SAP_Barrier_Comm);
VRFY((H5Fclose(fid) >= 0), "H5Fclose");
}
free(orig_data);
if (fapl > -1)
h5_cleanup(FILENAME, fapl);
}
VRFY((H5FPfinalize() >= 0), "H5FPfinalize");
printf("%d: H5FP finalized\n", mpi_rank);
if (MAINPROCESS) { /* only process 0 reports */
fprintf(stderr, "===================================\n");
if (nerrors)
fprintf(stderr, "***FPHDF5 test detected %d errors***\n", nerrors);
else
fprintf(stderr, "FPHDF5 test finished with no errors\n");
fprintf(stderr, "===================================\n");
}
done:
H5close();
MPI_Finalize();
return nerrors;
}
#else
/* Dummy program since FPHDF5 is not configured in */
int
main(int argc, char *argv[])
{
int mpi_rank;
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
if (mpi_rank == 0)
printf("No t_fphdf5 test because FPHDF5 is not configured in\n");
MPI_Finalize();
return 0;
}
#endif /* H5_HAVE_FPHDF5 */
Reference in New Issue View Git Blame Copy Permalink