/* Write multiple groups with a chunked dataset in each group collectively. * These groups and datasets are for testing independent read later. * * Changes: Updated function to use a dynamically calculated size, * instead of the old SIZE #define. This should allow it * to function with an arbitrary number of processors. * * JRM - 8/16/04 */ void collective_group_write(void) { int mpi_rank, mpi_size, size; int i, j, m; hbool_t use_gpfs = FALSE; char gname[64], dname[32]; hid_t fid, gid, did, plist, dcpl, memspace, filespace; DATATYPE * outme = NULL; hsize_t chunk_origin[DIM]; hsize_t chunk_dims[DIM], file_dims[DIM], count[DIM]; hsize_t chunk_size[2]; /* Chunk dimensions - computed shortly */ herr_t ret1, ret2; const H5Ptest_param_t *pt; char *filename; int ngroups; pt = GetTestParameters(); filename = pt->name; ngroups = pt->count; MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank); MPI_Comm_size(MPI_COMM_WORLD, &mpi_size); size = get_size(); chunk_size[0] = (hsize_t)(size / 2); chunk_size[1] = (hsize_t)(size / 2); outme = HDmalloc((size_t)(size * size * sizeof(DATATYPE))); VRFY((outme != NULL), "HDmalloc succeeded for outme"); plist = create_faccess_plist(MPI_COMM_WORLD, MPI_INFO_NULL, facc_type, use_gpfs); fid = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, plist); H5Pclose(plist); /* decide the hyperslab according to process number. */ get_slab(chunk_origin, chunk_dims, count, file_dims, size); /* select hyperslab in memory and file spaces. These two operations are * identical since the datasets are the same. */ memspace = H5Screate_simple(DIM, file_dims, NULL); ret1 = H5Sselect_hyperslab(memspace, H5S_SELECT_SET, chunk_origin, chunk_dims, count, chunk_dims); filespace = H5Screate_simple(DIM, file_dims, NULL); ret2 = H5Sselect_hyperslab(filespace, H5S_SELECT_SET, chunk_origin, chunk_dims, count, chunk_dims); VRFY((memspace>=0), "memspace"); VRFY((filespace>=0), "filespace"); VRFY((ret1>=0), "mgroup memspace selection"); VRFY((ret2>=0), "mgroup filespace selection"); dcpl = H5Pcreate(H5P_DATASET_CREATE); ret1 = H5Pset_chunk (dcpl, 2, chunk_size); VRFY((dcpl>=0), "dataset creation property"); VRFY((ret1>=0), "set chunk for dataset creation property"); /* creates ngroups groups under the root group, writes chunked * datasets in parallel. */ for(m = 0; m < ngroups; m++) { sprintf(gname, "group%d", m); gid = H5Gcreate(fid, gname, 0); VRFY((gid > 0), gname); sprintf(dname, "dataset%d", m); did = H5Dcreate(gid, dname, H5T_NATIVE_INT, filespace, dcpl); VRFY((did > 0), dname); for(i=0; i < size; i++) for(j=0; j < size; j++) outme[(i * size) + j] = (i+j)*1000 + mpi_rank; H5Dwrite(did, H5T_NATIVE_INT, memspace, filespace, H5P_DEFAULT, outme); H5Dclose(did); H5Gclose(gid); #ifdef BARRIER_CHECKS if(! ((m+1) % 10)) { printf("created %d groups\n", m+1); MPI_Barrier(MPI_COMM_WORLD); } #endif /* BARRIER_CHECKS */ } H5Pclose(dcpl); H5Sclose(filespace); H5Sclose(memspace); H5Fclose(fid); HDfree(outme); }
/* Example of using PHDF5 to create "large" datasets. (>2GB, >4GB, >8GB) * Actual data is _not_ written to these datasets. Dataspaces are exact * sizes (2GB, 4GB, etc.), but the metadata for the file pushes the file over * the boundary of interest. * * Changes: Removed the assert that mpi_size <= the SIZE #define. * As best I can tell, this assert isn't needed here, * and in any case, the SIZE #define is being removed * in an update of the functions in this file to run * with an arbitrary number of processes. * * JRM - 8/11/04 */ void big_dataset(void) { int mpi_size, mpi_rank; /* MPI info */ hbool_t use_gpfs = FALSE; /* Don't use GPFS stuff for this test */ hid_t iof, /* File ID */ fapl, /* File access property list ID */ dataset, /* Dataset ID */ filespace; /* Dataset's dataspace ID */ hsize_t file_dims [4]; /* Dimensions of dataspace */ char dname[]="dataset"; /* Name of dataset */ MPI_Offset file_size; /* Size of file on disk */ herr_t ret; /* Generic return value */ const char *filename; MPI_Comm_rank (MPI_COMM_WORLD, &mpi_rank); MPI_Comm_size (MPI_COMM_WORLD, &mpi_size); /* Verify MPI_Offset can handle larger than 2GB sizes */ VRFY((sizeof(MPI_Offset)>4), "sizeof(MPI_Offset)>4"); filename = GetTestParameters(); fapl = create_faccess_plist(MPI_COMM_WORLD, MPI_INFO_NULL, facc_type, use_gpfs); VRFY((fapl >= 0), "create_faccess_plist succeeded"); /* * Create >2GB HDF5 file */ iof = H5Fcreate (filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl); VRFY((iof >= 0), "H5Fcreate succeeded"); /* Define dataspace for 2GB dataspace */ file_dims[0]= 2; file_dims[1]= 1024; file_dims[2]= 1024; file_dims[3]= 1024; filespace = H5Screate_simple (4, file_dims, NULL); VRFY((filespace >= 0), "H5Screate_simple succeeded"); dataset = H5Dcreate (iof, dname, H5T_NATIVE_UCHAR, filespace, H5P_DEFAULT); VRFY((dataset >= 0), "H5Dcreate succeeded"); /* Close all file objects */ ret=H5Dclose (dataset); VRFY((ret >= 0), "H5Dclose succeeded"); ret=H5Sclose (filespace); VRFY((ret >= 0), "H5Sclose succeeded"); ret=H5Fclose (iof); VRFY((ret >= 0), "H5Fclose succeeded"); /* Check that file of the correct size was created */ file_size=h5_get_file_size(filename); VRFY((file_size == 2147485696ULL), "File is correct size"); /* * Create >4GB HDF5 file */ iof = H5Fcreate (filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl); VRFY((iof >= 0), "H5Fcreate succeeded"); /* Define dataspace for 4GB dataspace */ file_dims[0]= 4; file_dims[1]= 1024; file_dims[2]= 1024; file_dims[3]= 1024; filespace = H5Screate_simple (4, file_dims, NULL); VRFY((filespace >= 0), "H5Screate_simple succeeded"); dataset = H5Dcreate (iof, dname, H5T_NATIVE_UCHAR, filespace, H5P_DEFAULT); VRFY((dataset >= 0), "H5Dcreate succeeded"); /* Close all file objects */ ret=H5Dclose (dataset); VRFY((ret >= 0), "H5Dclose succeeded"); ret=H5Sclose (filespace); VRFY((ret >= 0), "H5Sclose succeeded"); ret=H5Fclose (iof); VRFY((ret >= 0), "H5Fclose succeeded"); /* Check that file of the correct size was created */ file_size=h5_get_file_size(filename); VRFY((file_size == 4294969344ULL), "File is correct size"); /* * Create >8GB HDF5 file */ iof = H5Fcreate (filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl); VRFY((iof >= 0), "H5Fcreate succeeded"); /* Define dataspace for 8GB dataspace */ file_dims[0]= 8; file_dims[1]= 1024; file_dims[2]= 1024; file_dims[3]= 1024; filespace = H5Screate_simple (4, file_dims, NULL); VRFY((filespace >= 0), "H5Screate_simple succeeded"); dataset = H5Dcreate (iof, dname, H5T_NATIVE_UCHAR, filespace, H5P_DEFAULT); VRFY((dataset >= 0), "H5Dcreate succeeded"); /* Close all file objects */ ret=H5Dclose (dataset); VRFY((ret >= 0), "H5Dclose succeeded"); ret=H5Sclose (filespace); VRFY((ret >= 0), "H5Sclose succeeded"); ret=H5Fclose (iof); VRFY((ret >= 0), "H5Fclose succeeded"); /* Check that file of the correct size was created */ file_size=h5_get_file_size(filename); VRFY((file_size == 8589936640ULL), "File is correct size"); /* Close fapl */ ret=H5Pclose (fapl); VRFY((ret >= 0), "H5Pclose succeeded"); }
/* Example of using PHDF5 to read a partial written dataset. The dataset does * not have actual data written to the entire raw data area and relies on the * default fill value of zeros to work correctly. * * Changes: Removed the assert that mpi_size <= the SIZE #define. * As best I can tell, this assert isn't needed here, * and in any case, the SIZE #define is being removed * in an update of the functions in this file to run * with an arbitrary number of processes. * * Also added code to free dynamically allocated buffers. * * JRM - 8/11/04 */ void dataset_fillvalue(void) { int mpi_size, mpi_rank; /* MPI info */ hbool_t use_gpfs = FALSE; /* Don't use GPFS stuff for this test */ int err_num; /* Number of errors */ hid_t iof, /* File ID */ fapl, /* File access property list ID */ dxpl, /* Data transfer property list ID */ dataset, /* Dataset ID */ memspace, /* Memory dataspace ID */ filespace; /* Dataset's dataspace ID */ char dname[]="dataset"; /* Name of dataset */ hsize_t dset_dims[4] = {0, 6, 7, 8}; hsize_t req_start[4] = {0, 0, 0, 0}; hsize_t req_count[4] = {1, 6, 7, 8}; hsize_t dset_size; /* Dataset size */ int *rdata, *wdata; /* Buffers for data to read and write */ int *twdata, *trdata; /* Temporary pointer into buffer */ int acc, i, j, k, l; /* Local index variables */ herr_t ret; /* Generic return value */ const char *filename; MPI_Comm_rank (MPI_COMM_WORLD, &mpi_rank); MPI_Comm_size (MPI_COMM_WORLD, &mpi_size); filename = GetTestParameters(); /* Set the dataset dimension to be one row more than number of processes */ /* and calculate the actual dataset size. */ dset_dims[0]=mpi_size+1; dset_size=dset_dims[0]*dset_dims[1]*dset_dims[2]*dset_dims[3]; /* Allocate space for the buffers */ rdata=HDmalloc((size_t)(dset_size*sizeof(int))); VRFY((rdata != NULL), "HDcalloc succeeded for read buffer"); wdata=HDmalloc((size_t)(dset_size*sizeof(int))); VRFY((wdata != NULL), "HDmalloc succeeded for write buffer"); fapl = create_faccess_plist(MPI_COMM_WORLD, MPI_INFO_NULL, facc_type, use_gpfs); VRFY((fapl >= 0), "create_faccess_plist succeeded"); /* * Create HDF5 file */ iof = H5Fcreate (filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl); VRFY((iof >= 0), "H5Fcreate succeeded"); filespace = H5Screate_simple(4, dset_dims, NULL); VRFY((filespace >= 0), "File H5Screate_simple succeeded"); dataset = H5Dcreate(iof, dname, H5T_NATIVE_INT, filespace, H5P_DEFAULT); VRFY((dataset >= 0), "H5Dcreate succeeded"); memspace = H5Screate_simple(4, dset_dims, NULL); VRFY((memspace >= 0), "Memory H5Screate_simple succeeded"); /* * Read dataset before any data is written. */ /* set entire read buffer with the constant 2 */ HDmemset(rdata,2,(size_t)(dset_size*sizeof(int))); /* Independently read the entire dataset back */ ret=H5Dread(dataset, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, rdata); VRFY((ret >= 0), "H5Dread succeeded"); /* Verify all data read are the fill value 0 */ trdata=rdata; err_num=0; for (i=0; i<(int)dset_dims[0]; i++) for (j=0; j<(int)dset_dims[1]; j++) for (k=0; k<(int)dset_dims[2]; k++) for (l=0; l<(int)dset_dims[3]; l++, twdata++, trdata++) if( *trdata != 0) if(err_num++ < MAX_ERR_REPORT || VERBOSE_MED) printf("Dataset Verify failed at [%d][%d][%d][%d]: expect 0, got %d\n", i,j,k,l, *trdata); if(err_num > MAX_ERR_REPORT && !VERBOSE_MED) printf("[more errors ...]\n"); if(err_num){ printf("%d errors found in check_value\n", err_num); nerrors++; } /* Barrier to ensure all processes have completed the above test. */ MPI_Barrier(MPI_COMM_WORLD); /* * Each process writes 1 row of data. Thus last row is not written. */ /* Create hyperslabs in memory and file dataspaces */ req_start[0]=mpi_rank; ret=H5Sselect_hyperslab(filespace, H5S_SELECT_SET, req_start, NULL, req_count, NULL); VRFY((ret >= 0), "H5Sselect_hyperslab succeeded on memory dataspace"); ret=H5Sselect_hyperslab(memspace, H5S_SELECT_SET, req_start, NULL, req_count, NULL); VRFY((ret >= 0), "H5Sselect_hyperslab succeeded on memory dataspace"); /* Create DXPL for collective I/O */ dxpl = H5Pcreate (H5P_DATASET_XFER); VRFY((dxpl >= 0), "H5Pcreate succeeded"); ret=H5Pset_dxpl_mpio(dxpl, H5FD_MPIO_COLLECTIVE); VRFY((ret >= 0), "H5Pset_dxpl_mpio succeeded"); /* Fill write buffer with some values */ twdata=wdata; for (i=0, acc=0; i<(int)dset_dims[0]; i++) for (j=0; j<(int)dset_dims[1]; j++) for (k=0; k<(int)dset_dims[2]; k++) for (l=0; l<(int)dset_dims[3]; l++) *twdata++ = acc++; /* Collectively write a hyperslab of data to the dataset */ ret=H5Dwrite(dataset, H5T_NATIVE_INT, memspace, filespace, dxpl, wdata); VRFY((ret >= 0), "H5Dwrite succeeded"); /* Barrier here, to allow MPI-posix I/O to sync */ MPI_Barrier(MPI_COMM_WORLD); /* * Read dataset after partial write. */ /* set entire read buffer with the constant 2 */ HDmemset(rdata,2,(size_t)(dset_size*sizeof(int))); /* Independently read the entire dataset back */ ret=H5Dread(dataset, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, rdata); VRFY((ret >= 0), "H5Dread succeeded"); /* Verify correct data read */ twdata=wdata; trdata=rdata; err_num=0; for (i=0; i<(int)dset_dims[0]; i++) for (j=0; j<(int)dset_dims[1]; j++) for (k=0; k<(int)dset_dims[2]; k++) for (l=0; l<(int)dset_dims[3]; l++, twdata++, trdata++) if(i<mpi_size) { if( *twdata != *trdata ) if(err_num++ < MAX_ERR_REPORT || VERBOSE_MED) printf("Dataset Verify failed at [%d][%d][%d][%d]: expect %d, got %d\n", i,j,k,l, *twdata, *trdata); } /* end if */ else { if( *trdata != 0) if(err_num++ < MAX_ERR_REPORT || VERBOSE_MED) printf("Dataset Verify failed at [%d][%d][%d][%d]: expect 0, got %d\n", i,j,k,l, *trdata); } /* end else */ if(err_num > MAX_ERR_REPORT && !VERBOSE_MED) printf("[more errors ...]\n"); if(err_num){ printf("%d errors found in check_value\n", err_num); nerrors++; } /* Close all file objects */ ret=H5Dclose (dataset); VRFY((ret >= 0), "H5Dclose succeeded"); ret=H5Sclose (filespace); VRFY((ret >= 0), "H5Sclose succeeded"); ret=H5Fclose (iof); VRFY((ret >= 0), "H5Fclose succeeded"); /* Close memory dataspace */ ret=H5Sclose (memspace); VRFY((ret >= 0), "H5Sclose succeeded"); /* Close dxpl */ ret=H5Pclose (dxpl); VRFY((ret >= 0), "H5Pclose succeeded"); /* Close fapl */ ret=H5Pclose (fapl); VRFY((ret >= 0), "H5Pclose succeeded"); /* free the buffers */ HDfree(rdata); HDfree(wdata); }
void io_mode_confusion(void) { /* * HDF5 APIs definitions */ const int rank = 1; const char *dataset_name = "IntArray"; hid_t file_id, dset_id; /* file and dataset identifiers */ hid_t filespace, memspace; /* file and memory dataspace */ /* identifiers */ hsize_t dimsf[1]; /* dataset dimensions */ int data[N] = {1}; /* pointer to data buffer to write */ hsize_t coord[N] = {0L,1L,2L,3L}; hsize_t start[1]; hsize_t stride[1]; hsize_t count[1]; hsize_t block[1]; hid_t plist_id; /* property list identifier */ herr_t status; /* * MPI variables */ int mpi_size, mpi_rank; /* * test bed related variables */ const char * fcn_name = "io_mode_confusion"; const hbool_t verbose = FALSE; const H5Ptest_param_t * pt; char * filename; pt = GetTestParameters(); filename = pt->name; MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank); MPI_Comm_size(MPI_COMM_WORLD, &mpi_size); /* * Set up file access property list with parallel I/O access */ if ( verbose ) HDfprintf(stdout, "%0d:%s: Setting up property list.\n", mpi_rank, fcn_name); plist_id = H5Pcreate(H5P_FILE_ACCESS); VRFY((plist_id != -1), "H5Pcreate() failed"); status = H5Pset_fapl_mpio(plist_id, MPI_COMM_WORLD, MPI_INFO_NULL); VRFY(( status >= 0 ), "H5Pset_fapl_mpio() failed"); /* * Create a new file collectively and release property list identifier. */ if ( verbose ) HDfprintf(stdout, "%0d:%s: Creating new file.\n", mpi_rank, fcn_name); file_id = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, plist_id); VRFY(( file_id >= 0 ), "H5Fcreate() failed"); status = H5Pclose(plist_id); VRFY(( status >= 0 ), "H5Pclose() failed"); /* * Create the dataspace for the dataset. */ if ( verbose ) HDfprintf(stdout, "%0d:%s: Creating the dataspace for the dataset.\n", mpi_rank, fcn_name); dimsf[0] = N; filespace = H5Screate_simple(rank, dimsf, NULL); VRFY(( filespace >= 0 ), "H5Screate_simple() failed."); /* * Create the dataset with default properties and close filespace. */ if ( verbose ) HDfprintf(stdout, "%0d:%s: Creating the dataset, and closing filespace.\n", mpi_rank, fcn_name); dset_id = H5Dcreate(file_id, dataset_name, H5T_NATIVE_INT, filespace, H5P_DEFAULT); VRFY(( dset_id >= 0 ), "H5Dcreate() failed"); status = H5Sclose(filespace); VRFY(( status >= 0 ), "H5Sclose() failed"); if ( verbose ) HDfprintf(stdout, "%0d:%s: Calling H5Screate_simple().\n", mpi_rank, fcn_name); memspace = H5Screate_simple(rank, dimsf, NULL); VRFY(( memspace >= 0 ), "H5Screate_simple() failed."); if( mpi_rank == 0 ) { if ( verbose ) HDfprintf(stdout, "%0d:%s: Calling H5Sselect_all(memspace).\n", mpi_rank, fcn_name); status = H5Sselect_all(memspace); VRFY(( status >= 0 ), "H5Sselect_all() failed"); } else { if ( verbose ) HDfprintf(stdout, "%0d:%s: Calling H5Sselect_none(memspace).\n", mpi_rank, fcn_name); status = H5Sselect_none(memspace); VRFY(( status >= 0 ), "H5Sselect_none() failed"); } if ( verbose ) HDfprintf(stdout, "%0d:%s: Calling MPI_Barrier().\n", mpi_rank, fcn_name); MPI_Barrier(MPI_COMM_WORLD); if ( verbose ) HDfprintf(stdout, "%0d:%s: Calling H5Dget_space().\n", mpi_rank, fcn_name); filespace = H5Dget_space(dset_id); VRFY(( filespace >= 0 ), "H5Dget_space() failed"); start[0] = 0L; stride[0] = 1; count[0] = 1; block[0] = N; if ( mpi_rank == 0 ) { /* select all */ if ( verbose ) HDfprintf(stdout, "%0d:%s: Calling H5Sselect_elements() -- set up hang?\n", mpi_rank, fcn_name); status = H5Sselect_elements(filespace, H5S_SELECT_SET, N, (const hsize_t **)&coord); VRFY(( status >= 0 ), "H5Sselect_elements() failed"); } else { /* select nothing */ if ( verbose ) HDfprintf(stdout, "%0d:%s: Calling H5Sselect_none().\n", mpi_rank, fcn_name); status = H5Sselect_none(filespace); VRFY(( status >= 0 ), "H5Sselect_none() failed"); } if ( verbose ) HDfprintf(stdout, "%0d:%s: Calling MPI_Barrier().\n", mpi_rank, fcn_name); MPI_Barrier(MPI_COMM_WORLD); if ( verbose ) HDfprintf(stdout, "%0d:%s: Calling H5Pcreate().\n", mpi_rank, fcn_name); plist_id = H5Pcreate(H5P_DATASET_XFER); VRFY(( plist_id != -1 ), "H5Pcreate() failed"); if ( verbose ) HDfprintf(stdout, "%0d:%s: Calling H5Pset_dxpl_mpio().\n", mpi_rank, fcn_name); status = H5Pset_dxpl_mpio(plist_id, H5FD_MPIO_COLLECTIVE); VRFY(( status >= 0 ), "H5Pset_dxpl_mpio() failed"); if ( verbose ) HDfprintf(stdout, "%0d:%s: Calling H5Dwrite() -- hang here?.\n", mpi_rank, fcn_name); status = H5Dwrite(dset_id, H5T_NATIVE_INT, memspace, filespace, plist_id, data); if ( verbose ) HDfprintf(stdout, "%0d:%s: Returned from H5Dwrite(), status=%d.\n", mpi_rank, fcn_name, status); VRFY(( status >= 0 ), "H5Dwrite() failed"); /* * Close/release resources. */ if ( verbose ) HDfprintf(stdout, "%0d:%s: Cleaning up from test.\n", mpi_rank, fcn_name); status = H5Dclose(dset_id); VRFY(( status >= 0 ), "H5Dclose() failed"); status = H5Sclose(filespace); VRFY(( status >= 0 ), "H5Dclose() failed"); status = H5Sclose(memspace); VRFY(( status >= 0 ), "H5Sclose() failed"); status = H5Pclose(plist_id); VRFY(( status >= 0 ), "H5Pclose() failed"); status = H5Fclose(file_id); VRFY(( status >= 0 ), "H5Fclose() failed"); if ( verbose ) HDfprintf(stdout, "%0d:%s: Done.\n", mpi_rank, fcn_name); return; } /* io_mode_confusion() */
/* Example of using PHDF5 to create, write, and read compact dataset. * * Changes: Updated function to use a dynamically calculated size, * instead of the old SIZE #define. This should allow it * to function with an arbitrary number of processors. * * JRM - 8/11/04 */ void compact_dataset(void) { int i, j, mpi_size, mpi_rank, size, err_num=0; hbool_t use_gpfs = FALSE; hid_t iof, plist, dcpl, dxpl, dataset, filespace; hsize_t file_dims [DIM]; double * outme; double * inme; char dname[]="dataset"; herr_t ret; const char *filename; size = get_size(); for ( i = 0; i < DIM; i++ ) { file_dims[i] = size; } MPI_Comm_rank (MPI_COMM_WORLD, &mpi_rank); MPI_Comm_size (MPI_COMM_WORLD, &mpi_size); outme = HDmalloc((size_t)(size * size * sizeof(double))); VRFY((outme != NULL), "HDmalloc succeeded for outme"); inme = HDmalloc((size_t)(size * size * sizeof(double))); VRFY((outme != NULL), "HDmalloc succeeded for inme"); filename = GetTestParameters(); VRFY((mpi_size <= size), "mpi_size <= size"); plist = create_faccess_plist(MPI_COMM_WORLD, MPI_INFO_NULL, facc_type, use_gpfs); iof = H5Fcreate (filename, H5F_ACC_TRUNC, H5P_DEFAULT, plist); /* Define data space */ filespace = H5Screate_simple (DIM, file_dims, NULL); /* Create a compact dataset */ dcpl = H5Pcreate(H5P_DATASET_CREATE); VRFY((dcpl>=0), "dataset creation property list succeeded"); ret=H5Pset_layout(dcpl, H5D_COMPACT); VRFY((dcpl >= 0), "set property list for compact dataset"); ret=H5Pset_alloc_time(dcpl, H5D_ALLOC_TIME_EARLY); VRFY((ret >= 0), "set space allocation time for compact dataset"); dataset = H5Dcreate (iof, dname, H5T_NATIVE_DOUBLE, filespace, dcpl); VRFY((dataset >= 0), "H5Dcreate succeeded"); /* set up the collective transfer properties list */ dxpl = H5Pcreate (H5P_DATASET_XFER); VRFY((dxpl >= 0), ""); ret=H5Pset_dxpl_mpio(dxpl, H5FD_MPIO_COLLECTIVE); VRFY((ret >= 0), "H5Pcreate xfer succeeded"); /* Recalculate data to write. Each process writes the same data. */ for (i = 0; i < size; i++) for (j = 0; j < size; j++) outme[(i * size) + j] = (i+j)*1000; ret=H5Dwrite (dataset, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL, dxpl, outme); VRFY((ret >= 0), "H5Dwrite succeeded"); H5Pclose (dcpl); H5Pclose (plist); H5Dclose (dataset); H5Sclose (filespace); H5Fclose (iof); /* Open the file and dataset, read and compare the data. */ plist = create_faccess_plist(MPI_COMM_WORLD, MPI_INFO_NULL, facc_type, use_gpfs); iof = H5Fopen(filename, H5F_ACC_RDONLY, plist); VRFY((iof >= 0), "H5Fopen succeeded"); /* set up the collective transfer properties list */ dxpl = H5Pcreate (H5P_DATASET_XFER); VRFY((dxpl >= 0), ""); ret=H5Pset_dxpl_mpio(dxpl, H5FD_MPIO_COLLECTIVE); VRFY((ret >= 0), "H5Pcreate xfer succeeded"); dataset = H5Dopen(iof, dname); VRFY((dataset >= 0), "H5Dcreate succeeded"); ret = H5Dread(dataset, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL, dxpl, inme); VRFY((ret >= 0), "H5Dread succeeded"); /* Verify data value */ for (i = 0; i < size; i++) for (j = 0; j < size; j++) if ( inme[(i * size) + j] != outme[(i * size) + j]) if(err_num++ < MAX_ERR_REPORT || VERBOSE_MED) printf("Dataset Verify failed at [%d][%d]: expect %f, got %f\n", i, j, outme[(i * size) + j], inme[(i * size) + j]); H5Pclose(plist); H5Pclose(dxpl); H5Dclose(dataset); H5Fclose(iof); HDfree(inme); HDfree(outme); }
int main(void) { hid_t file_id, prop_id, memspace_id, type_id; hid_t group_id; hid_t dataset_id, dataspace_id; herr_t status; hsize_t dims[1]; hsize_t maxdims[1]; float data[NPOINTS]; float floatval; unsigned numdataobj = 0; unsigned i, j; char name[80]; hsize_t start[1] = {0}; hsize_t stride[1] = {1}; hsize_t count[1] = {1}; /* Create a file */ file_id = H5Fcreate(FILEN, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT); /* Create a dataset to hold the number of data objects */ /* Create the data space */ dataspace_id = H5Screate(H5S_SCALAR); /* Create dataset */ dataset_id = H5Dcreate2(file_id, "/NumDataObj", H5T_NATIVE_UINT, dataspace_id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT); /* Write value to NumDataObj dataset */ status = H5Dwrite(dataset_id, H5T_NATIVE_UINT, H5S_ALL, H5S_ALL, H5P_DEFAULT, &numdataobj); /* Close the identifiers */ status = H5Dclose(dataset_id); status = H5Sclose(dataspace_id); /* Create extendible arrays */ /* Set up for extendible dataset */ prop_id = H5Pcreate(H5P_DATASET_CREATE); dims[0] = CHUNK_SIZE; status = H5Pset_chunk(prop_id, 1, dims); /* Create dataspace */ dims[0]=1; maxdims[0]=H5S_UNLIMITED; dataspace_id = H5Screate_simple(1, dims, maxdims); for(i=0; i<NEXTARRAYS; i++) { /* Create dataset */ sprintf(name, "/ExtArray%06d", i); dataset_id = H5Dcreate2(file_id, name, H5T_NATIVE_FLOAT, dataspace_id, H5P_DEFAULT, prop_id, H5P_DEFAULT); /* Close the identifier */ status = H5Dclose(dataset_id); } /* Close the identifiers */ status = H5Sclose(dataspace_id); status = H5Pclose(prop_id); /* Create group to hold data object data arrays */ group_id = H5Gcreate2(file_id, "/DataArray", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT); H5Gclose(group_id); for(j=0; j<NDATAOBJECTS; j++) { /* Removed print statement as it would lock system resources on Windows */ /* * printf("\rWriting Object #%d of %d", j+1, NDATAOBJECTS); * fflush(stdout); */ floatval = (float)j; /* Create group to hold data arrays for this object */ sprintf(name, "/DataArray/%06d", j); group_id = H5Gcreate2(file_id, name, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT); if(group_id < 0) { fprintf(stderr, "Failed to create DataArray group.\n"); status = H5Fclose(file_id); return -1; } /* Loop over data arrays */ for(i=0; i<NDATAARRAYS; i++) { /* Create dataspace */ dims[0]=NPOINTS; maxdims[0]=NPOINTS; dataspace_id = H5Screate_simple(1 ,dims, maxdims); /* Create dataset */ sprintf(name, "DataArray%06d", i); dataset_id = H5Dcreate2(group_id, name, H5T_NATIVE_FLOAT, dataspace_id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT); if(dataset_id < 0) { fprintf(stderr, "Failed to create DataArray dataset.\n"); status = H5Fclose(file_id); return -1; } /* Write the data array data */ status = H5Dwrite(dataset_id, H5T_NATIVE_FLOAT, H5S_ALL, H5S_ALL, H5P_DEFAULT, data); if(status < 0) { fprintf(stderr, "Failed to write DataArray dataset.\n"); status = H5Fclose(file_id); return -1; } /* Close the identifiers */ status = H5Dclose(dataset_id); status = H5Sclose(dataspace_id); } /* Open NumDataObj dataset */ dataset_id = H5Dopen2(file_id, "/NumDataObj", H5P_DEFAULT); if(dataset_id < 0) { fprintf(stderr, "Failed to open NumDataObj dataset.\n"); status = H5Fclose(file_id); return -1; } /* Write value to NumDataObj dataset */ numdataobj = j + 1; status = H5Dwrite(dataset_id, H5T_NATIVE_UINT, H5S_ALL, H5S_ALL, H5P_DEFAULT, &numdataobj); if(status < 0) { fprintf(stderr, "Failed to write NumDataObj dataset.\n"); status = H5Fclose(file_id); return -1; } /* Close identifiers */ status = H5Dclose(dataset_id); status = H5Gclose(group_id); /* Extend attribute arrays */ for(i = 0; i < NEXTARRAYS; i++) { /* Open extendable dataset */ sprintf(name, "/ExtArray%06d", i); dataset_id = H5Dopen2(file_id, name, H5P_DEFAULT); if(dataset_id < 0) { fprintf(stderr, "Failed to open ExtArray dataset.\n"); status = H5Fclose(file_id); return -1; } /* end if */ /* Extend attribute dataset */ dims[0] = (hsize_t)j + 1; status = H5Dset_extent(dataset_id, dims); if(status < 0) { fprintf(stderr, "Failed to extend DataArray dataset.\n"); status = H5Fclose(file_id); return -1; } /* end if */ /* Select element and write value to attribute dataset */ dims[0] = 1; memspace_id = H5Screate_simple(1, dims, dims); dataspace_id = H5Dget_space(dataset_id); type_id = H5Dget_type(dataset_id); start[0] = 0; status = H5Sselect_hyperslab(memspace_id, H5S_SELECT_SET, start, stride, count, NULL); start[0] = (hssize_t)j; status = H5Sselect_hyperslab(dataspace_id, H5S_SELECT_SET, start, stride, count, NULL); status = H5Dwrite(dataset_id, type_id, memspace_id, dataspace_id, H5P_DEFAULT, &floatval); if(status < 0) { fprintf(stderr, "Failed to write DataArray dataset.\n"); status = H5Fclose(file_id); return -1; } /* Close identifiers */ status = H5Tclose(type_id); status = H5Sclose(dataspace_id); status = H5Sclose(memspace_id); status = H5Dclose(dataset_id); } } /* Close the file */ status = H5Fclose(file_id); printf("\n"); return 0; }
void Particle_source::write_hdf5_particles( hid_t current_source_group_id ) { int mpi_n_of_proc, mpi_process_rank; MPI_Comm_size( MPI_COMM_WORLD, &mpi_n_of_proc ); MPI_Comm_rank( MPI_COMM_WORLD, &mpi_process_rank ); herr_t status; hid_t filespace, memspace, dset; hid_t plist_id; int rank = 1; hsize_t dims[rank], subset_dims[rank], subset_offset[rank]; dims[0] = total_particles_across_all_processes(); // todo: is it possible to get rid of this copying? int *id_buf = new int[ particles.size() ]; double *x_buf = new double[ particles.size() ]; double *y_buf = new double[ particles.size() ]; double *z_buf = new double[ particles.size() ]; double *px_buf = new double[ particles.size() ]; double *py_buf = new double[ particles.size() ]; double *pz_buf = new double[ particles.size() ]; int *mpi_proc_buf = new int[ particles.size() ]; for( unsigned int i = 0; i < particles.size(); i++ ){ id_buf[i] = particles[i].id; x_buf[i] = vec3d_x( particles[i].position ); y_buf[i] = vec3d_y( particles[i].position ); z_buf[i] = vec3d_z( particles[i].position ); px_buf[i] = vec3d_x( particles[i].momentum ); py_buf[i] = vec3d_y( particles[i].momentum ); pz_buf[i] = vec3d_z( particles[i].momentum ); mpi_proc_buf[i] = mpi_process_rank; } plist_id = H5Pcreate( H5P_DATASET_XFER ); hdf5_status_check( plist_id ); status = H5Pset_dxpl_mpio( plist_id, H5FD_MPIO_COLLECTIVE ); hdf5_status_check( status ); subset_dims[0] = particles.size(); subset_offset[0] = data_offset_for_each_process_for_1d_dataset(); // check is necessary for old hdf5 versions if ( subset_dims[0] != 0 ){ memspace = H5Screate_simple( rank, subset_dims, NULL ); hdf5_status_check( memspace ); filespace = H5Screate_simple( rank, dims, NULL ); hdf5_status_check( filespace ); } else { hsize_t max_dims[rank]; max_dims[0] = H5S_UNLIMITED; memspace = H5Screate_simple( rank, subset_dims, max_dims ); hdf5_status_check( memspace ); filespace = H5Screate_simple( rank, dims, NULL ); hdf5_status_check( filespace ); } status = H5Sselect_hyperslab( filespace, H5S_SELECT_SET, subset_offset, NULL, subset_dims, NULL ); hdf5_status_check( status ); dset = H5Dcreate( current_source_group_id, "./particle_id", H5T_STD_I32BE, filespace, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT ); hdf5_status_check( dset ); status = H5Dwrite( dset, H5T_NATIVE_INT, memspace, filespace, plist_id, id_buf ); hdf5_status_check( status ); status = H5Dclose( dset ); hdf5_status_check( status ); dset = H5Dcreate( current_source_group_id, "./position_x", H5T_IEEE_F64BE, filespace, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT ); hdf5_status_check( dset ); status = H5Dwrite( dset, H5T_NATIVE_DOUBLE, memspace, filespace, plist_id, x_buf ); hdf5_status_check( status ); status = H5Dclose( dset ); hdf5_status_check( status ); dset = H5Dcreate( current_source_group_id, "./position_y", H5T_IEEE_F64BE, filespace, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT ); hdf5_status_check( dset ); status = H5Dwrite( dset, H5T_NATIVE_DOUBLE, memspace, filespace, plist_id, y_buf ); hdf5_status_check( status ); status = H5Dclose( dset ); hdf5_status_check( status ); dset = H5Dcreate( current_source_group_id, "./position_z", H5T_IEEE_F64BE, filespace, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT ); hdf5_status_check( dset ); status = H5Dwrite( dset, H5T_NATIVE_DOUBLE, memspace, filespace, plist_id, z_buf ); hdf5_status_check( status ); status = H5Dclose( dset ); hdf5_status_check( status ); dset = H5Dcreate( current_source_group_id, "./momentum_x", H5T_IEEE_F64BE, filespace, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT ); hdf5_status_check( dset ); status = H5Dwrite( dset, H5T_NATIVE_DOUBLE, memspace, filespace, plist_id, px_buf ); hdf5_status_check( status ); status = H5Dclose( dset ); hdf5_status_check( status ); dset = H5Dcreate( current_source_group_id, "./momentum_y", H5T_IEEE_F64BE, filespace, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT ); hdf5_status_check( dset ); status = H5Dwrite( dset, H5T_NATIVE_DOUBLE, memspace, filespace, plist_id, py_buf ); hdf5_status_check( status ); status = H5Dclose( dset ); hdf5_status_check( status ); dset = H5Dcreate( current_source_group_id, "./momentum_z", H5T_IEEE_F64BE, filespace, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT ); hdf5_status_check( dset ); status = H5Dwrite( dset, H5T_NATIVE_DOUBLE, memspace, filespace, plist_id, pz_buf ); hdf5_status_check( status ); status = H5Dclose( dset ); hdf5_status_check( status ); dset = H5Dcreate( current_source_group_id, "./particle_mpi_proc", H5T_STD_I32BE, filespace, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT ); hdf5_status_check( dset ); status = H5Dwrite( dset, H5T_NATIVE_INT, memspace, filespace, plist_id, mpi_proc_buf ); hdf5_status_check( status ); status = H5Dclose( dset ); hdf5_status_check( status ); status = H5Sclose( filespace ); hdf5_status_check( status ); status = H5Sclose( memspace ); hdf5_status_check( status ); status = H5Pclose( plist_id ); hdf5_status_check( status ); delete[] id_buf; delete[] x_buf; delete[] y_buf; delete[] z_buf; delete[] px_buf; delete[] py_buf; delete[] pz_buf; delete[] mpi_proc_buf; }
////////////////////////////////////////////////////////////////////////////////////////// //HaloTrees Append Datasets Group// ////////////////////////////////////////////////////////////////////////////////////////// void HaloTreesGroupDataAppend(hid_t file_out_hdf5, MergerTree **halo, int tree_levels, int nb_nodes) { int i, j, count; int rank, nb_elements; int *nodeIndex, *nodeHost, *nodeDescendent; hid_t dataset, dataspace, cparams, filespace; hsize_t newdims[1], finaldims[1], newdims2[2], finaldims2[2], offset[1], offset2[2]; newdims[0] = nb_nodes; newdims2[0] = nb_nodes; newdims2[1] = 3; double *time, *expansionFactor, *redshift; double *nodeMass; double nodePosition[nb_nodes][3], nodeVelocity[nb_nodes][3]; //for some reason dynamic memory allocation doesn't work with hdf5 2D datasets nodeIndex = (int *)malloc(nb_nodes*sizeof(int)); nodeDescendent = (int *)malloc(nb_nodes*sizeof(int)); nodeMass = (double *)malloc(nb_nodes*sizeof(double)); expansionFactor = (double *)malloc(nb_nodes*sizeof(double)); redshift = (double *)malloc(nb_nodes*sizeof(double)); time = (double *)malloc(nb_nodes*sizeof(double)); for(i = 0, count = 0; i < tree_levels; i++) for(j = 0; j < halo[i][0].snapshot.nb_halos; j++) { nodeIndex[count] = halo[i][j].idAlias; nodeMass[count] = halo[i][j].mvir; nodeDescendent[count] = halo[i][j].son_idAlias; expansionFactor[count] = halo[i][j].sfactor; time[count] = halo[i][j].age; redshift[count] = 1.0/halo[i][j].sfactor - 1.0; nodePosition[count][0] = halo[i][j].position[0]; nodePosition[count][1] = halo[i][j].position[1]; nodePosition[count][2] = halo[i][j].position[2]; count++; } /* hostIndex Dataset */ dataset = H5Dopen (file_out_hdf5, "/haloTrees/hostIndex", H5P_DEFAULT); filespace = H5Dget_space (dataset); rank = H5Sget_simple_extent_ndims (filespace); nb_elements = H5Sget_simple_extent_npoints( filespace ); finaldims[0] = nb_elements+10;// + nb_nodes-1000; finaldims2[0] = nb_elements + nb_nodes; finaldims2[1] = 3; offset[0] = nb_elements; offset2[0] = nb_elements; offset2[1] = 0; printf("finaldims:%d\n",(int)finaldims[0]); H5Dextend(dataset, finaldims); filespace = H5Dget_space( dataset ); H5Sselect_hyperslab (filespace, H5S_SELECT_SET, offset, NULL, newdims, NULL); dataspace = H5Screate_simple (1, newdims, NULL); //H5Dwrite (dataset, H5T_NATIVE_INT, dataspace, filespace, H5P_DEFAULT, nodeIndex); H5Sclose(dataspace); H5Sclose(filespace); H5Dclose(dataset); /* nodeIndex Dataset */ /* dataset = H5Dopen (file_out_hdf5, "/haloTrees/nodeIndex", H5P_DEFAULT); */ /* H5Dextend(dataset, finaldims); */ /* filespace = H5Dget_space( dataset ); */ /* H5Sselect_hyperslab (filespace, H5S_SELECT_SET, offset, NULL, newdims, NULL); */ /* dataspace = H5Screate_simple (1, newdims, NULL); */ /* H5Dwrite (dataset, H5T_NATIVE_INT, dataspace, filespace, H5P_DEFAULT, nodeIndex); */ /* H5Sclose(dataspace); */ /* H5Dclose(filespace); */ /* H5Dclose(dataset); */ /* descendentIndex Dataset*/ /* dataset = H5Dopen (file_out_hdf5, "/haloTrees/descendentIndex", H5P_DEFAULT); */ /* H5Dextend(dataset, finaldims); */ /* filespace = H5Dget_space( dataset ); */ /* H5Sselect_hyperslab (filespace, H5S_SELECT_SET, offset, NULL, newdims, NULL); */ /* dataspace = H5Screate_simple (1, newdims, NULL); */ /* H5Dwrite (dataset, H5T_NATIVE_INT, dataspace, filespace, H5P_DEFAULT, nodeDescendent); */ /* H5Sclose(dataspace); */ /* H5Dclose(filespace); */ /* H5Dclose(dataset); */ /* nodeMass Dataset*/ /* dataset = H5Dopen (file_out_hdf5, "/haloTrees/nodeMass", H5P_DEFAULT); */ /* H5Dextend(dataset, finaldims); */ /* filespace = H5Dget_space( dataset ); */ /* H5Sselect_hyperslab (filespace, H5S_SELECT_SET, offset, NULL, newdims, NULL); */ /* dataspace = H5Screate_simple (1, newdims, NULL); */ /* H5Dwrite (dataset, H5T_NATIVE_DOUBLE, dataspace, filespace, H5P_DEFAULT, nodeMass); */ /* H5Sclose(dataspace); */ /* H5Dclose(filespace); */ /* H5Dclose(dataset); */ /* /\* exapansionFactor Dataset*\/ */ /* dataset = H5Dopen (file_out_hdf5, "/haloTrees/exapansionFactor", H5P_DEFAULT); */ /* H5Dextend(dataset, finaldims); */ /* filespace = H5Dget_space( dataset ); */ /* H5Sselect_hyperslab (filespace, H5S_SELECT_SET, offset, NULL, newdims, NULL); */ /* dataspace = H5Screate_simple (1, newdims, NULL); */ /* H5Dwrite (dataset, H5T_NATIVE_DOUBLE, dataspace, filespace, H5P_DEFAULT, expansionFactor); */ /* H5Sclose(dataspace); */ /* H5Dclose(filespace); */ /* H5Dclose(dataset); */ /* /\* redshift Dataset *\/ */ /* dataset = H5Dopen (file_out_hdf5, "/haloTrees/redshift", H5P_DEFAULT); */ /* H5Dextend(dataset, finaldims); */ /* filespace = H5Dget_space( dataset ); */ /* H5Sselect_hyperslab (filespace, H5S_SELECT_SET, offset, NULL, newdims, NULL); */ /* dataspace = H5Screate_simple (1, newdims, NULL); */ /* H5Dwrite (dataset, H5T_NATIVE_DOUBLE, dataspace, filespace, H5P_DEFAULT, redshift); */ /* H5Sclose(dataspace); */ /* H5Dclose(filespace); */ /* H5Dclose(dataset); */ /* /\* time Dataset *\/ */ /* dataset = H5Dopen (file_out_hdf5, "/haloTrees/time", H5P_DEFAULT); */ /* H5Dextend(dataset, finaldims); */ /* filespace = H5Dget_space( dataset ); */ /* H5Sselect_hyperslab (filespace, H5S_SELECT_SET, offset, NULL, newdims, NULL); */ /* dataspace = H5Screate_simple (1, newdims, NULL); */ /* H5Dwrite (dataset, H5T_NATIVE_DOUBLE, dataspace, filespace, H5P_DEFAULT, time); */ /* H5Sclose(dataspace); */ /* H5Dclose(filespace); */ /* H5Dclose(dataset); */ /* /\* position Dataset *\/ */ /* dataset = H5Dopen (file_out_hdf5, "/haloTrees/position", H5P_DEFAULT); */ /* H5Dextend(dataset, finaldims2); */ /* filespace = H5Dget_space( dataset ); */ /* H5Sselect_hyperslab (filespace, H5S_SELECT_SET, offset2, NULL, newdims2, NULL); */ /* dataspace = H5Screate_simple (2, newdims2, NULL); */ /* H5Dwrite (dataset, H5T_NATIVE_DOUBLE, dataspace, filespace, H5P_DEFAULT, nodePosition); */ /* H5Sclose(dataspace); */ /* H5Dclose(filespace); */ /* H5Dclose(dataset); */ /* velocity Dataset */ //not used by Galacticus yet! /* dataspace = H5Screate_simple(2, dims2, maxdims2); */ /* cparams = H5Pcreate (H5P_DATASET_CREATE); */ /* H5Pset_chunk ( cparams, 2, chunk_dims2); */ /* dataset = H5Dcreate(file_out_hdf5, "/haloTrees/velocity", H5T_IEEE_F64LE, dataspace, H5P_DEFAULT, cparams, H5P_DEFAULT); */ /* H5Dwrite( dataset, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL, H5P_DEFAULT, nodeVelocity); */ /* H5Pclose(cparams); */ /* H5Sclose(dataspace); */ /* H5Dclose(dataset); */ }
static void gent_ub(const char * filename, size_t ub_size, size_t ub_fill) { hid_t fid, group, attr, dataset, space; hid_t create_plist; hsize_t dims[2]; int data[2][2], dset1[10][10], dset2[20]; char buf[BUF_SIZE]; int i, j; size_t u; float dset2_1[10], dset2_2[3][5]; int fd; char *bp; if(ub_size > 0) { create_plist = H5Pcreate(H5P_FILE_CREATE); H5Pset_userblock(create_plist, (hsize_t)ub_size); fid = H5Fcreate(filename, H5F_ACC_TRUNC, create_plist, H5P_DEFAULT); } else { fid = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT); } /* create groups */ group = H5Gcreate2(fid, "/g1", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT); H5Gclose(group); group = H5Gcreate2(fid, "/g2", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT); H5Gclose(group); group = H5Gcreate2(fid, "/g1/g1.1", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT); H5Gclose(group); group = H5Gcreate2(fid, "/g1/g1.2", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT); H5Gclose(group); group = H5Gcreate2(fid, "/g1/g1.2/g1.2.1", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT); H5Gclose(group); /* root attributes */ group = H5Gopen2(fid, "/", H5P_DEFAULT); dims[0] = 10; space = H5Screate_simple(1, dims, NULL); attr = H5Acreate2(group, "attr1", H5T_STD_I8BE, space, H5P_DEFAULT, H5P_DEFAULT); sprintf(buf, "abcdefghi"); H5Awrite(attr, H5T_NATIVE_SCHAR, buf); H5Sclose(space); H5Aclose(attr); dims[0] = 2; dims[1] = 2; space = H5Screate_simple(2, dims, NULL); attr = H5Acreate2(group, "attr2", H5T_STD_I32BE, space, H5P_DEFAULT, H5P_DEFAULT); data[0][0] = 0; data[0][1] = 1; data[1][0] = 2; data[1][1] = 3; H5Awrite(attr, H5T_NATIVE_INT, data); H5Sclose(space); H5Aclose(attr); H5Gclose(group); group = H5Gopen2(fid, "/g1/g1.1", H5P_DEFAULT); /* dset1.1.1 */ dims[0] = 10; dims[1] = 10; space = H5Screate_simple(2, dims, NULL); dataset = H5Dcreate2(group, "dset1.1.1", H5T_STD_I32BE, space, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT); for (i = 0; i < 10; i++) for (j = 0; j < 10; j++) dset1[i][j] = j*i; H5Dwrite(dataset, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, dset1); H5Sclose(space); /* attributes of dset1.1.1 */ dims[0] = 27; space = H5Screate_simple(1, dims, NULL); attr = H5Acreate2(dataset, "attr1", H5T_STD_I8BE, space, H5P_DEFAULT, H5P_DEFAULT); sprintf(buf, "1st attribute of dset1.1.1"); H5Awrite(attr, H5T_NATIVE_SCHAR, buf); H5Sclose(space); H5Aclose(attr); dims[0] = 27; space = H5Screate_simple(1, dims, NULL); attr = H5Acreate2(dataset, "attr2", H5T_STD_I8BE, space, H5P_DEFAULT, H5P_DEFAULT); sprintf(buf, "2nd attribute of dset1.1.1"); H5Awrite(attr, H5T_NATIVE_SCHAR, buf); H5Sclose(space); H5Aclose(attr); H5Dclose(dataset); /* dset1.1.2 */ dims[0] = 20; space = H5Screate_simple(1, dims, NULL); dataset = H5Dcreate2(group, "dset1.1.2", H5T_STD_I32BE, space, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT); for (i = 0; i < 20; i++) dset2[i] = i; H5Dwrite(dataset, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, dset2); H5Sclose(space); H5Dclose(dataset); H5Gclose(group); /* external link */ H5Lcreate_external("somefile", "somepath", fid, "/g1/g1.2/extlink", H5P_DEFAULT, H5P_DEFAULT); /* soft link */ group = H5Gopen2(fid, "/g1/g1.2/g1.2.1", H5P_DEFAULT); H5Lcreate_soft("somevalue", group, "slink", H5P_DEFAULT, H5P_DEFAULT); H5Gclose(group); group = H5Gopen2(fid, "/g2", H5P_DEFAULT); /* dset2.1 */ dims[0] = 10; space = H5Screate_simple(1, dims, NULL); dataset = H5Dcreate2(group, "dset2.1", H5T_IEEE_F32BE, space, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT); for (i = 0; i < 10; i++) dset2_1[i] = (float)(i*0.1F+1); H5Dwrite(dataset, H5T_NATIVE_FLOAT, H5S_ALL, H5S_ALL, H5P_DEFAULT, dset2_1); H5Sclose(space); H5Dclose(dataset); /* dset2.2 */ dims[0] = 3; dims[1] = 5; space = H5Screate_simple(2, dims, NULL); dataset = H5Dcreate2(group, "dset2.2", H5T_IEEE_F32BE, space, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT); for (i = 0; i < 3; i++) for (j = 0; j < 5; j++) dset2_2[i][j] = (float)((i+1)*j*0.1F); H5Dwrite(dataset, H5T_NATIVE_FLOAT, H5S_ALL, H5S_ALL, H5P_DEFAULT, dset2_2); H5Sclose(space); H5Dclose(dataset); H5Gclose(group); /* user-defined link */ H5Lregister(UD_link_class); H5Lcreate_ud(fid, "/g2/udlink", (H5L_type_t)MY_LINKCLASS, NULL, (size_t)0, H5P_DEFAULT, H5P_DEFAULT); H5Fclose(fid); /* If a user block is being used, write to it here */ if(ub_size > 0) { HDassert(ub_size <= BUF_SIZE); fd = HDopen(filename, O_RDWR, 0); HDassert(fd >= 0); /* fill buf with pattern */ HDmemset(buf, '\0', ub_size); bp = buf; for (u = 0; u < ub_fill; u++) *bp++ = pattern[u % 10]; HDwrite(fd, buf, ub_size); HDclose(fd); } }
int main (void) { hid_t file, space, dtype, dset, attr; /* Handles */ herr_t status; hsize_t dims[1] = {DIM0}; size_t len; char wdata[DIM0*LEN], /* Write buffer */ *rdata, /* Read buffer */ str[LEN] = "OPAQUE", *tag; int ndims, i, j; /* * Initialize data. */ for (i=0; i<DIM0; i++) { for (j=0; j<LEN-1; j++) wdata[j + i * LEN] = str[j]; wdata[LEN - 1 + i * LEN] = (char) i + '0'; } /* * Create a new file using the default properties. */ file = H5Fcreate (FILE, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT); /* * Create dataset with a null dataspace. */ space = H5Screate (H5S_NULL); dset = H5Dcreate (file, DATASET, H5T_STD_I32LE, space, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT); status = H5Sclose (space); /* * Create opaque datatype and set the tag to something appropriate. * For this example we will write and view the data as a character * array. */ dtype = H5Tcreate (H5T_OPAQUE, LEN); status = H5Tset_tag (dtype, "Character array"); /* * Create dataspace. Setting maximum size to NULL sets the maximum * size to be the current size. */ space = H5Screate_simple (1, dims, NULL); /* * Create the attribute and write the opaque data to it. */ attr = H5Acreate (dset, ATTRIBUTE, dtype, space, H5P_DEFAULT, H5P_DEFAULT); status = H5Awrite (attr, dtype, wdata); /* * Close and release resources. */ status = H5Aclose (attr); status = H5Dclose (dset); status = H5Sclose (space); status = H5Tclose (dtype); status = H5Fclose (file); /* * Now we begin the read section of this example. Here we assume * the attribute has the same name and rank, but can have any size. * Therefore we must allocate a new array to read in data using * malloc(). */ /* * Open file, dataset, and attribute. */ file = H5Fopen (FILE, H5F_ACC_RDONLY, H5P_DEFAULT); dset = H5Dopen (file, DATASET, H5P_DEFAULT); attr = H5Aopen (dset, ATTRIBUTE, H5P_DEFAULT); /* * Get datatype and properties for the datatype. Note that H5Tget_tag * allocates space for the string in tag, so we must remember to free() it * later. */ dtype = H5Aget_type (attr); len = H5Tget_size (dtype); tag = H5Tget_tag (dtype); /* * Get dataspace and allocate memory for read buffer. */ space = H5Aget_space (attr); ndims = H5Sget_simple_extent_dims (space, dims, NULL); rdata = (char *) malloc (dims[0] * len); /* * Read the data. */ status = H5Aread (attr, dtype, rdata); /* * Output the data to the screen. */ printf ("Datatype tag for %s is: \"%s\"\n", ATTRIBUTE, tag); for (i=0; i<dims[0]; i++) { printf ("%s[%u]: ",ATTRIBUTE,i); for (j=0; j<len; j++) printf ("%c", rdata[j + i * len]); printf ("\n"); } /* * Close and release resources. */ free (rdata); free (tag); status = H5Aclose (attr); status = H5Dclose (dset); status = H5Sclose (space); status = H5Tclose (dtype); status = H5Fclose (file); return 0; }
/*------------------------------------------------------------------------- * Function: gen_region_ref * * Purpose: Generate dataset region references * * Programmer: Jonathan Kim (Feb 23, 2010) *------------------------------------------------------------------------*/ static herr_t gen_region_ref(hid_t loc_id) { hid_t sid=0, oid1=0, oid2=0; int status; herr_t ret = SUCCEED; char data[3][16] = {"The quick brown", "fox jumps over ", "the 5 lazy dogs"}; hsize_t dims2[2] = {3,16}; hsize_t coords[4][2] = { {0,1}, {2,11}, {1,0}, {2,4} }; hdset_reg_ref_t rr_data[2]; hsize_t start[2] = {0,0}; hsize_t stride[2] = {2,11}; hsize_t count[2] = {2,2}; hsize_t block[2] = {1,3}; hsize_t dims1[1] = {2}; sid = H5Screate_simple (2, dims2, NULL); if (sid < 0) { fprintf(stderr, "Error: %s %d> H5Screate_simple failed.\n", FUNC, __LINE__); ret = FAIL; goto out; } /* create normal dataset which is refered */ oid2 = H5Dcreate2 (loc_id, REG_REF_DS2, H5T_STD_I8LE, sid, H5P_DEFAULT,H5P_DEFAULT,H5P_DEFAULT); if (oid2 < 0) { fprintf(stderr, "Error: %s %d> H5Dcreate2 failed.\n", FUNC, __LINE__); ret = FAIL; goto out; } /* write values to dataset */ status = H5Dwrite (oid2, H5T_NATIVE_CHAR, H5S_ALL, H5S_ALL, H5P_DEFAULT, data); if (status < 0) { fprintf(stderr, "Error: %s %d> H5Dwrite failed.\n", FUNC, __LINE__); ret = FAIL; goto out; } /* select elements space for reference */ status = H5Sselect_elements (sid, H5S_SELECT_SET, 4, coords[0]); if (status < 0) { fprintf(stderr, "Error: %s %d> H5Sselect_elements failed.\n", FUNC, __LINE__); ret = FAIL; goto out; } /* create region reference from elements space */ status = H5Rcreate (&rr_data[0], loc_id, REG_REF_DS2, H5R_DATASET_REGION, sid); if (status < 0) { fprintf(stderr, "Error: %s %d> H5Rcreate failed.\n", FUNC, __LINE__); ret = FAIL; goto out; } /* select hyperslab space for reference */ status = H5Sselect_hyperslab (sid, H5S_SELECT_SET, start, stride, count, block); if (status < 0) { fprintf(stderr, "Error: %s %d> H5Sselect_hyperslab failed.\n", FUNC, __LINE__); ret = FAIL; goto out; } /* create region reference from hyperslab space */ status = H5Rcreate (&rr_data[1], loc_id, REG_REF_DS2, H5R_DATASET_REGION, sid); if (status < 0) { fprintf(stderr, "Error: %s %d> H5Rcreate failed.\n", FUNC, __LINE__); ret = FAIL; goto out; } H5Sclose (sid); /* Create dataspace. */ sid = H5Screate_simple (1, dims1, NULL); if (sid < 0) { fprintf(stderr, "Error: %s %d> H5Screate_simple failed.\n", FUNC, __LINE__); ret = FAIL; goto out; } /* create region reference dataset */ oid1 = H5Dcreate2 (loc_id, REG_REF_DS1, H5T_STD_REF_DSETREG, sid, H5P_DEFAULT,H5P_DEFAULT,H5P_DEFAULT); if (oid1 < 0) { fprintf(stderr, "Error: %s %d> H5Dcreate2 failed.\n", FUNC, __LINE__); ret = FAIL; goto out; } /* write data as region references */ status = H5Dwrite (oid1, H5T_STD_REF_DSETREG, H5S_ALL, H5S_ALL, H5P_DEFAULT, rr_data); if (status < 0) { fprintf(stderr, "Error: %s %d> H5Dwrite failed.\n", FUNC, __LINE__); ret = FAIL; goto out; } out: if (oid1 > 0) H5Dclose (oid1); if (oid2 > 0) H5Dclose (oid2); if (sid > 0) H5Sclose (sid); return ret; }
/*------------------------------------------------------------------------- * Function: gen_obj_ref * * Purpose: Generate object references to dataset and group * * Programmer: Jonathan Kim (Feb 23, 2010) *------------------------------------------------------------------------*/ static herr_t gen_obj_ref(hid_t loc_id) { hid_t sid=0, oid=0; hsize_t dims1[1]={3}; hsize_t dims2[1]={2}; int data[3] = {10,20,30}; int status; /*--------------------- * create obj references to the previously created objects. * Passing -1 as reference is an object.*/ hobj_ref_t or_data[2]; /* write buffer */ herr_t ret = SUCCEED; /*-------------- * add dataset */ sid = H5Screate_simple(1, dims1, NULL); if (sid < 0) { fprintf(stderr, "Error: %s %d> H5Screate_simple failed.\n", FUNC, __LINE__); ret = FAIL; goto out; } oid = H5Dcreate2 (loc_id, OBJ_REF_DS, H5T_NATIVE_INT, sid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT); if (oid < 0) { fprintf(stderr, "Error: %s %d> H5Dcreate2 failed.\n", FUNC, __LINE__); ret = FAIL; goto out; } status = H5Dwrite(oid, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, data); if (status < 0) { fprintf(stderr, "Error: %s %d> H5Dwrite failed.\n", FUNC, __LINE__); ret = FAIL; goto out; } H5Dclose(oid); H5Sclose(sid); /*-------------- * add group */ oid = H5Gcreate2 (loc_id, OBJ_REF_GRP, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT); if (oid < 0) { fprintf(stderr, "Error: %s %d> H5Gcreate2 failed.\n", FUNC, __LINE__); ret = FAIL; goto out; } H5Gclose(oid); status = H5Rcreate (&or_data[0], loc_id, OBJ_REF_DS, H5R_OBJECT, -1); if (status < 0) { fprintf(stderr, "Error: %s %d> H5Rcreate failed.\n", FUNC, __LINE__); ret = FAIL; goto out; } status = H5Rcreate (&or_data[1], loc_id, OBJ_REF_GRP, H5R_OBJECT, -1); if (status < 0) { fprintf(stderr, "Error: %s %d> H5Rcreate failed.\n", FUNC, __LINE__); ret = FAIL; goto out; } sid = H5Screate_simple (1, dims2, NULL); if (sid < 0) { fprintf(stderr, "Error: %s %d> H5Screate_simple failed.\n", FUNC, __LINE__); ret = FAIL; goto out; } oid = H5Dcreate2 (loc_id, "Dset_OBJREF", H5T_STD_REF_OBJ, sid, H5P_DEFAULT,H5P_DEFAULT,H5P_DEFAULT); if (oid < 0) { fprintf(stderr, "Error: %s %d> H5Dcreate2 failed.\n", FUNC, __LINE__); ret = FAIL; goto out; } status = H5Dwrite(oid, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, or_data); if (status < 0) { fprintf(stderr, "Error: %s %d> H5Dwrite failed.\n", FUNC, __LINE__); ret = FAIL; goto out; } out: if(oid > 0) H5Dclose(oid); if(sid > 0) H5Sclose(sid); return ret; }