From 00db3355adaf1dc517e622c74de53ca40c5f73f6 Mon Sep 17 00:00:00 2001 From: vchoi Date: Wed, 16 Jun 2021 10:05:56 -0500 Subject: Add new test that handles chunk operations for chunked datasets. --- MANIFEST | 2 + test/Makefile.am | 4 + test/testvfdswmr.sh.in | 75 +- test/vfd_swmr_dsetchks_writer.c | 2246 +++++++++++++++++++++++++++++++++++++++ 4 files changed, 2325 insertions(+), 2 deletions(-) create mode 100644 test/vfd_swmr_dsetchks_writer.c diff --git a/MANIFEST b/MANIFEST index b73a726..0d20db2 100644 --- a/MANIFEST +++ b/MANIFEST @@ -1404,6 +1404,8 @@ ./test/vfd_swmr.c ./test/vfd_swmr_addrem_writer.c ./test/vfd_swmr_attrdset_writer.c +./test/vfd_swmr_dsetops_writer.c +./test/vfd_swmr_dsetchks_writer.c ./test/vfd_swmr_bigset_writer.c ./test/vfd_swmr_check_compat.c ./test/vfd_swmr_common.c diff --git a/test/Makefile.am b/test/Makefile.am index 2d76946..ee35664 100644 --- a/test/Makefile.am +++ b/test/Makefile.am @@ -112,6 +112,7 @@ check_PROGRAMS=$(TEST_PROG) error_test err_compat tcheck_version \ vfd_swmr_zoo_reader vfd_swmr_zoo_writer \ vfd_swmr_attrdset_reader vfd_swmr_attrdset_writer \ vfd_swmr_check_compat \ + vfd_swmr_dsetchks_reader vfd_swmr_dsetchks_writer \ swmr_check_compat_vfd vds_env vds_swmr_gen vds_swmr_reader vds_swmr_writer \ mirror_vfd if HAVE_SHARED_CONDITIONAL @@ -182,6 +183,9 @@ vfd_swmr_dsetops_reader_SOURCES=vfd_swmr_dsetops_writer.c vfd_swmr_attrdset_writer_SOURCES=vfd_swmr_attrdset_writer.c vfd_swmr_attrdset_reader_SOURCES=vfd_swmr_attrdset_writer.c +vfd_swmr_dsetchks_writer_SOURCES=vfd_swmr_dsetchks_writer.c +vfd_swmr_dsetchks_reader_SOURCES=vfd_swmr_dsetchks_writer.c + # Additional target for running timing test timings _timings: testmeta @for timing in $(TIMINGS) dummy; do \ diff --git a/test/testvfdswmr.sh.in b/test/testvfdswmr.sh.in index 69f4235..b0ab785 100644 --- a/test/testvfdswmr.sh.in +++ b/test/testvfdswmr.sh.in @@ -68,6 +68,13 @@ DSETOPS_FIFO_WRITER_TO_READER=fifo_dsetops_writer_to_reader DSETOPS_FIFO_READER_TO_WRITER=fifo_dsetops_reader_to_writer ############################################################################### +## For dsetchks test: definitions for fifo files to coordinate test runs +############################################################################### +# +DSETCHKS_FIFO_WRITER_TO_READER=fifo_dsetchks_writer_to_reader +DSETCHKS_FIFO_READER_TO_WRITER=fifo_dsetchks_reader_to_writer + +############################################################################### ## short hands and function definitions ############################################################################### # @@ -138,9 +145,9 @@ all_tests="generator expand shrink expand_shrink sparse vlstr_null vlstr_oob zoo all_tests="${all_tests} groups groups_attrs groups_ops few_big many_small attrdset" tests=${all_tests} -# For exhaustive run, add: os_groups_attrs, os_groups_ops, dsetops +# For exhaustive run, add: os_groups_attrs, os_groups_ops, dsetops, dsetchks if [[ "$HDF5TestExpress" -eq 0 ]] ; then # exhaustive run - all_tests="${all_tests} os_groups_attrs os_groups_ops dsetops" + all_tests="${all_tests} os_groups_attrs os_groups_ops dsetops dsetchks" fi if [ $# -gt 0 ]; then @@ -1252,6 +1259,70 @@ for options in "-p -e 20 -t -q" "-g -m 5 -n 2 -s 10 -w 7 -q" "-k -m 10 -n 5 -r 5 done ############################################################################### +# +# "dsetchks" test +# +# Only for exhaustive run +# +############################################################################### +# +# +dsetchks_list=( + "-s -m 8 -n 3 -g 1 -q" + "-i -o -g 3 -q" + "-f -p 4 -q" + "-e -m 3 -n 5 -t 1 -q" + "-r -m 11 -n 5 -l 7 -q" + "-f -x 5 -y 2 -q" + ) +for options in "${dsetchks_list[@]}"; do + # + # + if [ ${do_dsetchks:-no} = no ]; then + continue + fi + # Clean up any existing fifo files from previous runs + if [ -e ./$DSETCHKS_FIFO_WRITER_TO_READER ]; then # If writer fifo file is found + rm -f ./$DSETCHKS_FIFO_WRITER_TO_READER + fi + if [ -e ./$DSETCHKS_FIFO_READER_TO_WRITER ]; then # If reader fifo file is found + rm -f ./$DSETCHKS_FIFO_READER_TO_WRITER + fi + # + echo launch vfd_swmr_dsetchks_writer dsetchks, options $options ......may take some time...... + catch_out_err_and_rc vfd_swmr_dsetchks_writer \ + ../vfd_swmr_dsetchks_writer $options & + pid_writer=$! + + catch_out_err_and_rc vfd_swmr_dsetchks_reader \ + ../vfd_swmr_dsetchks_reader $options & + pid_reader=$! + + # Wait for the reader to finish before signaling the + # writer to quit: the writer holds the file open so that the + # reader will find the shadow file when it opens + # the .h5 file. + wait $pid_reader + wait $pid_writer + + # Collect exit code of the reader + if [ $(cat vfd_swmr_dsetchks_reader.rc) -ne 0 ]; then + echo reader had error + nerrors=$((nerrors + 1)) + fi + + # Collect exit code of the writer + if [ $(cat vfd_swmr_dsetchks_writer.rc) -ne 0 ]; then + echo writer had error + nerrors=$((nerrors + 1)) + fi + + # Clean up output files + rm -f vfd_swmr_dsetchks_writer.{out,rc} + rm -f vfd_swmr_dsetchks_reader.*.{out,rc} +done + +############################################################################### ## Report and exit ############################################################################### cd .. diff --git a/test/vfd_swmr_dsetchks_writer.c b/test/vfd_swmr_dsetchks_writer.c new file mode 100644 index 0000000..9f8176b --- /dev/null +++ b/test/vfd_swmr_dsetchks_writer.c @@ -0,0 +1,2246 @@ +/* + * Copyright by The HDF Group. + * 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 COPYING file, which can be found at the root of the source code + * distribution tree, or in https://support.hdfgroup.org/ftp/HDF5/releases. + * If you do not have access to either file, you may request a copy from + * help@hdfgroup.org. + */ + +/* + * Purpose: To test chunk operations for chunked dataset specifically: + * --chunked datasets with the 5 indexing types: + * 1. single (dims=max_dims=chunk_dims, default incremental allocation) + * 2. implicit (dims=max_dims, early allocation, no filter) + * 3. fixed array (fixed max_dims, default incremental allocation) + * 4. extensible array (1 unlimited max_dims, default incremental allocation) + * 5. btree2 (2 unlimited max_dims, default incremental allocation) + * + * --with compression--H5Pset_shuffle(dcpl) + * --with fill values--H5Pset_fill_value(dcpl, H5T_NATIVE_INT, &fillval); + * + * Types of chunk operations: + * -- writes that cover a single chunk + * -- writes that cover a partial chunk + * -- writes that cover multiple chunks + * -- writes that cover multiple partial chunks + * + * For fa, ea, bt2 indexes: + * --increase size of dataset dimensions + * --decrease size of dataset dimensions + */ +#include "hdf5.h" +#include "testhdf5.h" +#include "vfd_swmr_common.h" + +#ifndef H5_HAVE_WIN32_API + +#define READER_WAIT_TICKS 4 + +/* Names for datasets */ +#define DSET_SINGLE_NAME "chunked_single" +#define DSET_IMPLICIT_NAME "chunked_implicit" +#define DSET_FA_NAME "chunked_fa" +#define DSET_EA_NAME "chunked_ea" +#define DSET_BT2_NAME "chunked_bt2" + +/* Operations for testing */ +#define GWRITES 1 /* Writes that cover a single chunk per write */ +#define PWRITES 2 /* Writes that cover a partial chunk per write */ +#define TWRITES 3 /* Writes that cover multiple chunks per write */ +#define LWRITES 4 /* Writes that cover multiple partial chunks per write */ +#define INCR_EXT 5 /* Increase dataset dimenion sizes */ +#define DECR_EXT 6 /* Decrease dataset dimension sizes */ + +/* Fill values */ +#define FILL_INIT 1 /* Fill value used when creating the datasets */ +#define FILL_FULL 7 /* Fill value used when writing a full chunk */ +#define FILL_PARTIAL 9 /* Fill value used when writing partial chunk(s) */ + +#define MULTI_CHUNKS 2 + +/* Structure to hold info for options specified */ +typedef struct { + char filename[PATH_MAX]; /* File name */ + char progname[PATH_MAX]; /* Program name */ + hid_t file; /* File ID */ + hid_t filetype; /* Datatype ID */ + unsigned int update_interval; /* For -u option */ + unsigned int csteps; /* For -c option */ + bool use_np; /* For -N option */ + bool use_vfd_swmr; /* For -S option */ + bool use_filter; /* For -o option */ + + bool single_index; /* -s option: create a chunked dataset with single chunk index */ + bool implicit_index; /* -i option: create a chunked datasets with implicit chunk index */ + bool fa_index; /* -f option: create a chunked dataset with fixed array index */ + bool ea_index; /* -e option: create a chunked dataset with extensible array index */ + bool bt2_index; /* -r option: create a chunked dataset with version 2 btree index */ + + unsigned int rows; /* -m option for the chunked datasets */ + unsigned int cols; /* -n option: writes that cover a single chunk per write */ + unsigned int pwrites; /* -p option: writes that cover a partial chunk per write */ + unsigned int twrites; /* -t option: writes that cover multiple chunks per write */ + unsigned int lwrites; /* -l option: writes that cover multiple partial chunks per write */ + + unsigned int xincrs; /* -x option */ + unsigned int ydecrs; /* -y option */ +} state_t; + +/* Initializations for state_t */ +#define ALL_HID_INITIALIZER (state_t) { \ + .filename = "" \ + , .file = H5I_INVALID_HID \ + , .filetype = H5T_NATIVE_UINT32 \ + , .update_interval = READER_WAIT_TICKS \ + , .csteps = 1 \ + , .use_np = true \ + , .use_vfd_swmr = true \ + , .use_filter = false \ + , .single_index = false \ + , .implicit_index = false \ + , .fa_index = false \ + , .ea_index = false \ + , .bt2_index = false \ + , .rows = 10 \ + , .cols = 5 \ + , .gwrites = 0 \ + , .pwrites = 0 \ + , .twrites = 0 \ + , .lwrites = 0 \ + , .xincrs = 0 \ + , .ydecrs = 0 } + +/* Structure to hold info for different dataset types */ +typedef struct { + hsize_t chunk_dims[2]; /* Chunk dimensions for all datasets except single_did */ + hsize_t scaled_dims[2]; + hsize_t multi_scaled[2]; + hid_t single_did; /* ID for chunked dataset: single index */ + hid_t implicit_did; /* ID for chunked dataset: implicit index */ + hid_t fa_did; /* ID for chunked dataset: fixed array index */ + hid_t ea_did; /* ID for chunked dataset: extensible array index */ + hid_t bt2_did; /* ID for chunked dataset: version 2 btree index */ +} dsets_state_t; + +/* Initializations for dsets_state_t */ +#define DSETS_INITIALIZER (dsets_state_t) { \ + .single_did = H5I_INVALID_HID \ + , .implicit_did = H5I_INVALID_HID \ + , .fa_did = H5I_INVALID_HID \ + , .ea_did = H5I_INVALID_HID \ + , .bt2_did = H5I_INVALID_HID } + +/* Structure to hold info for named pipes */ +typedef struct { + const char *fifo_writer_to_reader; /* Name of fifo for writer to reader */ + const char *fifo_reader_to_writer; /* Name of fifo for reader to writer */ + int fd_writer_to_reader; /* File ID for fifo from writer to reader */ + int fd_reader_to_writer; /* File ID for fifo from reader to writer */ + int notify; /* Value to notify between writer and reader */ + int verify; /* Value to verify between writer and reader */ +} np_state_t; + +/* Initializations for np_state_t */ +#define NP_INITIALIZER (np_state_t) { \ + .fifo_writer_to_reader = "./fifo_dsetchks_writer_to_reader" \ + , .fifo_reader_to_writer = "./fifo_dsetchks_reader_to_writer" \ + , .fd_writer_to_reader = -1 \ + , .fd_reader_to_writer = -1 \ + , .notify = 0 \ + , .verify = 0 } + +static bool state_init(state_t *, int, char **); + +static bool np_init(np_state_t *np, bool writer); +static bool np_close(np_state_t *np, bool writer); +static bool np_writer(bool result, unsigned step, const state_t *s, np_state_t *np, H5F_vfd_swmr_config_t *config); +static bool np_reader(bool result, unsigned step, const state_t *s, np_state_t *np); +static bool np_confirm_verify_notify(int fd, unsigned step, const state_t *s, np_state_t *np); + +static bool create_dsets(const state_t *s, dsets_state_t *ds); +static bool open_dsets(const state_t *s, dsets_state_t *ds); +static bool close_dsets(const dsets_state_t *ds); +static void set_chunk_scaled_dims(const state_t *s, dsets_state_t *ds); + +static bool perform_dsets_operations(state_t *s, dsets_state_t *ds, + H5F_vfd_swmr_config_t *config, np_state_t *np); + +static bool write_dsets_chunks(unsigned action, const state_t *s, const dsets_state_t *ds, unsigned step); +static void setup_selection(unsigned action, unsigned which, const state_t *s, const dsets_state_t *ds, + hsize_t *start, hsize_t *stride, hsize_t *count, hsize_t *block); +static void check_set_edge_block(const state_t *s, const dsets_state_t *ds, + unsigned i, unsigned j, hsize_t *block); +static void check_set_partial_block(unsigned action, const hsize_t *dims, hsize_t *block, hsize_t *start); +static bool write_dset(unsigned action, hid_t did, hid_t tid, + hsize_t *start, hsize_t *stride, hsize_t *count, hsize_t *block); +static bool write_dset_single(unsigned action, const state_t *s, const dsets_state_t *ds); + +static bool dsets_extent(unsigned action, const state_t *s, const dsets_state_t *ds); +static bool dset_extent_real(unsigned action, hid_t did, const hsize_t *chunk_dims); + +static bool verify_dsets_operations(state_t *s, dsets_state_t *ds, H5F_vfd_swmr_config_t *config, np_state_t *np); + +static bool verify_dsets_chunks(unsigned action, const state_t *s, const dsets_state_t *ds, unsigned which); +static bool verify_read_dset(unsigned action, hid_t did, hid_t tid, + hsize_t *start, hsize_t *stride, hsize_t *count, hsize_t *block); +static bool verify_read_dset_single(unsigned action, const state_t *s, const dsets_state_t *ds); + +static bool verify_dsets_extent(unsigned action, const state_t *s, const dsets_state_t *ds, unsigned which); +static bool verify_dset_extent_real(unsigned action, hid_t did, + unsigned rows, unsigned cols, unsigned which); + +static const hid_t badhid = H5I_INVALID_HID; + +static void +usage(const char *progname) +{ + fprintf(stderr, "usage: %s \n" + " [-s] [-i] [-f] [-e] [-r]\n" + " [-m rows] [-n cols]\n" + " [-g gwrites] [-p pwrites] [-t twrites] [-l lwrites]\n" + " [-x xincrs] [-y decrs]\n" + " [-u nticks] [-c csteps] [-S] [-N] [-q] [-b] [-o]\n", progname); + + fprintf(stderr, "\n" + "-s: create a 2-d chunked dataset with single index\n" + "-i: create a 2-d chunked dataset with implicit index\n" + "-f: create a 2-d chunked dataset with fixed array index\n" + "-e: create a 2-d chunked dataset with extensible array index\n" + "-r: create a 2-d chunked dataset with v2 btree index\n" + "-m rows: # of rows for the datasets\n" + "-n cols: # of columns for the chunked datasets\n" + "-g gwrites: perform writes that cover a single chunk per write to datasets\n" + "-p pwrites: perform writes that cover a single partial chunk per write to datasets\n" + "-t twrites: perform writes that cover multiple chunks per write to datasets\n" + "-l lwrites: perform writes that cover multiple partial chunks per write to datasets\n" + "-x xincrs: increase dataset dimension size by 1 for times to datasets\n" + "-y ydecrs: decrease dataset dimension size by 1 for times to datasets\n" + "-u nticks: `nticks` ticks for the reader to wait before verification\n" + " (default is 4)\n" + "-c csteps: `csteps` steps communication interval between reader and writer\n" + " (default is 1)\n" + "-S: do not use VFD SWMR\n" + "-N: do not use named pipes for test synchronization\n" + "-q: silence printouts, few messages\n" + "-b: write data in big-endian byte order\n" + " (default is H5T_NATIVE_UINT32)\n\n" + "-o: enable compression (shuffle filter) for the datasets\n"); + + fprintf(stderr, "\n" + "Note:\n" + "1. Require to specify at least -s, -i, -f, -e or -r option\n" + "2. -m and -n options: and have to be > 0.\n" + "3. The chunk size for datasets is /2 by \n" + "4. The maximum dimension for dataset with fixed array index is: *2 by *2\n" + "5. Writes to dataset with single index:\n" + " -g and -t options will be the same: write one single chunk\n" + " -p and -l options will be the same: write one single partial chunk\n" + "6. Writes to dataset with implicit/fixed array/extensible array/v2 btree index:\n" + " i) Partial chunk writes to datasets via -p or -l option:\n" + " Apply only to a single or a multiple chunk with size > 2 in both dimensions\n" + " Otherwise, the whole chunk (single or multiple) is written\n" + " ii) Multiple chunk writes to datasets via -t or -l option:\n" + " Will expand the chunk size by 2 for both dimensions\n" + "7. Increase/decrease dataset dimension sizes to datasets:\n" + " Apply only for datasets with fixed array/extensible array/v2 btree index\n" + " -x option: for dataset with fixed array index, the increase cannot exceed maximum dimension\n" + " -y option: the decrease cannot go below the dataset's chunk size\n" + "8. -c option cannot exceed the input for the following options:\n" + " -g or -p or\n" + " -t or -l or\n" + " -x or -y \n" + "\n"); + + exit(EXIT_FAILURE); +} /* usage() */ + +/* + * Initialize option info in state_t + */ +static bool +state_init(state_t *s, int argc, char **argv) +{ + unsigned long tmp; + int ch; + char tfile[PATH_MAX]; + char *end; + + *s = ALL_HID_INITIALIZER; + esnprintf(tfile, sizeof(tfile), "%s", argv[0]); + esnprintf(s->progname, sizeof(s->progname), "%s", basename(tfile)); + + while ((ch = getopt(argc, argv, "siferom:n:x:y:g:p:t:l:bqSNu:c:")) != -1) { + switch (ch) { + + case 's': /* A chunked dataset with single index */ + s->single_index = true; + break; + + case 'i': /* A chunked dataset with implicit index */ + s->implicit_index = true; + break; + + case 'f': /* A chunked dataset with fixed array index */ + s->fa_index = true; + break; + + case 'e': /* A chunked dataset with extensible array index */ + s->ea_index = true; + break; + + case 'r': /* A chunked dataset with version 2 btree index */ + s->bt2_index = true; + break; + + case 'o': /* A chunked dataset with version 2 btree index */ + s->use_filter = true; + break; + + case 'q': /* Be quiet: few/no progress messages */ + verbosity = 0; + break; + + case 'b': /* Write data in big-endian byte order */ + s->filetype = H5T_STD_U32BE; + break; + + case 'S': /* Disable VFD SWMR */ + s->use_vfd_swmr = false; + break; + + case 'N': /* Disable named pipes synchronization */ + s->use_np = false; + break; + + case 'm': /* # of rows for datasets */ + case 'n': /* # of cols for datasets */ + case 'x': /* Increase by 1 for times */ + case 'y': /* Decrease by 1 for times */ + case 'g': /* # of writes that cover a single chunk per write */ + case 'p': /* # of writes that cover a single partial chunk per write */ + case 't': /* # of writes that cover multiple chunks per write */ + case 'l': /* # of writes that cover multiple partial chunks per write */ + case 'u': /* Ticks for reader to wait before verification */ + case 'c': /* Communication interval */ + errno = 0; + tmp = strtoul(optarg, &end, 0); + if (end == optarg || *end != '\0') { + printf("couldn't parse `-%c` argument `%s`\n", ch, optarg); + TEST_ERROR; + } else if (errno != 0) { + printf("couldn't parse `-%c` argument `%s`\n", ch, optarg); + TEST_ERROR; + } else if (tmp > UINT_MAX) { + printf("`-%c` argument `%lu` too large\n", ch, tmp); + TEST_ERROR; + } + + if (ch == 'm') + s->rows = (unsigned)tmp; + else if (ch == 'n') + s->cols = (unsigned)tmp; + else if (ch == 'x') + s->xincrs = (unsigned)tmp; + else if (ch == 'y') + s->ydecrs = (unsigned)tmp; + else if (ch == 'g') + s->gwrites = (unsigned)tmp; + else if (ch == 'p') + s->pwrites = (unsigned)tmp; + else if (ch == 't') + s->twrites = (unsigned)tmp; + else if (ch == 'l') + s->lwrites = (unsigned)tmp; + else if (ch == 'u') + s->update_interval = (unsigned)tmp; + else if (ch == 'c') + s->csteps = (unsigned)tmp; + + break; + + case '?': + default: + usage(s->progname); + break; + } + } + argc -= optind; + argv += optind; + + /* Require to specify at least -s or -i or -f or -e or -r option */ + if(!s->single_index && !s->implicit_index && + !s->fa_index && !s->ea_index && !s->bt2_index) { + printf("Require to specify at least -s or -i or -f or -e or -r option\n"); + usage(s->progname); + goto error; + } + + /* -x or -y option only apply to dataset with fixed/extensible array/v2 btree index */ + if((s->single_index || s->implicit_index) && (s->xincrs || s->ydecrs)) { + printf("-x or -y option not applicable to dataset with single or implicit index\n"); + usage(s->progname); + goto error; + } + + /* rows and cols cannot be zero */ + if(s->rows == 0 || s->cols == 0) { + printf("-m or -n cannot be zero\n"); + TEST_ERROR; + } + + /* -c cannot be zero */ + if(!s->csteps) { + printf("communication interval cannot be zero\n"); + TEST_ERROR; + } + + /* -c and -g options */ + if(s->gwrites && s->csteps > s->gwrites) { + printf("communication interval with -g is out of bounds\n"); + TEST_ERROR; + } + + /* -c and -p options */ + if(s->pwrites && s->csteps > s->pwrites) { + printf("communication interval with -p is out of bounds\n"); + TEST_ERROR; + } + + /* -c and -t options */ + if(s->twrites && s->csteps > s->twrites) { + printf("communication interval with -t is out of bounds\n"); + TEST_ERROR; + } + + /* -c and -l options */ + if(s->lwrites && s->csteps > s->lwrites) { + printf("communication interval with -l is out of bounds\n"); + TEST_ERROR; + } + + /* -c and -x options */ + if(s->xincrs && s->csteps > s->xincrs) { + printf("communication interval with -x is out of bounds\n"); + TEST_ERROR; + } + + /* -c and -y options */ + if(s->ydecrs && s->csteps > s->ydecrs) { + printf("communication interval with -y is out of bounds\n"); + TEST_ERROR; + } + + + /* The test file name */ + esnprintf(s->filename, sizeof(s->filename), "vfd_swmr_dsetchks.h5"); + + return true; + +error: + return false; + +} /* state_init() */ + + +/* + * Create the specified datasets: + * --2-dimensional chunked datasets + * --chunk dimension is rows/2 by cols/2 + * --fill value is FILL_INIT + * --shuffle filter if specified + * --dataset with single index if specified + * --dataset with implicit index if specified + * --dataset with fixeda array index if specified + * --dataset with extensible array index if specified + * --dataset with bt2 index if specified + */ +static bool +create_dsets(const state_t *s, dsets_state_t *ds) +{ + hid_t dcpl = badhid; + hid_t dcpl2 = badhid; + hid_t sid = badhid; + hsize_t dims[2]; + unsigned fillval = FILL_INIT; + + *ds = DSETS_INITIALIZER; + set_chunk_scaled_dims(s, ds); + + dims[0] = s->rows; + dims[1] = s->cols; + + /* Create dataset creation property list */ + /* Set properties in dcpl that are common for all the datasets */ + if((dcpl = H5Pcreate(H5P_DATASET_CREATE)) < 0) { + printf("H5Pcreate failed\n"); + TEST_ERROR; + } + + /* Set to chunked layout */ + if(H5Pset_layout(dcpl, H5D_CHUNKED) < 0) { + printf("H5Pset_layout failed\n"); + TEST_ERROR; + } + + /* Set fill value to FILL_INIT */ + if (H5Pset_fill_value(dcpl, s->filetype, &fillval) < 0) { + printf("H5Pset_fill_value failed\n"); + goto error; + } + + /* Set to use filter as specified */ + if(s->use_filter) { + if (H5Pset_shuffle(dcpl) < 0) { + printf("H5Pset_shuffle failed\n"); + goto error; + } + } + + /* Create 2-D chunked dataset with single index */ + /* Chunked, dims=max_dims=chunk_dims */ + if(s->single_index) { + + if((dcpl2 = H5Pcopy(dcpl)) < 0) { + printf("H5Tcopy failed\n"); + TEST_ERROR; + } + + if(H5Pset_chunk(dcpl2, 2, dims) < 0) { + printf("H5Pset_chunk failed\n"); + TEST_ERROR; + } + + if ((sid = H5Screate_simple(2, dims, dims)) < 0) { + printf("H5Screate_simple failed\n"); + TEST_ERROR; + } + + /* Create the chunked dataset: single index */ + if((ds->single_did = H5Dcreate2(s->file, DSET_SINGLE_NAME, s->filetype, + sid, H5P_DEFAULT, dcpl2, H5P_DEFAULT)) < 0) { + printf("H5Dcreate2 chunked dataset:single index failed\n"); + TEST_ERROR; + } + + if(H5Pclose(dcpl2) < 0) { + printf("H5Pclose failed\n"); + TEST_ERROR; + } + + if(H5Sclose(sid) < 0) { + printf("H5Sclose failed\n"); + TEST_ERROR; + } + } + + /* Chunk size is common for datasets with implicit/fa/ea/bt2 index */ + if(H5Pset_chunk(dcpl, 2, ds->chunk_dims) < 0) { + printf("H5Pset_chunk failed\n"); + TEST_ERROR; + } + + /* Create 2-D chunked dataset with implicit index */ + /* Chunked, dims=max_dims, early allocation */ + if(s->implicit_index) { + + if((dcpl2 = H5Pcopy(dcpl)) < 0) { + printf("H5Pcopy failed\n"); + TEST_ERROR; + } + + if(H5Pset_alloc_time(dcpl2, H5D_ALLOC_TIME_EARLY) < 0) { + printf("H5Pset_alloc_time\n"); + TEST_ERROR; + } + + if ((sid = H5Screate_simple(2, dims, dims)) < 0) { + printf("H5Screate_simple failed\n"); + TEST_ERROR; + } + + /* Create the chunked dataset: implicit index */ + if((ds->implicit_did = H5Dcreate2(s->file, DSET_IMPLICIT_NAME, s->filetype, + sid, H5P_DEFAULT, dcpl2, H5P_DEFAULT)) < 0) { + printf("H5Dcreate2 chunked dataset:implicit index failed\n"); + TEST_ERROR; + } + + if(H5Pclose(dcpl2) < 0) { + printf("H5Pclose failed\n"); + TEST_ERROR; + } + + if(H5Sclose(sid) < 0) { + printf("H5Sclose failed\n"); + TEST_ERROR; + } + } + + /* Create 2-D chunked dataset with fixed array index */ + /* Chunked, fixed max_dims */ + if(s->fa_index) { + hsize_t max_dims[2]; + + max_dims[0] = dims[0] * 2; + max_dims[1] = dims[1] * 2; + + if((sid = H5Screate_simple(2, dims, max_dims)) < 0) { + printf("H5Screate_simple failed\n"); + TEST_ERROR; + } + + /* Create the chunked dataset (fixed array index) with the named datatype */ + if((ds->fa_did = H5Dcreate2(s->file, DSET_FA_NAME, s->filetype, + sid, H5P_DEFAULT, dcpl, H5P_DEFAULT)) < 0) { + printf("H5Dcreate2 chunked dataset: fa index failed\n"); + TEST_ERROR; + } + + if(H5Sclose(sid) < 0) { + printf("H5Sclose failed\n"); + TEST_ERROR; + } + } + + /* Create 2-D chunked dataset with extensible array index */ + /* Chunked, 1 unlimited max_dims */ + if(s->ea_index) { + hsize_t max_dims[2]; + + max_dims[0] = dims[0] * 2; + max_dims[1] = H5S_UNLIMITED; + + if((sid = H5Screate_simple(2, dims, max_dims)) < 0) { + printf("H5Screate_simple failed\n"); + TEST_ERROR; + } + + /* Create the chunked dataset (extensible array index) with the named datatype */ + if((ds->ea_did = H5Dcreate2(s->file, DSET_EA_NAME, s->filetype, + sid, H5P_DEFAULT, dcpl, H5P_DEFAULT)) < 0) { + printf("H5Dcreate2 chunked dataset: ea index failed\n"); + TEST_ERROR; + } + + if(H5Sclose(sid) < 0) { + printf("H5Sclose failed\n"); + TEST_ERROR; + } + } + + /* Create 2-D chunked dataset with bt2 index */ + /* Chunked, 2 unlimited max_dims */ + if(s->bt2_index) { + hsize_t max_dims[2]; + + max_dims[0] = max_dims[1] = H5S_UNLIMITED; + + if((sid = H5Screate_simple(2, dims, max_dims)) < 0) { + printf("H5Screate_simple failed\n"); + TEST_ERROR; + } + + /* Create the chunked dataset (btree2 index) with the named datatype */ + if((ds->bt2_did = H5Dcreate2(s->file, DSET_BT2_NAME, s->filetype, + sid, H5P_DEFAULT, dcpl, H5P_DEFAULT)) < 0) { + printf("H5Dcreate2 chunked dataset: bt2 index failed\n"); + TEST_ERROR; + } + + if(H5Sclose(sid) < 0) { + printf("H5Sclose failed\n"); + TEST_ERROR; + } + } + + if(H5Pclose(dcpl) < 0) { + printf("H5Pclose failed\n"); + TEST_ERROR; + } + + return true; + +error: + H5E_BEGIN_TRY { + H5Pclose(dcpl); + H5Pclose(dcpl2); + H5Sclose(sid); + H5Dclose(ds->single_did); + H5Dclose(ds->implicit_did); + H5Dclose(ds->fa_did); + H5Dclose(ds->ea_did); + H5Dclose(ds->bt2_did); + } H5E_END_TRY; + + return false; + +} /* create_dsets() */ + +/* + * Open the specified datasets. + */ +static bool +open_dsets(const state_t *s, dsets_state_t *ds) +{ + *ds = DSETS_INITIALIZER; + set_chunk_scaled_dims(s, ds); + + /* Dataset with single index */ + if(s->single_index) { + if ((ds->single_did = H5Dopen2(s->file, DSET_SINGLE_NAME, H5P_DEFAULT)) < 0) { + printf("H5Dopen dataset with single index failed\n"); + TEST_ERROR; + } + } + + /* Dataset with implicit index */ + if(s->implicit_index) { + if ((ds->implicit_did = H5Dopen2(s->file, DSET_IMPLICIT_NAME, H5P_DEFAULT)) < 0) { + printf("H5Dopen dataset with implicit index failed\n"); + TEST_ERROR; + } + } + + /* Dataset with fixed array index */ + if(s->fa_index) { + if ((ds->fa_did = H5Dopen2(s->file, DSET_FA_NAME, H5P_DEFAULT)) < 0) { + printf("H5Dopen dataset with fa index failed\n"); + TEST_ERROR; + } + } + + /* Dataset with extensible array index */ + if(s->ea_index) { + if ((ds->ea_did = H5Dopen2(s->file, DSET_EA_NAME, H5P_DEFAULT)) < 0) { + printf("H5Dopen dataset with ea index failed\n"); + TEST_ERROR; + } + } + + /* Dataset with v2 btree index */ + if(s->bt2_index) { + if ((ds->bt2_did = H5Dopen2(s->file, DSET_BT2_NAME, H5P_DEFAULT)) < 0) { + printf("H5Dopen dataset with ea index failed\n"); + TEST_ERROR; + } + } + + return true; + +error: + return false; + +} /* open_dsets() */ + +/* + * Initialize the following 3 fields in ds: + * --chunk_dims[]: chunk sizes for datasets with implicit/fa/ea/bt2 index + * --scaled_dims[]: # of chunks in x and y dimensions + * --multi_scaled[]: # of multiple chunks (2 chunks) in x and y dimensions + */ +static void +set_chunk_scaled_dims(const state_t *s, dsets_state_t *ds) +{ + /* Default chunk size is s->rows/2 or s->cols/2 but not less than 1 */ + ds->chunk_dims[0] = MAX(1, s->rows/2); + ds->chunk_dims[1] = MAX(1, s->cols/2); + + /* # of chunks in x and y dimensions */ + ds->scaled_dims[0] = (s->rows + ds->chunk_dims[0] - 1) / ds->chunk_dims[0]; + ds->scaled_dims[1] = (s->cols + ds->chunk_dims[1] - 1) / ds->chunk_dims[1]; + + /* # of "multiple chunks" (2-chunks) in x and y dimensions */ + ds->multi_scaled[0] = (ds->scaled_dims[0] + MULTI_CHUNKS - 1) / MULTI_CHUNKS; + ds->multi_scaled[1] = (ds->scaled_dims[1] + MULTI_CHUNKS - 1) / MULTI_CHUNKS; + +} /* set_chunk_scaled_dims() */ + +/* + * Close the specified datasets + */ +static bool +close_dsets(const dsets_state_t *ds) +{ + /* Close dataset with single index */ + if(ds->single_did != badhid && H5Dclose(ds->single_did) < 0) { + printf("close_dset_real() dataset: single index failed\n"); + TEST_ERROR; + } + + /* Close dataset with implicit index */ + if(ds->implicit_did != badhid && H5Dclose(ds->implicit_did) < 0) { + printf("close_dset_real() dataset: implicit index failed\n"); + TEST_ERROR; + } + + /* Close dataset with fixed array index */ + if(ds->fa_did != badhid && H5Dclose(ds->fa_did) < 0) { + printf("close_dset_real() dataset: fa index failed\n"); + TEST_ERROR; + } + + /* Close dataset with extensible array index */ + if(ds->ea_did != badhid && H5Dclose(ds->ea_did) < 0) { + printf("close_dset_real() : ea index failed\n"); + TEST_ERROR; + } + + /* Close dataset with v2 btree index */ + if(ds->bt2_did != badhid && H5Dclose(ds->bt2_did) < 0) { + printf("close_dset_real() dataset: bt2 index failed\n"); + TEST_ERROR; + } + + return true; + +error: + H5E_BEGIN_TRY { + H5Dclose(ds->single_did); + H5Dclose(ds->implicit_did); + H5Dclose(ds->fa_did); + H5Dclose(ds->ea_did); + H5Dclose(ds->bt2_did); + } H5E_END_TRY; + + return false; + +} /* close_dsets() */ + +/* + * Writer + */ + +/* + * Perform the operations for the specified datasets: + * + * Dataset with single index: + * --only 1 write is performed because this dataset only has a single chunk + * + * Dataset with implicit/fixed array/extensible array/version 2 btree index: + * --GWRITES: writes that cover a single chunk per write + * --PWRITES: writes that cover a partial chunk per write + * --TWRITES: writes that cover multiple chunks per write + * --LWRITES: writes that cover multiple partial chunks per write + * + * Dataset with fixed array/extensible array/version 2 btree index: + * --INCR_EXT: increase dataset dimension sizes + * --DECR_EXT: decrease dataset dimenions sizes + */ +static bool +perform_dsets_operations(state_t *s, dsets_state_t *ds, H5F_vfd_swmr_config_t *config, np_state_t *np) +{ + unsigned step; + unsigned allowed_writes; + bool result; + + /* Dataset with single index */ + if(s->single_index) { + /* Perform single full chunk write */ + /* gwrites and twrites are the same */ + /* Doesn't matter how many writes, only perform once */ + if(s->gwrites || s->twrites) { + dbgf(2, "Perform single full chunk write to dataset with single index; only perform 1 write\n"); + + result = write_dset_single(GWRITES, s, ds); + + if(s->use_np && !np_writer(result, 0, s, np, config)) { + printf("np_writer() for addition failed\n"); + TEST_ERROR; + } + } + + /* Perform a single partial chunk write */ + /* pwrites and lwrites are the same */ + /* Doesn't matter how many writes, only perform once */ + if(s->pwrites || s->lwrites) { + dbgf(2, "Perform single partial chunk write to dataset with single index; only perform 1 write\n"); + + result = write_dset_single(PWRITES, s, ds); + + if(s->use_np && !np_writer(result, 0, s, np, config)) { + printf("np_writer() for addition failed\n"); + TEST_ERROR; + } + } + } + + /* Datasets with implicit/fa/ea/bt2 index */ + if(s->implicit_index || s->fa_index || s->ea_index || s->bt2_index) { + + /* Perform single full chunk writes */ + if(s->gwrites) { + allowed_writes = (unsigned)(ds->scaled_dims[0]*ds->scaled_dims[1]); + dbgf(2, "The allowed -g writes is %u; you specify %u writes\n", allowed_writes, s->gwrites); + + for (step = 0; (step < s->gwrites && step < allowed_writes); step++) { + dbgf(2, "Perform single full chunk writes #%u to datasets with implicit/fa/ea/bt2 index\n", step); + + result = write_dsets_chunks(GWRITES, s, ds, step); + + if(s->use_np && !np_writer(result, step, s, np, config)) { + printf("np_writer() for single full chunk writes failed\n"); + TEST_ERROR; + } + } + } + + /* Perform single partial chunk writes */ + if(s->pwrites) { + allowed_writes = (unsigned)(ds->scaled_dims[0]*ds->scaled_dims[1]); + dbgf(2, "The allowed -p writes is %u; you specify %u writes\n", allowed_writes, s->pwrites); + + for (step = 0; (step < s->pwrites && step < allowed_writes); step++) { + dbgf(2, "Perform single partial chunk writes #%u to datasets with implicit/fa/ea/bt2 index\n", step); + + result = write_dsets_chunks(PWRITES, s, ds, step); + + if(s->use_np && !np_writer(result, step, s, np, config)) { + printf("np_writer() for partial single chunk writes failed\n"); + TEST_ERROR; + } + } + } + + /* Perform multiple full chunk writes */ + if(s->twrites) { + allowed_writes = (unsigned)(ds->multi_scaled[0]*ds->multi_scaled[1]); + dbgf(2, "The allowed -t writes is %u; you specify %u writes\n", allowed_writes, s->twrites); + + for (step = 0; (step < s->twrites && step < allowed_writes); step++) { + dbgf(2, "Perform multiple full chunk writes #%u to datasets with implicit/fa/ea/bt2 index\n", step); + + result = write_dsets_chunks(TWRITES, s, ds, step); + + if(s->use_np && !np_writer(result, step, s, np, config)) { + printf("np_writer() for multiple full chunk writes failed\n"); + TEST_ERROR; + } + } + } + + /* Perform multiple partial chunk writes */ + if(s->lwrites) { + allowed_writes = (unsigned)(ds->multi_scaled[0]*ds->multi_scaled[1]); + dbgf(2, "The allowed -l writes is %u; you specify %u writes\n", allowed_writes, s->lwrites); + + for (step = 0; (step < s->lwrites && step < allowed_writes); step++) { + dbgf(2, "Perform multiple partial chunk writes #%u to datasets with implicit/fa/ea/bt2 index\n", step); + + result = write_dsets_chunks(LWRITES, s, ds, step); + + if(s->use_np && !np_writer(result, step, s, np, config)) { + printf("np_writer() for multiple partial chunk writes failed\n"); + TEST_ERROR; + } + } + } + + /* Increase dataset dimensions: apply only to fa/ea/bt2 index */ + if(!s->implicit_index && s->xincrs) { + for (step = 0; step < s->xincrs; step++) { + dbgf(2, "Increase dataset dimension sizes by %u for datasets with fa/ea/bt2 index\n", step+1); + + result = dsets_extent(INCR_EXT, s, ds); + + if(s->use_np && !np_writer(result, step, s, np, config)) { + printf("np_writer() for increasing dimension sizes failed\n"); + TEST_ERROR; + } + } + } + + /* Decrease dataset dimensions: apply only to fa/ea/bt2 index */ + if(!s->implicit_index && s->ydecrs) { + for (step = 0; step < s->ydecrs; step++) { + dbgf(2, "Decrease dataset dimension sizes by %u for datasets with fa/ea/bt2 index\n", step+1); + + result = dsets_extent(DECR_EXT, s, ds); + + if(s->use_np && !np_writer(result, step, s, np, config)) { + printf("np_writer() for decreasing dimension sizes failed\n"); + TEST_ERROR; + } + } + } + } + + return true; + +error: + return false; + +} /* perform_dsets_operations() */ + +/* + * Perform the "action" for each of the specified datasets: + * GWRITES: perform `which` write that covers a single chunk + * PWRITES: perform `which` write that covers a partial chunk + * TWRITES: perform `which` write that covers multiple chunks + * LWRITEs: perform `which` write that covers multiple partial chunks + */ +static bool +write_dsets_chunks(unsigned action, const state_t *s, const dsets_state_t *ds, unsigned which) +{ + hsize_t start[2] = {0, 0}; + hsize_t stride[2] = {0, 0}; + hsize_t count[2] = {0, 0}; + hsize_t block[2] = {0, 0}; + + HDassert(s->implicit_index || s->fa_index || s->ea_index || s->bt2_index); + + /* Set up selection info according to the specified action */ + setup_selection(action, which, s, ds, start, stride, count, block); + + if(s->implicit_index) { + if(!write_dset(action, ds->implicit_did, s->filetype, start, stride, count, block)) { + printf("H5Dwrite to chunked dataset: implicit index dataset failed\n"); + TEST_ERROR; + } + } + + if(s->fa_index) { + if(!write_dset(action, ds->fa_did, s->filetype, start, stride, count, block)) { + printf("H5Dwrite to chunked dataset: fa index dataset failed\n"); + TEST_ERROR; + } + } + + + if(s->ea_index) { + if(!write_dset(action, ds->ea_did, s->filetype, start, stride, count, block)) { + printf("H5Dwrite to chunked dataset: ea index dataset failed\n"); + TEST_ERROR; + } + } + + if(s->bt2_index) { + if(!write_dset(action, ds->bt2_did, s->filetype, start, stride, count, block)) { + printf("H5Dwrite to chunked dataset: bt2 index dataset failed\n"); + TEST_ERROR; + } + } + + return true; + +error: + return false; + +} /* write_dsets_chunks() */ + + +/* + * Set up selection info: start, stride, count, block + */ +static void +setup_selection(unsigned action, unsigned which, const state_t *s, const dsets_state_t *ds, + hsize_t *start, hsize_t *stride, hsize_t *count, hsize_t *block) +{ + unsigned i, j, m, n; + bool end = false; + hsize_t chunk_dims[2]; + + HDassert(action == GWRITES || action == PWRITES || action == TWRITES || action == LWRITES); + + count[0] = 1; + count[1] = 1; + stride[0] = 1; + stride[1] = 1; + + /* Single or multiple chunk writes */ + if(action == GWRITES || action == PWRITES) { + block[0] = chunk_dims[0] = ds->chunk_dims[0]; + block[1] = chunk_dims[1] = ds->chunk_dims[1]; + + for (i = 0; i < ds->scaled_dims[0] && !end; i++) { + for(j = 0; j < ds->scaled_dims[1]; j++) { + + /* Determine which chunk to write */ + if(which == (i * ds->scaled_dims[1] + j)) { + start[0] = i * ds->chunk_dims[0]; + start[1] = j * ds->chunk_dims[1]; + + /* If an edge chunk, determine the block size */ + check_set_edge_block(s, ds, i, j, block); + + end = true; + break; + } /* end if */ + } /* end for */ + } /* end for */ + + /* Check and set partial chunk write */ + if (action == PWRITES) + check_set_partial_block(action, chunk_dims, block, start); + + /* Partial or multiple partial chunk writes */ + } else if (action == TWRITES || action == LWRITES) { + /* Multiple chunk writes: the block covers 2 chunks in each dimension */ + block[0] = chunk_dims[0] = ds->chunk_dims[0] * 2; + block[1] = chunk_dims[1] = ds->chunk_dims[1] * 2; + + for (i = 0, m = 0; i < ds->scaled_dims[0] && !end; i+=2, m++) { + for(j = 0, n = 0; j < ds->scaled_dims[1]; j+=2, n++) { + if(which == (m * ds->multi_scaled[1] + n)) { + start[0] = i * ds->chunk_dims[0]; + start[1] = j * ds->chunk_dims[1]; + + /* If an edge chunk, determine the block size */ + check_set_edge_block(s, ds, i, j, block); + + end = true; + break; + + } /* end if */ + } /* end for */ + } /* end for */ + + /* Check and set multiple partial chunk write */ + if (action == LWRITES) + check_set_partial_block(action, chunk_dims, block, start); + } + +} /* setup_selection() */ + +/* + * Check if "i" or "j" is an edge block. + * If so, determine the block size. + */ +static void +check_set_edge_block(const state_t *s, const dsets_state_t *ds, + unsigned i, unsigned j, hsize_t *block) +{ + + if(i == (ds->scaled_dims[0] - 1)) { + if ((ds->scaled_dims[0] * ds->chunk_dims[0]) >= s->rows) + block[0] = s->rows - i * ds->chunk_dims[0]; + } + + if(j == (ds->scaled_dims[1] - 1)) { + if ((ds->scaled_dims[1] * ds->chunk_dims[1]) >= s->cols) + block[1] = s->cols - (j * ds->chunk_dims[1]); + } + +} /* check_set_edge_block() */ + +/* + * Determine the starting offset and the partial block size if the block is: + * --a full chunk or a multiple full chunks + * --the block size is at least 2 + * Otherwise, nothing is done i.e. the whole block is applied + */ +static void +check_set_partial_block(unsigned action, const hsize_t *chunk_dims, hsize_t *block, hsize_t *start) +{ + HDassert(action == PWRITES || action == LWRITES); + + /* Apply only to full chunk or multi full chunks with block size > 2 */ + if(block[0] == chunk_dims[0] && + block[1] == chunk_dims[1]) { + + if(block[0] > 2) { + start[0] += 1; + block[0] -= 2; + }; + + if(block[1] > 2) { + start[1] += 1; + block[1] -= 2; + }; + } + +} /* check_set_partial_block() */ + +/* + * Make the selection and then write to the dataset. + */ +static bool +write_dset(unsigned action, hid_t did, hid_t tid, + hsize_t *start, hsize_t *stride, hsize_t *count, hsize_t *block) +{ + hid_t sid = badhid; + hid_t mem_sid = badhid; + hsize_t mem_dims[2]; + unsigned int *buf = NULL; + unsigned i; + + if((sid = H5Dget_space(did)) < 0) { + printf("H5Sget_space failed\n"); + TEST_ERROR; + } + + if(H5Sselect_hyperslab(sid, H5S_SELECT_SET, start, stride, count, block) < 0) { + printf("H5Sselect_hyperslab failed\n"); + TEST_ERROR; + } + + mem_dims[0] = block[0]; + mem_dims[1] = block[1]; + + if((mem_sid = H5Screate_simple(2, mem_dims, NULL)) < 0) { + printf("H5Screate_simple failed\n"); + TEST_ERROR; + } + + /* Allocate the buffer for writing */ + if((buf = HDmalloc(block[0] * block[1] * sizeof(unsigned int))) == NULL) { + printf("HDmalloc failed\n"); + TEST_ERROR; + } + + /* Fill the value to be written depending on full or partial writes */ + for (i = 0; i < (block[0] * block[1]); i++) { + if(action == GWRITES || action == TWRITES) + buf[i] = FILL_FULL; + else + buf[i] = FILL_PARTIAL; + } + + if(H5Dwrite(did, tid, mem_sid, sid, H5P_DEFAULT, buf) < 0) { + printf("H5Dwrite failed\n"); + TEST_ERROR; + } + + if(H5Sclose(sid) < 0) { + printf("H5Sclose failed\n"); + TEST_ERROR; + } + + if(buf) HDfree(buf); + + return true; + +error: + H5E_BEGIN_TRY { + H5Sclose(sid); + H5Sclose(mem_sid); + } H5E_END_TRY; + + if(buf) HDfree(buf); + + return false; + +} /* write_dset() */ + +/* + * Increase or decrease the dimenion sizes for the specified datasets. + */ +static bool +dsets_extent(unsigned action, const state_t *s, const dsets_state_t *ds) +{ + unsigned nerrors = 0; + bool ret = true; + + HDassert(s->fa_index || s->ea_index || s->bt2_index); + HDassert(action == INCR_EXT || action == DECR_EXT); + + if(s->fa_index) { + dbgf(2, "Setting dataset extent for FA dataset\n"); + if(!dset_extent_real(action, ds->fa_did, ds->chunk_dims)) { + ++nerrors; + } + } + + if(s->ea_index) { + dbgf(2, "Setting dataset extent for EA dataset\n"); + if(!dset_extent_real(action, ds->ea_did, ds->chunk_dims)) + ++nerrors; + } + + if(s->bt2_index) { + dbgf(2, "Setting dataset extent for BT2 dataset\n"); + if(!dset_extent_real(action, ds->bt2_did, ds->chunk_dims)) + ++nerrors; + } + + if(nerrors) + ret = false; + + return (ret); + +} /* dsets_extent() */ + +/* + * Perform the real work of increasing/decreasing the dataset dimension sizes + */ +static bool +dset_extent_real(unsigned action, hid_t did, const hsize_t *chunk_dims) +{ + hsize_t dims[2]; + hsize_t max_dims[2]; + hsize_t new[2]; + hid_t sid = badhid; + + if((sid = H5Dget_space(did)) < 0) { + printf("H5Sget_space failed\n"); + TEST_ERROR; + } + + if(H5Sget_simple_extent_dims(sid, dims, max_dims) < 0) { + printf("H5Sget_simple_extent_dims failed\n"); + TEST_ERROR; + } + + switch (action) { + + case INCR_EXT: + new[0] = dims[0] + 1; + new[1] = dims[1] + 1; + + /* Cannot increase to more than maximum dimension (both dims) for FA dataset */ + /* Cannot increase to more than maximum dimension (dim 0) for EA dataset */ + if((max_dims[0] != H5S_UNLIMITED && new[0] > max_dims[0]) || + (max_dims[1] != H5S_UNLIMITED && new[1] > max_dims[1])) { + printf("Cannot exceed maximum dimension for dataset\n"); + TEST_ERROR; + } + + break; + + case DECR_EXT: + new[0] = dims[0] - 1; + new[1] = dims[1] - 1; + + if(new[0] < chunk_dims[0] || new[1] < chunk_dims[1]) { + printf("Cannot decrease to less than chunk dimension\n"); + TEST_ERROR; + } + break; + + default: + HDassert(0 && "Unknown action?!?"); + + } /* end switch */ + + if(H5Dset_extent(did, new) < 0) { + printf("H5Dset_extent for dataset failed\n"); + TEST_ERROR; + } + + if(H5Sclose(sid) < 0) { + printf("H5Sclose failed\n"); + TEST_ERROR; + } + + return true; + +error: + H5E_BEGIN_TRY { + H5Sclose(sid); + } H5E_END_TRY; + + return false; +} /* dset_extent_real() */ + +/* + * Write to dataset with single index: only 1 chunk is written + */ +static bool +write_dset_single(unsigned action, const state_t *s, const dsets_state_t *ds) +{ + hsize_t count[2] = {1, 1}; + hsize_t stride[2] = {1, 1}; + hsize_t start[2] = {0, 0}; + hsize_t block[2] = {s->rows, s->cols}; + + HDassert(action == GWRITES || action == PWRITES || action == TWRITES || action == LWRITES); + HDassert(s->single_index); + + /* Check and set partial chunk write */ + if(action == PWRITES || action == LWRITES) + check_set_partial_block(action, block, block, start); + + if(!write_dset(action, ds->single_did, s->filetype, start, stride, count, block)) { + printf("H5Dwrite to dataset with single index dataset failed\n"); + TEST_ERROR; + } + + return true; + +error: + return false; + +} /* write_dset_single() */ + +/* + * Reader + */ + +/* + * Verify the operations for the specified datasets: + * + * Dataset with single index: + * --verify only 1 write because this dataset only has a single chunk + * + * Dataset with implicit/fixed array/extensible array/version 2 btree index: + * --GWRITES: verify writes that cover a single chunk per write + * --PWRITES: verify writes that cover a partial chunk per write + * --TWRITES: verify writes that cover multiple chunks per write + * --LWRITES: verify writes that cover multiple partial chunks per write + * + * Dataset with fixed array/extensible array/version 2 btree index: + * --INCR_EXT: verify the increase to dataset dimension sizes + * --DECR_EXT: verify the decrease to dataset dimensions sizes + */ +static bool +verify_dsets_operations(state_t *s, dsets_state_t *ds, H5F_vfd_swmr_config_t *config, np_state_t *np) +{ + unsigned step; + unsigned allowed_writes; + bool result; + + /* Verify dataset with single index */ + if(s->single_index) { + /* Verify a single full chunk write to dataset with single index */ + /* gwrites and twrites are the same */ + /* Doesn't matter how many writes, only perform once */ + if(s->gwrites || s->twrites) { + dbgf(2, "Verify single full chunk write to dataset with single index; only verify 1 write\n"); + + if(s->use_np && !np_confirm_verify_notify(np->fd_writer_to_reader, 0, s, np)) { + printf("np_confirm_verify_notify() verify/notify not in sync failed\n"); + TEST_ERROR; + } + + /* Wait for a few ticks for the update to happen */ + decisleep(config->tick_len * s->update_interval); + + result = verify_read_dset_single(GWRITES, s, ds); + + if(s->use_np && !np_reader(result, 0, s, np)) { + printf("np_reader() for verifying addition failed\n"); + TEST_ERROR; + } + + } + + /* Verify a single partial chunk write to dataset with single index */ + /* pwrites and lwrites are the same */ + /* Doesn't matter how many writes, only perform once */ + if(s->pwrites || s->lwrites) { + dbgf(2, "Verify single partial chunk write to dataset with single index; only verify 1 write\n"); + + if(s->use_np && !np_confirm_verify_notify(np->fd_writer_to_reader, 0, s, np)) { + printf("np_confirm_verify_notify() verify/notify not in sync failed\n"); + TEST_ERROR; + } + /* Wait for a few ticks for the update to happen */ + decisleep(config->tick_len * s->update_interval); + + result = verify_read_dset_single(PWRITES, s, ds); + + if(s->use_np && !np_reader(result, 0, s, np)) { + printf("np_reader() for verifying addition failed\n"); + TEST_ERROR; + } + } + + } + + /* Verify datasets with implicit/fa/ea/bt2 index */ + if(s->implicit_index || s->fa_index || s->ea_index || s->bt2_index) { + + /* Verify single full chunk writes */ + if(s->gwrites) { + allowed_writes = (unsigned)(ds->scaled_dims[0]*ds->scaled_dims[1]); + dbgf(2, "The allowed -g writes is %u; you specify %u writes\n", allowed_writes, s->gwrites); + + for (step = 0; (step < s->gwrites && step < allowed_writes); step++) { + dbgf(2, "Verify single full chunk writes #%u to datasets with implicit/fa/ea/bt2 index\n", step); + + if(s->use_np && !np_confirm_verify_notify(np->fd_writer_to_reader, step, s, np)) { + printf("np_confirm_verify_notify() verify/notify not in sync failed\n"); + TEST_ERROR; + } + /* Wait for a few ticks for the update to happen */ + decisleep(config->tick_len * s->update_interval); + + result = verify_dsets_chunks(GWRITES, s, ds, step); + + if(s->use_np && !np_reader(result, step, s, np)) { + printf("np_reader() for verification failed\n"); + TEST_ERROR; + } + } + } + + /* Verify single partial chunk writes */ + if(s->pwrites) { + allowed_writes = (unsigned)(ds->scaled_dims[0]*ds->scaled_dims[1]); + dbgf(2, "The allowed -p writes is %u; you specify %u writes\n", allowed_writes, s->pwrites); + + for (step = 0; (step < s->pwrites && step < allowed_writes); step++) { + dbgf(2, "Verify single partial chunk writes #%u to datasets with implicit/fa/ea/bt2 index\n", step); + + if(s->use_np && !np_confirm_verify_notify(np->fd_writer_to_reader, step, s, np)) { + printf("np_confirm_verify_notify() verify/notify not in sync failed\n"); + TEST_ERROR; + } + /* Wait for a few ticks for the update to happen */ + decisleep(config->tick_len * s->update_interval); + + result = verify_dsets_chunks(PWRITES, s, ds, step); + + if(s->use_np && !np_reader(result, step, s, np)) { + printf("np_reader() for verification failed\n"); + TEST_ERROR; + } + } + } + + /* Verify multiple full chunk writes */ + if(s->twrites) { + allowed_writes = (unsigned)(ds->multi_scaled[0]*ds->multi_scaled[1]); + dbgf(2, "The allowed -t writes is %u; you specify %u writes\n", allowed_writes, s->twrites); + + for (step = 0; (step < s->twrites && step < allowed_writes); step++) { + dbgf(2, "Verify multiple full chunk writes #%u to datasets with implicit/fa/ea/bt2 index\n", step); + + if(s->use_np && !np_confirm_verify_notify(np->fd_writer_to_reader, step, s, np)) { + printf("np_confirm_verify_notify() verify/notify not in sync failed\n"); + TEST_ERROR; + } + /* Wait for a few ticks for the update to happen */ + decisleep(config->tick_len * s->update_interval); + + result = verify_dsets_chunks(TWRITES, s, ds, step); + + if(s->use_np && !np_reader(result, step, s, np)) { + printf("np_reader() for verification failed\n"); + TEST_ERROR; + } + } + } + + /* Verify multiple partial chunk writes */ + if(s->lwrites) { + allowed_writes = (unsigned)(ds->multi_scaled[0]*ds->multi_scaled[1]); + dbgf(2, "The allowed -l writes is %u; you specify %u writes\n", allowed_writes, s->lwrites); + + for (step = 0; (step < s->lwrites && step < allowed_writes); step++) { + dbgf(2, "Verify multiple partial chunk writes #%u to datasets with implicit/fa/ea/bt2 index\n", step); + + if(s->use_np && !np_confirm_verify_notify(np->fd_writer_to_reader, step, s, np)) { + printf("np_confirm_verify_notify() verify/notify not in sync failed\n"); + TEST_ERROR; + } + /* Wait for a few ticks for the update to happen */ + decisleep(config->tick_len * s->update_interval); + + result = verify_dsets_chunks(LWRITES, s, ds, step); + + if(s->use_np && !np_reader(result, step, s, np)) { + printf("np_reader() for verification failed\n"); + TEST_ERROR; + } + } + } + + /* Verify increase to dataset dimensions: apply only for fa, ea and bt2 index */ + if(!s->implicit_index && s->xincrs) { + for (step = 0; step < s->xincrs; step++) { + dbgf(2, "Verify increase to dimension sizes by %u for datasets with fa/ea/bt2 index\n", step+1); + + if(s->use_np && !np_confirm_verify_notify(np->fd_writer_to_reader, step, s, np)) { + printf("np_confirm_verify_notify() verify/notify not in sync failed\n"); + TEST_ERROR; + } + /* Wait for a few ticks for the update to happen */ + decisleep(config->tick_len * s->update_interval); + + result = verify_dsets_extent(INCR_EXT, s, ds, step+1); + + if(s->use_np && !np_reader(result, step, s, np)) { + printf("np_reader() for failed\n"); + TEST_ERROR; + } + } + } + + /* Verify decrease to dataset dimensions: apply only for fa, ea and bt2 index */ + if(!s->implicit_index && s->ydecrs) { + for (step = 0; step < s->ydecrs; step++) { + dbgf(2, "Verify decrease to dimension sizes by %u for datasets with fa/ea/bt2 index\n", step+1); + + if(s->use_np && !np_confirm_verify_notify(np->fd_writer_to_reader, step, s, np)) { + printf("np_confirm_verify_notify() verify/notify not in sync failed\n"); + TEST_ERROR; + } + /* Wait for a few ticks for the update to happen */ + decisleep(config->tick_len * s->update_interval); + + result = verify_dsets_extent(DECR_EXT, s, ds, step+1); + + if(s->use_np && !np_reader(result, step, s, np)) { + printf("np_reader() for verification failed\n"); + TEST_ERROR; + } + } + } + } + + return true; + +error: + + return false; + +} /* verify_dsets_operations() */ + +/* + * Verify the data read from each of the specified datasets: + * GWRITES: verify `which` write that covers a single chunk + * PWRITES: verify `which` write that covers a partial chunk + * TWRITES: verify `which` write that covers multiple chunks + * LWRITEs: verify `which` write that covers multiple partial chunks + */ +static bool +verify_dsets_chunks(unsigned action, const state_t *s, const dsets_state_t *ds, unsigned which) +{ + hsize_t start[2] = {0, 0}; + hsize_t stride[2] = {0, 0}; + hsize_t count[2] = {0, 0}; + hsize_t block[2] = {0, 0}; + unsigned int *vbuf = NULL; + + HDassert(s->implicit_index || s->fa_index || s->ea_index || s->bt2_index); + + /* Set up selection according to the specified action */ + setup_selection(action, which, s, ds, start, stride, count, block); + + if(s->implicit_index) { + if(!verify_read_dset(action, ds->implicit_did, s->filetype, start, stride, count, block)) { + printf("verify_read_dset() to dataset with implicit index failed\n"); + TEST_ERROR; + } + } + + if(s->fa_index) { + if(!verify_read_dset(action, ds->fa_did, s->filetype, start, stride, count, block)) { + printf("verify_read_dset() to dataset with fixed array index failed\n"); + TEST_ERROR; + } + } + + if(s->ea_index) { + if(!verify_read_dset(action, ds->ea_did, s->filetype, start, stride, count, block)) { + printf("verify_read_dset() to dataset with extensible array index failed\n"); + TEST_ERROR; + } + } + + if(s->bt2_index) { + if(!verify_read_dset(action, ds->bt2_did, s->filetype, start, stride, count, block)) { + printf("verify_read_dset() to dataset with bt2 index failed\n"); + TEST_ERROR; + } + } + + if(vbuf) HDfree(vbuf); + + return true; + +error: + if(vbuf) HDfree(vbuf); + + return false; + +} /* verify_dsets_chunks() */ + +/* + * Verify the data read from the dataset is as expected. + */ +static bool +verify_read_dset(unsigned action, hid_t did, hid_t tid, + hsize_t *start, hsize_t *stride, hsize_t *count, hsize_t *block) +{ + hid_t mem_sid = badhid; + hid_t sid = badhid; + hsize_t mem_dims[2]; + unsigned int *rbuf = NULL; + unsigned i; + + /* Refresh the dataset */ + if(H5Drefresh(did) < 0) { + printf("H5Drefresh dataset failed\n"); + TEST_ERROR; + } + + if((sid = H5Dget_space(did)) < 0) { + printf("H5Dget_space dataset failed\n"); + TEST_ERROR; + } + + /* Make the selection the file dataspace */ + if(H5Sselect_hyperslab(sid, H5S_SELECT_SET, start, stride, count, block) < 0) { + printf("H5Sselect to dataset failed\n"); + TEST_ERROR; + } + + mem_dims[0] = block[0]; + mem_dims[1] = block[1]; + if((mem_sid = H5Screate_simple(2, mem_dims, NULL)) < 0) { + printf("H5Screate_simple failed\n"); + TEST_ERROR; + } + + /* Allocate the buffer for reading */ + if((rbuf = HDmalloc(block[0] * block[1] * sizeof(unsigned int))) == NULL) { + printf("HDmalloc failed\n"); + TEST_ERROR; + } + + /* Read the data from the dataset into `rbuf` */ + if(H5Dread(did, tid, mem_sid, sid, H5P_DEFAULT, rbuf) < 0) { + printf("H5Dread from dataset failed\n"); + TEST_ERROR; + } + + /* Verify the data read in `rbuf` is as the fill value expected */ + for (i = 0; i < block[0] * block[1]; i++) { + if(action == GWRITES || action == TWRITES) { + if(rbuf[i] != FILL_FULL) { + printf("Invalid value for dataset for GWRITES/TWRITES\n"); + TEST_ERROR; + } + } else { + HDassert(action == PWRITES || action == LWRITES); + if (rbuf[i] != FILL_PARTIAL) { + printf("Invalid value for dataset for GWRITES/TWRITES\n"); + TEST_ERROR; + } + } + } + + if(H5Sclose(sid) < 0) { + printf("H5Sclose failed\n"); + TEST_ERROR; + } + + if(rbuf) HDfree(rbuf); + + return true; + +error: + H5E_BEGIN_TRY { + H5Sclose(sid); + H5Sclose(mem_sid); + } H5E_END_TRY; + + if(rbuf) HDfree(rbuf); + + return false; + +} /* verify_read_dset() */ + +/* + * Verify the increase or decrease of dimenion sizes for the specified datasets. + */ +static bool +verify_dsets_extent(unsigned action, const state_t *s, const dsets_state_t *ds, unsigned which) +{ + unsigned rows = s->rows; + unsigned cols = s->cols; + + HDassert(action == INCR_EXT || action == DECR_EXT); + HDassert(s->fa_index || s->ea_index || s->bt2_index); + + /* s->xincrs can be 0 or the increased extent of the dataset */ + if(action == DECR_EXT) { + rows = s->rows + s->xincrs; + cols = s->cols + s->xincrs; + } + + if(s->fa_index) { + dbgf(2, "Verify dataset extent for FA dataset\n"); + if(!verify_dset_extent_real(action, ds->fa_did, rows, cols, which)) { + printf("verify_read_dset() to dataset with fixed array index failed\n"); + TEST_ERROR; + } + } + + if(s->ea_index) { + dbgf(2, "Verify dataset extent for EA dataset\n"); + if(!verify_dset_extent_real(action, ds->fa_did, rows, cols, which)) { + printf("verify_read_dset() to dataset with fixed array index failed\n"); + TEST_ERROR; + } + } + + if(s->bt2_index) { + dbgf(2, "Verify dataset extent for BT2 dataset\n"); + if(!verify_dset_extent_real(action, ds->bt2_did, rows, cols, which)) { + printf("verify_read_dset() to dataset with fixed array index failed\n"); + TEST_ERROR; + } + } + + return true; + +error: + return false; + +} /* verify_dsets_extent() */ + + +/* + * Do the real work of verifying the increase/decrease for the dataset dimension sizes + */ +static bool +verify_dset_extent_real(unsigned action, hid_t did, unsigned rows, unsigned cols, unsigned which) +{ + hsize_t dims[2]; + hid_t sid = badhid; + + /* Refresh the dataset */ + if(H5Drefresh(did) < 0) { + printf("H5Drefresh dataset failed\n"); + TEST_ERROR; + } + + if((sid = H5Dget_space(did)) < 0) { + printf("H5Dget_space dataset failed\n"); + TEST_ERROR; + } + + if(H5Sget_simple_extent_dims(sid, dims, NULL) < 0) { + printf("H5Sget_simple_extent_dims() failed\n"); + TEST_ERROR; + } + + switch (action) { + + case INCR_EXT: + if(dims[0] != (rows + which) || + dims[1] != (cols + which)) + TEST_ERROR + + break; + + case DECR_EXT: + if(dims[0] != (rows - which) || + dims[1] != (cols - which)) + TEST_ERROR + break; + + default: + HDassert(0 && "Unknown action?!?"); + + } /* end switch */ + + return true; + +error: + H5E_BEGIN_TRY { + H5Sclose(sid); + } H5E_END_TRY; + + return false; +} /* verify_dset_extent_real() */ + +/* + * Verify that the data read from the dataset with single index is as unexpected. + */ +static bool +verify_read_dset_single(unsigned action, const state_t *s, const dsets_state_t *ds) +{ + hsize_t block[2] = {s->rows, s->cols}; + hsize_t count[2] = {1, 1}; + hsize_t stride[2] = {1, 1}; + hsize_t start[2] = {0, 0}; + + HDassert(action == GWRITES || action == PWRITES); + HDassert(s->single_index); + + if(action == PWRITES) + check_set_partial_block(action, block, block, start); + + if(!verify_read_dset(action, ds->single_did, s->filetype, start, stride, count, block)) { + printf("verify_read_dset() to dataset with single index failed\n"); + TEST_ERROR; + } + + return true; + +error: + return false; + +} /* verify_read_dset_single() */ + +/* + * Named pipes handling + */ + +/* + * Initialize the named pipes for test synchronization. + */ +static bool +np_init(np_state_t *np, bool writer) +{ + *np = NP_INITIALIZER; + + /* + * Use two named pipes(FIFO) to coordinate the writer and reader for + * two-way communication so that the two sides can move forward together. + * One is for the writer to write to the reader. + * The other one is for the reader to signal the writer. + */ + if (writer) { + /* If the named pipes are present at the start of the test, remove them */ + if (HDaccess(np->fifo_writer_to_reader, F_OK) == 0) + if(HDremove(np->fifo_writer_to_reader) != 0) { + printf("HDremove fifo_writer_to_reader failed\n"); + TEST_ERROR; + } + + if (HDaccess(np->fifo_reader_to_writer, F_OK) == 0) + if(HDremove(np->fifo_reader_to_writer) != 0) { + printf("HDremove fifo_reader_to_writer failed\n"); + TEST_ERROR; + } + + /* Writer creates two named pipes(FIFO) */ + if (HDmkfifo(np->fifo_writer_to_reader, 0600) < 0) { + printf("HDmkfifo fifo_writer_to_reader failed\n"); + TEST_ERROR; + } + + if (HDmkfifo(np->fifo_reader_to_writer, 0600) < 0) { + printf("HDmkfifo fifo_reader_to_writer failed\n"); + TEST_ERROR; + } + } + + /* Both the writer and reader open the pipes */ + if ((np->fd_writer_to_reader = HDopen(np->fifo_writer_to_reader, O_RDWR)) < 0) { + printf("HDopen fifo_writer_to_reader failed\n"); + TEST_ERROR; + } + + if ((np->fd_reader_to_writer = HDopen(np->fifo_reader_to_writer, O_RDWR)) < 0) { + printf("HDopen fifo_reader_to_writer failed\n"); + TEST_ERROR; + } + + return true; + +error: + return false; + +} /* np_init() */ + +/* + * Close the named pipes. + */ +static bool +np_close(np_state_t *np, bool writer) +{ + /* Both the writer and reader close the named pipes */ + if (HDclose(np->fd_writer_to_reader) < 0) { + printf("HDclose fd_writer_to_reader failed\n"); + TEST_ERROR; + } + + if (HDclose(np->fd_reader_to_writer) < 0) { + printf("HDclose fd_reader_to_writer failed\n"); + TEST_ERROR; + } + + /* Reader finishes last and deletes the named pipes */ + if(!writer) { + if(HDremove(np->fifo_writer_to_reader) != 0) { + printf("HDremove fifo_writer_to_reader failed\n"); + TEST_ERROR; + } + + if(HDremove(np->fifo_reader_to_writer) != 0) { + printf("HDremove fifo_reader_to_writer failed\n"); + TEST_ERROR; + } + } + return true; + +error: + return false; +} /* np_close() */ + +/* + * Writer synchronization depending on the result from the action performed. + */ +static bool +np_writer(bool result, unsigned step, const state_t *s, np_state_t *np, H5F_vfd_swmr_config_t *config) +{ + unsigned int i; + + /* The action fails */ + if(!result) { + printf("action failed\n"); + H5_FAILED(); AT(); + + /* At communication interval, notify the reader about the failure and quit */ + if (step % s->csteps == 0) { + np->notify = -1; + HDwrite(np->fd_writer_to_reader, &np->notify, sizeof(int)); + goto error; + } + /* The action succeeds */ + } else { + /* At communication interval, notify the reader and wait for its response */ + if (step % s->csteps == 0) { + /* Bump up the value of notify to tell the reader to start reading */ + np->notify++; + if (HDwrite(np->fd_writer_to_reader, &np->notify, sizeof(int)) < 0) { + printf("HDwrite failed\n"); + TEST_ERROR; + } + + /* During the wait, writer makes repeated HDF5 API calls + * to trigger EOT at approximately the correct time */ + for(i = 0; i < config->max_lag + 1; i++) { + decisleep(config->tick_len); + H5E_BEGIN_TRY { + H5Aexists(s->file, "nonexistent"); + } H5E_END_TRY; + } + + /* Handshake between writer and reader */ + if(!np_confirm_verify_notify(np->fd_reader_to_writer, step, s, np)) { + printf("np_confirm_verify_notify() verify/notify not in sync failed\n"); + TEST_ERROR; + } + } + } + return true; + +error: + return false; + +} /* np_writer() */ + +/* + * + * Reader synchronization depending on the result from the verification. + */ +static bool +np_reader(bool result, unsigned step, const state_t *s, np_state_t *np) +{ + /* The verification fails */ + if(!result) { + printf("verify action failed\n"); + H5_FAILED(); AT(); + + /* At communication interval, tell the writer about the failure and exit */ + if (step % s->csteps == 0) { + np->notify = -1; + HDwrite(np->fd_reader_to_writer, &np->notify, sizeof(int)); + goto error; + } + /* The verification succeeds */ + } else { + if (step % s->csteps == 0) { + /* Send back the same notify value for acknowledgement: + * --inform the writer to move to the next step */ + if (HDwrite(np->fd_reader_to_writer, &np->notify, sizeof(int)) < 0) { + printf("HDwrite failed\n"); + TEST_ERROR; + } + } + } + return true; + +error: + return false; + +} /* np_reader() */ + +/* + * Handshake between writer and reader: + * Confirm `verify` is same as `notify`. + */ +static bool +np_confirm_verify_notify(int fd, unsigned step, const state_t *s, np_state_t *np) +{ + if (step % s->csteps == 0) { + np->verify++; + if (HDread(fd, &np->notify, sizeof(int)) < 0) { + printf("HDread failed\n"); + TEST_ERROR; + } + + if (np->notify == -1) { + printf("reader/writer failed to verify\n"); + TEST_ERROR; + } + + if (np->notify != np->verify) { + printf("received message %d, expecting %d\n", np->notify, np->verify); + TEST_ERROR; + } + } + + return true; + +error: + return false; +} /* np_confirm_verify_notify() */ + +/* + * Main + */ +int +main(int argc, char **argv) +{ + hid_t fapl, fcpl; + bool writer; + state_t s; + const char *personality; + H5F_vfd_swmr_config_t config; + np_state_t np; + dsets_state_t ds; + + if(!state_init(&s, argc, argv)) { + printf("state_init() failed\n"); + TEST_ERROR; + } + + personality = strstr(s.progname, "vfd_swmr_dsetchks_"); + + if (personality != NULL && + strcmp(personality, "vfd_swmr_dsetchks_writer") == 0) + writer = true; + else if (personality != NULL && + strcmp(personality, "vfd_swmr_dsetchks_reader") == 0) + writer = false; + else { + printf("unknown personality, expected vfd_swmr_dsetchks_{reader,writer}\n"); + TEST_ERROR; + } + + /* config, tick_len, max_lag, writer, flush_raw_data, md_pages_reserved, md_file_path */ + init_vfd_swmr_config(&config, 4, 7, writer, FALSE, 128, "./dsetchks-shadow"); + + /* use_latest_format, use_vfd_swmr, only_meta_page, config */ + if((fapl = vfd_swmr_create_fapl(true, s.use_vfd_swmr, true, &config)) < 0) { + printf("vfd_swmr_create_fapl() failed\n"); + TEST_ERROR; + } + + if ((fcpl = H5Pcreate(H5P_FILE_CREATE)) < 0) { + printf("H5Pcreate failed\n"); + TEST_ERROR; + } + + if(H5Pset_file_space_strategy(fcpl, H5F_FSPACE_STRATEGY_PAGE, false, 1) < 0) { + printf("H5Pset_file_space_strategy failed\n"); + TEST_ERROR; + } + + if (writer) { + if((s.file = H5Fcreate(s.filename, H5F_ACC_TRUNC, fcpl, fapl)) < 0) { + printf("H5Fcreate failed\n"); + TEST_ERROR; + } + + if(!create_dsets(&s, &ds)) { + printf("create_dsets() failed\n"); + TEST_ERROR; + } + + } else { + if ((s.file = H5Fopen(s.filename, H5F_ACC_RDONLY, fapl)) < 0) { + printf("H5Fopen failed\n"); + TEST_ERROR; + } + if(!open_dsets(&s, &ds)) { + printf("open_dsets() failed\n"); + TEST_ERROR; + } + } + + /* Initiailze named pipes */ + if(s.use_np && !np_init(&np, writer)) { + printf("np_init() failed\n"); + TEST_ERROR; + } + + if (writer) { + + if(!perform_dsets_operations(&s, &ds, &config, &np)) { + printf("perform_dsets_operations() failed\n"); + TEST_ERROR; + } + + } else { + + if(!verify_dsets_operations(&s, &ds, &config, &np)) { + printf("perform_dsets_operations() failed\n"); + TEST_ERROR; + } + + } + + if(!close_dsets(&ds)) { + printf("close_dsets() failed\n"); + TEST_ERROR; + } + + if (H5Pclose(fapl) < 0) { + printf("H5Pclose failed\n"); + TEST_ERROR; + } + + if (H5Pclose(fcpl) < 0) { + printf("H5Pclose failed\n"); + TEST_ERROR; + } + + if (H5Fclose(s.file) < 0) { + printf("H5Fclose failed\n"); + TEST_ERROR; + } + + if(s.use_np && !np_close(&np, writer)) { + printf("np_close() failed\n"); + TEST_ERROR; + } + + return EXIT_SUCCESS; + +error: + H5E_BEGIN_TRY { + H5Pclose(fapl); + H5Pclose(fcpl); + H5Fclose(s.file); + } H5E_END_TRY; + + if (s.use_np && np.fd_writer_to_reader >= 0) + HDclose(np.fd_writer_to_reader); + + if (s.use_np && np.fd_reader_to_writer >= 0) + HDclose(np.fd_reader_to_writer); + + if(s.use_np && !writer) { + HDremove(np.fifo_writer_to_reader); + HDremove(np.fifo_reader_to_writer); + } + + return EXIT_FAILURE; +} /* main */ + +#else /* H5_HAVE_WIN32_API */ + +int +main(void) +{ + HDfprintf(stderr, "Non-POSIX platform. Skipping.\n"); + return EXIT_SUCCESS; +} /* end main() */ + +#endif /* H5_HAVE_WIN32_API */ + -- cgit v0.12 From ca981a460b2b74708bc8f4002728f471f23bd597 Mon Sep 17 00:00:00 2001 From: github-actions <41898282+github-actions[bot]@users.noreply.github.com> Date: Wed, 16 Jun 2021 15:10:14 +0000 Subject: Committing clang-format changes --- test/vfd_swmr_dsetchks_writer.c | 1191 ++++++++++++++++++++------------------- 1 file changed, 607 insertions(+), 584 deletions(-) diff --git a/test/vfd_swmr_dsetchks_writer.c b/test/vfd_swmr_dsetchks_writer.c index 9f8176b..47802c4 100644 --- a/test/vfd_swmr_dsetchks_writer.c +++ b/test/vfd_swmr_dsetchks_writer.c @@ -13,7 +13,7 @@ /* * Purpose: To test chunk operations for chunked dataset specifically: - * --chunked datasets with the 5 indexing types: + * --chunked datasets with the 5 indexing types: * 1. single (dims=max_dims=chunk_dims, default incremental allocation) * 2. implicit (dims=max_dims, early allocation, no filter) * 3. fixed array (fixed max_dims, default incremental allocation) @@ -28,7 +28,7 @@ * -- writes that cover a partial chunk * -- writes that cover multiple chunks * -- writes that cover multiple partial chunks - * + * * For fa, ea, bt2 indexes: * --increase size of dataset dimensions * --decrease size of dataset dimensions @@ -39,128 +39,116 @@ #ifndef H5_HAVE_WIN32_API -#define READER_WAIT_TICKS 4 +#define READER_WAIT_TICKS 4 /* Names for datasets */ -#define DSET_SINGLE_NAME "chunked_single" -#define DSET_IMPLICIT_NAME "chunked_implicit" -#define DSET_FA_NAME "chunked_fa" -#define DSET_EA_NAME "chunked_ea" -#define DSET_BT2_NAME "chunked_bt2" +#define DSET_SINGLE_NAME "chunked_single" +#define DSET_IMPLICIT_NAME "chunked_implicit" +#define DSET_FA_NAME "chunked_fa" +#define DSET_EA_NAME "chunked_ea" +#define DSET_BT2_NAME "chunked_bt2" /* Operations for testing */ -#define GWRITES 1 /* Writes that cover a single chunk per write */ -#define PWRITES 2 /* Writes that cover a partial chunk per write */ -#define TWRITES 3 /* Writes that cover multiple chunks per write */ -#define LWRITES 4 /* Writes that cover multiple partial chunks per write */ -#define INCR_EXT 5 /* Increase dataset dimenion sizes */ -#define DECR_EXT 6 /* Decrease dataset dimension sizes */ +#define GWRITES 1 /* Writes that cover a single chunk per write */ +#define PWRITES 2 /* Writes that cover a partial chunk per write */ +#define TWRITES 3 /* Writes that cover multiple chunks per write */ +#define LWRITES 4 /* Writes that cover multiple partial chunks per write */ +#define INCR_EXT 5 /* Increase dataset dimenion sizes */ +#define DECR_EXT 6 /* Decrease dataset dimension sizes */ /* Fill values */ -#define FILL_INIT 1 /* Fill value used when creating the datasets */ -#define FILL_FULL 7 /* Fill value used when writing a full chunk */ -#define FILL_PARTIAL 9 /* Fill value used when writing partial chunk(s) */ +#define FILL_INIT 1 /* Fill value used when creating the datasets */ +#define FILL_FULL 7 /* Fill value used when writing a full chunk */ +#define FILL_PARTIAL 9 /* Fill value used when writing partial chunk(s) */ -#define MULTI_CHUNKS 2 +#define MULTI_CHUNKS 2 /* Structure to hold info for options specified */ typedef struct { - char filename[PATH_MAX]; /* File name */ - char progname[PATH_MAX]; /* Program name */ - hid_t file; /* File ID */ - hid_t filetype; /* Datatype ID */ - unsigned int update_interval; /* For -u option */ - unsigned int csteps; /* For -c option */ - bool use_np; /* For -N option */ - bool use_vfd_swmr; /* For -S option */ - bool use_filter; /* For -o option */ - - bool single_index; /* -s option: create a chunked dataset with single chunk index */ - bool implicit_index; /* -i option: create a chunked datasets with implicit chunk index */ - bool fa_index; /* -f option: create a chunked dataset with fixed array index */ - bool ea_index; /* -e option: create a chunked dataset with extensible array index */ - bool bt2_index; /* -r option: create a chunked dataset with version 2 btree index */ - - unsigned int rows; /* -m option for the chunked datasets */ - unsigned int cols; /* -n option: writes that cover a single chunk per write */ - unsigned int pwrites; /* -p option: writes that cover a partial chunk per write */ - unsigned int twrites; /* -t option: writes that cover multiple chunks per write */ - unsigned int lwrites; /* -l option: writes that cover multiple partial chunks per write */ - - unsigned int xincrs; /* -x option */ - unsigned int ydecrs; /* -y option */ + char filename[PATH_MAX]; /* File name */ + char progname[PATH_MAX]; /* Program name */ + hid_t file; /* File ID */ + hid_t filetype; /* Datatype ID */ + unsigned int update_interval; /* For -u option */ + unsigned int csteps; /* For -c option */ + bool use_np; /* For -N option */ + bool use_vfd_swmr; /* For -S option */ + bool use_filter; /* For -o option */ + + bool single_index; /* -s option: create a chunked dataset with single chunk index */ + bool implicit_index; /* -i option: create a chunked datasets with implicit chunk index */ + bool fa_index; /* -f option: create a chunked dataset with fixed array index */ + bool ea_index; /* -e option: create a chunked dataset with extensible array index */ + bool bt2_index; /* -r option: create a chunked dataset with version 2 btree index */ + + unsigned int rows; /* -m option for the chunked datasets */ + unsigned int cols; /* -n option: writes that cover a single chunk per write */ + unsigned int pwrites; /* -p option: writes that cover a partial chunk per write */ + unsigned int twrites; /* -t option: writes that cover multiple chunks per write */ + unsigned int lwrites; /* -l option: writes that cover multiple partial chunks per write */ + + unsigned int xincrs; /* -x option */ + unsigned int ydecrs; /* -y option */ } state_t; /* Initializations for state_t */ -#define ALL_HID_INITIALIZER (state_t) { \ - .filename = "" \ - , .file = H5I_INVALID_HID \ - , .filetype = H5T_NATIVE_UINT32 \ - , .update_interval = READER_WAIT_TICKS \ - , .csteps = 1 \ - , .use_np = true \ - , .use_vfd_swmr = true \ - , .use_filter = false \ - , .single_index = false \ - , .implicit_index = false \ - , .fa_index = false \ - , .ea_index = false \ - , .bt2_index = false \ - , .rows = 10 \ - , .cols = 5 \ - , .gwrites = 0 \ - , .pwrites = 0 \ - , .twrites = 0 \ - , .lwrites = 0 \ - , .xincrs = 0 \ - , .ydecrs = 0 } +#define ALL_HID_INITIALIZER \ + (state_t) \ + { \ + .filename = "", .file = H5I_INVALID_HID, .filetype = H5T_NATIVE_UINT32, \ + .update_interval = READER_WAIT_TICKS, .csteps = 1, .use_np = true, .use_vfd_swmr = true, \ + .use_filter = false, .single_index = false, .implicit_index = false, .fa_index = false, \ + .ea_index = false, .bt2_index = false, .rows = 10, .cols = 5, .gwrites = 0, .pwrites = 0, \ + .twrites = 0, .lwrites = 0, .xincrs = 0, .ydecrs = 0 \ + } /* Structure to hold info for different dataset types */ typedef struct { - hsize_t chunk_dims[2]; /* Chunk dimensions for all datasets except single_did */ + hsize_t chunk_dims[2]; /* Chunk dimensions for all datasets except single_did */ hsize_t scaled_dims[2]; hsize_t multi_scaled[2]; - hid_t single_did; /* ID for chunked dataset: single index */ - hid_t implicit_did; /* ID for chunked dataset: implicit index */ - hid_t fa_did; /* ID for chunked dataset: fixed array index */ - hid_t ea_did; /* ID for chunked dataset: extensible array index */ - hid_t bt2_did; /* ID for chunked dataset: version 2 btree index */ + hid_t single_did; /* ID for chunked dataset: single index */ + hid_t implicit_did; /* ID for chunked dataset: implicit index */ + hid_t fa_did; /* ID for chunked dataset: fixed array index */ + hid_t ea_did; /* ID for chunked dataset: extensible array index */ + hid_t bt2_did; /* ID for chunked dataset: version 2 btree index */ } dsets_state_t; /* Initializations for dsets_state_t */ -#define DSETS_INITIALIZER (dsets_state_t) { \ - .single_did = H5I_INVALID_HID \ - , .implicit_did = H5I_INVALID_HID \ - , .fa_did = H5I_INVALID_HID \ - , .ea_did = H5I_INVALID_HID \ - , .bt2_did = H5I_INVALID_HID } +#define DSETS_INITIALIZER \ + (dsets_state_t) \ + { \ + .single_did = H5I_INVALID_HID, .implicit_did = H5I_INVALID_HID, .fa_did = H5I_INVALID_HID, \ + .ea_did = H5I_INVALID_HID, .bt2_did = H5I_INVALID_HID \ + } /* Structure to hold info for named pipes */ typedef struct { - const char *fifo_writer_to_reader; /* Name of fifo for writer to reader */ - const char *fifo_reader_to_writer; /* Name of fifo for reader to writer */ - int fd_writer_to_reader; /* File ID for fifo from writer to reader */ - int fd_reader_to_writer; /* File ID for fifo from reader to writer */ - int notify; /* Value to notify between writer and reader */ - int verify; /* Value to verify between writer and reader */ + const char *fifo_writer_to_reader; /* Name of fifo for writer to reader */ + const char *fifo_reader_to_writer; /* Name of fifo for reader to writer */ + int fd_writer_to_reader; /* File ID for fifo from writer to reader */ + int fd_reader_to_writer; /* File ID for fifo from reader to writer */ + int notify; /* Value to notify between writer and reader */ + int verify; /* Value to verify between writer and reader */ } np_state_t; /* Initializations for np_state_t */ -#define NP_INITIALIZER (np_state_t) { \ - .fifo_writer_to_reader = "./fifo_dsetchks_writer_to_reader" \ - , .fifo_reader_to_writer = "./fifo_dsetchks_reader_to_writer" \ - , .fd_writer_to_reader = -1 \ - , .fd_reader_to_writer = -1 \ - , .notify = 0 \ - , .verify = 0 } +#define NP_INITIALIZER \ + (np_state_t) \ + { \ + .fifo_writer_to_reader = "./fifo_dsetchks_writer_to_reader", \ + .fifo_reader_to_writer = "./fifo_dsetchks_reader_to_writer", .fd_writer_to_reader = -1, \ + .fd_reader_to_writer = -1, .notify = 0, .verify = 0 \ + } static bool state_init(state_t *, int, char **); static bool np_init(np_state_t *np, bool writer); static bool np_close(np_state_t *np, bool writer); -static bool np_writer(bool result, unsigned step, const state_t *s, np_state_t *np, H5F_vfd_swmr_config_t *config); +static bool np_writer(bool result, unsigned step, const state_t *s, np_state_t *np, + H5F_vfd_swmr_config_t *config); static bool np_reader(bool result, unsigned step, const state_t *s, np_state_t *np); static bool np_confirm_verify_notify(int fd, unsigned step, const state_t *s, np_state_t *np); @@ -169,71 +157,77 @@ static bool open_dsets(const state_t *s, dsets_state_t *ds); static bool close_dsets(const dsets_state_t *ds); static void set_chunk_scaled_dims(const state_t *s, dsets_state_t *ds); -static bool perform_dsets_operations(state_t *s, dsets_state_t *ds, - H5F_vfd_swmr_config_t *config, np_state_t *np); +static bool perform_dsets_operations(state_t *s, dsets_state_t *ds, H5F_vfd_swmr_config_t *config, + np_state_t *np); static bool write_dsets_chunks(unsigned action, const state_t *s, const dsets_state_t *ds, unsigned step); static void setup_selection(unsigned action, unsigned which, const state_t *s, const dsets_state_t *ds, - hsize_t *start, hsize_t *stride, hsize_t *count, hsize_t *block); -static void check_set_edge_block(const state_t *s, const dsets_state_t *ds, - unsigned i, unsigned j, hsize_t *block); + hsize_t *start, hsize_t *stride, hsize_t *count, hsize_t *block); +static void check_set_edge_block(const state_t *s, const dsets_state_t *ds, unsigned i, unsigned j, + hsize_t *block); static void check_set_partial_block(unsigned action, const hsize_t *dims, hsize_t *block, hsize_t *start); -static bool write_dset(unsigned action, hid_t did, hid_t tid, - hsize_t *start, hsize_t *stride, hsize_t *count, hsize_t *block); +static bool write_dset(unsigned action, hid_t did, hid_t tid, hsize_t *start, hsize_t *stride, hsize_t *count, + hsize_t *block); static bool write_dset_single(unsigned action, const state_t *s, const dsets_state_t *ds); static bool dsets_extent(unsigned action, const state_t *s, const dsets_state_t *ds); static bool dset_extent_real(unsigned action, hid_t did, const hsize_t *chunk_dims); -static bool verify_dsets_operations(state_t *s, dsets_state_t *ds, H5F_vfd_swmr_config_t *config, np_state_t *np); +static bool verify_dsets_operations(state_t *s, dsets_state_t *ds, H5F_vfd_swmr_config_t *config, + np_state_t *np); static bool verify_dsets_chunks(unsigned action, const state_t *s, const dsets_state_t *ds, unsigned which); -static bool verify_read_dset(unsigned action, hid_t did, hid_t tid, - hsize_t *start, hsize_t *stride, hsize_t *count, hsize_t *block); +static bool verify_read_dset(unsigned action, hid_t did, hid_t tid, hsize_t *start, hsize_t *stride, + hsize_t *count, hsize_t *block); static bool verify_read_dset_single(unsigned action, const state_t *s, const dsets_state_t *ds); static bool verify_dsets_extent(unsigned action, const state_t *s, const dsets_state_t *ds, unsigned which); -static bool verify_dset_extent_real(unsigned action, hid_t did, - unsigned rows, unsigned cols, unsigned which); +static bool verify_dset_extent_real(unsigned action, hid_t did, unsigned rows, unsigned cols, unsigned which); static const hid_t badhid = H5I_INVALID_HID; static void usage(const char *progname) { - fprintf(stderr, "usage: %s \n" - " [-s] [-i] [-f] [-e] [-r]\n" - " [-m rows] [-n cols]\n" - " [-g gwrites] [-p pwrites] [-t twrites] [-l lwrites]\n" - " [-x xincrs] [-y decrs]\n" - " [-u nticks] [-c csteps] [-S] [-N] [-q] [-b] [-o]\n", progname); - - fprintf(stderr, "\n" - "-s: create a 2-d chunked dataset with single index\n" - "-i: create a 2-d chunked dataset with implicit index\n" - "-f: create a 2-d chunked dataset with fixed array index\n" - "-e: create a 2-d chunked dataset with extensible array index\n" - "-r: create a 2-d chunked dataset with v2 btree index\n" - "-m rows: # of rows for the datasets\n" - "-n cols: # of columns for the chunked datasets\n" - "-g gwrites: perform writes that cover a single chunk per write to datasets\n" - "-p pwrites: perform writes that cover a single partial chunk per write to datasets\n" - "-t twrites: perform writes that cover multiple chunks per write to datasets\n" - "-l lwrites: perform writes that cover multiple partial chunks per write to datasets\n" - "-x xincrs: increase dataset dimension size by 1 for times to datasets\n" - "-y ydecrs: decrease dataset dimension size by 1 for times to datasets\n" - "-u nticks: `nticks` ticks for the reader to wait before verification\n" + fprintf(stderr, + "usage: %s \n" + " [-s] [-i] [-f] [-e] [-r]\n" + " [-m rows] [-n cols]\n" + " [-g gwrites] [-p pwrites] [-t twrites] [-l lwrites]\n" + " [-x xincrs] [-y decrs]\n" + " [-u nticks] [-c csteps] [-S] [-N] [-q] [-b] [-o]\n", + progname); + + fprintf( + stderr, + "\n" + "-s: create a 2-d chunked dataset with single index\n" + "-i: create a 2-d chunked dataset with implicit index\n" + "-f: create a 2-d chunked dataset with fixed array index\n" + "-e: create a 2-d chunked dataset with extensible array index\n" + "-r: create a 2-d chunked dataset with v2 btree index\n" + "-m rows: # of rows for the datasets\n" + "-n cols: # of columns for the chunked datasets\n" + "-g gwrites: perform writes that cover a single chunk per write to datasets\n" + "-p pwrites: perform writes that cover a single partial chunk per write to datasets\n" + "-t twrites: perform writes that cover multiple chunks per write to datasets\n" + "-l lwrites: perform writes that cover multiple partial chunks per write to datasets\n" + "-x xincrs: increase dataset dimension size by 1 for times to datasets\n" + "-y ydecrs: decrease dataset dimension size by 1 for times to datasets\n" + "-u nticks: `nticks` ticks for the reader to wait before verification\n" " (default is 4)\n" - "-c csteps: `csteps` steps communication interval between reader and writer\n" + "-c csteps: `csteps` steps communication interval between reader and writer\n" " (default is 1)\n" - "-S: do not use VFD SWMR\n" - "-N: do not use named pipes for test synchronization\n" + "-S: do not use VFD SWMR\n" + "-N: do not use named pipes for test synchronization\n" "-q: silence printouts, few messages\n" - "-b: write data in big-endian byte order\n" + "-b: write data in big-endian byte order\n" " (default is H5T_NATIVE_UINT32)\n\n" - "-o: enable compression (shuffle filter) for the datasets\n"); + "-o: enable compression (shuffle filter) for the datasets\n"); - fprintf(stderr, "\n" + fprintf( + stderr, + "\n" "Note:\n" "1. Require to specify at least -s, -i, -f, -e or -r option\n" "2. -m and -n options: and have to be > 0.\n" @@ -256,9 +250,9 @@ usage(const char *progname) " -g or -p or\n" " -t or -l or\n" " -x or -y \n" - "\n"); + "\n"); - exit(EXIT_FAILURE); + exit(EXIT_FAILURE); } /* usage() */ /* @@ -268,9 +262,9 @@ static bool state_init(state_t *s, int argc, char **argv) { unsigned long tmp; - int ch; - char tfile[PATH_MAX]; - char *end; + int ch; + char tfile[PATH_MAX]; + char * end; *s = ALL_HID_INITIALIZER; esnprintf(tfile, sizeof(tfile), "%s", argv[0]); @@ -279,165 +273,165 @@ state_init(state_t *s, int argc, char **argv) while ((ch = getopt(argc, argv, "siferom:n:x:y:g:p:t:l:bqSNu:c:")) != -1) { switch (ch) { - case 's': /* A chunked dataset with single index */ - s->single_index = true; - break; - - case 'i': /* A chunked dataset with implicit index */ - s->implicit_index = true; - break; - - case 'f': /* A chunked dataset with fixed array index */ - s->fa_index = true; - break; - - case 'e': /* A chunked dataset with extensible array index */ - s->ea_index = true; - break; - - case 'r': /* A chunked dataset with version 2 btree index */ - s->bt2_index = true; - break; - - case 'o': /* A chunked dataset with version 2 btree index */ - s->use_filter = true; - break; - - case 'q': /* Be quiet: few/no progress messages */ - verbosity = 0; - break; - - case 'b': /* Write data in big-endian byte order */ - s->filetype = H5T_STD_U32BE; - break; - - case 'S': /* Disable VFD SWMR */ - s->use_vfd_swmr = false; - break; - - case 'N': /* Disable named pipes synchronization */ - s->use_np = false; - break; - - case 'm': /* # of rows for datasets */ - case 'n': /* # of cols for datasets */ - case 'x': /* Increase by 1 for times */ - case 'y': /* Decrease by 1 for times */ - case 'g': /* # of writes that cover a single chunk per write */ - case 'p': /* # of writes that cover a single partial chunk per write */ - case 't': /* # of writes that cover multiple chunks per write */ - case 'l': /* # of writes that cover multiple partial chunks per write */ - case 'u': /* Ticks for reader to wait before verification */ - case 'c': /* Communication interval */ - errno = 0; - tmp = strtoul(optarg, &end, 0); - if (end == optarg || *end != '\0') { - printf("couldn't parse `-%c` argument `%s`\n", ch, optarg); - TEST_ERROR; - } else if (errno != 0) { - printf("couldn't parse `-%c` argument `%s`\n", ch, optarg); - TEST_ERROR; - } else if (tmp > UINT_MAX) { - printf("`-%c` argument `%lu` too large\n", ch, tmp); - TEST_ERROR; - } - - if (ch == 'm') - s->rows = (unsigned)tmp; - else if (ch == 'n') - s->cols = (unsigned)tmp; - else if (ch == 'x') - s->xincrs = (unsigned)tmp; - else if (ch == 'y') - s->ydecrs = (unsigned)tmp; - else if (ch == 'g') - s->gwrites = (unsigned)tmp; - else if (ch == 'p') - s->pwrites = (unsigned)tmp; - else if (ch == 't') - s->twrites = (unsigned)tmp; - else if (ch == 'l') - s->lwrites = (unsigned)tmp; - else if (ch == 'u') - s->update_interval = (unsigned)tmp; - else if (ch == 'c') - s->csteps = (unsigned)tmp; - - break; + case 's': /* A chunked dataset with single index */ + s->single_index = true; + break; + + case 'i': /* A chunked dataset with implicit index */ + s->implicit_index = true; + break; + + case 'f': /* A chunked dataset with fixed array index */ + s->fa_index = true; + break; + + case 'e': /* A chunked dataset with extensible array index */ + s->ea_index = true; + break; + + case 'r': /* A chunked dataset with version 2 btree index */ + s->bt2_index = true; + break; + + case 'o': /* A chunked dataset with version 2 btree index */ + s->use_filter = true; + break; + + case 'q': /* Be quiet: few/no progress messages */ + verbosity = 0; + break; + + case 'b': /* Write data in big-endian byte order */ + s->filetype = H5T_STD_U32BE; + break; + + case 'S': /* Disable VFD SWMR */ + s->use_vfd_swmr = false; + break; + + case 'N': /* Disable named pipes synchronization */ + s->use_np = false; + break; + + case 'm': /* # of rows for datasets */ + case 'n': /* # of cols for datasets */ + case 'x': /* Increase by 1 for times */ + case 'y': /* Decrease by 1 for times */ + case 'g': /* # of writes that cover a single chunk per write */ + case 'p': /* # of writes that cover a single partial chunk per write */ + case 't': /* # of writes that cover multiple chunks per write */ + case 'l': /* # of writes that cover multiple partial chunks per write */ + case 'u': /* Ticks for reader to wait before verification */ + case 'c': /* Communication interval */ + errno = 0; + tmp = strtoul(optarg, &end, 0); + if (end == optarg || *end != '\0') { + printf("couldn't parse `-%c` argument `%s`\n", ch, optarg); + TEST_ERROR; + } + else if (errno != 0) { + printf("couldn't parse `-%c` argument `%s`\n", ch, optarg); + TEST_ERROR; + } + else if (tmp > UINT_MAX) { + printf("`-%c` argument `%lu` too large\n", ch, tmp); + TEST_ERROR; + } - case '?': - default: - usage(s->progname); - break; + if (ch == 'm') + s->rows = (unsigned)tmp; + else if (ch == 'n') + s->cols = (unsigned)tmp; + else if (ch == 'x') + s->xincrs = (unsigned)tmp; + else if (ch == 'y') + s->ydecrs = (unsigned)tmp; + else if (ch == 'g') + s->gwrites = (unsigned)tmp; + else if (ch == 'p') + s->pwrites = (unsigned)tmp; + else if (ch == 't') + s->twrites = (unsigned)tmp; + else if (ch == 'l') + s->lwrites = (unsigned)tmp; + else if (ch == 'u') + s->update_interval = (unsigned)tmp; + else if (ch == 'c') + s->csteps = (unsigned)tmp; + + break; + + case '?': + default: + usage(s->progname); + break; } } argc -= optind; argv += optind; /* Require to specify at least -s or -i or -f or -e or -r option */ - if(!s->single_index && !s->implicit_index && - !s->fa_index && !s->ea_index && !s->bt2_index) { + if (!s->single_index && !s->implicit_index && !s->fa_index && !s->ea_index && !s->bt2_index) { printf("Require to specify at least -s or -i or -f or -e or -r option\n"); usage(s->progname); goto error; } /* -x or -y option only apply to dataset with fixed/extensible array/v2 btree index */ - if((s->single_index || s->implicit_index) && (s->xincrs || s->ydecrs)) { + if ((s->single_index || s->implicit_index) && (s->xincrs || s->ydecrs)) { printf("-x or -y option not applicable to dataset with single or implicit index\n"); usage(s->progname); goto error; } /* rows and cols cannot be zero */ - if(s->rows == 0 || s->cols == 0) { + if (s->rows == 0 || s->cols == 0) { printf("-m or -n cannot be zero\n"); TEST_ERROR; } /* -c cannot be zero */ - if(!s->csteps) { + if (!s->csteps) { printf("communication interval cannot be zero\n"); TEST_ERROR; } /* -c and -g options */ - if(s->gwrites && s->csteps > s->gwrites) { + if (s->gwrites && s->csteps > s->gwrites) { printf("communication interval with -g is out of bounds\n"); TEST_ERROR; } /* -c and -p options */ - if(s->pwrites && s->csteps > s->pwrites) { + if (s->pwrites && s->csteps > s->pwrites) { printf("communication interval with -p is out of bounds\n"); TEST_ERROR; } /* -c and -t options */ - if(s->twrites && s->csteps > s->twrites) { + if (s->twrites && s->csteps > s->twrites) { printf("communication interval with -t is out of bounds\n"); TEST_ERROR; } /* -c and -l options */ - if(s->lwrites && s->csteps > s->lwrites) { + if (s->lwrites && s->csteps > s->lwrites) { printf("communication interval with -l is out of bounds\n"); TEST_ERROR; } - + /* -c and -x options */ - if(s->xincrs && s->csteps > s->xincrs) { + if (s->xincrs && s->csteps > s->xincrs) { printf("communication interval with -x is out of bounds\n"); TEST_ERROR; } /* -c and -y options */ - if(s->ydecrs && s->csteps > s->ydecrs) { + if (s->ydecrs && s->csteps > s->ydecrs) { printf("communication interval with -y is out of bounds\n"); TEST_ERROR; } - /* The test file name */ esnprintf(s->filename, sizeof(s->filename), "vfd_swmr_dsetchks.h5"); @@ -448,7 +442,6 @@ error: } /* state_init() */ - /* * Create the specified datasets: * --2-dimensional chunked datasets @@ -464,10 +457,10 @@ error: static bool create_dsets(const state_t *s, dsets_state_t *ds) { - hid_t dcpl = badhid; - hid_t dcpl2 = badhid; - hid_t sid = badhid; - hsize_t dims[2]; + hid_t dcpl = badhid; + hid_t dcpl2 = badhid; + hid_t sid = badhid; + hsize_t dims[2]; unsigned fillval = FILL_INIT; *ds = DSETS_INITIALIZER; @@ -478,13 +471,13 @@ create_dsets(const state_t *s, dsets_state_t *ds) /* Create dataset creation property list */ /* Set properties in dcpl that are common for all the datasets */ - if((dcpl = H5Pcreate(H5P_DATASET_CREATE)) < 0) { + if ((dcpl = H5Pcreate(H5P_DATASET_CREATE)) < 0) { printf("H5Pcreate failed\n"); TEST_ERROR; } /* Set to chunked layout */ - if(H5Pset_layout(dcpl, H5D_CHUNKED) < 0) { + if (H5Pset_layout(dcpl, H5D_CHUNKED) < 0) { printf("H5Pset_layout failed\n"); TEST_ERROR; } @@ -496,7 +489,7 @@ create_dsets(const state_t *s, dsets_state_t *ds) } /* Set to use filter as specified */ - if(s->use_filter) { + if (s->use_filter) { if (H5Pset_shuffle(dcpl) < 0) { printf("H5Pset_shuffle failed\n"); goto error; @@ -505,14 +498,14 @@ create_dsets(const state_t *s, dsets_state_t *ds) /* Create 2-D chunked dataset with single index */ /* Chunked, dims=max_dims=chunk_dims */ - if(s->single_index) { + if (s->single_index) { - if((dcpl2 = H5Pcopy(dcpl)) < 0) { + if ((dcpl2 = H5Pcopy(dcpl)) < 0) { printf("H5Tcopy failed\n"); TEST_ERROR; } - if(H5Pset_chunk(dcpl2, 2, dims) < 0) { + if (H5Pset_chunk(dcpl2, 2, dims) < 0) { printf("H5Pset_chunk failed\n"); TEST_ERROR; } @@ -523,39 +516,39 @@ create_dsets(const state_t *s, dsets_state_t *ds) } /* Create the chunked dataset: single index */ - if((ds->single_did = H5Dcreate2(s->file, DSET_SINGLE_NAME, s->filetype, - sid, H5P_DEFAULT, dcpl2, H5P_DEFAULT)) < 0) { + if ((ds->single_did = H5Dcreate2(s->file, DSET_SINGLE_NAME, s->filetype, sid, H5P_DEFAULT, dcpl2, + H5P_DEFAULT)) < 0) { printf("H5Dcreate2 chunked dataset:single index failed\n"); TEST_ERROR; } - if(H5Pclose(dcpl2) < 0) { + if (H5Pclose(dcpl2) < 0) { printf("H5Pclose failed\n"); TEST_ERROR; } - if(H5Sclose(sid) < 0) { + if (H5Sclose(sid) < 0) { printf("H5Sclose failed\n"); TEST_ERROR; } } /* Chunk size is common for datasets with implicit/fa/ea/bt2 index */ - if(H5Pset_chunk(dcpl, 2, ds->chunk_dims) < 0) { + if (H5Pset_chunk(dcpl, 2, ds->chunk_dims) < 0) { printf("H5Pset_chunk failed\n"); TEST_ERROR; } /* Create 2-D chunked dataset with implicit index */ /* Chunked, dims=max_dims, early allocation */ - if(s->implicit_index) { + if (s->implicit_index) { - if((dcpl2 = H5Pcopy(dcpl)) < 0) { + if ((dcpl2 = H5Pcopy(dcpl)) < 0) { printf("H5Pcopy failed\n"); TEST_ERROR; } - if(H5Pset_alloc_time(dcpl2, H5D_ALLOC_TIME_EARLY) < 0) { + if (H5Pset_alloc_time(dcpl2, H5D_ALLOC_TIME_EARLY) < 0) { printf("H5Pset_alloc_time\n"); TEST_ERROR; } @@ -566,18 +559,18 @@ create_dsets(const state_t *s, dsets_state_t *ds) } /* Create the chunked dataset: implicit index */ - if((ds->implicit_did = H5Dcreate2(s->file, DSET_IMPLICIT_NAME, s->filetype, - sid, H5P_DEFAULT, dcpl2, H5P_DEFAULT)) < 0) { + if ((ds->implicit_did = H5Dcreate2(s->file, DSET_IMPLICIT_NAME, s->filetype, sid, H5P_DEFAULT, dcpl2, + H5P_DEFAULT)) < 0) { printf("H5Dcreate2 chunked dataset:implicit index failed\n"); TEST_ERROR; } - if(H5Pclose(dcpl2) < 0) { + if (H5Pclose(dcpl2) < 0) { printf("H5Pclose failed\n"); TEST_ERROR; } - if(H5Sclose(sid) < 0) { + if (H5Sclose(sid) < 0) { printf("H5Sclose failed\n"); TEST_ERROR; } @@ -585,25 +578,25 @@ create_dsets(const state_t *s, dsets_state_t *ds) /* Create 2-D chunked dataset with fixed array index */ /* Chunked, fixed max_dims */ - if(s->fa_index) { + if (s->fa_index) { hsize_t max_dims[2]; max_dims[0] = dims[0] * 2; max_dims[1] = dims[1] * 2; - if((sid = H5Screate_simple(2, dims, max_dims)) < 0) { + if ((sid = H5Screate_simple(2, dims, max_dims)) < 0) { printf("H5Screate_simple failed\n"); TEST_ERROR; } /* Create the chunked dataset (fixed array index) with the named datatype */ - if((ds->fa_did = H5Dcreate2(s->file, DSET_FA_NAME, s->filetype, - sid, H5P_DEFAULT, dcpl, H5P_DEFAULT)) < 0) { + if ((ds->fa_did = + H5Dcreate2(s->file, DSET_FA_NAME, s->filetype, sid, H5P_DEFAULT, dcpl, H5P_DEFAULT)) < 0) { printf("H5Dcreate2 chunked dataset: fa index failed\n"); TEST_ERROR; } - if(H5Sclose(sid) < 0) { + if (H5Sclose(sid) < 0) { printf("H5Sclose failed\n"); TEST_ERROR; } @@ -611,25 +604,25 @@ create_dsets(const state_t *s, dsets_state_t *ds) /* Create 2-D chunked dataset with extensible array index */ /* Chunked, 1 unlimited max_dims */ - if(s->ea_index) { + if (s->ea_index) { hsize_t max_dims[2]; max_dims[0] = dims[0] * 2; max_dims[1] = H5S_UNLIMITED; - if((sid = H5Screate_simple(2, dims, max_dims)) < 0) { + if ((sid = H5Screate_simple(2, dims, max_dims)) < 0) { printf("H5Screate_simple failed\n"); TEST_ERROR; } /* Create the chunked dataset (extensible array index) with the named datatype */ - if((ds->ea_did = H5Dcreate2(s->file, DSET_EA_NAME, s->filetype, - sid, H5P_DEFAULT, dcpl, H5P_DEFAULT)) < 0) { + if ((ds->ea_did = + H5Dcreate2(s->file, DSET_EA_NAME, s->filetype, sid, H5P_DEFAULT, dcpl, H5P_DEFAULT)) < 0) { printf("H5Dcreate2 chunked dataset: ea index failed\n"); TEST_ERROR; } - if(H5Sclose(sid) < 0) { + if (H5Sclose(sid) < 0) { printf("H5Sclose failed\n"); TEST_ERROR; } @@ -637,30 +630,30 @@ create_dsets(const state_t *s, dsets_state_t *ds) /* Create 2-D chunked dataset with bt2 index */ /* Chunked, 2 unlimited max_dims */ - if(s->bt2_index) { + if (s->bt2_index) { hsize_t max_dims[2]; max_dims[0] = max_dims[1] = H5S_UNLIMITED; - if((sid = H5Screate_simple(2, dims, max_dims)) < 0) { + if ((sid = H5Screate_simple(2, dims, max_dims)) < 0) { printf("H5Screate_simple failed\n"); TEST_ERROR; } /* Create the chunked dataset (btree2 index) with the named datatype */ - if((ds->bt2_did = H5Dcreate2(s->file, DSET_BT2_NAME, s->filetype, - sid, H5P_DEFAULT, dcpl, H5P_DEFAULT)) < 0) { + if ((ds->bt2_did = + H5Dcreate2(s->file, DSET_BT2_NAME, s->filetype, sid, H5P_DEFAULT, dcpl, H5P_DEFAULT)) < 0) { printf("H5Dcreate2 chunked dataset: bt2 index failed\n"); TEST_ERROR; } - if(H5Sclose(sid) < 0) { + if (H5Sclose(sid) < 0) { printf("H5Sclose failed\n"); TEST_ERROR; } } - if(H5Pclose(dcpl) < 0) { + if (H5Pclose(dcpl) < 0) { printf("H5Pclose failed\n"); TEST_ERROR; } @@ -668,7 +661,8 @@ create_dsets(const state_t *s, dsets_state_t *ds) return true; error: - H5E_BEGIN_TRY { + H5E_BEGIN_TRY + { H5Pclose(dcpl); H5Pclose(dcpl2); H5Sclose(sid); @@ -677,13 +671,14 @@ error: H5Dclose(ds->fa_did); H5Dclose(ds->ea_did); H5Dclose(ds->bt2_did); - } H5E_END_TRY; + } + H5E_END_TRY; return false; } /* create_dsets() */ -/* +/* * Open the specified datasets. */ static bool @@ -693,7 +688,7 @@ open_dsets(const state_t *s, dsets_state_t *ds) set_chunk_scaled_dims(s, ds); /* Dataset with single index */ - if(s->single_index) { + if (s->single_index) { if ((ds->single_did = H5Dopen2(s->file, DSET_SINGLE_NAME, H5P_DEFAULT)) < 0) { printf("H5Dopen dataset with single index failed\n"); TEST_ERROR; @@ -701,7 +696,7 @@ open_dsets(const state_t *s, dsets_state_t *ds) } /* Dataset with implicit index */ - if(s->implicit_index) { + if (s->implicit_index) { if ((ds->implicit_did = H5Dopen2(s->file, DSET_IMPLICIT_NAME, H5P_DEFAULT)) < 0) { printf("H5Dopen dataset with implicit index failed\n"); TEST_ERROR; @@ -709,7 +704,7 @@ open_dsets(const state_t *s, dsets_state_t *ds) } /* Dataset with fixed array index */ - if(s->fa_index) { + if (s->fa_index) { if ((ds->fa_did = H5Dopen2(s->file, DSET_FA_NAME, H5P_DEFAULT)) < 0) { printf("H5Dopen dataset with fa index failed\n"); TEST_ERROR; @@ -717,7 +712,7 @@ open_dsets(const state_t *s, dsets_state_t *ds) } /* Dataset with extensible array index */ - if(s->ea_index) { + if (s->ea_index) { if ((ds->ea_did = H5Dopen2(s->file, DSET_EA_NAME, H5P_DEFAULT)) < 0) { printf("H5Dopen dataset with ea index failed\n"); TEST_ERROR; @@ -725,7 +720,7 @@ open_dsets(const state_t *s, dsets_state_t *ds) } /* Dataset with v2 btree index */ - if(s->bt2_index) { + if (s->bt2_index) { if ((ds->bt2_did = H5Dopen2(s->file, DSET_BT2_NAME, H5P_DEFAULT)) < 0) { printf("H5Dopen dataset with ea index failed\n"); TEST_ERROR; @@ -749,8 +744,8 @@ static void set_chunk_scaled_dims(const state_t *s, dsets_state_t *ds) { /* Default chunk size is s->rows/2 or s->cols/2 but not less than 1 */ - ds->chunk_dims[0] = MAX(1, s->rows/2); - ds->chunk_dims[1] = MAX(1, s->cols/2); + ds->chunk_dims[0] = MAX(1, s->rows / 2); + ds->chunk_dims[1] = MAX(1, s->cols / 2); /* # of chunks in x and y dimensions */ ds->scaled_dims[0] = (s->rows + ds->chunk_dims[0] - 1) / ds->chunk_dims[0]; @@ -769,31 +764,31 @@ static bool close_dsets(const dsets_state_t *ds) { /* Close dataset with single index */ - if(ds->single_did != badhid && H5Dclose(ds->single_did) < 0) { + if (ds->single_did != badhid && H5Dclose(ds->single_did) < 0) { printf("close_dset_real() dataset: single index failed\n"); TEST_ERROR; } /* Close dataset with implicit index */ - if(ds->implicit_did != badhid && H5Dclose(ds->implicit_did) < 0) { + if (ds->implicit_did != badhid && H5Dclose(ds->implicit_did) < 0) { printf("close_dset_real() dataset: implicit index failed\n"); TEST_ERROR; } /* Close dataset with fixed array index */ - if(ds->fa_did != badhid && H5Dclose(ds->fa_did) < 0) { + if (ds->fa_did != badhid && H5Dclose(ds->fa_did) < 0) { printf("close_dset_real() dataset: fa index failed\n"); TEST_ERROR; } /* Close dataset with extensible array index */ - if(ds->ea_did != badhid && H5Dclose(ds->ea_did) < 0) { + if (ds->ea_did != badhid && H5Dclose(ds->ea_did) < 0) { printf("close_dset_real() : ea index failed\n"); TEST_ERROR; } /* Close dataset with v2 btree index */ - if(ds->bt2_did != badhid && H5Dclose(ds->bt2_did) < 0) { + if (ds->bt2_did != badhid && H5Dclose(ds->bt2_did) < 0) { printf("close_dset_real() dataset: bt2 index failed\n"); TEST_ERROR; } @@ -801,13 +796,15 @@ close_dsets(const dsets_state_t *ds) return true; error: - H5E_BEGIN_TRY { + H5E_BEGIN_TRY + { H5Dclose(ds->single_did); H5Dclose(ds->implicit_did); H5Dclose(ds->fa_did); H5Dclose(ds->ea_did); H5Dclose(ds->bt2_did); - } H5E_END_TRY; + } + H5E_END_TRY; return false; @@ -834,23 +831,23 @@ error: * --DECR_EXT: decrease dataset dimenions sizes */ static bool -perform_dsets_operations(state_t *s, dsets_state_t *ds, H5F_vfd_swmr_config_t *config, np_state_t *np) +perform_dsets_operations(state_t *s, dsets_state_t *ds, H5F_vfd_swmr_config_t *config, np_state_t *np) { - unsigned step; - unsigned allowed_writes; - bool result; + unsigned step; + unsigned allowed_writes; + bool result; /* Dataset with single index */ - if(s->single_index) { + if (s->single_index) { /* Perform single full chunk write */ /* gwrites and twrites are the same */ /* Doesn't matter how many writes, only perform once */ - if(s->gwrites || s->twrites) { + if (s->gwrites || s->twrites) { dbgf(2, "Perform single full chunk write to dataset with single index; only perform 1 write\n"); result = write_dset_single(GWRITES, s, ds); - if(s->use_np && !np_writer(result, 0, s, np, config)) { + if (s->use_np && !np_writer(result, 0, s, np, config)) { printf("np_writer() for addition failed\n"); TEST_ERROR; } @@ -859,12 +856,13 @@ perform_dsets_operations(state_t *s, dsets_state_t *ds, H5F_vfd_swmr_config_t *c /* Perform a single partial chunk write */ /* pwrites and lwrites are the same */ /* Doesn't matter how many writes, only perform once */ - if(s->pwrites || s->lwrites) { - dbgf(2, "Perform single partial chunk write to dataset with single index; only perform 1 write\n"); + if (s->pwrites || s->lwrites) { + dbgf(2, + "Perform single partial chunk write to dataset with single index; only perform 1 write\n"); result = write_dset_single(PWRITES, s, ds); - if(s->use_np && !np_writer(result, 0, s, np, config)) { + if (s->use_np && !np_writer(result, 0, s, np, config)) { printf("np_writer() for addition failed\n"); TEST_ERROR; } @@ -872,19 +870,20 @@ perform_dsets_operations(state_t *s, dsets_state_t *ds, H5F_vfd_swmr_config_t *c } /* Datasets with implicit/fa/ea/bt2 index */ - if(s->implicit_index || s->fa_index || s->ea_index || s->bt2_index) { + if (s->implicit_index || s->fa_index || s->ea_index || s->bt2_index) { /* Perform single full chunk writes */ - if(s->gwrites) { - allowed_writes = (unsigned)(ds->scaled_dims[0]*ds->scaled_dims[1]); + if (s->gwrites) { + allowed_writes = (unsigned)(ds->scaled_dims[0] * ds->scaled_dims[1]); dbgf(2, "The allowed -g writes is %u; you specify %u writes\n", allowed_writes, s->gwrites); for (step = 0; (step < s->gwrites && step < allowed_writes); step++) { - dbgf(2, "Perform single full chunk writes #%u to datasets with implicit/fa/ea/bt2 index\n", step); + dbgf(2, "Perform single full chunk writes #%u to datasets with implicit/fa/ea/bt2 index\n", + step); result = write_dsets_chunks(GWRITES, s, ds, step); - if(s->use_np && !np_writer(result, step, s, np, config)) { + if (s->use_np && !np_writer(result, step, s, np, config)) { printf("np_writer() for single full chunk writes failed\n"); TEST_ERROR; } @@ -892,33 +891,35 @@ perform_dsets_operations(state_t *s, dsets_state_t *ds, H5F_vfd_swmr_config_t *c } /* Perform single partial chunk writes */ - if(s->pwrites) { - allowed_writes = (unsigned)(ds->scaled_dims[0]*ds->scaled_dims[1]); + if (s->pwrites) { + allowed_writes = (unsigned)(ds->scaled_dims[0] * ds->scaled_dims[1]); dbgf(2, "The allowed -p writes is %u; you specify %u writes\n", allowed_writes, s->pwrites); for (step = 0; (step < s->pwrites && step < allowed_writes); step++) { - dbgf(2, "Perform single partial chunk writes #%u to datasets with implicit/fa/ea/bt2 index\n", step); + dbgf(2, "Perform single partial chunk writes #%u to datasets with implicit/fa/ea/bt2 index\n", + step); result = write_dsets_chunks(PWRITES, s, ds, step); - if(s->use_np && !np_writer(result, step, s, np, config)) { + if (s->use_np && !np_writer(result, step, s, np, config)) { printf("np_writer() for partial single chunk writes failed\n"); TEST_ERROR; } } } - + /* Perform multiple full chunk writes */ - if(s->twrites) { - allowed_writes = (unsigned)(ds->multi_scaled[0]*ds->multi_scaled[1]); + if (s->twrites) { + allowed_writes = (unsigned)(ds->multi_scaled[0] * ds->multi_scaled[1]); dbgf(2, "The allowed -t writes is %u; you specify %u writes\n", allowed_writes, s->twrites); for (step = 0; (step < s->twrites && step < allowed_writes); step++) { - dbgf(2, "Perform multiple full chunk writes #%u to datasets with implicit/fa/ea/bt2 index\n", step); + dbgf(2, "Perform multiple full chunk writes #%u to datasets with implicit/fa/ea/bt2 index\n", + step); result = write_dsets_chunks(TWRITES, s, ds, step); - if(s->use_np && !np_writer(result, step, s, np, config)) { + if (s->use_np && !np_writer(result, step, s, np, config)) { printf("np_writer() for multiple full chunk writes failed\n"); TEST_ERROR; } @@ -926,16 +927,18 @@ perform_dsets_operations(state_t *s, dsets_state_t *ds, H5F_vfd_swmr_config_t *c } /* Perform multiple partial chunk writes */ - if(s->lwrites) { - allowed_writes = (unsigned)(ds->multi_scaled[0]*ds->multi_scaled[1]); + if (s->lwrites) { + allowed_writes = (unsigned)(ds->multi_scaled[0] * ds->multi_scaled[1]); dbgf(2, "The allowed -l writes is %u; you specify %u writes\n", allowed_writes, s->lwrites); for (step = 0; (step < s->lwrites && step < allowed_writes); step++) { - dbgf(2, "Perform multiple partial chunk writes #%u to datasets with implicit/fa/ea/bt2 index\n", step); + dbgf(2, + "Perform multiple partial chunk writes #%u to datasets with implicit/fa/ea/bt2 index\n", + step); result = write_dsets_chunks(LWRITES, s, ds, step); - if(s->use_np && !np_writer(result, step, s, np, config)) { + if (s->use_np && !np_writer(result, step, s, np, config)) { printf("np_writer() for multiple partial chunk writes failed\n"); TEST_ERROR; } @@ -943,13 +946,14 @@ perform_dsets_operations(state_t *s, dsets_state_t *ds, H5F_vfd_swmr_config_t *c } /* Increase dataset dimensions: apply only to fa/ea/bt2 index */ - if(!s->implicit_index && s->xincrs) { + if (!s->implicit_index && s->xincrs) { for (step = 0; step < s->xincrs; step++) { - dbgf(2, "Increase dataset dimension sizes by %u for datasets with fa/ea/bt2 index\n", step+1); + dbgf(2, "Increase dataset dimension sizes by %u for datasets with fa/ea/bt2 index\n", + step + 1); result = dsets_extent(INCR_EXT, s, ds); - if(s->use_np && !np_writer(result, step, s, np, config)) { + if (s->use_np && !np_writer(result, step, s, np, config)) { printf("np_writer() for increasing dimension sizes failed\n"); TEST_ERROR; } @@ -957,13 +961,14 @@ perform_dsets_operations(state_t *s, dsets_state_t *ds, H5F_vfd_swmr_config_t *c } /* Decrease dataset dimensions: apply only to fa/ea/bt2 index */ - if(!s->implicit_index && s->ydecrs) { + if (!s->implicit_index && s->ydecrs) { for (step = 0; step < s->ydecrs; step++) { - dbgf(2, "Decrease dataset dimension sizes by %u for datasets with fa/ea/bt2 index\n", step+1); + dbgf(2, "Decrease dataset dimension sizes by %u for datasets with fa/ea/bt2 index\n", + step + 1); result = dsets_extent(DECR_EXT, s, ds); - if(s->use_np && !np_writer(result, step, s, np, config)) { + if (s->use_np && !np_writer(result, step, s, np, config)) { printf("np_writer() for decreasing dimension sizes failed\n"); TEST_ERROR; } @@ -985,43 +990,42 @@ error: * TWRITES: perform `which` write that covers multiple chunks * LWRITEs: perform `which` write that covers multiple partial chunks */ -static bool +static bool write_dsets_chunks(unsigned action, const state_t *s, const dsets_state_t *ds, unsigned which) { - hsize_t start[2] = {0, 0}; + hsize_t start[2] = {0, 0}; hsize_t stride[2] = {0, 0}; - hsize_t count[2] = {0, 0}; - hsize_t block[2] = {0, 0}; + hsize_t count[2] = {0, 0}; + hsize_t block[2] = {0, 0}; HDassert(s->implicit_index || s->fa_index || s->ea_index || s->bt2_index); /* Set up selection info according to the specified action */ setup_selection(action, which, s, ds, start, stride, count, block); - if(s->implicit_index) { - if(!write_dset(action, ds->implicit_did, s->filetype, start, stride, count, block)) { + if (s->implicit_index) { + if (!write_dset(action, ds->implicit_did, s->filetype, start, stride, count, block)) { printf("H5Dwrite to chunked dataset: implicit index dataset failed\n"); TEST_ERROR; } } - if(s->fa_index) { - if(!write_dset(action, ds->fa_did, s->filetype, start, stride, count, block)) { + if (s->fa_index) { + if (!write_dset(action, ds->fa_did, s->filetype, start, stride, count, block)) { printf("H5Dwrite to chunked dataset: fa index dataset failed\n"); TEST_ERROR; } } - - if(s->ea_index) { - if(!write_dset(action, ds->ea_did, s->filetype, start, stride, count, block)) { + if (s->ea_index) { + if (!write_dset(action, ds->ea_did, s->filetype, start, stride, count, block)) { printf("H5Dwrite to chunked dataset: ea index dataset failed\n"); TEST_ERROR; } } - if(s->bt2_index) { - if(!write_dset(action, ds->bt2_did, s->filetype, start, stride, count, block)) { + if (s->bt2_index) { + if (!write_dset(action, ds->bt2_did, s->filetype, start, stride, count, block)) { printf("H5Dwrite to chunked dataset: bt2 index dataset failed\n"); TEST_ERROR; } @@ -1034,35 +1038,34 @@ error: } /* write_dsets_chunks() */ - /* * Set up selection info: start, stride, count, block */ static void -setup_selection(unsigned action, unsigned which, const state_t *s, const dsets_state_t *ds, - hsize_t *start, hsize_t *stride, hsize_t *count, hsize_t *block) +setup_selection(unsigned action, unsigned which, const state_t *s, const dsets_state_t *ds, hsize_t *start, + hsize_t *stride, hsize_t *count, hsize_t *block) { unsigned i, j, m, n; - bool end = false; - hsize_t chunk_dims[2]; + bool end = false; + hsize_t chunk_dims[2]; HDassert(action == GWRITES || action == PWRITES || action == TWRITES || action == LWRITES); - count[0] = 1; - count[1] = 1; + count[0] = 1; + count[1] = 1; stride[0] = 1; stride[1] = 1; /* Single or multiple chunk writes */ - if(action == GWRITES || action == PWRITES) { + if (action == GWRITES || action == PWRITES) { block[0] = chunk_dims[0] = ds->chunk_dims[0]; block[1] = chunk_dims[1] = ds->chunk_dims[1]; for (i = 0; i < ds->scaled_dims[0] && !end; i++) { - for(j = 0; j < ds->scaled_dims[1]; j++) { + for (j = 0; j < ds->scaled_dims[1]; j++) { /* Determine which chunk to write */ - if(which == (i * ds->scaled_dims[1] + j)) { + if (which == (i * ds->scaled_dims[1] + j)) { start[0] = i * ds->chunk_dims[0]; start[1] = j * ds->chunk_dims[1]; @@ -1072,22 +1075,23 @@ setup_selection(unsigned action, unsigned which, const state_t *s, const dsets_s end = true; break; } /* end if */ - } /* end for */ - } /* end for */ + } /* end for */ + } /* end for */ /* Check and set partial chunk write */ if (action == PWRITES) check_set_partial_block(action, chunk_dims, block, start); - /* Partial or multiple partial chunk writes */ - } else if (action == TWRITES || action == LWRITES) { + /* Partial or multiple partial chunk writes */ + } + else if (action == TWRITES || action == LWRITES) { /* Multiple chunk writes: the block covers 2 chunks in each dimension */ block[0] = chunk_dims[0] = ds->chunk_dims[0] * 2; block[1] = chunk_dims[1] = ds->chunk_dims[1] * 2; - for (i = 0, m = 0; i < ds->scaled_dims[0] && !end; i+=2, m++) { - for(j = 0, n = 0; j < ds->scaled_dims[1]; j+=2, n++) { - if(which == (m * ds->multi_scaled[1] + n)) { + for (i = 0, m = 0; i < ds->scaled_dims[0] && !end; i += 2, m++) { + for (j = 0, n = 0; j < ds->scaled_dims[1]; j += 2, n++) { + if (which == (m * ds->multi_scaled[1] + n)) { start[0] = i * ds->chunk_dims[0]; start[1] = j * ds->chunk_dims[1]; @@ -1098,11 +1102,11 @@ setup_selection(unsigned action, unsigned which, const state_t *s, const dsets_s break; } /* end if */ - } /* end for */ - } /* end for */ + } /* end for */ + } /* end for */ /* Check and set multiple partial chunk write */ - if (action == LWRITES) + if (action == LWRITES) check_set_partial_block(action, chunk_dims, block, start); } @@ -1112,47 +1116,45 @@ setup_selection(unsigned action, unsigned which, const state_t *s, const dsets_s * Check if "i" or "j" is an edge block. * If so, determine the block size. */ -static void -check_set_edge_block(const state_t *s, const dsets_state_t *ds, - unsigned i, unsigned j, hsize_t *block) +static void +check_set_edge_block(const state_t *s, const dsets_state_t *ds, unsigned i, unsigned j, hsize_t *block) { - if(i == (ds->scaled_dims[0] - 1)) { + if (i == (ds->scaled_dims[0] - 1)) { if ((ds->scaled_dims[0] * ds->chunk_dims[0]) >= s->rows) block[0] = s->rows - i * ds->chunk_dims[0]; } - if(j == (ds->scaled_dims[1] - 1)) { + if (j == (ds->scaled_dims[1] - 1)) { if ((ds->scaled_dims[1] * ds->chunk_dims[1]) >= s->cols) block[1] = s->cols - (j * ds->chunk_dims[1]); } } /* check_set_edge_block() */ -/* +/* * Determine the starting offset and the partial block size if the block is: * --a full chunk or a multiple full chunks * --the block size is at least 2 * Otherwise, nothing is done i.e. the whole block is applied - */ + */ static void check_set_partial_block(unsigned action, const hsize_t *chunk_dims, hsize_t *block, hsize_t *start) { HDassert(action == PWRITES || action == LWRITES); /* Apply only to full chunk or multi full chunks with block size > 2 */ - if(block[0] == chunk_dims[0] && - block[1] == chunk_dims[1]) { + if (block[0] == chunk_dims[0] && block[1] == chunk_dims[1]) { - if(block[0] > 2) { + if (block[0] > 2) { start[0] += 1; block[0] -= 2; - }; + }; - if(block[1] > 2) { + if (block[1] > 2) { start[1] += 1; block[1] -= 2; - }; + }; } } /* check_set_partial_block() */ @@ -1160,22 +1162,22 @@ check_set_partial_block(unsigned action, const hsize_t *chunk_dims, hsize_t *blo /* * Make the selection and then write to the dataset. */ -static bool -write_dset(unsigned action, hid_t did, hid_t tid, - hsize_t *start, hsize_t *stride, hsize_t *count, hsize_t *block) +static bool +write_dset(unsigned action, hid_t did, hid_t tid, hsize_t *start, hsize_t *stride, hsize_t *count, + hsize_t *block) { - hid_t sid = badhid; - hid_t mem_sid = badhid; - hsize_t mem_dims[2]; + hid_t sid = badhid; + hid_t mem_sid = badhid; + hsize_t mem_dims[2]; unsigned int *buf = NULL; - unsigned i; - - if((sid = H5Dget_space(did)) < 0) { + unsigned i; + + if ((sid = H5Dget_space(did)) < 0) { printf("H5Sget_space failed\n"); TEST_ERROR; } - if(H5Sselect_hyperslab(sid, H5S_SELECT_SET, start, stride, count, block) < 0) { + if (H5Sselect_hyperslab(sid, H5S_SELECT_SET, start, stride, count, block) < 0) { printf("H5Sselect_hyperslab failed\n"); TEST_ERROR; } @@ -1183,46 +1185,50 @@ write_dset(unsigned action, hid_t did, hid_t tid, mem_dims[0] = block[0]; mem_dims[1] = block[1]; - if((mem_sid = H5Screate_simple(2, mem_dims, NULL)) < 0) { + if ((mem_sid = H5Screate_simple(2, mem_dims, NULL)) < 0) { printf("H5Screate_simple failed\n"); TEST_ERROR; } /* Allocate the buffer for writing */ - if((buf = HDmalloc(block[0] * block[1] * sizeof(unsigned int))) == NULL) { + if ((buf = HDmalloc(block[0] * block[1] * sizeof(unsigned int))) == NULL) { printf("HDmalloc failed\n"); TEST_ERROR; } /* Fill the value to be written depending on full or partial writes */ for (i = 0; i < (block[0] * block[1]); i++) { - if(action == GWRITES || action == TWRITES) + if (action == GWRITES || action == TWRITES) buf[i] = FILL_FULL; else buf[i] = FILL_PARTIAL; - } + } - if(H5Dwrite(did, tid, mem_sid, sid, H5P_DEFAULT, buf) < 0) { + if (H5Dwrite(did, tid, mem_sid, sid, H5P_DEFAULT, buf) < 0) { printf("H5Dwrite failed\n"); TEST_ERROR; } - if(H5Sclose(sid) < 0) { + if (H5Sclose(sid) < 0) { printf("H5Sclose failed\n"); TEST_ERROR; } - if(buf) HDfree(buf); + if (buf) + HDfree(buf); return true; error: - H5E_BEGIN_TRY { + H5E_BEGIN_TRY + { H5Sclose(sid); H5Sclose(mem_sid); - } H5E_END_TRY; + } + H5E_END_TRY; - if(buf) HDfree(buf); + if (buf) + HDfree(buf); return false; @@ -1235,31 +1241,31 @@ static bool dsets_extent(unsigned action, const state_t *s, const dsets_state_t *ds) { unsigned nerrors = 0; - bool ret = true; + bool ret = true; HDassert(s->fa_index || s->ea_index || s->bt2_index); HDassert(action == INCR_EXT || action == DECR_EXT); - if(s->fa_index) { + if (s->fa_index) { dbgf(2, "Setting dataset extent for FA dataset\n"); - if(!dset_extent_real(action, ds->fa_did, ds->chunk_dims)) { + if (!dset_extent_real(action, ds->fa_did, ds->chunk_dims)) { ++nerrors; } } - if(s->ea_index) { + if (s->ea_index) { dbgf(2, "Setting dataset extent for EA dataset\n"); - if(!dset_extent_real(action, ds->ea_did, ds->chunk_dims)) + if (!dset_extent_real(action, ds->ea_did, ds->chunk_dims)) ++nerrors; } - if(s->bt2_index) { + if (s->bt2_index) { dbgf(2, "Setting dataset extent for BT2 dataset\n"); - if(!dset_extent_real(action, ds->bt2_did, ds->chunk_dims)) + if (!dset_extent_real(action, ds->bt2_did, ds->chunk_dims)) ++nerrors; } - if(nerrors) + if (nerrors) ret = false; return (ret); @@ -1277,12 +1283,12 @@ dset_extent_real(unsigned action, hid_t did, const hsize_t *chunk_dims) hsize_t new[2]; hid_t sid = badhid; - if((sid = H5Dget_space(did)) < 0) { + if ((sid = H5Dget_space(did)) < 0) { printf("H5Sget_space failed\n"); TEST_ERROR; } - if(H5Sget_simple_extent_dims(sid, dims, max_dims) < 0) { + if (H5Sget_simple_extent_dims(sid, dims, max_dims) < 0) { printf("H5Sget_simple_extent_dims failed\n"); TEST_ERROR; } @@ -1295,8 +1301,8 @@ dset_extent_real(unsigned action, hid_t did, const hsize_t *chunk_dims) /* Cannot increase to more than maximum dimension (both dims) for FA dataset */ /* Cannot increase to more than maximum dimension (dim 0) for EA dataset */ - if((max_dims[0] != H5S_UNLIMITED && new[0] > max_dims[0]) || - (max_dims[1] != H5S_UNLIMITED && new[1] > max_dims[1])) { + if ((max_dims[0] != H5S_UNLIMITED && new[0] > max_dims[0]) || + (max_dims[1] != H5S_UNLIMITED && new[1] > max_dims[1])) { printf("Cannot exceed maximum dimension for dataset\n"); TEST_ERROR; } @@ -1307,23 +1313,23 @@ dset_extent_real(unsigned action, hid_t did, const hsize_t *chunk_dims) new[0] = dims[0] - 1; new[1] = dims[1] - 1; - if(new[0] < chunk_dims[0] || new[1] < chunk_dims[1]) { + if (new[0] < chunk_dims[0] || new[1] < chunk_dims[1]) { printf("Cannot decrease to less than chunk dimension\n"); TEST_ERROR; } break; - default: + default: HDassert(0 && "Unknown action?!?"); } /* end switch */ - if(H5Dset_extent(did, new) < 0) { + if (H5Dset_extent(did, new) < 0) { printf("H5Dset_extent for dataset failed\n"); TEST_ERROR; } - if(H5Sclose(sid) < 0) { + if (H5Sclose(sid) < 0) { printf("H5Sclose failed\n"); TEST_ERROR; } @@ -1331,9 +1337,11 @@ dset_extent_real(unsigned action, hid_t did, const hsize_t *chunk_dims) return true; error: - H5E_BEGIN_TRY { + H5E_BEGIN_TRY + { H5Sclose(sid); - } H5E_END_TRY; + } + H5E_END_TRY; return false; } /* dset_extent_real() */ @@ -1344,19 +1352,19 @@ error: static bool write_dset_single(unsigned action, const state_t *s, const dsets_state_t *ds) { - hsize_t count[2] = {1, 1}; + hsize_t count[2] = {1, 1}; hsize_t stride[2] = {1, 1}; - hsize_t start[2] = {0, 0}; - hsize_t block[2] = {s->rows, s->cols}; + hsize_t start[2] = {0, 0}; + hsize_t block[2] = {s->rows, s->cols}; HDassert(action == GWRITES || action == PWRITES || action == TWRITES || action == LWRITES); HDassert(s->single_index); /* Check and set partial chunk write */ - if(action == PWRITES || action == LWRITES) + if (action == PWRITES || action == LWRITES) check_set_partial_block(action, block, block, start); - - if(!write_dset(action, ds->single_did, s->filetype, start, stride, count, block)) { + + if (!write_dset(action, ds->single_did, s->filetype, start, stride, count, block)) { printf("H5Dwrite to dataset with single index dataset failed\n"); TEST_ERROR; } @@ -1368,7 +1376,7 @@ error: } /* write_dset_single() */ -/* +/* * Reader */ @@ -1389,21 +1397,21 @@ error: * --DECR_EXT: verify the decrease to dataset dimensions sizes */ static bool -verify_dsets_operations(state_t *s, dsets_state_t *ds, H5F_vfd_swmr_config_t *config, np_state_t *np) +verify_dsets_operations(state_t *s, dsets_state_t *ds, H5F_vfd_swmr_config_t *config, np_state_t *np) { - unsigned step; - unsigned allowed_writes; - bool result; + unsigned step; + unsigned allowed_writes; + bool result; /* Verify dataset with single index */ - if(s->single_index) { + if (s->single_index) { /* Verify a single full chunk write to dataset with single index */ /* gwrites and twrites are the same */ /* Doesn't matter how many writes, only perform once */ - if(s->gwrites || s->twrites) { + if (s->gwrites || s->twrites) { dbgf(2, "Verify single full chunk write to dataset with single index; only verify 1 write\n"); - if(s->use_np && !np_confirm_verify_notify(np->fd_writer_to_reader, 0, s, np)) { + if (s->use_np && !np_confirm_verify_notify(np->fd_writer_to_reader, 0, s, np)) { printf("np_confirm_verify_notify() verify/notify not in sync failed\n"); TEST_ERROR; } @@ -1413,20 +1421,19 @@ verify_dsets_operations(state_t *s, dsets_state_t *ds, H5F_vfd_swmr_config_t *co result = verify_read_dset_single(GWRITES, s, ds); - if(s->use_np && !np_reader(result, 0, s, np)) { + if (s->use_np && !np_reader(result, 0, s, np)) { printf("np_reader() for verifying addition failed\n"); TEST_ERROR; } - } /* Verify a single partial chunk write to dataset with single index */ /* pwrites and lwrites are the same */ /* Doesn't matter how many writes, only perform once */ - if(s->pwrites || s->lwrites) { + if (s->pwrites || s->lwrites) { dbgf(2, "Verify single partial chunk write to dataset with single index; only verify 1 write\n"); - if(s->use_np && !np_confirm_verify_notify(np->fd_writer_to_reader, 0, s, np)) { + if (s->use_np && !np_confirm_verify_notify(np->fd_writer_to_reader, 0, s, np)) { printf("np_confirm_verify_notify() verify/notify not in sync failed\n"); TEST_ERROR; } @@ -1435,35 +1442,35 @@ verify_dsets_operations(state_t *s, dsets_state_t *ds, H5F_vfd_swmr_config_t *co result = verify_read_dset_single(PWRITES, s, ds); - if(s->use_np && !np_reader(result, 0, s, np)) { + if (s->use_np && !np_reader(result, 0, s, np)) { printf("np_reader() for verifying addition failed\n"); TEST_ERROR; } } - } /* Verify datasets with implicit/fa/ea/bt2 index */ - if(s->implicit_index || s->fa_index || s->ea_index || s->bt2_index) { + if (s->implicit_index || s->fa_index || s->ea_index || s->bt2_index) { /* Verify single full chunk writes */ - if(s->gwrites) { - allowed_writes = (unsigned)(ds->scaled_dims[0]*ds->scaled_dims[1]); + if (s->gwrites) { + allowed_writes = (unsigned)(ds->scaled_dims[0] * ds->scaled_dims[1]); dbgf(2, "The allowed -g writes is %u; you specify %u writes\n", allowed_writes, s->gwrites); for (step = 0; (step < s->gwrites && step < allowed_writes); step++) { - dbgf(2, "Verify single full chunk writes #%u to datasets with implicit/fa/ea/bt2 index\n", step); + dbgf(2, "Verify single full chunk writes #%u to datasets with implicit/fa/ea/bt2 index\n", + step); - if(s->use_np && !np_confirm_verify_notify(np->fd_writer_to_reader, step, s, np)) { + if (s->use_np && !np_confirm_verify_notify(np->fd_writer_to_reader, step, s, np)) { printf("np_confirm_verify_notify() verify/notify not in sync failed\n"); TEST_ERROR; } /* Wait for a few ticks for the update to happen */ decisleep(config->tick_len * s->update_interval); - + result = verify_dsets_chunks(GWRITES, s, ds, step); - if(s->use_np && !np_reader(result, step, s, np)) { + if (s->use_np && !np_reader(result, step, s, np)) { printf("np_reader() for verification failed\n"); TEST_ERROR; } @@ -1471,14 +1478,15 @@ verify_dsets_operations(state_t *s, dsets_state_t *ds, H5F_vfd_swmr_config_t *co } /* Verify single partial chunk writes */ - if(s->pwrites) { - allowed_writes = (unsigned)(ds->scaled_dims[0]*ds->scaled_dims[1]); + if (s->pwrites) { + allowed_writes = (unsigned)(ds->scaled_dims[0] * ds->scaled_dims[1]); dbgf(2, "The allowed -p writes is %u; you specify %u writes\n", allowed_writes, s->pwrites); for (step = 0; (step < s->pwrites && step < allowed_writes); step++) { - dbgf(2, "Verify single partial chunk writes #%u to datasets with implicit/fa/ea/bt2 index\n", step); + dbgf(2, "Verify single partial chunk writes #%u to datasets with implicit/fa/ea/bt2 index\n", + step); - if(s->use_np && !np_confirm_verify_notify(np->fd_writer_to_reader, step, s, np)) { + if (s->use_np && !np_confirm_verify_notify(np->fd_writer_to_reader, step, s, np)) { printf("np_confirm_verify_notify() verify/notify not in sync failed\n"); TEST_ERROR; } @@ -1487,7 +1495,7 @@ verify_dsets_operations(state_t *s, dsets_state_t *ds, H5F_vfd_swmr_config_t *co result = verify_dsets_chunks(PWRITES, s, ds, step); - if(s->use_np && !np_reader(result, step, s, np)) { + if (s->use_np && !np_reader(result, step, s, np)) { printf("np_reader() for verification failed\n"); TEST_ERROR; } @@ -1495,14 +1503,15 @@ verify_dsets_operations(state_t *s, dsets_state_t *ds, H5F_vfd_swmr_config_t *co } /* Verify multiple full chunk writes */ - if(s->twrites) { - allowed_writes = (unsigned)(ds->multi_scaled[0]*ds->multi_scaled[1]); + if (s->twrites) { + allowed_writes = (unsigned)(ds->multi_scaled[0] * ds->multi_scaled[1]); dbgf(2, "The allowed -t writes is %u; you specify %u writes\n", allowed_writes, s->twrites); for (step = 0; (step < s->twrites && step < allowed_writes); step++) { - dbgf(2, "Verify multiple full chunk writes #%u to datasets with implicit/fa/ea/bt2 index\n", step); + dbgf(2, "Verify multiple full chunk writes #%u to datasets with implicit/fa/ea/bt2 index\n", + step); - if(s->use_np && !np_confirm_verify_notify(np->fd_writer_to_reader, step, s, np)) { + if (s->use_np && !np_confirm_verify_notify(np->fd_writer_to_reader, step, s, np)) { printf("np_confirm_verify_notify() verify/notify not in sync failed\n"); TEST_ERROR; } @@ -1511,7 +1520,7 @@ verify_dsets_operations(state_t *s, dsets_state_t *ds, H5F_vfd_swmr_config_t *co result = verify_dsets_chunks(TWRITES, s, ds, step); - if(s->use_np && !np_reader(result, step, s, np)) { + if (s->use_np && !np_reader(result, step, s, np)) { printf("np_reader() for verification failed\n"); TEST_ERROR; } @@ -1519,14 +1528,16 @@ verify_dsets_operations(state_t *s, dsets_state_t *ds, H5F_vfd_swmr_config_t *co } /* Verify multiple partial chunk writes */ - if(s->lwrites) { - allowed_writes = (unsigned)(ds->multi_scaled[0]*ds->multi_scaled[1]); + if (s->lwrites) { + allowed_writes = (unsigned)(ds->multi_scaled[0] * ds->multi_scaled[1]); dbgf(2, "The allowed -l writes is %u; you specify %u writes\n", allowed_writes, s->lwrites); for (step = 0; (step < s->lwrites && step < allowed_writes); step++) { - dbgf(2, "Verify multiple partial chunk writes #%u to datasets with implicit/fa/ea/bt2 index\n", step); + dbgf(2, + "Verify multiple partial chunk writes #%u to datasets with implicit/fa/ea/bt2 index\n", + step); - if(s->use_np && !np_confirm_verify_notify(np->fd_writer_to_reader, step, s, np)) { + if (s->use_np && !np_confirm_verify_notify(np->fd_writer_to_reader, step, s, np)) { printf("np_confirm_verify_notify() verify/notify not in sync failed\n"); TEST_ERROR; } @@ -1535,7 +1546,7 @@ verify_dsets_operations(state_t *s, dsets_state_t *ds, H5F_vfd_swmr_config_t *co result = verify_dsets_chunks(LWRITES, s, ds, step); - if(s->use_np && !np_reader(result, step, s, np)) { + if (s->use_np && !np_reader(result, step, s, np)) { printf("np_reader() for verification failed\n"); TEST_ERROR; } @@ -1543,20 +1554,21 @@ verify_dsets_operations(state_t *s, dsets_state_t *ds, H5F_vfd_swmr_config_t *co } /* Verify increase to dataset dimensions: apply only for fa, ea and bt2 index */ - if(!s->implicit_index && s->xincrs) { + if (!s->implicit_index && s->xincrs) { for (step = 0; step < s->xincrs; step++) { - dbgf(2, "Verify increase to dimension sizes by %u for datasets with fa/ea/bt2 index\n", step+1); + dbgf(2, "Verify increase to dimension sizes by %u for datasets with fa/ea/bt2 index\n", + step + 1); - if(s->use_np && !np_confirm_verify_notify(np->fd_writer_to_reader, step, s, np)) { + if (s->use_np && !np_confirm_verify_notify(np->fd_writer_to_reader, step, s, np)) { printf("np_confirm_verify_notify() verify/notify not in sync failed\n"); TEST_ERROR; } /* Wait for a few ticks for the update to happen */ decisleep(config->tick_len * s->update_interval); - result = verify_dsets_extent(INCR_EXT, s, ds, step+1); - - if(s->use_np && !np_reader(result, step, s, np)) { + result = verify_dsets_extent(INCR_EXT, s, ds, step + 1); + + if (s->use_np && !np_reader(result, step, s, np)) { printf("np_reader() for failed\n"); TEST_ERROR; } @@ -1564,20 +1576,21 @@ verify_dsets_operations(state_t *s, dsets_state_t *ds, H5F_vfd_swmr_config_t *co } /* Verify decrease to dataset dimensions: apply only for fa, ea and bt2 index */ - if(!s->implicit_index && s->ydecrs) { + if (!s->implicit_index && s->ydecrs) { for (step = 0; step < s->ydecrs; step++) { - dbgf(2, "Verify decrease to dimension sizes by %u for datasets with fa/ea/bt2 index\n", step+1); + dbgf(2, "Verify decrease to dimension sizes by %u for datasets with fa/ea/bt2 index\n", + step + 1); - if(s->use_np && !np_confirm_verify_notify(np->fd_writer_to_reader, step, s, np)) { + if (s->use_np && !np_confirm_verify_notify(np->fd_writer_to_reader, step, s, np)) { printf("np_confirm_verify_notify() verify/notify not in sync failed\n"); TEST_ERROR; } /* Wait for a few ticks for the update to happen */ decisleep(config->tick_len * s->update_interval); - result = verify_dsets_extent(DECR_EXT, s, ds, step+1); + result = verify_dsets_extent(DECR_EXT, s, ds, step + 1); - if(s->use_np && !np_reader(result, step, s, np)) { + if (s->use_np && !np_reader(result, step, s, np)) { printf("np_reader() for verification failed\n"); TEST_ERROR; } @@ -1592,62 +1605,64 @@ error: return false; } /* verify_dsets_operations() */ - -/* + +/* * Verify the data read from each of the specified datasets: * GWRITES: verify `which` write that covers a single chunk * PWRITES: verify `which` write that covers a partial chunk * TWRITES: verify `which` write that covers multiple chunks * LWRITEs: verify `which` write that covers multiple partial chunks */ -static bool +static bool verify_dsets_chunks(unsigned action, const state_t *s, const dsets_state_t *ds, unsigned which) { - hsize_t start[2] = {0, 0}; - hsize_t stride[2] = {0, 0}; - hsize_t count[2] = {0, 0}; - hsize_t block[2] = {0, 0}; - unsigned int *vbuf = NULL; + hsize_t start[2] = {0, 0}; + hsize_t stride[2] = {0, 0}; + hsize_t count[2] = {0, 0}; + hsize_t block[2] = {0, 0}; + unsigned int *vbuf = NULL; HDassert(s->implicit_index || s->fa_index || s->ea_index || s->bt2_index); /* Set up selection according to the specified action */ setup_selection(action, which, s, ds, start, stride, count, block); - if(s->implicit_index) { - if(!verify_read_dset(action, ds->implicit_did, s->filetype, start, stride, count, block)) { + if (s->implicit_index) { + if (!verify_read_dset(action, ds->implicit_did, s->filetype, start, stride, count, block)) { printf("verify_read_dset() to dataset with implicit index failed\n"); TEST_ERROR; } } - if(s->fa_index) { - if(!verify_read_dset(action, ds->fa_did, s->filetype, start, stride, count, block)) { + if (s->fa_index) { + if (!verify_read_dset(action, ds->fa_did, s->filetype, start, stride, count, block)) { printf("verify_read_dset() to dataset with fixed array index failed\n"); TEST_ERROR; } } - if(s->ea_index) { - if(!verify_read_dset(action, ds->ea_did, s->filetype, start, stride, count, block)) { + if (s->ea_index) { + if (!verify_read_dset(action, ds->ea_did, s->filetype, start, stride, count, block)) { printf("verify_read_dset() to dataset with extensible array index failed\n"); TEST_ERROR; } } - if(s->bt2_index) { - if(!verify_read_dset(action, ds->bt2_did, s->filetype, start, stride, count, block)) { + if (s->bt2_index) { + if (!verify_read_dset(action, ds->bt2_did, s->filetype, start, stride, count, block)) { printf("verify_read_dset() to dataset with bt2 index failed\n"); TEST_ERROR; } } - if(vbuf) HDfree(vbuf); + if (vbuf) + HDfree(vbuf); return true; error: - if(vbuf) HDfree(vbuf); + if (vbuf) + HDfree(vbuf); return false; @@ -1656,60 +1671,61 @@ error: /* * Verify the data read from the dataset is as expected. */ -static bool -verify_read_dset(unsigned action, hid_t did, hid_t tid, - hsize_t *start, hsize_t *stride, hsize_t *count, hsize_t *block) +static bool +verify_read_dset(unsigned action, hid_t did, hid_t tid, hsize_t *start, hsize_t *stride, hsize_t *count, + hsize_t *block) { - hid_t mem_sid = badhid; - hid_t sid = badhid; - hsize_t mem_dims[2]; + hid_t mem_sid = badhid; + hid_t sid = badhid; + hsize_t mem_dims[2]; unsigned int *rbuf = NULL; - unsigned i; - + unsigned i; + /* Refresh the dataset */ - if(H5Drefresh(did) < 0) { + if (H5Drefresh(did) < 0) { printf("H5Drefresh dataset failed\n"); TEST_ERROR; } - if((sid = H5Dget_space(did)) < 0) { + if ((sid = H5Dget_space(did)) < 0) { printf("H5Dget_space dataset failed\n"); TEST_ERROR; } /* Make the selection the file dataspace */ - if(H5Sselect_hyperslab(sid, H5S_SELECT_SET, start, stride, count, block) < 0) { + if (H5Sselect_hyperslab(sid, H5S_SELECT_SET, start, stride, count, block) < 0) { printf("H5Sselect to dataset failed\n"); TEST_ERROR; } mem_dims[0] = block[0]; mem_dims[1] = block[1]; - if((mem_sid = H5Screate_simple(2, mem_dims, NULL)) < 0) { + if ((mem_sid = H5Screate_simple(2, mem_dims, NULL)) < 0) { printf("H5Screate_simple failed\n"); TEST_ERROR; } /* Allocate the buffer for reading */ - if((rbuf = HDmalloc(block[0] * block[1] * sizeof(unsigned int))) == NULL) { + if ((rbuf = HDmalloc(block[0] * block[1] * sizeof(unsigned int))) == NULL) { printf("HDmalloc failed\n"); TEST_ERROR; } /* Read the data from the dataset into `rbuf` */ - if(H5Dread(did, tid, mem_sid, sid, H5P_DEFAULT, rbuf) < 0) { + if (H5Dread(did, tid, mem_sid, sid, H5P_DEFAULT, rbuf) < 0) { printf("H5Dread from dataset failed\n"); TEST_ERROR; } - + /* Verify the data read in `rbuf` is as the fill value expected */ for (i = 0; i < block[0] * block[1]; i++) { - if(action == GWRITES || action == TWRITES) { - if(rbuf[i] != FILL_FULL) { + if (action == GWRITES || action == TWRITES) { + if (rbuf[i] != FILL_FULL) { printf("Invalid value for dataset for GWRITES/TWRITES\n"); TEST_ERROR; } - } else { + } + else { HDassert(action == PWRITES || action == LWRITES); if (rbuf[i] != FILL_PARTIAL) { printf("Invalid value for dataset for GWRITES/TWRITES\n"); @@ -1718,22 +1734,26 @@ verify_read_dset(unsigned action, hid_t did, hid_t tid, } } - if(H5Sclose(sid) < 0) { + if (H5Sclose(sid) < 0) { printf("H5Sclose failed\n"); TEST_ERROR; } - if(rbuf) HDfree(rbuf); + if (rbuf) + HDfree(rbuf); return true; error: - H5E_BEGIN_TRY { + H5E_BEGIN_TRY + { H5Sclose(sid); H5Sclose(mem_sid); - } H5E_END_TRY; + } + H5E_END_TRY; - if(rbuf) HDfree(rbuf); + if (rbuf) + HDfree(rbuf); return false; @@ -1742,7 +1762,7 @@ error: /* * Verify the increase or decrease of dimenion sizes for the specified datasets. */ -static bool +static bool verify_dsets_extent(unsigned action, const state_t *s, const dsets_state_t *ds, unsigned which) { unsigned rows = s->rows; @@ -1752,30 +1772,30 @@ verify_dsets_extent(unsigned action, const state_t *s, const dsets_state_t *ds, HDassert(s->fa_index || s->ea_index || s->bt2_index); /* s->xincrs can be 0 or the increased extent of the dataset */ - if(action == DECR_EXT) { + if (action == DECR_EXT) { rows = s->rows + s->xincrs; cols = s->cols + s->xincrs; } - if(s->fa_index) { + if (s->fa_index) { dbgf(2, "Verify dataset extent for FA dataset\n"); - if(!verify_dset_extent_real(action, ds->fa_did, rows, cols, which)) { + if (!verify_dset_extent_real(action, ds->fa_did, rows, cols, which)) { printf("verify_read_dset() to dataset with fixed array index failed\n"); TEST_ERROR; } } - if(s->ea_index) { + if (s->ea_index) { dbgf(2, "Verify dataset extent for EA dataset\n"); - if(!verify_dset_extent_real(action, ds->fa_did, rows, cols, which)) { + if (!verify_dset_extent_real(action, ds->fa_did, rows, cols, which)) { printf("verify_read_dset() to dataset with fixed array index failed\n"); TEST_ERROR; } } - if(s->bt2_index) { + if (s->bt2_index) { dbgf(2, "Verify dataset extent for BT2 dataset\n"); - if(!verify_dset_extent_real(action, ds->bt2_did, rows, cols, which)) { + if (!verify_dset_extent_real(action, ds->bt2_did, rows, cols, which)) { printf("verify_read_dset() to dataset with fixed array index failed\n"); TEST_ERROR; } @@ -1788,7 +1808,6 @@ error: } /* verify_dsets_extent() */ - /* * Do the real work of verifying the increase/decrease for the dataset dimension sizes */ @@ -1796,20 +1815,20 @@ static bool verify_dset_extent_real(unsigned action, hid_t did, unsigned rows, unsigned cols, unsigned which) { hsize_t dims[2]; - hid_t sid = badhid; + hid_t sid = badhid; /* Refresh the dataset */ - if(H5Drefresh(did) < 0) { + if (H5Drefresh(did) < 0) { printf("H5Drefresh dataset failed\n"); TEST_ERROR; } - if((sid = H5Dget_space(did)) < 0) { + if ((sid = H5Dget_space(did)) < 0) { printf("H5Dget_space dataset failed\n"); TEST_ERROR; } - if(H5Sget_simple_extent_dims(sid, dims, NULL) < 0) { + if (H5Sget_simple_extent_dims(sid, dims, NULL) < 0) { printf("H5Sget_simple_extent_dims() failed\n"); TEST_ERROR; } @@ -1817,19 +1836,17 @@ verify_dset_extent_real(unsigned action, hid_t did, unsigned rows, unsigned cols switch (action) { case INCR_EXT: - if(dims[0] != (rows + which) || - dims[1] != (cols + which)) + if (dims[0] != (rows + which) || dims[1] != (cols + which)) TEST_ERROR break; case DECR_EXT: - if(dims[0] != (rows - which) || - dims[1] != (cols - which)) + if (dims[0] != (rows - which) || dims[1] != (cols - which)) TEST_ERROR break; - default: + default: HDassert(0 && "Unknown action?!?"); } /* end switch */ @@ -1837,9 +1854,11 @@ verify_dset_extent_real(unsigned action, hid_t did, unsigned rows, unsigned cols return true; error: - H5E_BEGIN_TRY { + H5E_BEGIN_TRY + { H5Sclose(sid); - } H5E_END_TRY; + } + H5E_END_TRY; return false; } /* verify_dset_extent_real() */ @@ -1850,20 +1869,20 @@ error: static bool verify_read_dset_single(unsigned action, const state_t *s, const dsets_state_t *ds) { - hsize_t block[2] = {s->rows, s->cols}; - hsize_t count[2] = {1, 1}; + hsize_t block[2] = {s->rows, s->cols}; + hsize_t count[2] = {1, 1}; hsize_t stride[2] = {1, 1}; - hsize_t start[2] = {0, 0}; + hsize_t start[2] = {0, 0}; HDassert(action == GWRITES || action == PWRITES); HDassert(s->single_index); - if(action == PWRITES) + if (action == PWRITES) check_set_partial_block(action, block, block, start); - if(!verify_read_dset(action, ds->single_did, s->filetype, start, stride, count, block)) { - printf("verify_read_dset() to dataset with single index failed\n"); - TEST_ERROR; + if (!verify_read_dset(action, ds->single_did, s->filetype, start, stride, count, block)) { + printf("verify_read_dset() to dataset with single index failed\n"); + TEST_ERROR; } return true; @@ -1885,7 +1904,7 @@ np_init(np_state_t *np, bool writer) { *np = NP_INITIALIZER; - /* + /* * Use two named pipes(FIFO) to coordinate the writer and reader for * two-way communication so that the two sides can move forward together. * One is for the writer to write to the reader. @@ -1894,13 +1913,13 @@ np_init(np_state_t *np, bool writer) if (writer) { /* If the named pipes are present at the start of the test, remove them */ if (HDaccess(np->fifo_writer_to_reader, F_OK) == 0) - if(HDremove(np->fifo_writer_to_reader) != 0) { + if (HDremove(np->fifo_writer_to_reader) != 0) { printf("HDremove fifo_writer_to_reader failed\n"); TEST_ERROR; } if (HDaccess(np->fifo_reader_to_writer, F_OK) == 0) - if(HDremove(np->fifo_reader_to_writer) != 0) { + if (HDremove(np->fifo_reader_to_writer) != 0) { printf("HDremove fifo_reader_to_writer failed\n"); TEST_ERROR; } @@ -1953,13 +1972,13 @@ np_close(np_state_t *np, bool writer) } /* Reader finishes last and deletes the named pipes */ - if(!writer) { - if(HDremove(np->fifo_writer_to_reader) != 0) { + if (!writer) { + if (HDremove(np->fifo_writer_to_reader) != 0) { printf("HDremove fifo_writer_to_reader failed\n"); TEST_ERROR; } - if(HDremove(np->fifo_reader_to_writer) != 0) { + if (HDremove(np->fifo_reader_to_writer) != 0) { printf("HDremove fifo_reader_to_writer failed\n"); TEST_ERROR; } @@ -1974,14 +1993,15 @@ error: * Writer synchronization depending on the result from the action performed. */ static bool -np_writer(bool result, unsigned step, const state_t *s, np_state_t *np, H5F_vfd_swmr_config_t *config) +np_writer(bool result, unsigned step, const state_t *s, np_state_t *np, H5F_vfd_swmr_config_t *config) { unsigned int i; /* The action fails */ - if(!result) { + if (!result) { printf("action failed\n"); - H5_FAILED(); AT(); + H5_FAILED(); + AT(); /* At communication interval, notify the reader about the failure and quit */ if (step % s->csteps == 0) { @@ -1989,8 +2009,9 @@ np_writer(bool result, unsigned step, const state_t *s, np_state_t *np, H5F_vfd HDwrite(np->fd_writer_to_reader, &np->notify, sizeof(int)); goto error; } - /* The action succeeds */ - } else { + /* The action succeeds */ + } + else { /* At communication interval, notify the reader and wait for its response */ if (step % s->csteps == 0) { /* Bump up the value of notify to tell the reader to start reading */ @@ -2002,15 +2023,17 @@ np_writer(bool result, unsigned step, const state_t *s, np_state_t *np, H5F_vfd /* During the wait, writer makes repeated HDF5 API calls * to trigger EOT at approximately the correct time */ - for(i = 0; i < config->max_lag + 1; i++) { + for (i = 0; i < config->max_lag + 1; i++) { decisleep(config->tick_len); - H5E_BEGIN_TRY { + H5E_BEGIN_TRY + { H5Aexists(s->file, "nonexistent"); - } H5E_END_TRY; + } + H5E_END_TRY; } /* Handshake between writer and reader */ - if(!np_confirm_verify_notify(np->fd_reader_to_writer, step, s, np)) { + if (!np_confirm_verify_notify(np->fd_reader_to_writer, step, s, np)) { printf("np_confirm_verify_notify() verify/notify not in sync failed\n"); TEST_ERROR; } @@ -2031,9 +2054,10 @@ static bool np_reader(bool result, unsigned step, const state_t *s, np_state_t *np) { /* The verification fails */ - if(!result) { + if (!result) { printf("verify action failed\n"); - H5_FAILED(); AT(); + H5_FAILED(); + AT(); /* At communication interval, tell the writer about the failure and exit */ if (step % s->csteps == 0) { @@ -2041,8 +2065,9 @@ np_reader(bool result, unsigned step, const state_t *s, np_state_t *np) HDwrite(np->fd_reader_to_writer, &np->notify, sizeof(int)); goto error; } - /* The verification succeeds */ - } else { + /* The verification succeeds */ + } + else { if (step % s->csteps == 0) { /* Send back the same notify value for acknowledgement: * --inform the writer to move to the next step */ @@ -2096,26 +2121,24 @@ error: int main(int argc, char **argv) { - hid_t fapl, fcpl; - bool writer; - state_t s; - const char *personality; + hid_t fapl, fcpl; + bool writer; + state_t s; + const char * personality; H5F_vfd_swmr_config_t config; - np_state_t np; - dsets_state_t ds; + np_state_t np; + dsets_state_t ds; - if(!state_init(&s, argc, argv)) { + if (!state_init(&s, argc, argv)) { printf("state_init() failed\n"); TEST_ERROR; } personality = strstr(s.progname, "vfd_swmr_dsetchks_"); - if (personality != NULL && - strcmp(personality, "vfd_swmr_dsetchks_writer") == 0) + if (personality != NULL && strcmp(personality, "vfd_swmr_dsetchks_writer") == 0) writer = true; - else if (personality != NULL && - strcmp(personality, "vfd_swmr_dsetchks_reader") == 0) + else if (personality != NULL && strcmp(personality, "vfd_swmr_dsetchks_reader") == 0) writer = false; else { printf("unknown personality, expected vfd_swmr_dsetchks_{reader,writer}\n"); @@ -2126,7 +2149,7 @@ main(int argc, char **argv) init_vfd_swmr_config(&config, 4, 7, writer, FALSE, 128, "./dsetchks-shadow"); /* use_latest_format, use_vfd_swmr, only_meta_page, config */ - if((fapl = vfd_swmr_create_fapl(true, s.use_vfd_swmr, true, &config)) < 0) { + if ((fapl = vfd_swmr_create_fapl(true, s.use_vfd_swmr, true, &config)) < 0) { printf("vfd_swmr_create_fapl() failed\n"); TEST_ERROR; } @@ -2136,56 +2159,55 @@ main(int argc, char **argv) TEST_ERROR; } - if(H5Pset_file_space_strategy(fcpl, H5F_FSPACE_STRATEGY_PAGE, false, 1) < 0) { + if (H5Pset_file_space_strategy(fcpl, H5F_FSPACE_STRATEGY_PAGE, false, 1) < 0) { printf("H5Pset_file_space_strategy failed\n"); TEST_ERROR; } if (writer) { - if((s.file = H5Fcreate(s.filename, H5F_ACC_TRUNC, fcpl, fapl)) < 0) { + if ((s.file = H5Fcreate(s.filename, H5F_ACC_TRUNC, fcpl, fapl)) < 0) { printf("H5Fcreate failed\n"); TEST_ERROR; } - if(!create_dsets(&s, &ds)) { + if (!create_dsets(&s, &ds)) { printf("create_dsets() failed\n"); TEST_ERROR; } - - } else { - if ((s.file = H5Fopen(s.filename, H5F_ACC_RDONLY, fapl)) < 0) { + } + else { + if ((s.file = H5Fopen(s.filename, H5F_ACC_RDONLY, fapl)) < 0) { printf("H5Fopen failed\n"); TEST_ERROR; } - if(!open_dsets(&s, &ds)) { + if (!open_dsets(&s, &ds)) { printf("open_dsets() failed\n"); TEST_ERROR; } } /* Initiailze named pipes */ - if(s.use_np && !np_init(&np, writer)) { + if (s.use_np && !np_init(&np, writer)) { printf("np_init() failed\n"); TEST_ERROR; } if (writer) { - if(!perform_dsets_operations(&s, &ds, &config, &np)) { + if (!perform_dsets_operations(&s, &ds, &config, &np)) { printf("perform_dsets_operations() failed\n"); TEST_ERROR; } + } + else { - } else { - - if(!verify_dsets_operations(&s, &ds, &config, &np)) { + if (!verify_dsets_operations(&s, &ds, &config, &np)) { printf("perform_dsets_operations() failed\n"); TEST_ERROR; } - } - if(!close_dsets(&ds)) { + if (!close_dsets(&ds)) { printf("close_dsets() failed\n"); TEST_ERROR; } @@ -2205,7 +2227,7 @@ main(int argc, char **argv) TEST_ERROR; } - if(s.use_np && !np_close(&np, writer)) { + if (s.use_np && !np_close(&np, writer)) { printf("np_close() failed\n"); TEST_ERROR; } @@ -2213,11 +2235,13 @@ main(int argc, char **argv) return EXIT_SUCCESS; error: - H5E_BEGIN_TRY { + H5E_BEGIN_TRY + { H5Pclose(fapl); H5Pclose(fcpl); H5Fclose(s.file); - } H5E_END_TRY; + } + H5E_END_TRY; if (s.use_np && np.fd_writer_to_reader >= 0) HDclose(np.fd_writer_to_reader); @@ -2225,7 +2249,7 @@ error: if (s.use_np && np.fd_reader_to_writer >= 0) HDclose(np.fd_reader_to_writer); - if(s.use_np && !writer) { + if (s.use_np && !writer) { HDremove(np.fifo_writer_to_reader); HDremove(np.fifo_reader_to_writer); } @@ -2243,4 +2267,3 @@ main(void) } /* end main() */ #endif /* H5_HAVE_WIN32_API */ - -- cgit v0.12 From a396a18d40c3b400a0c69e178fd7c2745b831c74 Mon Sep 17 00:00:00 2001 From: vchoi Date: Tue, 29 Jun 2021 13:15:28 -0500 Subject: Modifications based on PR feedback. --- test/vfd_swmr_dsetchks_writer.c | 31 ++++++++++++++++++------------- 1 file changed, 18 insertions(+), 13 deletions(-) diff --git a/test/vfd_swmr_dsetchks_writer.c b/test/vfd_swmr_dsetchks_writer.c index 47802c4..25066d8 100644 --- a/test/vfd_swmr_dsetchks_writer.c +++ b/test/vfd_swmr_dsetchks_writer.c @@ -20,7 +20,7 @@ * 4. extensible array (1 unlimited max_dims, default incremental allocation) * 5. btree2 (2 unlimited max_dims, default incremental allocation) * - * --with compression--H5Pset_shuffle(dcpl) + * --with compression--H5Pset_deflate(dcpl) * --with fill values--H5Pset_fill_value(dcpl, H5T_NATIVE_INT, &fillval); * * Types of chunk operations: @@ -223,7 +223,7 @@ usage(const char *progname) "-q: silence printouts, few messages\n" "-b: write data in big-endian byte order\n" " (default is H5T_NATIVE_UINT32)\n\n" - "-o: enable compression (shuffle filter) for the datasets\n"); + "-o: enable compression (deflate filter) for the datasets\n"); fprintf( stderr, @@ -447,7 +447,7 @@ error: * --2-dimensional chunked datasets * --chunk dimension is rows/2 by cols/2 * --fill value is FILL_INIT - * --shuffle filter if specified + * --deflate filter if specified * --dataset with single index if specified * --dataset with implicit index if specified * --dataset with fixeda array index if specified @@ -490,8 +490,8 @@ create_dsets(const state_t *s, dsets_state_t *ds) /* Set to use filter as specified */ if (s->use_filter) { - if (H5Pset_shuffle(dcpl) < 0) { - printf("H5Pset_shuffle failed\n"); + if (H5Pset_deflate(dcpl, 5) < 0) { + printf("H5Pset_deflate failed\n"); goto error; } } @@ -1655,14 +1655,9 @@ verify_dsets_chunks(unsigned action, const state_t *s, const dsets_state_t *ds, } } - if (vbuf) - HDfree(vbuf); - return true; error: - if (vbuf) - HDfree(vbuf); return false; @@ -1739,6 +1734,11 @@ verify_read_dset(unsigned action, hid_t did, hid_t tid, hsize_t *start, hsize_t TEST_ERROR; } + if (H5Sclose(mem_sid) < 0) { + printf("H5Sclose failed\n"); + TEST_ERROR; + } + if (rbuf) HDfree(rbuf); @@ -1851,6 +1851,11 @@ verify_dset_extent_real(unsigned action, hid_t did, unsigned rows, unsigned cols } /* end switch */ + if (H5Sclose(sid) < 0) { + printf("H5Sclose failed\n"); + TEST_ERROR; + } + return true; error: @@ -2134,11 +2139,11 @@ main(int argc, char **argv) TEST_ERROR; } - personality = strstr(s.progname, "vfd_swmr_dsetchks_"); + personality = HDstrstr(s.progname, "vfd_swmr_dsetchks_"); - if (personality != NULL && strcmp(personality, "vfd_swmr_dsetchks_writer") == 0) + if (personality != NULL && HDstrcmp(personality, "vfd_swmr_dsetchks_writer") == 0) writer = true; - else if (personality != NULL && strcmp(personality, "vfd_swmr_dsetchks_reader") == 0) + else if (personality != NULL && HDstrcmp(personality, "vfd_swmr_dsetchks_reader") == 0) writer = false; else { printf("unknown personality, expected vfd_swmr_dsetchks_{reader,writer}\n"); -- cgit v0.12 From 823b8a829839a15b13787ad0afd9b7c37450dcb1 Mon Sep 17 00:00:00 2001 From: vchoi Date: Tue, 29 Jun 2021 13:24:21 -0500 Subject: Remove the duplicate entry. --- MANIFEST | 1 - 1 file changed, 1 deletion(-) diff --git a/MANIFEST b/MANIFEST index ea5645d..a183dc5 100644 --- a/MANIFEST +++ b/MANIFEST @@ -1418,7 +1418,6 @@ ./test/vfd_swmr_check_compat.c ./test/vfd_swmr_common.c ./test/vfd_swmr_common.h -./test/vfd_swmr_dsetops_writer.c ./test/vfd_swmr_generator.c ./test/vfd_swmr_group_writer.c ./test/vfd_swmr_reader.c -- cgit v0.12