diff options
Diffstat (limited to 'testpar/t_pread.c')
| -rw-r--r-- | testpar/t_pread.c | 1219 |
1 files changed, 1219 insertions, 0 deletions
diff --git a/testpar/t_pread.c b/testpar/t_pread.c new file mode 100644 index 0000000..9a2493d --- /dev/null +++ b/testpar/t_pread.c @@ -0,0 +1,1219 @@ +/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * + * Copyright by The HDF Group. * + * 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 COPYING file, which can be found at the root of the source code * + * distribution tree, or in https://www.hdfgroup.org/licenses. * + * If you do not have access to either file, you may request a copy from * + * help@hdfgroup.org. * + * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ + +/* + * Collective file open optimization tests + * + */ + +#include "testpar.h" +#include "H5Dprivate.h" + +/* The collection of files is included below to aid + * an external "cleanup" process if required. + * + * Note that the code below relies on the ordering of this array + * since each set of three is used by the tests either to construct + * or to read and validate. + */ +#define NFILENAME 3 +const char *FILENAMES[NFILENAME + 1] = {"reloc_t_pread_data_file", "reloc_t_pread_group_0_file", + "reloc_t_pread_group_1_file", NULL}; +#define FILENAME_BUF_SIZE 1024 + +#define COUNT 1000 + +#define LIMIT_NPROC 6 + +hbool_t pass = TRUE; +static const char *random_hdf5_text = "Now is the time for all first-time-users of HDF5 to read their \ +manual or go thru the tutorials!\n\ +While you\'re at it, now is also the time to read up on MPI-IO."; + +static const char *hitchhiker_quote = "A common mistake that people make when trying to design something\n\ +completely foolproof is to underestimate the ingenuity of complete\n\ +fools.\n"; + +static int generate_test_file(MPI_Comm comm, int mpi_rank, int group); +static int test_parallel_read(MPI_Comm comm, int mpi_rank, int mpi_size, int group); + +static char *test_argv0 = NULL; + +/*------------------------------------------------------------------------- + * Function: generate_test_file + * + * Purpose: This function is called to produce an HDF5 data file + * whose superblock is relocated to a power-of-2 boundary. + * + * Since data will be read back and validated, we generate + * data in a predictable manner rather than randomly. + * For now, we simply use the global mpi_rank of the writing + * process as a starting component for the data generation. + * Subsequent writes are increments from the initial start + * value. + * + * In the overall scheme of running the test, we'll call + * this function twice: first as a collection of all MPI + * processes and then a second time with the processes split + * more or less in half. Each sub group will operate + * collectively on their assigned file. This split into + * subgroups validates that parallel groups can successfully + * open and read data independently from the other parallel + * operations taking place. + * + * Return: Success: 0 + * + * Failure: 1 + * + * Programmer: Richard Warren + * 10/1/17 + * + * Modifications: + * + *------------------------------------------------------------------------- + */ +static int +generate_test_file(MPI_Comm comm, int mpi_rank, int group_id) +{ + int header = -1; + const char *fcn_name = "generate_test_file()"; + const char *failure_mssg = NULL; + const char *group_filename = NULL; + char data_filename[FILENAME_BUF_SIZE]; + int file_index = 0; + int group_size; + int group_rank; + int local_failure = 0; + int global_failures = 0; + hsize_t count = COUNT; + hsize_t i; + hsize_t offset; + hsize_t dims[1] = {0}; + hid_t file_id = -1; + hid_t memspace = -1; + hid_t filespace = -1; + hid_t fctmpl = -1; + hid_t fapl_id = -1; + hid_t dxpl_id = -1; + hid_t dset_id = -1; + hid_t dset_id_ch = -1; + hid_t dcpl_id = H5P_DEFAULT; + hsize_t chunk[1]; + float nextValue; + float *data_slice = NULL; + + pass = TRUE; + + HDassert(comm != MPI_COMM_NULL); + + if ((MPI_Comm_rank(comm, &group_rank)) != MPI_SUCCESS) { + pass = FALSE; + failure_mssg = "generate_test_file: MPI_Comm_rank failed.\n"; + } + + if ((MPI_Comm_size(comm, &group_size)) != MPI_SUCCESS) { + pass = FALSE; + failure_mssg = "generate_test_file: MPI_Comm_size failed.\n"; + } + + if (mpi_rank == 0) { + + HDfprintf(stdout, "Constructing test files..."); + } + + /* Setup the file names + * The test specific filenames are stored as consecutive + * array entries in the global 'FILENAMES' array above. + * Here, we simply decide on the starting index for + * file construction. The reading portion of the test + * will have a similar setup process... + */ + if (pass) { + if (comm == MPI_COMM_WORLD) { /* Test 1 */ + file_index = 0; + } + else if (group_id == 0) { /* Test 2 group 0 */ + file_index = 1; + } + else { /* Test 2 group 1 */ + file_index = 2; + } + + /* The 'group_filename' is just a temp variable and + * is used to call into the h5_fixname function. No + * need to worry that we reassign it for each file! + */ + group_filename = FILENAMES[file_index]; + HDassert(group_filename); + + /* Assign the 'data_filename' */ + if (h5_fixname(group_filename, H5P_DEFAULT, data_filename, sizeof(data_filename)) == NULL) { + pass = FALSE; + failure_mssg = "h5_fixname(0) failed.\n"; + } + } + + /* setup data to write */ + if (pass) { + if ((data_slice = (float *)HDmalloc(COUNT * sizeof(float))) == NULL) { + pass = FALSE; + failure_mssg = "malloc of data_slice failed.\n"; + } + } + + if (pass) { + nextValue = (float)(mpi_rank * COUNT); + + for (i = 0; i < COUNT; i++) { + data_slice[i] = nextValue; + nextValue += 1; + } + } + + /* Initialize a file creation template */ + if (pass) { + if ((fctmpl = H5Pcreate(H5P_FILE_CREATE)) < 0) { + pass = FALSE; + failure_mssg = "H5Pcreate(H5P_FILE_CREATE) failed.\n"; + } + else if (H5Pset_userblock(fctmpl, 512) != SUCCEED) { + pass = FALSE; + failure_mssg = "H5Pset_userblock(,size) failed.\n"; + } + } + /* setup FAPL */ + if (pass) { + if ((fapl_id = H5Pcreate(H5P_FILE_ACCESS)) < 0) { + pass = FALSE; + failure_mssg = "H5Pcreate(H5P_FILE_ACCESS) failed.\n"; + } + } + + if (pass) { + if ((H5Pset_fapl_mpio(fapl_id, comm, MPI_INFO_NULL)) < 0) { + pass = FALSE; + failure_mssg = "H5Pset_fapl_mpio() failed\n"; + } + } + + /* create the data file */ + if (pass) { + if ((file_id = H5Fcreate(data_filename, H5F_ACC_TRUNC, fctmpl, fapl_id)) < 0) { + pass = FALSE; + failure_mssg = "H5Fcreate() failed.\n"; + } + } + + /* create and write the dataset */ + if (pass) { + if ((dxpl_id = H5Pcreate(H5P_DATASET_XFER)) < 0) { + pass = FALSE; + failure_mssg = "H5Pcreate(H5P_DATASET_XFER) failed.\n"; + } + } + + if (pass) { + if ((H5Pset_dxpl_mpio(dxpl_id, H5FD_MPIO_COLLECTIVE)) < 0) { + pass = FALSE; + failure_mssg = "H5Pset_dxpl_mpio() failed.\n"; + } + } + + if (pass) { + dims[0] = COUNT; + if ((memspace = H5Screate_simple(1, dims, NULL)) < 0) { + pass = FALSE; + failure_mssg = "H5Screate_simple(1, dims, NULL) failed (1).\n"; + } + } + + if (pass) { + dims[0] *= (hsize_t)group_size; + if ((filespace = H5Screate_simple(1, dims, NULL)) < 0) { + pass = FALSE; + failure_mssg = "H5Screate_simple(1, dims, NULL) failed (2).\n"; + } + } + + if (pass) { + offset = (hsize_t)group_rank * (hsize_t)COUNT; + if ((H5Sselect_hyperslab(filespace, H5S_SELECT_SET, &offset, NULL, &count, NULL)) < 0) { + pass = FALSE; + failure_mssg = "H5Sselect_hyperslab() failed.\n"; + } + } + + if (pass) { + if ((dset_id = H5Dcreate2(file_id, "dataset0", H5T_NATIVE_FLOAT, filespace, H5P_DEFAULT, H5P_DEFAULT, + H5P_DEFAULT)) < 0) { + pass = FALSE; + failure_mssg = "H5Dcreate2() failed.\n"; + } + } + + if (pass) { + if ((H5Dwrite(dset_id, H5T_NATIVE_FLOAT, memspace, filespace, dxpl_id, data_slice)) < 0) { + pass = FALSE; + failure_mssg = "H5Dwrite() failed.\n"; + } + } + + /* create a chunked dataset */ + chunk[0] = COUNT / 8; + + if (pass) { + if ((dcpl_id = H5Pcreate(H5P_DATASET_CREATE)) < 0) { + pass = FALSE; + failure_mssg = "H5Pcreate() failed.\n"; + } + } + + if (pass) { + if ((H5Pset_chunk(dcpl_id, 1, chunk)) < 0) { + pass = FALSE; + failure_mssg = "H5Pset_chunk() failed.\n"; + } + } + + if (pass) { + + if ((dset_id_ch = H5Dcreate2(file_id, "dataset0_chunked", H5T_NATIVE_FLOAT, filespace, H5P_DEFAULT, + dcpl_id, H5P_DEFAULT)) < 0) { + pass = FALSE; + failure_mssg = "H5Dcreate2() failed.\n"; + } + } + + if (pass) { + if ((H5Dwrite(dset_id_ch, H5T_NATIVE_FLOAT, memspace, filespace, dxpl_id, data_slice)) < 0) { + pass = FALSE; + failure_mssg = "H5Dwrite() failed.\n"; + } + } + if (pass || (dcpl_id != -1)) { + if (H5Pclose(dcpl_id) < 0) { + pass = FALSE; + failure_mssg = "H5Pclose(dcpl_id) failed.\n"; + } + } + + if (pass || (dset_id_ch != -1)) { + if (H5Dclose(dset_id_ch) < 0) { + pass = FALSE; + failure_mssg = "H5Dclose(dset_id_ch) failed.\n"; + } + } + + /* close file, etc. */ + if (pass || (dset_id != -1)) { + if (H5Dclose(dset_id) < 0) { + pass = FALSE; + failure_mssg = "H5Dclose(dset_id) failed.\n"; + } + } + + if (pass || (memspace != -1)) { + if (H5Sclose(memspace) < 0) { + pass = FALSE; + failure_mssg = "H5Sclose(memspace) failed.\n"; + } + } + + if (pass || (filespace != -1)) { + if (H5Sclose(filespace) < 0) { + pass = FALSE; + failure_mssg = "H5Sclose(filespace) failed.\n"; + } + } + + if (pass || (file_id != -1)) { + if (H5Fclose(file_id) < 0) { + pass = FALSE; + failure_mssg = "H5Fclose(file_id) failed.\n"; + } + } + + if (pass || (dxpl_id != -1)) { + if (H5Pclose(dxpl_id) < 0) { + pass = FALSE; + failure_mssg = "H5Pclose(dxpl_id) failed.\n"; + } + } + + if (pass || (fapl_id != -1)) { + if (H5Pclose(fapl_id) < 0) { + pass = FALSE; + failure_mssg = "H5Pclose(fapl_id) failed.\n"; + } + } + + if (pass || (fctmpl != -1)) { + if (H5Pclose(fctmpl) < 0) { + pass = FALSE; + failure_mssg = "H5Pclose(fctmpl) failed.\n"; + } + } + + /* Add a userblock to the head of the datafile. + * We will use this to for a functional test of the + * file open optimization. This is superblock + * relocation is done by the rank 0 process associated + * with the communicator being used. For test 1, we + * utilize MPI_COMM_WORLD, so group_rank 0 is the + * same as mpi_rank 0. For test 2 which utilizes + * two groups resulting from an MPI_Comm_split, we + * will have parallel groups and hence two + * group_rank(0) processes. Each parallel group + * will create a unique file with different text + * headers and different data. + */ + if (group_rank == 0) { + const char *text_to_write; + size_t bytes_to_write; + + if (group_id == 0) + text_to_write = random_hdf5_text; + else + text_to_write = hitchhiker_quote; + + bytes_to_write = HDstrlen(text_to_write); + + if (pass) { + if ((header = HDopen(data_filename, O_WRONLY)) < 0) { + pass = FALSE; + failure_mssg = "HDopen(data_filename, O_WRONLY) failed.\n"; + } + } + + if (pass) { + HDlseek(header, 0, SEEK_SET); + if (HDwrite(header, text_to_write, bytes_to_write) < 0) { + pass = FALSE; + failure_mssg = "Unable to write user text into file.\n"; + } + } + + if (pass || (header > 0)) { + if (HDclose(header) < 0) { + pass = FALSE; + failure_mssg = "HDclose() failed.\n"; + } + } + } + + /* collect results from other processes. + * Only overwrite the failure message if no previous error + * has been detected + */ + local_failure = (pass ? 0 : 1); + + /* This is a global all reduce (NOT group specific) */ + if (MPI_Allreduce(&local_failure, &global_failures, 1, MPI_INT, MPI_SUM, MPI_COMM_WORLD) != MPI_SUCCESS) { + if (pass) { + pass = FALSE; + failure_mssg = "MPI_Allreduce() failed.\n"; + } + } + else if ((pass) && (global_failures > 0)) { + pass = FALSE; + failure_mssg = "One or more processes report failure.\n"; + } + + /* report results */ + if (mpi_rank == 0) { + if (pass) { + HDfprintf(stdout, "Done.\n"); + } + else { + HDfprintf(stdout, "FAILED.\n"); + HDfprintf(stdout, "%s: failure_mssg = \"%s\"\n", fcn_name, failure_mssg); + } + } + + /* free data_slice if it has been allocated */ + if (data_slice != NULL) { + HDfree(data_slice); + data_slice = NULL; + } + + return (!pass); + +} /* generate_test_file() */ + +/*------------------------------------------------------------------------- + * Function: test_parallel_read + * + * Purpose: This actually tests the superblock optimization + * and covers the three primary cases we're interested in. + * 1). That HDF5 files can be opened in parallel by + * the rank 0 process and that the superblock + * offset is correctly broadcast to the other + * parallel file readers. + * 2). That a parallel application can correctly + * handle reading multiple files by using + * subgroups of MPI_COMM_WORLD and that each + * subgroup operates as described in (1) to + * collectively read the data. + * 3). Testing proc0-read-and-MPI_Bcast using + * sub-communicators, and reading into + * a memory space that is different from the + * file space, and chunked datasets. + * + * The global MPI rank is used for reading and + * writing data for process specific data in the + * dataset. We do this rather simplisticly, i.e. + * rank 0: writes/reads 0-9999 + * rank 1: writes/reads 1000-1999 + * rank 2: writes/reads 2000-2999 + * ... + * + * Return: Success: 0 + * + * Failure: 1 + * + * Programmer: Richard Warren + * 10/1/17 + * + * Modifications: + * + *------------------------------------------------------------------------- + */ +static int +test_parallel_read(MPI_Comm comm, int mpi_rank, int mpi_size, int group_id) +{ + const char *failure_mssg; + const char *fcn_name = "test_parallel_read()"; + const char *group_filename = NULL; + char reloc_data_filename[FILENAME_BUF_SIZE]; + int local_failure = 0; + int global_failures = 0; + int group_size; + int group_rank; + hid_t fapl_id = -1; + hid_t file_id = -1; + hid_t dset_id = -1; + hid_t dset_id_ch = -1; + hid_t dxpl_id = H5P_DEFAULT; + hid_t memspace = -1; + hid_t filespace = -1; + hid_t filetype = -1; + size_t filetype_size; + hssize_t dset_size; + hsize_t i; + hsize_t offset; + hsize_t count = COUNT; + hsize_t dims[1] = {0}; + float nextValue; + float *data_slice = NULL; + + pass = TRUE; + + HDassert(comm != MPI_COMM_NULL); + + if ((MPI_Comm_rank(comm, &group_rank)) != MPI_SUCCESS) { + pass = FALSE; + failure_mssg = "test_parallel_read: MPI_Comm_rank failed.\n"; + } + + if ((MPI_Comm_size(comm, &group_size)) != MPI_SUCCESS) { + pass = FALSE; + failure_mssg = "test_parallel_read: MPI_Comm_size failed.\n"; + } + + if (mpi_rank == 0) { + if (comm == MPI_COMM_WORLD) { + TESTING("parallel file open test 1"); + } + else { + TESTING("parallel file open test 2"); + } + } + + /* allocate space for the data_slice array */ + if (pass) { + if ((data_slice = (float *)HDmalloc(COUNT * sizeof(float))) == NULL) { + pass = FALSE; + failure_mssg = "malloc of data_slice failed.\n"; + } + } + + /* Select the file file name to read + * Please see the comments in the 'generate_test_file' function + * for more details... + */ + if (pass) { + + if (comm == MPI_COMM_WORLD) /* test 1 */ + group_filename = FILENAMES[0]; + else if (group_id == 0) /* test 2 group 0 */ + group_filename = FILENAMES[1]; + else /* test 2 group 1 */ + group_filename = FILENAMES[2]; + + HDassert(group_filename); + if (h5_fixname(group_filename, H5P_DEFAULT, reloc_data_filename, sizeof(reloc_data_filename)) == + NULL) { + + pass = FALSE; + failure_mssg = "h5_fixname(1) failed.\n"; + } + } + + /* setup FAPL */ + if (pass) { + if ((fapl_id = H5Pcreate(H5P_FILE_ACCESS)) < 0) { + pass = FALSE; + failure_mssg = "H5Pcreate(H5P_FILE_ACCESS) failed.\n"; + } + } + + if (pass) { + if ((H5Pset_fapl_mpio(fapl_id, comm, MPI_INFO_NULL)) < 0) { + pass = FALSE; + failure_mssg = "H5Pset_fapl_mpio() failed\n"; + } + } + + /* open the file -- should have user block, exercising the optimization */ + if (pass) { + if ((file_id = H5Fopen(reloc_data_filename, H5F_ACC_RDONLY, fapl_id)) < 0) { + pass = FALSE; + failure_mssg = "H5Fopen() failed\n"; + } + } + + /* open the data set */ + if (pass) { + if ((dset_id = H5Dopen2(file_id, "dataset0", H5P_DEFAULT)) < 0) { + pass = FALSE; + failure_mssg = "H5Dopen2() failed\n"; + } + } + + /* open the chunked data set */ + if (pass) { + if ((dset_id_ch = H5Dopen2(file_id, "dataset0_chunked", H5P_DEFAULT)) < 0) { + pass = FALSE; + failure_mssg = "H5Dopen2() failed\n"; + } + } + + /* setup memspace */ + if (pass) { + dims[0] = count; + if ((memspace = H5Screate_simple(1, dims, NULL)) < 0) { + pass = FALSE; + failure_mssg = "H5Screate_simple(1, dims, NULL) failed\n"; + } + } + + /* setup filespace */ + if (pass) { + if ((filespace = H5Dget_space(dset_id)) < 0) { + pass = FALSE; + failure_mssg = "H5Dget_space(dataset) failed\n"; + } + } + + if (pass) { + offset = (hsize_t)group_rank * count; + if ((H5Sselect_hyperslab(filespace, H5S_SELECT_SET, &offset, NULL, &count, NULL)) < 0) { + pass = FALSE; + failure_mssg = "H5Sselect_hyperslab() failed\n"; + } + } + + /* read this processes section of the data */ + if (pass) { + if ((H5Dread(dset_id, H5T_NATIVE_FLOAT, memspace, filespace, H5P_DEFAULT, data_slice)) < 0) { + pass = FALSE; + failure_mssg = "H5Dread() failed\n"; + } + } + + /* verify the data */ + if (pass) { + nextValue = (float)((hsize_t)mpi_rank * count); + i = 0; + while ((pass) && (i < count)) { + /* what we really want is data_slice[i] != nextValue -- + * the following is a circumlocution to shut up the + * the compiler. + */ + if ((data_slice[i] > nextValue) || (data_slice[i] < nextValue)) { + pass = FALSE; + failure_mssg = "Unexpected dset contents.\n"; + } + nextValue += 1; + i++; + } + } + + if (pass || (memspace != -1)) { + if (H5Sclose(memspace) < 0) { + pass = FALSE; + failure_mssg = "H5Sclose(memspace) failed.\n"; + } + } + + if (pass || (filespace != -1)) { + if (H5Sclose(filespace) < 0) { + pass = FALSE; + failure_mssg = "H5Sclose(filespace) failed.\n"; + } + } + + /* free data_slice if it has been allocated */ + if (data_slice != NULL) { + HDfree(data_slice); + data_slice = NULL; + } + + /* + * Test reading proc0-read-and-bcast with sub-communicators + */ + + /* Don't test with more than LIMIT_NPROC processes to avoid memory issues */ + + if (group_size <= LIMIT_NPROC) { +#ifdef H5_HAVE_INSTRUMENTED_LIBRARY + hbool_t prop_value; +#endif /* H5_HAVE_INSTRUMENTED_LIBRARY */ + + if ((filespace = H5Dget_space(dset_id)) < 0) { + pass = FALSE; + failure_mssg = "H5Dget_space failed.\n"; + } + + if ((dset_size = H5Sget_simple_extent_npoints(filespace)) < 0) { + pass = FALSE; + failure_mssg = "H5Sget_simple_extent_npoints failed.\n"; + } + + if ((filetype = H5Dget_type(dset_id)) < 0) { + pass = FALSE; + failure_mssg = "H5Dget_type failed.\n"; + } + + if ((filetype_size = H5Tget_size(filetype)) == 0) { + pass = FALSE; + failure_mssg = "H5Tget_size failed.\n"; + } + + if (H5Tclose(filetype) < 0) { + pass = FALSE; + failure_mssg = "H5Tclose failed.\n"; + }; + + if ((data_slice = (float *)HDmalloc((size_t)dset_size * filetype_size)) == NULL) { + pass = FALSE; + failure_mssg = "malloc of data_slice failed.\n"; + } + + if (pass) { + if ((dxpl_id = H5Pcreate(H5P_DATASET_XFER)) < 0) { + pass = FALSE; + failure_mssg = "H5Pcreate(H5P_DATASET_XFER) failed.\n"; + } + } + + if (pass) { + if ((H5Pset_dxpl_mpio(dxpl_id, H5FD_MPIO_COLLECTIVE)) < 0) { + pass = FALSE; + failure_mssg = "H5Pset_dxpl_mpio() failed.\n"; + } + } + +#ifdef H5_HAVE_INSTRUMENTED_LIBRARY + if (pass) { + prop_value = H5D_XFER_COLL_RANK0_BCAST_DEF; + if (H5Pinsert2(dxpl_id, H5D_XFER_COLL_RANK0_BCAST_NAME, H5D_XFER_COLL_RANK0_BCAST_SIZE, + &prop_value, NULL, NULL, NULL, NULL, NULL, NULL) < 0) { + pass = FALSE; + failure_mssg = "H5Pinsert2() failed\n"; + } + } +#endif /* H5_HAVE_INSTRUMENTED_LIBRARY */ + + /* read H5S_ALL section */ + if (pass) { + if ((H5Dread(dset_id, H5T_NATIVE_FLOAT, H5S_ALL, H5S_ALL, dxpl_id, data_slice)) < 0) { + pass = FALSE; + failure_mssg = "H5Dread() failed\n"; + } + } + +#ifdef H5_HAVE_INSTRUMENTED_LIBRARY + if (pass) { + prop_value = FALSE; + if (H5Pget(dxpl_id, H5D_XFER_COLL_RANK0_BCAST_NAME, &prop_value) < 0) { + pass = FALSE; + failure_mssg = "H5Pget() failed\n"; + } + if (pass) { + if (prop_value != TRUE) { + pass = FALSE; + failure_mssg = "rank 0 Bcast optimization was mistakenly not performed\n"; + } + } + } +#endif /* H5_HAVE_INSTRUMENTED_LIBRARY */ + + /* verify the data */ + if (pass) { + + if (comm == MPI_COMM_WORLD) /* test 1 */ + nextValue = 0; + else if (group_id == 0) /* test 2 group 0 */ + nextValue = 0; + else /* test 2 group 1 */ + nextValue = (float)((hsize_t)(mpi_size / 2) * count); + + i = 0; + while ((pass) && (i < (hsize_t)dset_size)) { + /* what we really want is data_slice[i] != nextValue -- + * the following is a circumlocution to shut up the + * the compiler. + */ + if ((data_slice[i] > nextValue) || (data_slice[i] < nextValue)) { + pass = FALSE; + failure_mssg = "Unexpected dset contents.\n"; + } + nextValue += 1; + i++; + } + } + + /* read H5S_ALL section for the chunked dataset */ + +#ifdef H5_HAVE_INSTRUMENTED_LIBRARY + if (pass) { + prop_value = H5D_XFER_COLL_RANK0_BCAST_DEF; + if (H5Pset(dxpl_id, H5D_XFER_COLL_RANK0_BCAST_NAME, &prop_value) < 0) { + pass = FALSE; + failure_mssg = "H5Pset() failed\n"; + } + } +#endif /* H5_HAVE_INSTRUMENTED_LIBRARY */ + + for (i = 0; i < (hsize_t)dset_size; i++) { + data_slice[i] = 0; + } + if (pass) { + if ((H5Dread(dset_id_ch, H5T_NATIVE_FLOAT, H5S_ALL, H5S_ALL, dxpl_id, data_slice)) < 0) { + pass = FALSE; + failure_mssg = "H5Dread() failed\n"; + } + } + +#ifdef H5_HAVE_INSTRUMENTED_LIBRARY + if (pass) { + prop_value = FALSE; + if (H5Pget(dxpl_id, H5D_XFER_COLL_RANK0_BCAST_NAME, &prop_value) < 0) { + pass = FALSE; + failure_mssg = "H5Pget() failed\n"; + } + if (pass) { + if (prop_value == TRUE) { + pass = FALSE; + failure_mssg = "rank 0 Bcast optimization was mistakenly performed for chunked dataset\n"; + } + } + } +#endif /* H5_HAVE_INSTRUMENTED_LIBRARY */ + + /* verify the data */ + if (pass) { + + if (comm == MPI_COMM_WORLD) /* test 1 */ + nextValue = 0; + else if (group_id == 0) /* test 2 group 0 */ + nextValue = 0; + else /* test 2 group 1 */ + nextValue = (float)((hsize_t)(mpi_size / 2) * count); + + i = 0; + while ((pass) && (i < (hsize_t)dset_size)) { + /* what we really want is data_slice[i] != nextValue -- + * the following is a circumlocution to shut up the + * the compiler. + */ + if ((data_slice[i] > nextValue) || (data_slice[i] < nextValue)) { + pass = FALSE; + failure_mssg = "Unexpected chunked dset contents.\n"; + } + nextValue += 1; + i++; + } + } + + if (pass || (filespace != -1)) { + if (H5Sclose(filespace) < 0) { + pass = FALSE; + failure_mssg = "H5Sclose(filespace) failed.\n"; + } + } + + /* free data_slice if it has been allocated */ + if (data_slice != NULL) { + HDfree(data_slice); + data_slice = NULL; + } + + /* + * Read an H5S_ALL filespace into a hyperslab defined memory space + */ + + if ((data_slice = (float *)HDmalloc((size_t)(dset_size * 2) * filetype_size)) == NULL) { + pass = FALSE; + failure_mssg = "malloc of data_slice failed.\n"; + } + + /* setup memspace */ + if (pass) { + dims[0] = (hsize_t)dset_size * 2; + if ((memspace = H5Screate_simple(1, dims, NULL)) < 0) { + pass = FALSE; + failure_mssg = "H5Screate_simple(1, dims, NULL) failed\n"; + } + } + if (pass) { + offset = (hsize_t)dset_size; + if ((H5Sselect_hyperslab(memspace, H5S_SELECT_SET, &offset, NULL, &offset, NULL)) < 0) { + pass = FALSE; + failure_mssg = "H5Sselect_hyperslab() failed\n"; + } + } + +#ifdef H5_HAVE_INSTRUMENTED_LIBRARY + if (pass) { + prop_value = H5D_XFER_COLL_RANK0_BCAST_DEF; + if (H5Pset(dxpl_id, H5D_XFER_COLL_RANK0_BCAST_NAME, &prop_value) < 0) { + pass = FALSE; + failure_mssg = "H5Pset() failed\n"; + } + } +#endif /* H5_HAVE_INSTRUMENTED_LIBRARY */ + + /* read this processes section of the data */ + if (pass) { + if ((H5Dread(dset_id, H5T_NATIVE_FLOAT, memspace, H5S_ALL, dxpl_id, data_slice)) < 0) { + pass = FALSE; + failure_mssg = "H5Dread() failed\n"; + } + } + +#ifdef H5_HAVE_INSTRUMENTED_LIBRARY + if (pass) { + prop_value = FALSE; + if (H5Pget(dxpl_id, H5D_XFER_COLL_RANK0_BCAST_NAME, &prop_value) < 0) { + pass = FALSE; + failure_mssg = "H5Pget() failed\n"; + } + if (pass) { + if (prop_value != TRUE) { + pass = FALSE; + failure_mssg = "rank 0 Bcast optimization was mistakenly not performed\n"; + } + } + } +#endif /* H5_HAVE_INSTRUMENTED_LIBRARY */ + + /* verify the data */ + if (pass) { + + if (comm == MPI_COMM_WORLD) /* test 1 */ + nextValue = 0; + else if (group_id == 0) /* test 2 group 0 */ + nextValue = 0; + else /* test 2 group 1 */ + nextValue = (float)((hsize_t)(mpi_size / 2) * count); + + i = (hsize_t)dset_size; + while ((pass) && (i < (hsize_t)dset_size)) { + /* what we really want is data_slice[i] != nextValue -- + * the following is a circumlocution to shut up the + * the compiler. + */ + if ((data_slice[i] > nextValue) || (data_slice[i] < nextValue)) { + pass = FALSE; + failure_mssg = "Unexpected dset contents.\n"; + } + nextValue += 1; + i++; + } + } + + if (pass || (memspace != -1)) { + if (H5Sclose(memspace) < 0) { + pass = FALSE; + failure_mssg = "H5Sclose(memspace) failed.\n"; + } + } + + /* free data_slice if it has been allocated */ + if (data_slice != NULL) { + HDfree(data_slice); + data_slice = NULL; + } + + if (pass || (dxpl_id != -1)) { + if (H5Pclose(dxpl_id) < 0) { + pass = FALSE; + failure_mssg = "H5Pclose(dxpl_id) failed.\n"; + } + } + } + + /* close file, etc. */ + if (pass || (dset_id != -1)) { + if (H5Dclose(dset_id) < 0) { + pass = FALSE; + failure_mssg = "H5Dclose(dset_id) failed.\n"; + } + } + + if (pass || (dset_id_ch != -1)) { + if (H5Dclose(dset_id_ch) < 0) { + pass = FALSE; + failure_mssg = "H5Dclose(dset_id_ch) failed.\n"; + } + } + + if (pass || (file_id != -1)) { + if (H5Fclose(file_id) < 0) { + pass = FALSE; + failure_mssg = "H5Fclose(file_id) failed.\n"; + } + } + + if (pass || (fapl_id != -1)) { + if (H5Pclose(fapl_id) < 0) { + pass = FALSE; + failure_mssg = "H5Pclose(fapl_id) failed.\n"; + } + } + + /* collect results from other processes. + * Only overwrite the failure message if no previous error + * has been detected + */ + local_failure = (pass ? 0 : 1); + + if (MPI_Allreduce(&local_failure, &global_failures, 1, MPI_INT, MPI_SUM, MPI_COMM_WORLD) != MPI_SUCCESS) { + if (pass) { + pass = FALSE; + failure_mssg = "MPI_Allreduce() failed.\n"; + } + } + else if ((pass) && (global_failures > 0)) { + pass = FALSE; + failure_mssg = "One or more processes report failure.\n"; + } + + /* report results and finish cleanup */ + if (group_rank == 0) { + if (pass) { + PASSED(); + } + else { + H5_FAILED(); + HDfprintf(stdout, "%s: failure_mssg = \"%s\"\n", fcn_name, failure_mssg); + } + HDremove(reloc_data_filename); + } + + return (!pass); + +} /* test_parallel_read() */ + +/*------------------------------------------------------------------------- + * Function: main + * + * Purpose: To implement a parallel test which validates whether the + * new superblock lookup functionality is working correctly. + * + * The test consists of creating two separate HDF datasets + * in which random text is inserted at the start of each + * file using the 'j5jam' application. This forces the + * HDF5 file superblock to a non-zero offset. + * Having created the two independent files, we create two + * non-overlapping MPI groups, each of which is then tasked + * with the opening and validation of the data contained + * therein. + * + * Return: Success: 0 + * Failure: 1 + * + * Programmer: Richard Warren + * 10/1/17 + *------------------------------------------------------------------------- + */ + +int +main(int argc, char **argv) +{ + int nerrs = 0; + int which_group = 0; + int mpi_rank; + int mpi_size; + int split_size; + MPI_Comm group_comm = MPI_COMM_NULL; + + /* I don't believe that argv[0] can ever be NULL. + * It should thus be safe to dup and save as a check + * for cmake testing. Note that in our Cmake builds, + * all executables are located in the same directory. + * We assume (but we'll check) that the h5jam utility + * is in the directory as this executable. If that + * isn't true, then we can use a relative path that + * should be valid for the autotools environment. + */ + test_argv0 = HDstrdup(argv[0]); + + if ((MPI_Init(&argc, &argv)) != MPI_SUCCESS) { + HDfprintf(stderr, "FATAL: Unable to initialize MPI\n"); + HDexit(EXIT_FAILURE); + } + + if ((MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank)) != MPI_SUCCESS) { + HDfprintf(stderr, "FATAL: MPI_Comm_rank returned an error\n"); + HDexit(EXIT_FAILURE); + } + + if ((MPI_Comm_size(MPI_COMM_WORLD, &mpi_size)) != MPI_SUCCESS) { + HDfprintf(stderr, "FATAL: MPI_Comm_size returned an error\n"); + HDexit(EXIT_FAILURE); + } + + H5open(); + + if (mpi_rank == 0) { + HDfprintf(stdout, "========================================\n"); + HDfprintf(stdout, "Collective file open optimization tests\n"); + HDfprintf(stdout, " mpi_size = %d\n", mpi_size); + HDfprintf(stdout, "========================================\n"); + } + + if (mpi_size < 3) { + + if (mpi_rank == 0) { + + HDprintf(" Need at least 3 processes. Exiting.\n"); + } + goto finish; + } + + /* ------ Create two (2) MPI groups ------ + * + * We split MPI_COMM_WORLD into 2 more or less equal sized + * groups. The resulting communicators will be used to generate + * two HDF files which in turn will be opened in parallel and the + * contents verified in the second read test below. + */ + split_size = mpi_size / 2; + which_group = (mpi_rank < split_size ? 0 : 1); + + if ((MPI_Comm_split(MPI_COMM_WORLD, which_group, 0, &group_comm)) != MPI_SUCCESS) { + + HDfprintf(stderr, "FATAL: MPI_Comm_split returned an error\n"); + HDexit(EXIT_FAILURE); + } + + /* ------ Generate all files ------ */ + + /* We generate the file used for test 1 */ + nerrs += generate_test_file(MPI_COMM_WORLD, mpi_rank, which_group); + + if (nerrs > 0) { + if (mpi_rank == 0) { + HDprintf(" Test(1) file construction failed -- skipping tests.\n"); + } + goto finish; + } + + /* We generate the file used for test 2 */ + nerrs += generate_test_file(group_comm, mpi_rank, which_group); + + if (nerrs > 0) { + if (mpi_rank == 0) { + HDprintf(" Test(2) file construction failed -- skipping tests.\n"); + } + goto finish; + } + + /* Now read the generated test file (still using MPI_COMM_WORLD) */ + nerrs += test_parallel_read(MPI_COMM_WORLD, mpi_rank, mpi_size, which_group); + + if (nerrs > 0) { + if (mpi_rank == 0) { + HDprintf(" Parallel read test(1) failed -- skipping tests.\n"); + } + goto finish; + } + + /* Update the user on our progress so far. */ + if (mpi_rank == 0) { + HDprintf(" Test 1 of 2 succeeded\n"); + HDprintf(" -- Starting multi-group parallel read test.\n"); + } + + /* run the 2nd set of tests */ + nerrs += test_parallel_read(group_comm, mpi_rank, mpi_size, which_group); + + if (nerrs > 0) { + if (mpi_rank == 0) { + HDprintf(" Multi-group read test(2) failed\n"); + } + goto finish; + } + + if (mpi_rank == 0) { + HDprintf(" Test 2 of 2 succeeded\n"); + } + +finish: + + if ((group_comm != MPI_COMM_NULL) && (MPI_Comm_free(&group_comm)) != MPI_SUCCESS) { + HDfprintf(stderr, "MPI_Comm_free failed!\n"); + } + + /* make sure all processes are finished before final report, cleanup + * and exit. + */ + MPI_Barrier(MPI_COMM_WORLD); + + if (mpi_rank == 0) { /* only process 0 reports */ + const char *header = "Collective file open optimization tests"; + + HDfprintf(stdout, "===================================\n"); + if (nerrs > 0) { + HDfprintf(stdout, "***%s detected %d failures***\n", header, nerrs); + } + else { + HDfprintf(stdout, "%s finished with no failures\n", header); + } + HDfprintf(stdout, "===================================\n"); + } + + /* close HDF5 library */ + if (H5close() != SUCCEED) { + HDfprintf(stdout, "H5close() failed. (Ignoring)\n"); + } + + /* MPI_Finalize must be called AFTER H5close which may use MPI calls */ + MPI_Finalize(); + + /* cannot just return (nerrs) because exit code is limited to 1byte */ + return ((nerrs > 0) ? EXIT_FAILURE : EXIT_SUCCESS); + +} /* main() */ |