/*------------------------------------------------------------------------- * test_append * * Tests appending packets to a FL packet table * *------------------------------------------------------------------------- */ static int test_append(hid_t fid) { herr_t err; hid_t table; hsize_t count; TESTING("H5PTappend"); /* Open the table */ table = H5PTopen(fid, PT_NAME); if( H5PTis_valid(table) < 0) goto out; /* Count the number of packets in the table */ err = H5PTget_num_packets(table, &count); if( err < 0) goto out; /* There should be 0 records in the table */ if( count != 0 ) goto out; /* Append one particle */ err = H5PTappend(table, (size_t)1, &(testPart[0])); if( err < 0) goto out; /* Append several particles */ err = H5PTappend(table, (size_t)6, &(testPart[1])); if( err < 0) goto out; /* Append one more particle */ err = H5PTappend(table, (size_t)1, &(testPart[7])); if( err < 0) goto out; /* Count the number of packets in the table */ err = H5PTget_num_packets(table, &count); if( err < 0) goto out; /* There should be 8 records in the table now */ if( count != 8 ) goto out; /* Close the table */ err = H5PTclose(table); if( err < 0) goto out; PASSED(); return 0; out: H5_FAILED(); if( H5PTis_valid(table) < 0) H5PTclose(table); return -1; }
AccessTraceReader::AccessTraceReader(std::string _fname) : fname(_fname.c_str()) { hid_t fid = H5Fopen(fname.c_str(), H5F_ACC_RDONLY, H5P_DEFAULT); if (fid == H5I_INVALID_HID) panic("Could not open HDF5 file %s", fname.c_str()); // Check that the trace finished hid_t fAttr = H5Aopen(fid, "finished", H5P_DEFAULT); uint32_t finished; H5Aread(fAttr, H5T_NATIVE_UINT, &finished); H5Aclose(fAttr); if (!finished) panic("Trace file %s unfinished (halted simulation?)", fname.c_str()); // Populate numRecords & numChildren hsize_t nPackets; hid_t table = H5PTopen(fid, "accs"); if (table == H5I_INVALID_HID) panic("Could not open HDF5 packet table"); H5PTget_num_packets(table, &nPackets); numRecords = nPackets; hid_t ncAttr = H5Aopen(fid, "numChildren", H5P_DEFAULT); H5Aread(ncAttr, H5T_NATIVE_UINT, &numChildren); H5Aclose(ncAttr); curFrameRecord = 0; cur = 0; max = MIN(PT_CHUNKSIZE, numRecords); buf = max? gm_calloc<PackedAccessRecord>(max) : nullptr; if (max) { H5PTread_packets(table, 0, max, buf); } H5PTclose(table); H5Fclose(fid); }
/* GetPacketCount * Returns the number of packets in the packet table. Error * is set to 0 on success. On failure, returns 0 and * error is set to negative. */ hsize_t PacketTable::GetPacketCount(int& error) { hsize_t npackets; error = H5PTget_num_packets( table_id, (hsize_t *)&npackets); return npackets; }
/*+++++++++++++++++++++++++ .IDENTifer SDMF_rd_pt_metaTable .PURPOSE read metaTable records from SDMF last-limb/Sun databases .INPUT/OUTPUT call as SDMF_rd_pt_metaTable( locID, &numIndx, metaIndx, &mtbl ); input: hid_t locID : HDF5 identifier of group size_t *metaIndx : array with requested indices in/output: size_t *numIndx : [input] dimension of metaIndx (or zero) [output] number of records read output: struct mtbl_pt_rec **mtbl : last-limb/Sun meta-table records .RETURNS nothing, error status passed by global variable ``nadc_stat'' .COMMENTS static function -------------------------*/ void SDMF_rd_pt_metaTable( hid_t locID, size_t *numIndx, size_t *metaIndx, struct mtbl_pt_rec **mtbl_out ) { register size_t nr; hid_t ptable; hsize_t nrecords; struct mtbl_pt_rec *mtbl; /* * initialize return values */ if ( ! Use_Extern_Alloc ) *mtbl_out = NULL; /* * does the table already exists? */ if ( (ptable = H5PTopen( locID, "metaTable" )) == H5I_BADID ) return; /* * obtain table info */ (void) H5PTget_num_packets( ptable, &nrecords ); if ( *numIndx == 0 ) { *numIndx = (size_t) nrecords; for ( nr = 0; nr < nrecords; nr++ ) metaIndx[nr] = nr; } if ( nrecords == 0 ) { (void) H5PTclose( ptable ); return; } /* * allocate memory to store the metaTable records */ if ( ! Use_Extern_Alloc ) { mtbl = (struct mtbl_pt_rec *) malloc( (size_t) nrecords * sizeof(struct mtbl_pt_rec)); if ( mtbl == NULL ) NADC_RETURN_ERROR( NADC_ERR_ALLOC, "mtbl" ); } else if ( (mtbl = mtbl_out[0]) == NULL ) NADC_RETURN_ERROR( NADC_ERR_ALLOC, "mtbl_out[0]" ); /* * read table records */ if ( (*numIndx) == (size_t) nrecords ) { (void) H5PTread_packets( ptable, 0, (size_t) nrecords, mtbl ); } else { nr = 0; do { (void) H5PTread_packets( ptable, (hsize_t) metaIndx[nr], 1, mtbl+nr ); } while ( ++nr < (*numIndx) ); } *mtbl_out = mtbl; }
/*+++++++++++++++++++++++++ .IDENTifer SDMF_get_pt_orbitIndex .PURPOSE obtain indices to last-limb/Sun records for given orbit number .INPUT/OUTPUT call as SDMF_get_pt_orbitIndex( locID, absOrbit, &numIndx, metaIndx ); input: hid_t locID : HDF5 identifier of group int absOrbit : orbit number in/output: size_t *numIndx : [input] dimension of metaIndx [output] number of indices found output: size_t *metaIndx : array with requested indices .RETURNS nothing, error status passed by global variable ``nadc_stat'' .COMMENTS static function -------------------------*/ void SDMF_get_pt_orbitIndex( hid_t locID, int absOrbit, size_t *numIndx, size_t *metaIndx ) { const size_t dimArray = *numIndx; register size_t nr; hid_t ptable; hsize_t nrecords; int *orbitList; /* * initialize return values */ *numIndx = 0; *metaIndx = 0; /* * check if orbitList exists */ if ( (ptable = H5PTopen( locID, "orbitList" )) == H5I_BADID ) NADC_RETURN_ERROR( NADC_ERR_HDF_DATA, "orbitList" ); (void) H5PTget_num_packets( ptable, &nrecords ); if ( nrecords == 0 ) { (void) H5PTclose( ptable ); return; } /* * read list of orbits stored sofar */ orbitList = (int *) malloc( (size_t) nrecords * sizeof(int) ); if ( orbitList == NULL ) NADC_GOTO_ERROR( NADC_ERR_ALLOC, "orbitList" ); (void) H5PTread_packets( ptable, 0, (size_t) nrecords, orbitList ); /* * find all matches */ for ( nr = 0; nr < (size_t) nrecords; nr++ ) { if ( orbitList[nr] == absOrbit ) { metaIndx[*numIndx] = nr; if ( ++(*numIndx) == dimArray ) break; } } free( orbitList ); done: (void) H5PTclose( ptable ); }
/*+++++++++++++++++++++++++ .IDENTifer SDMF_get_pt_jdayIndex .PURPOSE obtain indices to last-limb/Sun records for julianDay interval .INPUT/OUTPUT call as SDMF_get_pt_jdayIndex( locID, jdayRange, &numIndx, metaIndx ); input: hid_t locID : HDF5 identifier of group double jdayRange[2] : range in julianDay (min,max) in/output: size_t *numIndx : [input] dimension of metaIndx [output] number of indices found output: size_t *metaIndx : array with requested indices .RETURNS nothing, error status passed by global variable ``nadc_stat'' .COMMENTS static function -------------------------*/ void SDMF_get_pt_jdayIndex( hid_t locID, const double jdayRange[], size_t *numIndx, size_t *metaIndx ) { const size_t dimArray = *numIndx; register size_t nr; hid_t ptable; hsize_t nrecords; double *jdayList; /* * initialize return values */ *numIndx = 0; *metaIndx = 0; /* * check if jdayList exists */ if ( (ptable = H5PTopen( locID, "jdayList" )) == H5I_BADID ) NADC_RETURN_ERROR( NADC_ERR_HDF_DATA, "jdayList" ); (void) H5PTget_num_packets( ptable, &nrecords ); if ( nrecords == 0 ) { (void) H5PTclose( ptable ); return; } /* * read list of orbits stored sofar */ jdayList = (double *) malloc( (size_t) nrecords * sizeof(double) ); if ( jdayList == NULL ) NADC_GOTO_ERROR( NADC_ERR_ALLOC, "jdayList" ); (void) H5PTread_packets( ptable, 0, (size_t) nrecords, jdayList ); /* * find all matches */ for ( nr = 0; nr < (size_t) nrecords; nr++ ) { if ( jdayList[nr] >= jdayRange[0] && jdayList[nr] <= jdayRange[1] ) { metaIndx[*numIndx] = nr; if ( ++(*numIndx) == dimArray ) break; } } free( jdayList ); done: (void) H5PTclose( ptable ); }
void print_trial_info(hid_t trial,int num_trial) { char string_data[512]; hid_t string_type = H5Tcopy(H5T_C_S1); size_t string_size = 512; H5Tset_size(string_type,string_size); printf("Trial #%d\n",num_trial); hid_t data = H5Dopen(trial,"Date",H5P_DEFAULT); H5Dread(data,string_type,H5S_ALL,H5S_ALL,H5P_DEFAULT,string_data); H5Dclose(data); printf("\tDate: %s\n",string_data); data = H5Dopen(trial,"Synchronous Data/Channel Data",H5P_DEFAULT); hsize_t nchans = H5Tget_size(H5Dget_type(data))/sizeof(double); H5Dclose(data); data = H5PTopen(trial,"Synchronous Data/Channel Data"); hsize_t nsamples; H5PTget_num_packets(data,&nsamples); printf("\t%llu Channels X %llu samples\n",nchans,nsamples); for(int i=1;i<=nchans;++i) { std::stringstream channel_name; channel_name << "Synchronous Data/Channel " << i << " Name"; data = H5Dopen(trial,channel_name.str().c_str(),H5P_DEFAULT); H5Dread(data,string_type,H5S_ALL,H5S_ALL,H5P_DEFAULT,string_data); H5Dclose(data); printf("\t\t#%d: %s\n",i,string_data); } printf("\n"); }
/*+++++++++++++++++++++++++ .IDENTifer SDMF_rd_pt_pointing .PURPOSE read pointing infor for cluster records from SDMF database .INPUT/OUTPUT call as SDMF_rd_pt_pointing( locID, &numIndx, metaIndx, pointing ); input: hid_t locID : HDF5 identifier of group size_t *metaIndx : array with requested indices in/output: size_t *numIndx : [input] dimension of metaIndx (or zero) [output] number of records read output: struct geo_pt_rec *pointing : pointing of cluster records .RETURNS nothing, error status passed by global variable ``nadc_stat'' .COMMENTS static function -------------------------*/ void SDMF_rd_pt_pointing( hid_t locID, size_t *numIndx, size_t *metaIndx, struct geo_pt_rec *pointing ) { register size_t nr; unsigned short num_obs; hid_t ptable; hsize_t nrecords; /* * does the dataset already exists? */ if ( (ptable = H5PTopen( locID, "pointing" )) == H5I_BADID ) return; /* * obtain table info */ (void) H5PTget_num_packets( ptable, &nrecords ); if ( *numIndx == 0 ) { *numIndx = (size_t) nrecords; for ( nr = 0; nr < nrecords; nr++ ) metaIndx[nr] = nr; } if ( nrecords == 0 ) { (void) H5PTclose( ptable ); return; } (void) H5LTget_attribute_ushort( locID, "pointing", "numObs", &num_obs ); /* * read pointing records */ nr = 0; do { if ( nr > 0 ) pointing += num_obs; (void) H5PTread_packets( ptable, (hsize_t) metaIndx[nr], 1, pointing ); } while ( ++nr < (*numIndx) ); }
int main(void) { #ifdef VLPT_REMOVED hid_t fid; /* File identifier */ hid_t ptable; /* Packet table identifier */ herr_t err; /* Function return status */ hsize_t count; /* Number of records in the table */ int x; /* Loop variable */ /* Buffers to hold data */ hvl_t writeBuffer[5]; hvl_t readBuffer[5]; /* This example has two different sizes of "record": longs and shorts */ long longBuffer[5]; short shortBuffer[5]; /* Initialize buffers */ for(x=0; x<5; x++) { longBuffer[x] = -x; shortBuffer[x] = x; } /* Fill the write buffer with a mix of longs and shorts */ /* We need to supply the length of each record and a pointer to */ /* the beginning of each record. */ writeBuffer[0].len = sizeof(long); writeBuffer[0].p = &(longBuffer[0]); writeBuffer[1].len = sizeof(short); writeBuffer[1].p = &(shortBuffer[1]); writeBuffer[2].len = sizeof(long); writeBuffer[2].p = &(longBuffer[2]); writeBuffer[3].len = sizeof(long); writeBuffer[3].p = &(longBuffer[3]); writeBuffer[4].len = sizeof(short); writeBuffer[4].p = &(shortBuffer[4]); /* Create a file using default properties */ fid=H5Fcreate("packet_table_VLexample.h5",H5F_ACC_TRUNC,H5P_DEFAULT,H5P_DEFAULT); /* Create a variable-length packet table within the file */ ptable = H5PTcreate_vl(fid, "Packet Test Dataset", (hsize_t)1); if(ptable == H5I_INVALID_HID) goto out; /* Write the entire buffer to the packet table */ err = H5PTappend(ptable, (hsize_t)5, writeBuffer ); if(err < 0) goto out; /* Get the number of packets in the packet table. This should be five. */ err = H5PTget_num_packets(ptable, &count); if(err < 0) goto out; printf("Number of packets in packet table after five appends: %d\n", count); /* Read all five packets back */ err = H5PTread_packets(ptable, (hsize_t)0, (hsize_t)5, readBuffer ); if(err < 0) goto out; for(x=0; x<5; x++) { printf("Packet %d's length is %d\n", x, readBuffer[x].len); if(readBuffer[x].len == sizeof(long)) printf("Packet %d's value is %d\n", x, *( (long *) readBuffer[x].p) ); else printf("Packet %d's value is %d\n", x, *( (short *) readBuffer[x].p) ); } /* Before we close the packet table, we must free the memory that */ /* the pointers in readBuffer point to. */ err = H5PTfree_vlen_readbuff(ptable, (hsize_t)5, readBuffer); if(err < 0) goto out; /* Close the packet table */ err = H5PTclose(ptable); if(err < 0) goto out; /* Close the file */ H5Fclose(fid); #endif /* VLPT_REMOVED */ return 0; #ifdef VLPT_REMOVED out: /* An error has occurred. Clean up and exit. */ fprintf(stderr, "An error has occurred!\n"); H5PTclose(ptable); H5Fclose(fid); return -1; #endif /* VLPT_REMOVED */ }
/*------------------------------------------------------------------------- * test_rw_non-native_dt * * test reading and writing packet table using datatypes that are not * native. * *------------------------------------------------------------------------- */ static int test_rw_nonnative_dt(hid_t fid) { hid_t ptable; /* Packet table identifier */ herr_t err; /* Function return status */ hsize_t count; /* Number of records in the table */ int x; /* Loop variable */ /* Buffers to hold data */ int writeBuffer[5]; int readBuffer[5]; TESTING("reading/writing non-native packet table"); /* Initialize buffers */ for(x=0; x<5; x++) { writeBuffer[x]=x; readBuffer[x] = -1; } /* Create a fixed-length packet table within the file */ /* This table's "packets" will be simple integers and it will use no compression */ if(H5Tget_order(H5T_NATIVE_INT) == H5T_ORDER_LE) { ptable = H5PTcreate_fl(fid, "Packet Test Dataset, Non-native", H5T_STD_I32BE, (hsize_t)100, -1); } else { ptable = H5PTcreate_fl(fid, "Packet Test Dataset, Non-native", H5T_STD_I32LE, (hsize_t)100, -1); } if(ptable == H5I_INVALID_HID) goto out; /* Write one packet to the packet table */ if( (err = H5PTappend(ptable, (hsize_t)1, &(writeBuffer[0]))) < 0 ) goto out; /* Write several packets to the packet table */ if( (err = H5PTappend(ptable, (hsize_t)4, &(writeBuffer[1]))) < 0) goto out; if( (err = H5PTclose(ptable)) < 0) goto out; /* Open the Packet table */ if( (ptable = H5PTopen(fid, "Packet Test Dataset, Non-native")) < 0) goto out; /* Get the number of packets in the packet table. This should be five. */ if( (err = H5PTget_num_packets(ptable, &count)) < 0) goto out; if( (int)count != 5 ) goto out; /* Initialize packet table's "current record" */ if( (err = H5PTcreate_index(ptable)) < 0) goto out; /* Iterate through packets, read each one back */ for(x=0; x<5; x++) { if( (err = H5PTget_next(ptable, (hsize_t)1, &(readBuffer[x]))) < 0) goto out; if( x != readBuffer[x]) goto out; } /* Close the packet table */ if( (err = H5PTclose(ptable)) < 0) goto out; PASSED(); return 0; out: H5_FAILED(); if( H5PTis_valid(ptable) < 0) H5PTclose(ptable); return -1; }
/*------------------------------------------------------------------------- * test_compress * * Ensures that a FL packet table can be compressed. * This test creates a file named TEST_COMPRESS_FILE * *------------------------------------------------------------------------- */ static int test_compress(void) { hid_t fid1 = -1; herr_t err; hid_t table = -1; hid_t part_t = -1; hid_t dset_id = -1; hid_t plist_id = -1; size_t c; size_t num_elems = 1; unsigned filter_vals[1]; particle_t readPart[1]; hsize_t count; TESTING("packet table compression"); /* Create a file. */ if((fid1 = H5Fcreate(TEST_COMPRESS_FILE, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT)) < 0) TEST_ERROR; /* Create a datatype for the particle struct */ part_t = make_particle_type(); HDassert(part_t != -1); /* Create a new table with compression level 8 */ table = H5PTcreate_fl(fid1, "Compressed Test Dataset", part_t, (hsize_t)80, 8); if( H5PTis_valid(table) < 0) TEST_ERROR; /* We can now use this table exactly the same way we use a normal uncompressed * packet table, and it should pass the same tests. */ /* Add many particles */ for(c = 0; c < BIG_TABLE_SIZE ; c+=8) { /* Append eight particles at once*/ err = H5PTappend(table, (size_t)8, &(testPart[0])); if( err < 0) TEST_ERROR; } /* Count the number of packets in the table */ err = H5PTget_num_packets(table, &count); if( err < 0) TEST_ERROR; if( count != BIG_TABLE_SIZE ) TEST_ERROR; /* Read particles to ensure that all of them were written correctly */ HDmemset(readPart, 0, sizeof(readPart)); for(c = 0; c < BIG_TABLE_SIZE; c++) { err = H5PTget_next(table, 1, readPart); if(err < 0) TEST_ERROR; /* Ensure that particles were read correctly */ if( cmp_par(c % 8, 0, testPart, readPart) != 0) TEST_ERROR; } /* Close the table */ err = H5PTclose(table); if( err < 0) TEST_ERROR; /* Open the packet table as a regular dataset and make sure that the * compression filter is set. */ dset_id = H5Dopen2(fid1, "Compressed Test Dataset", H5P_DEFAULT); if( dset_id < 0) TEST_ERROR; plist_id = H5Dget_create_plist(dset_id); if( plist_id < 0) TEST_ERROR; err = H5Pget_filter_by_id2(plist_id, H5Z_FILTER_DEFLATE, NULL, &num_elems, filter_vals, 0, NULL, NULL); if( err < 0) TEST_ERROR; /* The compression level should be 8, the value we passed in */ if(filter_vals[0] != 8) TEST_ERROR; /* Clean up */ err = H5Pclose(plist_id); if( err < 0) TEST_ERROR; err = H5Dclose(dset_id); if( err < 0) TEST_ERROR; /* Create a new table without compression. */ table = H5PTcreate_fl(fid1, "Uncompressed Dataset", part_t, (hsize_t)80, -1); if(table < 0) TEST_ERROR; /* Close the packet table */ err = H5PTclose(table); if( err < 0) TEST_ERROR; /* Open the packet table as a regular dataset and make sure that the * compression filter is not set. */ dset_id = H5Dopen2(fid1, "Uncompressed Dataset", H5P_DEFAULT); if( dset_id < 0) TEST_ERROR; plist_id = H5Dget_create_plist(dset_id); if( plist_id < 0) TEST_ERROR; H5E_BEGIN_TRY { err = H5Pget_filter_by_id2(plist_id, H5Z_FILTER_DEFLATE, NULL, &num_elems, filter_vals, 0, NULL, NULL); if( err >= 0) TEST_ERROR; } H5E_END_TRY /* Clean up */ err = H5Pclose(plist_id); if( err < 0) TEST_ERROR; err = H5Dclose(dset_id); if( err < 0) TEST_ERROR; /* Close the datatype and the file */ err = H5Tclose(part_t); if( err < 0) TEST_ERROR; err = H5Fclose(fid1); if( err < 0) TEST_ERROR; PASSED(); return 0; error: H5E_BEGIN_TRY { H5Pclose(plist_id); H5Dclose(dset_id); H5Tclose(part_t); H5PTclose(table); H5Fclose(fid1); } H5E_END_TRY H5_FAILED(); return -1; }
/*------------------------------------------------------------------------- * test_varlen * * Tests creation, opening, closing, writing, reading, etc. on a * variable-length packet table. * *------------------------------------------------------------------------- */ static int test_varlen(hid_t fid) { herr_t err; hid_t table=H5I_BADID; hsize_t count; /* Buffers to hold data */ hvl_t writeBuffer[NRECORDS]; hvl_t readBuffer[NRECORDS]; /* This example has three different sizes of "record": longs, shorts, and particles */ long longBuffer[NRECORDS]; short shortBuffer[NRECORDS]; int x; TESTING("variable-length packet tables"); /* Initialize buffers */ for(x=0; x<NRECORDS; x++) { longBuffer[x] = -x; shortBuffer[x] = x; } /* Fill the write buffer with a mix of variable types */ for(x=0; x<8; x+=4) { writeBuffer[x].len = sizeof(long); writeBuffer[x].p = &(longBuffer[x]); writeBuffer[x+1].len = sizeof(short); writeBuffer[x+1].p = &(shortBuffer[x+1]); writeBuffer[x+2].len = sizeof(long); writeBuffer[x+2].p = &(longBuffer[x+2]); writeBuffer[x+3].len = sizeof(particle_t); writeBuffer[x+3].p = &(testPart[x+3]); } /* Create the table */ table = H5PTcreate_vl(fid, VL_TABLE_NAME, (hsize_t)1001); if( H5PTis_valid(table) < 0) goto out; if( H5PTis_varlen(table) != 1) goto out; /* Count the number of packets in the table */ err = H5PTget_num_packets(table, &count); if( err < 0) goto out; if( count != 0 ) goto out; /* Close the table */ err = H5PTclose(table); if( err < 0) goto out; /* Re-open the table */ table = H5PTopen(fid, VL_TABLE_NAME); if( H5PTis_valid(table) < 0) goto out; if( H5PTis_varlen(table) != 1) goto out; /* Count the number of packets in the table */ err = H5PTget_num_packets(table, &count); if( err < 0) goto out; if( count != 0 ) goto out; /* Add several variable-length packets */ err = H5PTappend(table, (size_t)8, writeBuffer ); if(err < 0) goto out; /* Read them back */ err = H5PTread_packets(table, (hsize_t)0, 4, &(readBuffer[0])); if( err < 0) goto out; err = H5PTread_packets(table, (hsize_t)4, 1, &(readBuffer[4])); if( err < 0) goto out; err = H5PTread_packets(table, (hsize_t)5, (NRECORDS - 5 ), &(readBuffer[5])); if( err < 0) goto out; /* Ensure that packets were read correctly */ for(x=0; x<NRECORDS; x++) { if( readBuffer[x].len != writeBuffer[x%4].len) goto out; switch(x%4) { case 0: case 2: if( *((long*)(readBuffer[x].p)) != *((long*)(writeBuffer[x].p))) goto out; break; case 1: if( *((short*)(readBuffer[x].p)) != *((short*)(writeBuffer[x].p))) goto out; break; case 3: if( cmp_par(0, 0, readBuffer[x].p, writeBuffer[x].p) < 0) goto out; break; default: goto out; } } /* Free memory used by read buffer */ if(H5PTfree_vlen_readbuff(table, NRECORDS, readBuffer) <0) goto out; /* Read packets back using get_next */ for(x=0; x < NRECORDS; x++) { err = H5PTget_next(table, 1, &readBuffer[x]); if(err < 0) goto out; } /* Ensure that packets were read correctly */ for(x=0; x<NRECORDS; x++) { if( readBuffer[x].len != writeBuffer[x%4].len) goto out; switch(x%4) { case 0: case 2: if( *((long*)(readBuffer[x].p)) != *((long*)(writeBuffer[x].p))) goto out; break; case 1: if( *((short*)(readBuffer[x].p)) != *((short*)(writeBuffer[x].p))) goto out; break; case 3: if( cmp_par(0, 0, readBuffer[x].p, writeBuffer[x].p) < 0) goto out; break; default: goto out; } } /* Free memory used by read buffer */ if(H5PTfree_vlen_readbuff(table, NRECORDS, readBuffer) <0) goto out; /* Close the table */ err = H5PTclose(table); if( err < 0) goto out; PASSED(); return 0; out: H5_FAILED(); H5E_BEGIN_TRY H5PTclose(table); H5E_END_TRY return -1; }
/*------------------------------------------------------------------------- * test_big_table * * Ensures that a FL packet table will not break when many (BIG_TABLE_SIZE) * packets are used. * *------------------------------------------------------------------------- */ static int test_big_table(hid_t fid) { herr_t err; hid_t table; hid_t part_t; size_t c; particle_t readPart; hsize_t count; TESTING("large packet table"); /* Create a datatype for the particle struct */ part_t = make_particle_type(); HDassert(part_t != -1); /* Create a new table */ table = H5PTcreate_fl(fid, "Packet Test Dataset2", part_t, (hsize_t)33, -1); H5Tclose(part_t); if( H5PTis_valid(table) < 0) goto out; /* Add many particles */ for(c = 0; c < BIG_TABLE_SIZE ; c+=8) { /* Append eight particles at once*/ err = H5PTappend(table, (size_t)8, &(testPart[0])); if( err < 0) goto out; } /* Count the number of packets in the table */ err = H5PTget_num_packets(table, &count); if( err < 0) goto out; if( count != BIG_TABLE_SIZE ) goto out; /* Read particles to ensure that all of them were written correctly */ /* Also, ensure that H5PTcreate_fl set the current packet to */ /* the first packet in the table */ for(c = 0; c < BIG_TABLE_SIZE; c++) { err = H5PTget_next(table, 1, &readPart); if(err < 0) goto out; /* Ensure that particles were read correctly */ if( cmp_par(c % 8, 0, testPart, &readPart) != 0) goto out; } /* Close the table */ err = H5PTclose(table); if( err < 0) goto out; PASSED(); return 0; out: H5_FAILED(); if( H5PTis_valid(table) < 0) H5PTclose(table); return -1; }
int main(void) { hid_t fid; /* File identifier */ hid_t ptable; /* Packet table identifier */ herr_t err; /* Function return status */ hsize_t count; /* Number of records in the table */ int x; /* Loop variable */ /* Buffers to hold data */ int writeBuffer[5]; int readBuffer[5]; /* Initialize buffers */ for(x=0; x<5; x++) { writeBuffer[x]=x; readBuffer[x] = -1; } /* Create a file using default properties */ fid=H5Fcreate("packet_table_FLexample.h5",H5F_ACC_TRUNC,H5P_DEFAULT,H5P_DEFAULT); /* Create a fixed-length packet table within the file */ /* This table's "packets" will be simple integers and it will use compression * level 5. */ ptable = H5PTcreate_fl(fid, "Packet Test Dataset", H5T_NATIVE_INT, (hsize_t)100, 5); if(ptable == H5I_INVALID_HID) goto out; /* Write one packet to the packet table */ err = H5PTappend(ptable, (hsize_t)1, &(writeBuffer[0]) ); if(err < 0) goto out; /* Write several packets to the packet table */ err = H5PTappend(ptable, (hsize_t)4, &(writeBuffer[1]) ); if(err < 0) goto out; /* Get the number of packets in the packet table. This should be five. */ err = H5PTget_num_packets(ptable, &count); if(err < 0) goto out; printf("Number of packets in packet table after five appends: %d\n", (int)count); /* Initialize packet table's "current record" */ err = H5PTcreate_index(ptable); if(err < 0) goto out; /* Iterate through packets, read each one back */ for(x=0; x<5; x++) { err = H5PTget_next(ptable, (hsize_t)1, &(readBuffer[x]) ); if(err < 0) goto out; printf("Packet %d's value is %d\n", x, readBuffer[x]); } /* Close the packet table */ err = H5PTclose(ptable); if(err < 0) goto out; /* Close the file */ H5Fclose(fid); return 0; out: /* An error has occurred. Clean up and exit. */ H5PTclose(ptable); H5Fclose(fid); return -1; }
int main(int argc,char *argv[]) { struct options opts = { 0, 1, 0, 0, -1, 1, 0, -1, 1, NULL, }; getopts(argc,argv,&opts); H5Eset_auto2(H5E_DEFAULT,NULL,NULL); hid_t fid = H5Fopen(opts.filename,H5F_ACC_RDONLY,H5P_DEFAULT); if(fid < 0) { fprintf(stderr,"Failed to open %s.\n",opts.filename); return fid; } if(opts.info) { // count the number of trials in the file hid_t trial; int num_trials = 0; std::stringstream trial_name; for(;;) { trial_name.str(""); trial_name << "/Trial" << num_trials+1; if((trial = H5Gopen(fid,trial_name.str().c_str(),H5P_DEFAULT)) < 0) break; else { print_trial_info(trial,++num_trials); H5Gclose(trial); } } H5Fclose(fid); return 0; } std::stringstream data_name; data_name << "/Trial" << opts.trial << "/Synchronous Data/Channel Data"; hid_t table = H5Dopen(fid,data_name.str().c_str(),H5P_DEFAULT); if(table < 0) { fprintf(stderr,"Requested trial #%d does not exist.\n",opts.trial); return table; } hsize_t ncols = H5Tget_size(H5Dget_type(table))/sizeof(double); H5Dclose(table); table = H5PTopen(fid,data_name.str().c_str()); hsize_t nrows; H5PTget_num_packets(table,&nrows); // validate column and row ranges if(opts.cols_end == -1 || opts.cols_end >= ncols) opts.cols_end = ncols-1; if(opts.rows_end == -1 || opts.rows_end >= nrows) opts.rows_end = nrows-1; opts.cols_end -= (opts.cols_end-opts.cols_start)%opts.cols_step; opts.rows_end -= (opts.rows_end-opts.rows_start)%opts.rows_step; if((opts.cols_start-opts.cols_end)*opts.cols_step > 0) opts.cols_step *= -1; if((opts.rows_start-opts.rows_end)*opts.rows_step > 0) opts.rows_step *= -1; int row_idx = opts.rows_start; do { H5PTset_index(table,row_idx); double data[ncols]; H5PTget_next(table,1,data); int col_idx = opts.cols_start; do { if(opts.binary) { write(1,data+col_idx,sizeof(double)); } else { printf("%e ",data[col_idx]); } if(col_idx == opts.cols_end) break; col_idx += opts.cols_step; } while(1); if(!opts.binary) printf("\n"); if(row_idx == opts.rows_end) break; row_idx += opts.rows_step; } while(1); H5PTclose(table); H5Fclose(fid); return 0; }
/*+++++++++++++++++++++++++ .IDENTifer SDMF_rd_pt_cluster .PURPOSE read cluster records from SDMF last-limb/Sun database .INPUT/OUTPUT call as SDMF_rd_pt_cluster( locID, clus_id, &numIndx, metaIndx, pixel_val ); input: hid_t locID : HDF5 identifier of group unsigned char clus_id : Cluster ID, range 1 - 40 size_t *metaIndx : array with requested indices in/output: size_t *numIndx : [input] dimension of metaIndx (or zero) [output] number of records read output: float *pixel_val : pixel values of SDMF last-limb/Sun database .RETURNS nothing, error status passed by global variable ``nadc_stat'' .COMMENTS static function -------------------------*/ void SDMF_rd_pt_cluster( hid_t locID, unsigned char clus_id, size_t *numIndx, size_t *metaIndx, float *pixel_val ) { register size_t nr, np; char clusName[11]; unsigned char coaddf; unsigned short num_pixels, num_obs, *usbuff; unsigned int *ubuff; hid_t ptable; hsize_t nrecords; size_t total_values; /* * does the dataset already exists? */ (void) snprintf( clusName, 11, "cluster_%02hhu", clus_id ); if ( (ptable = H5PTopen( locID, clusName )) == H5I_BADID ) return; /* * obtain table info */ (void) H5PTget_num_packets( ptable, &nrecords ); if ( *numIndx == 0 ) { *numIndx = (size_t) nrecords; for ( nr = 0; nr < nrecords; nr++ ) metaIndx[nr] = nr; } if ( nrecords == 0 ) { (void) H5PTclose( ptable ); return; } (void) H5LTget_attribute_uchar( locID, clusName, "coaddf", &coaddf ); (void) H5LTget_attribute_ushort( locID, clusName, "numObs", &num_obs ); (void) H5LTget_attribute_ushort( locID, clusName,"numPixels",&num_pixels ); total_values = (size_t) num_obs * num_pixels; /* * allocate temporary buffer to store cluster data */ if ( coaddf == (unsigned char) 1 ) { usbuff = (unsigned short *) malloc( total_values * sizeof(short) ); ubuff = NULL; } else { usbuff = NULL; ubuff = (unsigned int *) malloc( total_values * sizeof(int) ); } /* * read cluster records */ nr = 0; do { if ( coaddf == (unsigned char) 1 ) { (void) H5PTread_packets( ptable, (hsize_t) metaIndx[nr], 1, usbuff ); for ( np = 0; np < total_values; np++ ) *pixel_val++ = (float) usbuff[np]; } else { (void) H5PTread_packets( ptable, (hsize_t) metaIndx[nr], 1, ubuff ); for ( np = 0; np < total_values; np++ ) { *pixel_val++ = (float) ubuff[np]; } } } while ( ++nr < (*numIndx) ); if ( usbuff != NULL ) free( usbuff ); if ( ubuff != NULL ) free( ubuff ); }