mirror/hdf5
2
0
Fork 0
mirror of https://github.com/HDFGroup/hdf5.git synced 2024-12-09 07:32:32 +08:00
Code Issues Packages Projects Releases Wiki Activity
2423411a64
hdf5/test/cmpd_dset.c
Robb Matzke 6a1bea937d [svn-r469] Changes since 19980707 
----------------------

./bin/trace
./src/H5.c
	Added tracing support for H5S_seloper_t and H5S_class_t.

./src/H5Sselect.c
./src/H5S.c
	Added tracing statements that weren't inserted previously
	because of formatting problems.

./src/H5T.c
./src/H5Tconv.c
./src/H5Tpkg.h
./src/H5Tprivate.h
./src/H5Tpublic.h
./test/cmpd_dset.c
	Added H5Tinsert_array() for inserting an array member into a
	compound data type.  Added support to the struct conversion
	function for member arrays.  The index permutation is not
	supported yet in the conversion (source and destination must
	have the same permutations).
1998-07-08 11:46:16 -05:00

660 lines
18 KiB
C
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/*
* Copyright (C) 1998 NCSA
* All rights reserved.
*
* Programmer: Robb Matzke <matzke@llnl.gov>
* Friday, January 23, 1998
*/
#undef NDEBUG
#include <assert.h>
#include <hdf5.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define TEST_FILE_NAME "cmpd_dset.h5"
/* The first dataset */
typedef struct s1_t {
unsigned int a;
unsigned int b;
unsigned int c[4];
unsigned int d;
unsigned int e;
} s1_t;
/* The second dataset (same as first) */
typedef s1_t s2_t;
/* The third dataset (reversed fields of s1) */
typedef struct s3_t {
unsigned int e;
unsigned int d;
unsigned int c[4];
unsigned int b;
unsigned int a;
} s3_t;
/* The fourth dataset (a subset of s1) */
typedef struct s4_t {
unsigned int b;
unsigned int d;
} s4_t;
/* The fifth dataset (a superset of s1) */
typedef struct s5_t {
unsigned int pre;
unsigned int a;
unsigned int b;
unsigned int mid1;
unsigned int c[4];
unsigned int mid2;
unsigned int d;
unsigned int e;
unsigned int post;
} s5_t;
#if 1
# define NX 100u
# define NY 2000u
#else
# define NX 12u
# define NY 9u
#endif
/*-------------------------------------------------------------------------
* Function: cleanup
*
* Purpose: Cleanup temporary test files
*
* Return: none
*
* Programmer: Albert Cheng
* May 28, 1998
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static void
cleanup(void)
{
if (!getenv ("HDF5_NOCLEANUP")) {
remove(TEST_FILE_NAME);
}
}
/*-------------------------------------------------------------------------
* Function: main
*
* Purpose: Creates a simple dataset of a compound type and then reads
* it back. The dataset is read back in various ways to
* exercise the I/O pipeline and compound type conversion.
*
* Return: Success: 0
*
* Failure: 1
*
* Programmer: Robb Matzke
* Friday, January 23, 1998
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
int
main (void)
{
/* First dataset */
static s1_t s1[NX*NY];
hid_t s1_tid;
/* Second dataset */
static s2_t s2[NX*NY];
hid_t s2_tid;
/* Third dataset */
static s3_t s3[NX*NY];
hid_t s3_tid;
/* Fourth dataset */
static s4_t s4[NX*NY];
hid_t s4_tid;
/* Fifth dataset */
static s5_t s5[NX*NY];
hid_t s5_tid;
/* Sixth dataset */
/* Seventh dataset */
hid_t s7_sid;
/* Eighth dataset */
s1_t *s8 = NULL;
hid_t s8_f_sid; /*file data space */
hid_t s8_m_sid; /*memory data space */
/* Ninth dataset */
/* Tenth dataset */
/* Eleventh dataset */
s4_t *s11 = NULL;
/* Other variables */
unsigned int i, j;
int ndims;
hid_t file, dataset, space, PRESERVE;
herr_t status;
static hsize_t dim[] = {NX, NY};
hssize_t f_offset[2]; /*offset of hyperslab in file */
hsize_t h_size[2]; /*size of hyperslab */
hsize_t h_sample[2]; /*hyperslab sampling */
size_t memb_size[1] = {4};
/* Create the file */
file = H5Fcreate (TEST_FILE_NAME, H5F_ACC_TRUNC|H5F_ACC_DEBUG,
H5P_DEFAULT, H5P_DEFAULT);
assert (file>=0);
/* Create the data space */
space = H5Screate_simple (2, dim, NULL);
assert (space>=0);
/* Create xfer properties to preserve initialized data */
PRESERVE = H5Pcreate (H5P_DATASET_XFER);
assert (PRESERVE>=0);
status = H5Pset_preserve (PRESERVE, 1);
assert (status>=0);
/*
*######################################################################
* STEP 1: Save the original dataset natively.
*/
printf ("\
STEP 1: Initialize dataset `s1' and store it on disk in native order.\n");
fflush (stdout);
/* Initialize the dataset */
for (i=0; i<NX*NY; i++) {
s1[i].a = 8*i+0;
s1[i].b = 2000*2*i;
s1[i].c[0] = 8*i+2;
s1[i].c[1] = 8*i+3;
s1[i].c[2] = 8*i+4;
s1[i].c[3] = 8*i+5;
s1[i].d = 2001+2*i;
s1[i].e = 8*i+7;
}
/* Create the memory data type */
s1_tid = H5Tcreate (H5T_COMPOUND, sizeof(s1_t));
H5Tinsert (s1_tid, "a", HOFFSET(s1_t,a), H5T_NATIVE_INT);
H5Tinsert (s1_tid, "b", HOFFSET(s1_t,b), H5T_NATIVE_INT);
H5Tinsert_array (s1_tid, "c", HOFFSET(s1_t,c), 1, memb_size, NULL,
H5T_NATIVE_INT);
H5Tinsert (s1_tid, "d", HOFFSET(s1_t,d), H5T_NATIVE_INT);
H5Tinsert (s1_tid, "e", HOFFSET(s1_t,e), H5T_NATIVE_INT);
assert (s1_tid>=0);
/* Create the dataset */
dataset = H5Dcreate (file, "s1", s1_tid, space, H5P_DEFAULT);
assert (dataset>=0);
/* Write the data */
status = H5Dwrite (dataset, s1_tid, H5S_ALL, H5S_ALL, H5P_DEFAULT, s1);
assert (status>=0);
/*
*######################################################################
* STEP 2: We create a new type ID for the second dataset even though
* it's the same as the first just to test things better, but
* in fact, we could have used s1_tid.
*/
printf ("\
STEP 2: Read the dataset from disk into a new memory buffer which has the\n\
same data type and space. This will be the typical case.\n");
fflush (stdout);
/* Create a data type for s2 */
s2_tid = H5Tcreate (H5T_COMPOUND, sizeof(s2_t));
H5Tinsert (s2_tid, "a", HOFFSET(s2_t,a), H5T_NATIVE_INT);
H5Tinsert (s2_tid, "b", HOFFSET(s2_t,b), H5T_NATIVE_INT);
H5Tinsert_array (s2_tid, "c", HOFFSET(s2_t,c), 1, memb_size, NULL,
H5T_NATIVE_INT);
H5Tinsert (s2_tid, "d", HOFFSET(s2_t,d), H5T_NATIVE_INT);
H5Tinsert (s2_tid, "e", HOFFSET(s2_t,e), H5T_NATIVE_INT);
assert (s2_tid>=0);
/* Read the data */
status = H5Dread (dataset, s2_tid, H5S_ALL, H5S_ALL, H5P_DEFAULT, s2);
assert (status>=0);
/* Compare s2 with s1. They should be the same */
for (i=0; i<NX*NY; i++) {
assert (s1[i].a==s2[i].a);
assert (s1[i].b==s2[i].b);
assert (s1[i].c[0]==s2[i].c[0]);
assert (s1[i].c[1]==s2[i].c[1]);
assert (s1[i].c[2]==s2[i].c[2]);
assert (s1[i].c[3]==s2[i].c[3]);
assert (s1[i].d==s2[i].d);
assert (s1[i].e==s2[i].e);
}
/*
*######################################################################
* STEP 3: Read the dataset back into a third memory buffer. This buffer
* has the same data space but the data type is different: the
* data type is a struct whose members are in the opposite order.
*/
printf ("\
STEP 3: Read the dataset again with members in a different order.\n");
fflush (stdout);
/* Create a data type for s3 */
s3_tid = H5Tcreate (H5T_COMPOUND, sizeof(s3_t));
H5Tinsert (s3_tid, "a", HOFFSET(s3_t,a), H5T_NATIVE_INT);
H5Tinsert (s3_tid, "b", HOFFSET(s3_t,b), H5T_NATIVE_INT);
H5Tinsert_array (s3_tid, "c", HOFFSET(s3_t,c), 1, memb_size, NULL,
H5T_NATIVE_INT);
H5Tinsert (s3_tid, "d", HOFFSET(s3_t,d), H5T_NATIVE_INT);
H5Tinsert (s3_tid, "e", HOFFSET(s3_t,e), H5T_NATIVE_INT);
assert (s3_tid>=0);
/* Read the data */
status = H5Dread (dataset, s3_tid, H5S_ALL, H5S_ALL, H5P_DEFAULT, s3);
assert (status>=0);
/* Compare s3 with s1. They should be the same */
for (i=0; i<NX*NY; i++) {
assert (s1[i].a==s3[i].a);
assert (s1[i].b==s3[i].b);
assert (s1[i].c[0]==s3[i].c[0]);
assert (s1[i].c[1]==s3[i].c[1]);
assert (s1[i].c[2]==s3[i].c[2]);
assert (s1[i].c[3]==s3[i].c[3]);
assert (s1[i].d==s3[i].d);
assert (s1[i].e==s3[i].e);
}
/*
*######################################################################
* STEP 4: Read a subset of the members. Of the <a,b,c,d,e> members
* stored on disk we'll read <b,d>.
*/
printf ("\
STEP 4: Read a subset of the members.\n");
fflush (stdout);
/* Create a datatype for s4 */
s4_tid = H5Tcreate (H5T_COMPOUND, sizeof(s4_t));
H5Tinsert (s4_tid, "b", HOFFSET(s4_t,b), H5T_NATIVE_INT);
H5Tinsert (s4_tid, "d", HOFFSET(s4_t,d), H5T_NATIVE_INT);
assert (s4_tid>=0);
/* Read the data */
status = H5Dread (dataset, s4_tid, H5S_ALL, H5S_ALL, H5P_DEFAULT, s4);
assert (status>=0);
/* Compare s4 with s1 */
for (i=0; i<NX*NY; i++) {
assert (s1[i].b==s4[i].b);
assert (s1[i].d==s4[i].d);
}
/*
*######################################################################
* STEP 5: Read all the members into a struct which has other members
* which have already been initialized.
*/
printf ("\
STEP 5: Read members into a superset which is partially initialized.\n");
fflush (stdout);
/* Initialize some members */
for (i=0; i<NX*NY; i++) {
s5[i].pre = 1000+4*i;
s5[i].mid1 = 1001+4*i;
s5[i].mid2 = 1002+4*i;
s5[i].post = 1003+4*i;
}
/* Create a data type for s5 */
s5_tid = H5Tcreate (H5T_COMPOUND, sizeof(s5_t));
H5Tinsert (s5_tid, "a", HOFFSET(s5_t,a), H5T_NATIVE_INT);
H5Tinsert (s5_tid, "b", HOFFSET(s5_t,b), H5T_NATIVE_INT);
H5Tinsert_array (s5_tid, "c", HOFFSET(s5_t,c), 1, memb_size, NULL,
H5T_NATIVE_INT);
H5Tinsert (s5_tid, "d", HOFFSET(s5_t,d), H5T_NATIVE_INT);
H5Tinsert (s5_tid, "e", HOFFSET(s5_t,e), H5T_NATIVE_INT);
assert (s5_tid>=0);
/* Read the data */
status = H5Dread (dataset, s5_tid, H5S_ALL, H5S_ALL, PRESERVE, s5);
assert (status>=0);
/* Check that the data was read properly */
for (i=0; i<NX*NY; i++) {
assert (s1[i].a==s5[i].a);
assert (s1[i].b==s5[i].b);
assert (s1[i].c[0]==s5[i].c[0]);
assert (s1[i].c[1]==s5[i].c[1]);
assert (s1[i].c[2]==s5[i].c[2]);
assert (s1[i].c[3]==s5[i].c[3]);
assert (s1[i].d==s5[i].d);
assert (s1[i].e==s5[i].e);
}
/* Check that no previous values were clobbered */
for (i=0; i<NX*NY; i++) {
assert (s5[i].pre == 1000+4*i);
assert (s5[i].mid1 == 1001+4*i);
assert (s5[i].mid2 == 1002+4*i);
assert (s5[i].post == 1003+4*i);
}
/*
*######################################################################
* STEP 6: Update fields `b' and `d' on the file leaving the other
* fields unchanged. This tests member alignment and background
* buffers.
*/
printf ("\
STEP 6: Update fields `b' and `d' on the file, leaving the other fields\n\
unchanged.\n");
fflush (stdout);
/* Initialize `s4' with new values */
for (i=0; i<NX*NY; i++) {
s4[i].b = 8*i+1;
s4[i].d = 8*i+6;
}
/* Write the data to file */
status = H5Dwrite (dataset, s4_tid, H5S_ALL, H5S_ALL, PRESERVE, s4);
assert (status>=0);
/* Read the data back */
status = H5Dread (dataset, s1_tid, H5S_ALL, H5S_ALL, H5P_DEFAULT, s1);
assert (status>=0);
/* Compare */
for (i=0; i<NX*NY; i++) {
assert (s1[i].a == 8*i+0);
assert (s1[i].b == 8*i+1);
assert (s1[i].c[0] == 8*i+2);
assert (s1[i].c[1] == 8*i+3);
assert (s1[i].c[2] == 8*i+4);
assert (s1[i].c[3] == 8*i+5);
assert (s1[i].d == 8*i+6);
assert (s1[i].e == 8*i+7);
}
/*
*######################################################################
* STEP 7. Read the original dataset with an explicit data space. Even
* though these data spaces are equal it tests a different part of the
* library.
*/
printf ("\
STEP 7: Reading original dataset with explicit data space.\n");
fflush (stdout);
/* Create the data space */
s7_sid = H5Screate_simple (2, dim, NULL);
assert (s7_sid>=0);
/* Read the dataset */
status = H5Dread (dataset, s2_tid, s7_sid, H5S_ALL, H5P_DEFAULT, s2);
assert (status>=0);
/* Compare */
for (i=0; i<NX*NY; i++) {
assert (s2[i].a == s1[i].a);
assert (s2[i].b == s1[i].b);
assert (s2[i].c[0] == s1[i].c[0]);
assert (s2[i].c[1] == s1[i].c[1]);
assert (s2[i].c[2] == s1[i].c[2]);
assert (s2[i].c[3] == s1[i].c[3]);
assert (s2[i].d == s1[i].d);
assert (s2[i].e == s1[i].e);
}
/*
*######################################################################
* STEP 8. Read a hyperslab of the file into a complete array in memory.
* The hyperslab is the middle third of the array.
*/
printf ("\
STEP 8: Read middle third hyperslab into memory array.\n");
fflush (stdout);
/* Create the file data space */
s8_f_sid = H5Dget_space (dataset);
assert (s8_f_sid>=0);
f_offset[0] = NX/3;
f_offset[1] = NY/3;
h_size[0] = 2*NX/3 - f_offset[0];
h_size[1] = 2*NY/3 - f_offset[1];
status = H5Sselect_hyperslab (s8_f_sid, H5S_SELECT_SET, f_offset, NULL,
h_size, NULL);
assert (status>=0);
/* Create memory data space */
s8_m_sid = H5Screate_simple (2, h_size, NULL);
assert (s8_m_sid>=0);
/* Read the dataset */
s8 = calloc ((size_t)(h_size[0]*h_size[1]), sizeof(s1_t));
assert (s8);
status = H5Dread (dataset, s1_tid, s8_m_sid, s8_f_sid, H5P_DEFAULT, s8);
assert (status>=0);
/* Compare */
for (i=0; i<h_size[0]; i++) {
for (j=0; j<h_size[1]; j++) {
s1_t *ps1 = s1 + (f_offset[0]+i)*NY + f_offset[1] + j;
s1_t *ps8 = s8 + i*h_size[1] + j;
assert (ps8->a == ps1->a);
assert (ps8->b == ps1->b);
assert (ps8->c[0] == ps1->c[0]);
assert (ps8->c[1] == ps1->c[1]);
assert (ps8->c[2] == ps1->c[2]);
assert (ps8->c[3] == ps1->c[3]);
assert (ps8->d == ps1->d);
assert (ps8->e == ps1->e);
}
}
free (s8);
s8 = NULL;
/*
*######################################################################
* STEP 9. Read a hyperslab of the file into a hyperslab of memory. The
* part of memory not read is already initialized and must not change.
*/
printf ("\
STEP 9: Read middle third of hyperslab into middle third of memory array.\n");
fflush (stdout);
/* Initialize */
for (i=0; i<NX*NY; i++) {
s2[i].a = s2[i].b = s2[i].d = s2[i].e = (unsigned)(-1);
s2[i].c[0] = s2[i].c[1] = s2[i].c[2] = s2[i].c[3] = (unsigned)(-1);
}
/* Read the hyperslab */
status = H5Dread (dataset, s2_tid, s8_f_sid, s8_f_sid, H5P_DEFAULT, s2);
assert (status>=0);
/* Compare */
for (i=0; i<NX; i++) {
for (j=0; j<NY; j++) {
s1_t *ps1 = s1 + i*NY + j;
s2_t *ps2 = s2 + i*NY + j;
if ((hssize_t)i>=f_offset[0] &&
(hsize_t)i<f_offset[0]+h_size[0] &&
(hssize_t)j>=f_offset[1] &&
(hsize_t)j<f_offset[1]+h_size[1]) {
assert (ps2->a == ps1->a);
assert (ps2->b == ps1->b);
assert (ps2->c[0] == ps1->c[0]);
assert (ps2->c[1] == ps1->c[1]);
assert (ps2->c[2] == ps1->c[2]);
assert (ps2->c[3] == ps1->c[3]);
assert (ps2->d == ps1->d);
assert (ps2->e == ps1->e);
} else {
assert (ps2->a == (unsigned)(-1));
assert (ps2->b == (unsigned)(-1));
assert (ps2->c[0] == (unsigned)(-1));
assert (ps2->c[1] == (unsigned)(-1));
assert (ps2->c[2] == (unsigned)(-1));
assert (ps2->c[3] == (unsigned)(-1));
assert (ps2->d == (unsigned)(-1));
assert (ps2->e == (unsigned)(-1));
}
}
}
/*
*######################################################################
* STEP 10. Same as step 9 except the memory array contains some members
* which are already initialized, like step 5.
*/
printf ("\
STEP 10: Read middle third of hyperslab into middle third of memory array\n\
where some of the struct members are already initialized.\n");
fflush (stdout);
/* Initialize */
for (i=0; i<NX*NY; i++) {
s5[i].a = s5[i].b = s5[i].d = s5[i].e = (unsigned)(-1);
s5[i].c[0] = s5[i].c[1] = s5[i].c[2] = s5[i].c[3] = (unsigned)(-1);
s5[i].pre = s5[i].mid1 = s5[i].mid2 = s5[i].post = (unsigned)(-1);
}
/* Read the hyperslab */
status = H5Dread (dataset, s5_tid, s8_f_sid, s8_f_sid, PRESERVE, s5);
assert (status>=0);
/* Compare */
for (i=0; i<NX; i++) {
for (j=0; j<NY; j++) {
s1_t *ps1 = s1 + i*NY + j;
s5_t *ps5 = s5 + i*NY + j;
if ((hssize_t)i>=f_offset[0] &&
(hsize_t)i<f_offset[0]+h_size[0] &&
(hssize_t)j>=f_offset[1] &&
(hsize_t)j<f_offset[1]+h_size[1]) {
assert (ps5->pre == (unsigned)(-1));
assert (ps5->a == ps1->a);
assert (ps5->b == ps1->b);
assert (ps5->mid1 == (unsigned)(-1));
assert (ps5->c[0] == ps1->c[0]);
assert (ps5->c[1] == ps1->c[1]);
assert (ps5->c[2] == ps1->c[2]);
assert (ps5->c[3] == ps1->c[3]);
assert (ps5->mid2 == (unsigned)(-1));
assert (ps5->d == ps1->d);
assert (ps5->e == ps1->e);
assert (ps5->post == (unsigned)(-1));
} else {
assert (ps5->pre == (unsigned)(-1));
assert (ps5->a == (unsigned)(-1));
assert (ps5->b == (unsigned)(-1));
assert (ps5->mid1 == (unsigned)(-1));
assert (ps5->c[0] == (unsigned)(-1));
assert (ps5->c[1] == (unsigned)(-1));
assert (ps5->c[2] == (unsigned)(-1));
assert (ps5->c[3] == (unsigned)(-1));
assert (ps5->mid2 == (unsigned)(-1));
assert (ps5->d == (unsigned)(-1));
assert (ps5->e == (unsigned)(-1));
assert (ps5->post == (unsigned)(-1));
}
}
}
#ifdef OLD_WAY
/*
*######################################################################
* Step 11: Write an array into the middle third of the dataset
* initializeing only members `b' and `d' to -1.
*/
printf ("\
STEP 11: Write an array back to the middle third of the dataset to\n\
initialize the `b' and `d' members to -1.\n");
fflush (stdout);
/* Create the memory array and initialize all fields to zero */
ndims = H5Sget_hyperslab (s8_f_sid, f_offset, h_size, h_sample);
assert (ndims==2);
s11 = malloc ((size_t)h_size[0]*(size_t)h_size[1]*sizeof(s4_t));
assert (s11);
/* Initialize */
for (i=0; i<h_size[0]*h_size[1]; i++) {
s11[i].b = s11[i].d = (unsigned)(-1);
}
/* Write to disk */
status = H5Dwrite (dataset, s4_tid, s8_m_sid, s8_f_sid, PRESERVE, s11);
assert (status>=0);
free (s11);
s11=NULL;
/* Read the whole thing */
status = H5Dread (dataset, s1_tid, H5S_ALL, H5S_ALL, H5P_DEFAULT, s1);
assert (status>=0);
/* Compare */
for (i=0; i<NX; i++) {
for (j=0; j<NY; j++) {
s1_t *ps1 = s1 + i*NY + j;
assert (ps1->a == 8*(i*NY+j)+0);
assert (ps1->c[0] == 8*(i*NY+j)+2);
assert (ps1->c[1] == 8*(i*NY+j)+3);
assert (ps1->c[2] == 8*(i*NY+j)+4);
assert (ps1->c[3] == 8*(i*NY+j)+5);
assert (ps1->e == 8*(i*NY+j)+7);
if ((hssize_t)i>=f_offset[0] &&
(hsize_t)i<f_offset[0]+h_size[0] &&
(hssize_t)j>=f_offset[1] &&
(hsize_t)j<f_offset[1]+h_size[1]) {
assert (ps1->b == (unsigned)(-1));
assert (ps1->d == (unsigned)(-1));
} else {
assert (ps1->b == 8*(i*NY+j)+1);
assert (ps1->d == 8*(i*NY+j)+6);
}
}
}
#endif /* OLD_WAY */
/*
* Release resources.
*/
H5Pclose (PRESERVE);
H5Dclose (dataset);
H5Fclose (file);
cleanup();
return 0;
}
Reference in New Issue View Git Blame Copy Permalink