/*------------------------------------------------------------------------- * Function: main * * Purpose: HDF5 user block unjammer * * Return: Success: 0 * Failure: 1 * * Programmer: * * Modifications: * *------------------------------------------------------------------------- */ int main(int argc, const char *argv[]) { void *edata; H5E_auto2_t func; hid_t ifile = -1; hid_t plist = -1; off_t fsize; hsize_t usize; htri_t testval; herr_t status; int res; h5_stat_t sbuf; h5tools_setprogname(PROGRAMNAME); h5tools_setstatus(EXIT_SUCCESS); /* Disable error reporting */ H5Eget_auto2(H5E_DEFAULT, &func, &edata); H5Eset_auto2(H5E_DEFAULT, NULL, NULL); /* Initialize h5tools lib */ h5tools_init(); if(EXIT_FAILURE == parse_command_line(argc, argv)) goto done; if (input_file == NULL) { /* no user block */ error_msg("missing arguemnt for HDF5 file input.\n"); help_ref_msg(stderr); h5tools_setstatus(EXIT_FAILURE); goto done; } testval = H5Fis_hdf5(input_file); if (testval <= 0) { error_msg("Input HDF5 file \"%s\" is not HDF\n", input_file); help_ref_msg (stderr); h5tools_setstatus(EXIT_FAILURE); goto done; } ifile = H5Fopen(input_file, H5F_ACC_RDONLY , H5P_DEFAULT); if (ifile < 0) { error_msg("Can't open input HDF5 file \"%s\"\n", input_file); h5tools_setstatus(EXIT_FAILURE); goto done; } plist = H5Fget_create_plist(ifile); if (plist < 0) { error_msg("Can't get file creation plist for file \"%s\"\n", input_file); h5tools_setstatus(EXIT_FAILURE); goto done; } status = H5Pget_userblock(plist, & usize); if (status < 0) { error_msg("Can't get user block for file \"%s\"\n", input_file); h5tools_setstatus(EXIT_FAILURE); goto done; } status = H5Pclose(plist); HDassert(status >= 0); status = H5Fclose(ifile); HDassert(status >= 0); if (usize == 0) { /* no user block to remove: message? */ error_msg("\"%s\" has no user block: no change to file\n", input_file); h5tools_setstatus(EXIT_SUCCESS); goto done; } res = HDfstat(HDfileno(rawinstream), &sbuf); if(res < 0) { error_msg("Can't stat file \"%s\"\n", input_file); h5tools_setstatus(EXIT_FAILURE); goto done; } fsize = sbuf.st_size; if (do_delete && (ub_file != NULL)) { error_msg("??\"%s\"\n", ub_file); h5tools_setstatus(EXIT_FAILURE); goto done; } if (output_file == NULL) { error_msg("unable to open output HDF5 file \"%s\"\n", input_file); h5tools_setstatus(EXIT_FAILURE); goto done; } /* copy from 0 to 'usize - 1' into ufid */ if (!do_delete) { if(copy_to_file(rawinstream, rawoutstream, 0, (ssize_t) usize) < 0) { error_msg("unable to copy user block to output file \"%s\"\n", ub_file); h5tools_setstatus(EXIT_FAILURE); goto done; } } /* copy from usize to end of file into h5fid, * starting at end of user block if present */ if(copy_to_file(rawinstream, rawdatastream, (ssize_t) usize, (ssize_t)(fsize - (ssize_t)usize)) < 0) { error_msg("unable to copy hdf5 data to output file \"%s\"\n", output_file); h5tools_setstatus(EXIT_FAILURE); goto done; } done: if(input_file) HDfree(input_file); if(output_file) HDfree(output_file); if(ub_file) { HDfree(ub_file); } h5tools_close(); return h5tools_getstatus(); }
/*------------------------------------------------------------------------- * Function: copy_some_to_file * * Purpose: Copy part of the input file to output. * infid: fd of file to read * outfid: fd of file to write * startin: offset of where to read from infid * startout: offset of where to write to outfid * limit: bytes to read/write * * If limit is < 0, the entire input file is copied. * * Note: this routine can be used to copy within * the same file, i.e., infid and outfid can be the * same file. * * Return: Success: last byte written in the output. * Failure: Exits program with EXIT_FAILURE value. * *------------------------------------------------------------------------- */ hsize_t copy_some_to_file(int infid, int outfid, hsize_t startin, hsize_t startout, ssize_t limit) { char buf[1024]; h5_stat_t sbuf; int res; ssize_t tot = 0; ssize_t howmuch = 0; ssize_t nchars = -1; ssize_t to; ssize_t from; ssize_t toend; ssize_t fromend; if(startin > startout) { /* this case is prohibited */ error_msg("copy_some_to_file: panic: startin > startout?\n"); exit (EXIT_FAILURE); } /* end if */ if(limit < 0) { res = HDfstat(infid, &sbuf); if(res < 0) { error_msg("Can't stat file \n"); HDexit(EXIT_FAILURE); } /* end if */ howmuch = (ssize_t)sbuf.st_size; } else { howmuch = limit; } /* end if */ if(0 == howmuch) return 0; toend = (ssize_t) startout + howmuch; fromend = (ssize_t) startin + howmuch; if (howmuch > 512) { to = toend - 512; from = fromend - 512; } else { to = toend - howmuch; from = fromend - howmuch; } /* end if */ while (howmuch > 0) { HDlseek(outfid, (off_t) to, SEEK_SET); HDlseek(infid, (off_t) from, SEEK_SET); if (howmuch > 512) { nchars = HDread(infid, buf, (unsigned) 512); } else { nchars = HDread(infid, buf, (unsigned)howmuch); } /* end if */ if (nchars <= 0) { error_msg("Read error \n"); HDexit(EXIT_FAILURE); } /* end if */ if(HDwrite (outfid, buf, (unsigned) nchars) < 0) { error_msg("Write error \n"); HDexit(EXIT_FAILURE); } tot += nchars; howmuch -= nchars; if(howmuch > 512) { to -= nchars; from -= nchars; } else { to -= howmuch; from -= howmuch; } /* end if */ } /* end while */ return (hsize_t)tot + (hsize_t)startout; } /* end copy_some_to_file() */
/*------------------------------------------------------------------------- * Function: main * * Purpose: Split an hdf5 file * * Return: Success: * * Failure: * * Programmer: Robb Matzke * Wednesday, May 13, 1998 * * Modifications: * *------------------------------------------------------------------------- */ int main (int argc, char *argv[]) { const char *prog_name; /*program name */ size_t blk_size=1024; /*size of each I/O block */ char *buf=NULL; /*I/O block buffer */ size_t n, i; /*counters */ ssize_t nio; /*I/O return value */ int argno=1; /*program argument number */ int src, dst=-1; /*source & destination files */ int need_seek=FALSE; /*destination needs to seek? */ int need_write; /*data needs to be written? */ h5_stat_t sb; /*temporary file stat buffer */ int verbose=FALSE; /*display file names? */ const char *src_gen_name; /*general source name */ char *src_name=NULL; /*source member name */ int src_is_family; /*is source name a family name? */ int src_membno=0; /*source member number */ const char *dst_gen_name; /*general destination name */ char *dst_name=NULL; /*destination member name */ int dst_is_family; /*is dst name a family name? */ int dst_membno=0; /*destination member number */ off_t left_overs=0; /*amount of zeros left over */ off_t src_offset=0; /*offset in source member */ off_t dst_offset=0; /*offset in destination member */ off_t src_size; /*source logical member size */ off_t src_act_size; /*source actual member size */ off_t dst_size=1 GB; /*destination logical memb size */ hid_t fapl; /*file access property list */ hid_t file; hsize_t hdsize; /*destination logical memb size */ hbool_t family_to_sec2=FALSE; /*change family to sec2 driver? */ /* * Get the program name from argv[0]. Use only the last component. */ if ((prog_name=strrchr (argv[0], '/'))) prog_name++; else prog_name = argv[0]; /* * Parse switches. */ while (argno<argc && '-'==argv[argno][0]) { if (!strcmp (argv[argno], "-v")) { verbose = TRUE; argno++; } else if (!strcmp(argv[argno], "-V")) { printf("This is %s version %u.%u release %u\n", prog_name, H5_VERS_MAJOR, H5_VERS_MINOR, H5_VERS_RELEASE); exit(EXIT_SUCCESS); } else if (!strcmp (argv[argno], "-family_to_sec2")) { family_to_sec2 = TRUE; argno++; } else if ('b'==argv[argno][1]) { blk_size = (size_t)get_size (prog_name, &argno, argc, argv); } else if ('m'==argv[argno][1]) { dst_size = get_size (prog_name, &argno, argc, argv); } else { usage (prog_name); } /* end if */ } /* end while */ /* allocate names */ if(NULL == (src_name = (char *)HDcalloc((size_t)NAMELEN, sizeof(char)))) exit(EXIT_FAILURE); if(NULL == (dst_name = (char *)HDcalloc((size_t)NAMELEN, sizeof(char)))) exit(EXIT_FAILURE); /* * Get the name for the source file and open the first member. The size * of the first member determines the logical size of all the members. */ if (argno>=argc) usage (prog_name); src_gen_name = argv[argno++]; sprintf (src_name, src_gen_name, src_membno); src_is_family = strcmp (src_name, src_gen_name); if ((src = HDopen(src_name, O_RDONLY)) < 0) { HDperror(src_name); HDexit(EXIT_FAILURE); } if (HDfstat(src, &sb)<0) { perror ("fstat"); exit (EXIT_FAILURE); } src_size = src_act_size = sb.st_size; if (verbose) fprintf (stderr, "< %s\n", src_name); /* * Get the name for the destination file and open the first member. */ if (argno>=argc) usage (prog_name); dst_gen_name = argv[argno++]; sprintf (dst_name, dst_gen_name, dst_membno); dst_is_family = strcmp (dst_name, dst_gen_name); if ((dst = HDopen(dst_name, O_RDWR|O_CREAT|O_TRUNC, H5_POSIX_CREATE_MODE_RW)) < 0) { HDperror(dst_name); HDexit(EXIT_FAILURE); } if (verbose) fprintf (stderr, "> %s\n", dst_name); /* No more arguments */ if (argno<argc) usage (prog_name); /* Now the real work, split the file */ buf = (char *)HDmalloc(blk_size); while (src_offset<src_size) { /* Read a block. The amount to read is the minimum of: * 1. The I/O block size * 2. What's left to write in the destination member * 3. Left over zeros or what's left in the source member. */ n = blk_size; if (dst_is_family) n = (size_t)MIN((off_t)n, dst_size-dst_offset); if (left_overs) { n = (size_t)MIN ((off_t)n, left_overs); left_overs = left_overs - (off_t)n; need_write = FALSE; } else if (src_offset<src_act_size) { n = (size_t)MIN ((off_t)n, src_act_size-src_offset); if ((nio=HDread (src, buf, n))<0) { perror ("read"); exit (EXIT_FAILURE); } else if ((size_t)nio!=n) { fprintf (stderr, "%s: short read\n", src_name); exit (EXIT_FAILURE); } for (i=0; i<n; i++) { if (buf[i]) break; } need_write = (i<n); } else { n = 0; left_overs = src_size - src_act_size; need_write = FALSE; } /* * If the block contains non-zero data then write it to the * destination, otherwise just remember that we'll have to do a seek * later in the destination when we finally get non-zero data. */ if (need_write) { if (need_seek && HDlseek (dst, dst_offset, SEEK_SET)<0) { perror ("HDlseek"); exit (EXIT_FAILURE); } if ((nio=HDwrite (dst, buf, n))<0) { perror ("write"); exit (EXIT_FAILURE); } else if ((size_t)nio!=n) { fprintf (stderr, "%s: short write\n", dst_name); exit (EXIT_FAILURE); } need_seek = FALSE; } else { need_seek = TRUE; } /* * Update the source offset and open the next source family member if * necessary. The source stream ends at the first member which * cannot be opened because it doesn't exist. At the end of the * source stream, update the destination offset and break out of the * loop. The destination offset must be updated so we can fix * trailing holes. */ src_offset = src_offset + (off_t)n; if (src_offset==src_act_size) { HDclose (src); if (!src_is_family) { dst_offset = dst_offset + (off_t)n; break; } sprintf (src_name, src_gen_name, ++src_membno); if ((src = HDopen(src_name, O_RDONLY)) < 0 && ENOENT == errno) { dst_offset = dst_offset + (off_t)n; break; } else if (src<0) { perror (src_name); exit (EXIT_FAILURE); } if (HDfstat (src, &sb)<0) { perror ("fstat"); exit (EXIT_FAILURE); } src_act_size = sb.st_size; if (src_act_size>src_size) { fprintf (stderr, "%s: member truncated to %lu bytes\n", src_name, (unsigned long)src_size); } src_offset = 0; if (verbose) fprintf (stderr, "< %s\n", src_name); } /* * Update the destination offset, opening a new member if one will be * needed. The first member is extended to the logical member size * but other members might be smaller if they end with a hole. */ dst_offset = dst_offset + (off_t)n; if (dst_is_family && dst_offset==dst_size) { if (0==dst_membno) { if (HDlseek (dst, dst_size-1, SEEK_SET)<0) { perror ("HDHDlseek"); exit (EXIT_FAILURE); } if (HDread (dst, buf, 1)<0) { perror ("read"); exit (EXIT_FAILURE); } if (HDlseek (dst, dst_size-1, SEEK_SET)<0) { perror ("HDlseek"); exit (EXIT_FAILURE); } if (HDwrite (dst, buf, 1)<0) { perror ("write"); exit (EXIT_FAILURE); } } HDclose (dst); sprintf (dst_name, dst_gen_name, ++dst_membno); if ((dst = HDopen(dst_name, O_RDWR|O_CREAT|O_TRUNC, H5_POSIX_CREATE_MODE_RW)) < 0) { HDperror(dst_name); HDexit(EXIT_FAILURE); } dst_offset = 0; need_seek = FALSE; if (verbose) fprintf (stderr, "> %s\n", dst_name); } } /* * Make sure the last family member is the right size and then close it. * The last member can't end with a hole or hdf5 will think that the * family has been truncated. */ if (need_seek) { if (HDlseek (dst, dst_offset-1, SEEK_SET)<0) { perror ("HDlseek"); exit (EXIT_FAILURE); } if (HDread (dst, buf, 1)<0) { perror ("read"); exit (EXIT_FAILURE); } if (HDlseek (dst, dst_offset-1, SEEK_SET)<0) { perror ("HDlseek"); exit (EXIT_FAILURE); } if (HDwrite (dst, buf, 1)<0) { perror ("write"); exit (EXIT_FAILURE); } } HDclose (dst); /* Modify family driver information saved in superblock through private property. * These private properties are for this tool only. */ if ((fapl=H5Pcreate(H5P_FILE_ACCESS))<0) { perror ("H5Pcreate"); exit (EXIT_FAILURE); } if(family_to_sec2) { /* The user wants to change file driver from family to sec2. Open the file * with sec2 driver. This property signals the library to ignore the family * driver information saved in the superblock. */ if(H5Pset(fapl, H5F_ACS_FAMILY_TO_SEC2_NAME, &family_to_sec2) < 0) { perror ("H5Pset"); exit (EXIT_FAILURE); } } else { /* Modify family size saved in superblock through private property. It signals * library to save the new member size(specified in command line) in superblock. * This private property is for this tool only. */ if(H5Pset_fapl_family(fapl, H5F_FAMILY_DEFAULT, H5P_DEFAULT) < 0) { perror ("H5Pset_fapl_family"); exit (EXIT_FAILURE); } /* Set the property of the new member size as hsize_t */ hdsize = (hsize_t)dst_size; if(H5Pset(fapl, H5F_ACS_FAMILY_NEWSIZE_NAME, &hdsize) < 0) { perror ("H5Pset"); exit (EXIT_FAILURE); } } /* If the new file is a family file, try to open file for "read and write" to * flush metadata. Flushing metadata will update the superblock to the new * member size. If the original file is a family file and the new file is a sec2 * file, the property FAMILY_TO_SEC2 will signal the library to switch to sec2 * driver when the new file is opened. If the original file is a sec2 file and the * new file can only be a sec2 file, reopen the new file should fail. There's * nothing to do in this case. */ H5E_BEGIN_TRY { file=H5Fopen(dst_gen_name, H5F_ACC_RDWR, fapl); } H5E_END_TRY; if(file>=0) { if(H5Fclose(file)<0) { perror ("H5Fclose"); exit (EXIT_FAILURE); } /* end if */ } /* end if */ if(H5Pclose(fapl)<0) { perror ("H5Pclose"); exit (EXIT_FAILURE); } /* end if */ /* Free resources and return */ HDfree(src_name); HDfree(dst_name); HDfree(buf); return EXIT_SUCCESS; } /* end main */
/*------------------------------------------------------------------------- * Function: main * * Purpose: HDF5 user block jammer * * Return: Success: 0 * Failure: 1 * * Programmer: * * Modifications: * *------------------------------------------------------------------------- */ int main (int argc, const char *argv[]) { int ufid = -1; int h5fid = -1; int ofid = -1; void *edata; H5E_auto2_t func; hid_t ifile = -1; hid_t plist = -1; herr_t status; htri_t testval; hsize_t usize; hsize_t h5fsize; hsize_t startub; hsize_t where; hsize_t newubsize; off_t fsize; h5_stat_t sbuf; h5_stat_t sbuf2; int res; h5tools_setprogname(PROGRAMNAME); h5tools_setstatus(EXIT_SUCCESS); /* Disable error reporting */ H5Eget_auto2(H5E_DEFAULT, &func, &edata); H5Eset_auto2(H5E_DEFAULT, NULL, NULL); /* Initialize h5tools lib */ h5tools_init(); parse_command_line (argc, argv); if (ub_file == NULL) { /* no user block */ error_msg("missing arguemnt for -u <user_file>.\n"); help_ref_msg(stderr); leave (EXIT_FAILURE); } testval = H5Fis_hdf5 (ub_file); if (testval > 0) { error_msg("-u <user_file> cannot be HDF5 file, but it appears to be an HDF5 file.\n"); help_ref_msg(stderr); leave (EXIT_FAILURE); } if (input_file == NULL) { error_msg("missing arguemnt for -i <HDF5 file>.\n"); help_ref_msg(stderr); leave (EXIT_FAILURE); } testval = H5Fis_hdf5 (input_file); if (testval <= 0) { error_msg("Input HDF5 file \"%s\" is not HDF5 format.\n", input_file); help_ref_msg(stderr); leave (EXIT_FAILURE); } ifile = H5Fopen (input_file, H5F_ACC_RDONLY, H5P_DEFAULT); if (ifile < 0) { error_msg("Can't open input HDF5 file \"%s\"\n", input_file); leave (EXIT_FAILURE); } plist = H5Fget_create_plist (ifile); if (plist < 0) { error_msg("Can't get file creation plist for file \"%s\"\n", input_file); H5Fclose(ifile); leave (EXIT_FAILURE); } status = H5Pget_userblock (plist, &usize); if (status < 0) { error_msg("Can't get user block for file \"%s\"\n", input_file); H5Pclose(plist); H5Fclose(ifile); leave (EXIT_FAILURE); } H5Pclose(plist); H5Fclose(ifile); ufid = HDopen(ub_file, O_RDONLY, 0); if(ufid < 0) { error_msg("unable to open user block file \"%s\"\n", ub_file); leave (EXIT_FAILURE); } res = HDfstat(ufid, &sbuf); if(res < 0) { error_msg("Can't stat file \"%s\"\n", ub_file); HDclose (ufid); leave (EXIT_FAILURE); } fsize = (off_t)sbuf.st_size; h5fid = HDopen(input_file, O_RDONLY, 0); if(h5fid < 0) { error_msg("unable to open HDF5 file for read \"%s\"\n", input_file); HDclose (ufid); leave (EXIT_FAILURE); } res = HDfstat(h5fid, &sbuf2); if(res < 0) { error_msg("Can't stat file \"%s\"\n", input_file); HDclose (h5fid); HDclose (ufid); leave (EXIT_FAILURE); } h5fsize = (hsize_t)sbuf2.st_size; if (output_file == NULL) { ofid = HDopen (input_file, O_WRONLY, 0); if (ofid < 0) { error_msg("unable to open output file \"%s\"\n", output_file); HDclose (h5fid); HDclose (ufid); leave (EXIT_FAILURE); } } else { ofid = HDopen (output_file, O_WRONLY | O_CREAT | O_TRUNC, 0644); if (ofid < 0) { error_msg("unable to create output file \"%s\"\n", output_file); HDclose (h5fid); HDclose (ufid); leave (EXIT_FAILURE); } } newubsize = compute_user_block_size ((hsize_t) fsize); startub = usize; if (usize > 0) { if (do_clobber == TRUE) { /* where is max of the current size or the new UB */ if (usize > newubsize) { newubsize = usize; } startub = 0; /*blast the old */ } else { /* add new ub to current ublock, pad to new offset */ newubsize += usize; newubsize = compute_user_block_size ((hsize_t) newubsize); } } /* copy the HDF5 from starting at usize to starting at newubsize: * makes room at 'from' for new ub */ /* if no current ub, usize is 0 */ copy_some_to_file (h5fid, ofid, usize, newubsize, (ssize_t) (h5fsize - usize)); /* copy the old ub to the beginning of the new file */ if (!do_clobber) { where = copy_some_to_file (h5fid, ofid, (hsize_t) 0, (hsize_t) 0, (ssize_t) usize); } /* copy the new ub to the end of the ub */ where = copy_some_to_file (ufid, ofid, (hsize_t) 0, startub, (ssize_t) - 1); /* pad the ub */ where = write_pad (ofid, where); if(ub_file) HDfree (ub_file); if(input_file) HDfree (input_file); if(output_file) HDfree (output_file); if(ufid >= 0) HDclose (ufid); if(h5fid >= 0) HDclose (h5fid); if(ofid >= 0) HDclose (ofid); return h5tools_getstatus(); }
/*------------------------------------------------------------------------- * Function: test * * Purpose: The guts of the test * * Return: Success: 0 * * Failure: number of errors * * Programmer: Robb Matzke * Wednesday, September 30, 1998 * * Modifications: * *------------------------------------------------------------------------- */ static int test(fill_t fill_style, const double splits[], hbool_t verbose, hbool_t use_rdcc) { hid_t file = (-1), fapl = (-1), dcpl = (-1), xfer = (-1), mspace = (-1), fspace = (-1), dset = (-1); hsize_t ch_size[1] = {1}; /*chunk size */ hsize_t cur_size[1] = {1000}; /*current dataset size */ hsize_t max_size[1] = {H5S_UNLIMITED}; /*maximum dataset size */ hsize_t hs_start[1]; /*hyperslab start offset*/ hsize_t hs_count[1] = {1}; /*hyperslab nelmts */ int fd = (-1); /*h5 file direct */ int *had = NULL; /*for random filling */ const char *sname=NULL; /*fill style nam */ int mdc_nelmts; /*num meta objs to cache*/ hsize_t i; int j; h5_stat_t sb; if((fapl = H5Pcreate(H5P_FILE_ACCESS)) < 0) goto error; if(!use_rdcc) { if(H5Pget_cache(fapl, &mdc_nelmts, NULL, NULL, NULL) < 0) goto error; if(H5Pset_cache(fapl, mdc_nelmts, 0, 0, 0.0F) < 0) goto error; } if((file = H5Fcreate(FILE_NAME_1, H5F_ACC_TRUNC, H5P_DEFAULT, fapl)) < 0) goto error; if((dcpl = H5Pcreate(H5P_DATASET_CREATE)) < 0) goto error; if(H5Pset_chunk(dcpl, 1, ch_size) < 0) goto error; if((xfer = H5Pcreate(H5P_DATASET_XFER)) < 0) goto error; if(H5Pset_btree_ratios(xfer, splits[0], splits[1], splits[2]) < 0) goto error; if((fspace = H5Screate_simple(1, cur_size, max_size)) < 0) goto error; if((mspace = H5Screate_simple(1, ch_size, ch_size)) < 0) goto error; if((dset = H5Dcreate2(file, "chunked", H5T_NATIVE_INT, fspace, H5P_DEFAULT, dcpl, H5P_DEFAULT)) < 0) goto error; if ((fd=HDopen(FILE_NAME_1, O_RDONLY, 0666)) < 0) goto error; if(FILL_RANDOM==fill_style) had = calloc((size_t)cur_size[0], sizeof(int)); for (i=1; i<=cur_size[0]; i++) { /* Decide which chunk to write to */ switch (fill_style) { case FILL_FORWARD: hs_start[0] = i-1; break; case FILL_REVERSE: hs_start[0] = cur_size[0]-i; break; case FILL_INWARD: hs_start[0] = i%2 ? i/2 : cur_size[0]-i/2; break; case FILL_OUTWARD: j = (int)(cur_size[0]-i)+1; hs_start[0] = j%2 ? j/2 : (hssize_t)cur_size[0]-j/2; break; case FILL_RANDOM: for (j=HDrand()%(int)cur_size[0]; had[j]; j=(j+1)%(int)cur_size[0]) /*void*/; hs_start[0] = j; had[j] = 1; break; case FILL_ALL: abort(); default: /* unknown request */ HDfprintf(stderr, "Unknown fill style\n"); goto error; break; } /* Write the chunk */ if (H5Sselect_hyperslab(fspace, H5S_SELECT_SET, hs_start, NULL, hs_count, NULL) < 0) goto error; if (H5Dwrite(dset, H5T_NATIVE_INT, mspace, fspace, xfer, &i) < 0) { goto error; } /* Determine overhead */ if (verbose) { if (H5Fflush(file, H5F_SCOPE_LOCAL) < 0) goto error; if (HDfstat(fd, &sb) < 0) goto error; /* * The extra cast in the following statement is a bug workaround * for the Win32 version 5.0 compiler. * 1998-11-06 ptl */ printf("%4lu %8.3f ***\n", (unsigned long)i, (double)(hssize_t)(sb.st_size-i*sizeof(int))/(hssize_t)i); } } if(had) { free(had); had = NULL; } /* end if */ H5Dclose(dset); H5Sclose(mspace); H5Sclose(fspace); H5Pclose(dcpl); H5Pclose(xfer); H5Fclose(file); if (!verbose) { switch (fill_style) { case FILL_FORWARD: sname = "forward"; break; case FILL_REVERSE: sname = "reverse"; break; case FILL_INWARD: sname = "inward"; break; case FILL_OUTWARD: sname = "outward"; break; case FILL_RANDOM: sname = "random"; break; case FILL_ALL: abort(); default: /* unknown request */ HDfprintf(stderr, "Unknown fill style\n"); goto error; break; } if (HDfstat(fd, &sb) < 0) goto error; printf("%-7s %8.3f\n", sname, (double)(hssize_t)(sb.st_size-cur_size[0]*sizeof(int))/ (hssize_t)cur_size[0]); } HDclose(fd); return 0; error: H5Dclose(dset); H5Sclose(mspace); H5Sclose(fspace); H5Pclose(dcpl); H5Pclose(xfer); H5Fclose(file); if(had) free(had); HDclose(fd); return 1; }