/*-------------------------------------------------------------------------
* Function: print_found
*
* Purpose: print number of differences found
*
*-------------------------------------------------------------------------
*/
void print_found(hsize_t nfound)
{
if(g_Parallel)
parallel_print("%"H5_PRINTF_LL_WIDTH"u differences found\n", (unsigned long long)nfound);
else
HDfprintf(stdout,"%Hu differences found\n",nfound);
}
/*-------------------------------------------------------------------------
* Function: print_dimensions
*
* Purpose: print dimensions
*
*-------------------------------------------------------------------------
*/
void
print_dimensions (int rank, hsize_t *dims)
{
int i;
if ( rank <= 0 )
{
parallel_print("H5S_SCALAR" );
}
else
{
if (!dims)
parallel_print("dimension is NULL");
else
{
parallel_print("[");
for ( i = 0; i < rank-1; i++)
{
parallel_print(HSIZE_T_FORMAT, dims[i]);
parallel_print("x");
}
parallel_print(HSIZE_T_FORMAT, dims[rank-1]);
parallel_print("]" );
}
}
}
hsize_t diff_attr(hid_t loc1_id,
hid_t loc2_id,
const char *path1,
const char *path2,
diff_opt_t *options)
{
hid_t attr1_id=-1; /* attr ID */
hid_t attr2_id=-1; /* attr ID */
hid_t space1_id=-1; /* space ID */
hid_t space2_id=-1; /* space ID */
hid_t ftype1_id=-1; /* file data type ID */
hid_t ftype2_id=-1; /* file data type ID */
hid_t mtype1_id=-1; /* memory data type ID */
hid_t mtype2_id=-1; /* memory data type ID */
size_t msize1; /* memory size of memory type */
size_t msize2; /* memory size of memory type */
void *buf1=NULL; /* data buffer */
void *buf2=NULL; /* data buffer */
hsize_t nelmts1; /* number of elements in dataset */
int rank1; /* rank of dataset */
int rank2; /* rank of dataset */
hsize_t dims1[H5S_MAX_RANK];/* dimensions of dataset */
hsize_t dims2[H5S_MAX_RANK];/* dimensions of dataset */
char name1[512];
char name2[512];
char np1[512];
char np2[512];
H5O_info_t oinfo1, oinfo2; /* Object info */
unsigned u; /* Local index variable */
hsize_t nfound = 0;
hsize_t nfound_total = 0;
int j;
if(H5Oget_info(loc1_id, &oinfo1) < 0)
goto error;
if(H5Oget_info(loc2_id, &oinfo2) < 0)
goto error;
if(oinfo1.num_attrs != oinfo2.num_attrs)
return 1;
for( u = 0; u < (unsigned)oinfo1.num_attrs; u++)
{
/* reset buffers for every attribute, we might goto out and call free */
buf1 = NULL;
buf2 = NULL;
/* open attribute */
if((attr1_id = H5Aopen_by_idx(loc1_id, ".", H5_INDEX_CRT_ORDER, H5_ITER_INC, (hsize_t)u, H5P_DEFAULT, H5P_DEFAULT)) < 0)
goto error;
/* get name */
if(H5Aget_name(attr1_id, 255, name1) < 0)
goto error;
/* use the name on the first file to open the second file */
H5E_BEGIN_TRY
{
if((attr2_id = H5Aopen(loc2_id, name1, H5P_DEFAULT)) < 0)
goto error;
} H5E_END_TRY;
/* get name */
if(H5Aget_name(attr2_id, 255, name2) < 0)
goto error;
/* get the datatypes */
if ((ftype1_id = H5Aget_type(attr1_id)) < 0)
goto error;
if ((ftype2_id = H5Aget_type(attr2_id)) < 0)
goto error;
if ((mtype1_id = h5tools_get_native_type(ftype1_id))<0)
goto error;
if ((mtype2_id = h5tools_get_native_type(ftype2_id))<0)
goto error;
if ((msize1 = H5Tget_size(mtype1_id))==0)
goto error;
if ((msize2 = H5Tget_size(mtype2_id))==0)
goto error;
/* get the dataspace */
if ((space1_id = H5Aget_space(attr1_id)) < 0)
goto error;
if ((space2_id = H5Aget_space(attr2_id)) < 0)
goto error;
/* get dimensions */
if ( (rank1 = H5Sget_simple_extent_dims(space1_id, dims1, NULL)) < 0 )
goto error;
if ( (rank2 = H5Sget_simple_extent_dims(space2_id, dims2, NULL)) < 0 )
goto error;
/*-------------------------------------------------------------------------
* check for comparable TYPE and SPACE
*-------------------------------------------------------------------------
*/
if ( msize1 != msize2
||
diff_can_type(ftype1_id,
ftype2_id,
rank1,
rank2,
dims1,
dims2,
NULL,
NULL,
name1,
name2,
options,
0)!=1)
{
if (H5Tclose(ftype1_id)<0)
goto error;
if (H5Tclose(ftype2_id)<0)
goto error;
if (H5Sclose(space1_id)<0)
goto error;
if (H5Sclose(space2_id)<0)
goto error;
if (H5Aclose(attr1_id)<0)
goto error;
if (H5Aclose(attr2_id)<0)
goto error;
if (H5Tclose(mtype1_id)<0)
goto error;
if (H5Tclose(mtype2_id)<0)
goto error;
continue;
}
/*-------------------------------------------------------------------------
* read
*-------------------------------------------------------------------------
*/
nelmts1=1;
for (j=0; j<rank1; j++)
nelmts1*=dims1[j];
buf1=(void *) HDmalloc((unsigned)(nelmts1*msize1));
buf2=(void *) HDmalloc((unsigned)(nelmts1*msize2));
if ( buf1==NULL || buf2==NULL){
parallel_print( "cannot read into memory\n" );
goto error;
}
if (H5Aread(attr1_id,mtype1_id,buf1)<0)
goto error;
if (H5Aread(attr2_id,mtype2_id,buf2)<0)
goto error;
/* format output string */
sprintf(np1,"%s of <%s>",name1,path1);
sprintf(np2,"%s of <%s>",name2,path2);
/*-------------------------------------------------------------------------
* array compare
*-------------------------------------------------------------------------
*/
/* always print name */
if (options->m_verbose)
{
do_print_objname ("attribute", np1, np2);
nfound = diff_array(buf1,
buf2,
nelmts1,
(hsize_t)0,
rank1,
dims1,
options,
np1,
np2,
mtype1_id,
attr1_id,
attr2_id);
print_found(nfound);
}
/* check first if we have differences */
else
{
if (options->m_quiet==0)
{
/* shut up temporarily */
options->m_quiet=1;
nfound = diff_array(buf1,
buf2,
nelmts1,
(hsize_t)0,
rank1,
dims1,
options,
np1,
np2,
mtype1_id,
attr1_id,
attr2_id);
/* print again */
options->m_quiet=0;
if (nfound)
{
do_print_objname ("attribute", np1, np2);
nfound = diff_array(buf1,
buf2,
nelmts1,
(hsize_t)0,
rank1,
dims1,
options,
np1,
np2,
mtype1_id,
attr1_id,
attr2_id);
print_found(nfound);
} /*if*/
} /*if*/
/* in quiet mode, just count differences */
else
{
nfound = diff_array(buf1,
buf2,
nelmts1,
(hsize_t)0,
rank1,
dims1,
options,
np1,
np2,
mtype1_id,
attr1_id,
attr2_id);
} /*else quiet */
} /*else verbose */
/*-------------------------------------------------------------------------
* close
*-------------------------------------------------------------------------
*/
if (H5Tclose(ftype1_id)<0)
goto error;
if (H5Tclose(ftype2_id)<0)
goto error;
if (H5Sclose(space1_id)<0)
goto error;
if (H5Sclose(space2_id)<0)
goto error;
if (H5Aclose(attr1_id)<0)
goto error;
if (H5Aclose(attr2_id)<0)
goto error;
if (H5Tclose(mtype1_id)<0)
goto error;
if (H5Tclose(mtype2_id)<0)
goto error;
if (buf1)
HDfree(buf1);
if (buf2)
HDfree(buf2);
nfound_total += nfound;
} /* u */
return nfound_total;
error:
H5E_BEGIN_TRY {
H5Tclose(ftype1_id);
H5Tclose(ftype2_id);
H5Tclose(mtype1_id);
H5Tclose(mtype2_id);
H5Sclose(space1_id);
H5Sclose(space2_id);
H5Aclose(attr1_id);
H5Aclose(attr2_id);
if (buf1)
HDfree(buf1);
if (buf2)
HDfree(buf2);
} H5E_END_TRY;
options->err_stat=1;
return nfound_total;
}
hsize_t diff_attr(hid_t loc1_id,
hid_t loc2_id,
const char *path1,
const char *path2,
diff_opt_t *options)
{
hid_t attr1_id=-1; /* attr ID */
hid_t attr2_id=-1; /* attr ID */
hid_t space1_id=-1; /* space ID */
hid_t space2_id=-1; /* space ID */
hid_t ftype1_id=-1; /* file data type ID */
hid_t ftype2_id=-1; /* file data type ID */
int vstrtype1=0; /* ftype1 is a variable string */
int vstrtype2=0; /* ftype2 is a variable string */
hid_t mtype1_id=-1; /* memory data type ID */
hid_t mtype2_id=-1; /* memory data type ID */
size_t msize1; /* memory size of memory type */
size_t msize2; /* memory size of memory type */
void *buf1=NULL; /* data buffer */
void *buf2=NULL; /* data buffer */
int buf1hasdata=0; /* buffer has data */
int buf2hasdata=0; /* buffer has data */
hsize_t nelmts1; /* number of elements in dataset */
int rank1; /* rank of dataset */
int rank2; /* rank of dataset */
hsize_t dims1[H5S_MAX_RANK];/* dimensions of dataset */
hsize_t dims2[H5S_MAX_RANK];/* dimensions of dataset */
char *name1;
char *name2;
char np1[512];
char np2[512];
unsigned u; /* Local index variable */
hsize_t nfound = 0;
hsize_t nfound_total = 0;
int j;
table_attrs_t * match_list_attrs = NULL;
if( build_match_list_attrs(loc1_id, loc2_id, &match_list_attrs, options) < 0)
goto error;
/* if detect any unique extra attr */
if(match_list_attrs->nattrs_only1 || match_list_attrs->nattrs_only2)
{
/* exit will be 1 */
options->contents = 0;
}
for(u = 0; u < (unsigned)match_list_attrs->nattrs; u++)
{
if( (match_list_attrs->attrs[u].exist[0]) && (match_list_attrs->attrs[u].exist[1]) )
{
name1 = name2 = match_list_attrs->attrs[u].name;
/*--------------
* attribute 1 */
if((attr1_id = H5Aopen(loc1_id, name1, H5P_DEFAULT)) < 0)
goto error;
/*--------------
* attribute 2 */
if((attr2_id = H5Aopen(loc2_id, name2, H5P_DEFAULT)) < 0)
goto error;
/* get the datatypes */
if((ftype1_id = H5Aget_type(attr1_id)) < 0)
goto error;
vstrtype1 = H5Tis_variable_str(ftype1_id);
if((ftype2_id = H5Aget_type(attr2_id)) < 0)
goto error;
vstrtype2 = H5Tis_variable_str(ftype2_id);
/* no compare if either one but not both are variable string type */
if (vstrtype1 != vstrtype2){
if ((options->m_verbose||options->m_list_not_cmp))
parallel_print("Not comparable: one of attribute <%s/%s> or <%s/%s> is of variable length type\n",
path1, name1, path2, name2);
options->not_cmp = 1;
return 0;
}
if((mtype1_id = h5tools_get_native_type(ftype1_id))<0)
goto error;
if((mtype2_id = h5tools_get_native_type(ftype2_id))<0)
goto error;
if((msize1 = H5Tget_size(mtype1_id))==0)
goto error;
if((msize2 = H5Tget_size(mtype2_id))==0)
goto error;
/* get the dataspace */
if((space1_id = H5Aget_space(attr1_id)) < 0)
goto error;
if((space2_id = H5Aget_space(attr2_id)) < 0)
goto error;
/* get dimensions */
if((rank1 = H5Sget_simple_extent_dims(space1_id, dims1, NULL)) < 0)
goto error;
if((rank2 = H5Sget_simple_extent_dims(space2_id, dims2, NULL)) < 0)
goto error;
/*----------------------------------------------------------------------
* check for comparable TYPE and SPACE
*----------------------------------------------------------------------
*/
/* pass dims1 and dims2 for maxdims as well since attribute's maxdims
* are always same */
if( diff_can_type(ftype1_id, ftype2_id, rank1, rank2, dims1, dims2,
dims1, dims2, name1, name2, options, 0) != 1 )
{
if(H5Tclose(ftype1_id) < 0)
goto error;
if(H5Tclose(ftype2_id) < 0)
goto error;
if(H5Sclose(space1_id) < 0)
goto error;
if(H5Sclose(space2_id) < 0)
goto error;
if(H5Aclose(attr1_id) < 0)
goto error;
if(H5Aclose(attr2_id) < 0)
goto error;
if(H5Tclose(mtype1_id) < 0)
goto error;
if(H5Tclose(mtype2_id) < 0)
goto error;
continue;
}
/*-----------------------------------------------------------------
* "upgrade" the smaller memory size
*------------------------------------------------------------------
*/
if (FAIL == match_up_memsize (ftype1_id, ftype2_id,
&mtype1_id, &mtype2_id,
&msize1, &msize2))
goto error;
/*---------------------------------------------------------------------
* read
*----------------------------------------------------------------------
*/
nelmts1 = 1;
for(j = 0; j < rank1; j++)
nelmts1 *= dims1[j];
buf1 = (void *)HDmalloc((size_t)(nelmts1 * msize1));
buf2 = (void *)HDmalloc((size_t)(nelmts1 * msize2));
if(buf1 == NULL || buf2 == NULL){
parallel_print( "cannot read into memory\n" );
goto error;
}
if(H5Aread(attr1_id,mtype1_id,buf1) < 0){
parallel_print("Failed reading attribute1 %s/%s\n", path1, name1);
goto error;
}else
buf1hasdata = 1;
if(H5Aread(attr2_id,mtype2_id,buf2) < 0){
parallel_print("Failed reading attribute2 %s/%s\n", path2, name2);
goto error;
}else
buf2hasdata = 1;
/* format output string */
HDsnprintf(np1, sizeof(np1), "%s of <%s>", name1, path1);
HDsnprintf(np2, sizeof(np1), "%s of <%s>", name2, path2);
/*---------------------------------------------------------------------
* array compare
*----------------------------------------------------------------------
*/
/* always print name */
/* verbose (-v) and report (-r) mode */
if(options->m_verbose || options->m_report) {
do_print_attrname("attribute", np1, np2);
nfound = diff_array(buf1, buf2, nelmts1, (hsize_t)0, rank1, dims1,
options, np1, np2, mtype1_id, attr1_id, attr2_id);
print_found(nfound);
}
/* quiet mode (-q), just count differences */
else if(options->m_quiet) {
nfound = diff_array(buf1, buf2, nelmts1, (hsize_t)0, rank1, dims1,
options, np1, np2, mtype1_id, attr1_id, attr2_id);
}
/* the rest (-c, none, ...) */
else {
nfound = diff_array(buf1, buf2, nelmts1, (hsize_t)0, rank1, dims1,
options, np1, np2, mtype1_id, attr1_id, attr2_id);
/* print info if compatible and difference found */
if(nfound) {
do_print_attrname("attribute", np1, np2);
print_found(nfound);
} /* end if */
} /* end else */
/*----------------------------------------------------------------------
* close
*----------------------------------------------------------------------
*/
/* Free buf1 and buf2, check both VLEN-data VLEN-string to reclaim any
* VLEN memory first */
if(TRUE == h5tools_detect_vlen(mtype1_id))
H5Dvlen_reclaim(mtype1_id, space1_id, H5P_DEFAULT, buf1);
HDfree(buf1);
buf1 = NULL;
if(TRUE == h5tools_detect_vlen(mtype2_id))
H5Dvlen_reclaim(mtype2_id, space2_id, H5P_DEFAULT, buf2);
HDfree(buf2);
buf2 = NULL;
if(H5Tclose(ftype1_id) < 0)
goto error;
if(H5Tclose(ftype2_id) < 0)
goto error;
if(H5Sclose(space1_id) < 0)
goto error;
if(H5Sclose(space2_id) < 0)
goto error;
if(H5Aclose(attr1_id) < 0)
goto error;
if(H5Aclose(attr2_id) < 0)
goto error;
if(H5Tclose(mtype1_id) < 0)
goto error;
if(H5Tclose(mtype2_id) < 0)
goto error;
nfound_total += nfound;
}
} /* u */
table_attrs_free(match_list_attrs);
return nfound_total;
error:
H5E_BEGIN_TRY {
if(buf1) {
if(buf1hasdata && TRUE == h5tools_detect_vlen(mtype1_id))
H5Dvlen_reclaim(mtype1_id, space1_id, H5P_DEFAULT, buf1);
HDfree(buf1);
} /* end if */
if(buf2) {
if(buf2hasdata && TRUE == h5tools_detect_vlen(mtype2_id))
H5Dvlen_reclaim(mtype2_id, space2_id, H5P_DEFAULT, buf2);
HDfree(buf2);
} /* end if */
table_attrs_free(match_list_attrs);
H5Tclose(ftype1_id);
H5Tclose(ftype2_id);
H5Tclose(mtype1_id);
H5Tclose(mtype2_id);
H5Sclose(space1_id);
H5Sclose(space2_id);
H5Aclose(attr1_id);
H5Aclose(attr2_id);
} H5E_END_TRY;
options->err_stat = 1;
return nfound_total;
}
/*-------------------------------------------------------------------------
* Function: build_match_list_attrs
*
* Purpose: get list of matching attribute name from obj1 and obj2
*
* Note:
* Find common attribute; the algorithm for search is referred from
* build_match_list() in h5diff.c .
*
* Parameter:
* table_out [OUT] : return the list
*
* Programmer: Jonathan Kim
*
* Date: March 15, 2011
*------------------------------------------------------------------------*/
static herr_t build_match_list_attrs(hid_t loc1_id, hid_t loc2_id, table_attrs_t ** table_out, diff_opt_t *options)
{
H5O_info_t oinfo1, oinfo2; /* Object info */
hid_t attr1_id=-1; /* attr ID */
hid_t attr2_id=-1; /* attr ID */
size_t curr1 = 0;
size_t curr2 = 0;
unsigned infile[2];
char name1[ATTR_NAME_MAX];
char name2[ATTR_NAME_MAX];
int cmp;
unsigned i;
table_attrs_t *table_lp = NULL;
if(H5Oget_info(loc1_id, &oinfo1) < 0)
goto error;
if(H5Oget_info(loc2_id, &oinfo2) < 0)
goto error;
table_attrs_init( &table_lp );
/*--------------------------------------------------
* build the list
*/
while(curr1 < oinfo1.num_attrs && curr2 < oinfo2.num_attrs)
{
/*------------------
* open attribute1 */
if((attr1_id = H5Aopen_by_idx(loc1_id, ".", H5_INDEX_NAME, H5_ITER_INC, (hsize_t)curr1, H5P_DEFAULT, H5P_DEFAULT)) < 0)
goto error;
/* get name */
if(H5Aget_name(attr1_id, (size_t)ATTR_NAME_MAX, name1) < 0)
goto error;
/*------------------
* open attribute2 */
if((attr2_id = H5Aopen_by_idx(loc2_id, ".", H5_INDEX_NAME, H5_ITER_INC, (hsize_t)curr2, H5P_DEFAULT, H5P_DEFAULT)) < 0)
goto error;
/* get name */
if(H5Aget_name(attr2_id, (size_t)ATTR_NAME_MAX, name2) < 0)
goto error;
/* criteria is string compare */
cmp = HDstrcmp(name1, name2);
if(cmp == 0)
{
infile[0] = 1;
infile[1] = 1;
table_attr_mark_exist(infile, name1, table_lp);
curr1++;
curr2++;
}
else if(cmp < 0)
{
infile[0] = 1;
infile[1] = 0;
table_attr_mark_exist(infile, name1, table_lp);
table_lp->nattrs_only1++;
curr1++;
}
else
{
infile[0] = 0;
infile[1] = 1;
table_attr_mark_exist(infile, name2, table_lp);
table_lp->nattrs_only2++;
curr2++;
}
/* close for next turn */
H5Aclose(attr1_id);
attr1_id = -1;
H5Aclose(attr2_id);
attr2_id = -1;
} /* end while */
/* list1 did not end */
infile[0] = 1;
infile[1] = 0;
while(curr1 < oinfo1.num_attrs)
{
/*------------------
* open attribute1 */
if((attr1_id = H5Aopen_by_idx(loc1_id, ".", H5_INDEX_NAME, H5_ITER_INC, (hsize_t)curr1, H5P_DEFAULT, H5P_DEFAULT)) < 0)
goto error;
/* get name */
if(H5Aget_name(attr1_id, (size_t)ATTR_NAME_MAX, name1) < 0)
goto error;
table_attr_mark_exist(infile, name1, table_lp);
table_lp->nattrs_only1++;
curr1++;
/* close for next turn */
H5Aclose(attr1_id);
attr1_id = -1;
}
/* list2 did not end */
infile[0] = 0;
infile[1] = 1;
while(curr2 < oinfo2.num_attrs)
{
/*------------------
* open attribute2 */
if((attr2_id = H5Aopen_by_idx(loc2_id, ".", H5_INDEX_NAME, H5_ITER_INC, (hsize_t)curr2, H5P_DEFAULT, H5P_DEFAULT)) < 0)
goto error;
/* get name */
if(H5Aget_name(attr2_id, (size_t)ATTR_NAME_MAX, name2) < 0)
goto error;
table_attr_mark_exist(infile, name2, table_lp);
table_lp->nattrs_only2++;
curr2++;
/* close for next turn */
H5Aclose(attr2_id);
}
/*------------------------------------------------------
* print the list
*/
if(options->m_verbose_level == 2)
{
/* if '-v2' is detected */
parallel_print(" obj1 obj2\n");
parallel_print(" --------------------------------------\n");
for(i = 0; i < (unsigned int) table_lp->nattrs; i++)
{
char c1, c2;
c1 = (table_lp->attrs[i].exist[0]) ? 'x' : ' ';
c2 = (table_lp->attrs[i].exist[1]) ? 'x' : ' ';
parallel_print("%5c %6c %-15s\n", c1, c2, table_lp->attrs[i].name);
} /* end for */
}
if(options->m_verbose_level >= 1)
{
parallel_print("Attributes status: %d common, %d only in obj1, %d only in obj2\n", table_lp->nattrs - table_lp->nattrs_only1 - table_lp->nattrs_only2, table_lp->nattrs_only1, table_lp->nattrs_only2 );
}
*table_out = table_lp;
return 0;
error:
if (0 < attr1_id)
H5Aclose(attr1_id);
if (0 < attr2_id)
H5Aclose(attr2_id);
return -1;
}
void print_sizes( const char *obj1,
const char *obj2,
hid_t f_tid1,
hid_t f_tid2,
hid_t m_tid1,
hid_t m_tid2 )
{
size_t f_size1, f_size2; /* size of type in file */
size_t m_size1, m_size2; /* size of type in memory */
f_size1 = H5Tget_size( f_tid1 );
f_size2 = H5Tget_size( f_tid2 );
m_size1 = H5Tget_size( m_tid1 );
m_size2 = H5Tget_size( m_tid2 );
parallel_print("\n");
parallel_print("------------------\n");
parallel_print("sizeof(char) %u\n", sizeof(char) );
parallel_print("sizeof(short) %u\n", sizeof(short) );
parallel_print("sizeof(int) %u\n", sizeof(int) );
parallel_print("sizeof(long) %u\n", sizeof(long) );
parallel_print("<%s> ------------------\n", obj1);
parallel_print("type on file ");
print_type(f_tid1);
parallel_print("\n");
parallel_print("size on file %u\n", f_size1 );
parallel_print("type on memory ");
print_type(m_tid1);
parallel_print("\n");
parallel_print("size on memory %u\n", m_size1 );
parallel_print("<%s> ------------------\n", obj2);
parallel_print("type on file ");
print_type(f_tid2);
parallel_print("\n");
parallel_print("size on file %u\n", f_size2 );
parallel_print("type on memory ");
print_type(m_tid2);
parallel_print("\n");
parallel_print("size on memory %u\n", m_size2 );
parallel_print("\n");
}
int diff_can_type( hid_t f_tid1, /* file data type */
hid_t f_tid2, /* file data type */
int rank1,
int rank2,
hsize_t *dims1,
hsize_t *dims2,
hsize_t *maxdim1,
hsize_t *maxdim2,
const char *obj1_name,
const char *obj2_name,
diff_opt_t *options,
int is_compound)
{
H5T_class_t tclass1;
H5T_class_t tclass2;
int maxdim_diff=0; /* maximum dimensions are different */
int dim_diff=0; /* current dimensions are different */
int i;
int can_compare = 1; /* return value */
/*-------------------------------------------------------------------------
* check for the same class
*-------------------------------------------------------------------------
*/
if ((tclass1=H5Tget_class(f_tid1)) < 0)
return -1;
if ((tclass2=H5Tget_class(f_tid2)) < 0)
return -1;
if ( tclass1 != tclass2 )
{
if ( (options->m_verbose||options->m_list_not_cmp) && obj1_name && obj2_name)
{
if ( is_compound )
{
parallel_print("Not comparable: <%s> has a class %s and <%s> has a class %s\n",
obj1_name, get_class(tclass1),
obj2_name, get_class(tclass2) );
}
else
{
parallel_print("Not comparable: <%s> is of class %s and <%s> is of class %s\n",
obj1_name, get_class(tclass1),
obj2_name, get_class(tclass2) );
}
}
can_compare = 0;
options->not_cmp = 1;
return can_compare;
}
/*-------------------------------------------------------------------------
* check for non supported classes
*-------------------------------------------------------------------------
*/
HDassert(tclass1==tclass2);
switch (tclass1)
{
case H5T_INTEGER:
case H5T_FLOAT:
case H5T_COMPOUND:
case H5T_STRING:
case H5T_ARRAY:
case H5T_BITFIELD:
case H5T_OPAQUE:
case H5T_ENUM:
case H5T_VLEN:
case H5T_REFERENCE:
break;
default: /*H5T_TIME */
if ( (options->m_verbose||options->m_list_not_cmp) && obj1_name && obj2_name)
{
parallel_print("Not comparable: <%s> and <%s> are of class %s\n",
obj1_name,obj2_name,get_class(tclass2) );
}
can_compare = 0;
options->not_cmp = 1;
return can_compare;
}
/*-------------------------------------------------------------------------
* check for equal file datatype; warning only
*-------------------------------------------------------------------------
*/
if ( (H5Tequal(f_tid1, f_tid2)==0) &&
(options->m_verbose) && obj1_name && obj2_name)
{
H5T_class_t cl = H5Tget_class(f_tid1);
parallel_print("Warning: different storage datatype\n");
if ( cl == H5T_INTEGER || cl == H5T_FLOAT )
{
parallel_print("<%s> has file datatype ", obj1_name);
print_type(f_tid1);
parallel_print("\n");
parallel_print("<%s> has file datatype ", obj2_name);
print_type(f_tid2);
parallel_print("\n");
}
}
/*-------------------------------------------------------------------------
* check for the same rank
*-------------------------------------------------------------------------
*/
if ( rank1 != rank2 )
{
if ( (options->m_verbose||options->m_list_not_cmp) && obj1_name && obj2_name)
{
parallel_print("Not comparable: <%s> has rank %d, dimensions ", obj1_name, rank1);
print_dimensions(rank1,dims1);
parallel_print(", max dimensions ");
print_dimensions(rank1,maxdim1);
parallel_print("\n" );
parallel_print("and <%s> has rank %d, dimensions ", obj2_name, rank2);
print_dimensions(rank2,dims2);
parallel_print(", max dimensions ");
print_dimensions(rank2,maxdim2);
parallel_print("\n");
}
can_compare = 0;
options->not_cmp = 1;
return can_compare;
}
/*-------------------------------------------------------------------------
* check for different dimensions
*-------------------------------------------------------------------------
*/
HDassert(rank1==rank2);
for ( i=0; i<rank1; i++)
{
if (maxdim1 && maxdim2)
{
if ( maxdim1[i] != maxdim2[i] )
maxdim_diff=1;
}
if ( dims1[i] != dims2[i] )
dim_diff=1;
}
/*-------------------------------------------------------------------------
* current dimensions
*-------------------------------------------------------------------------
*/
if (dim_diff==1)
{
if ( (options->m_verbose||options->m_list_not_cmp) && obj1_name && obj2_name)
{
parallel_print("Not comparable: <%s> has rank %d, dimensions ", obj1_name, rank1);
print_dimensions(rank1,dims1);
if (maxdim1 && maxdim2)
{
parallel_print(", max dimensions ");
print_dimensions(rank1,maxdim1);
parallel_print("\n" );
parallel_print("and <%s> has rank %d, dimensions ", obj2_name, rank2);
print_dimensions(rank2,dims2);
parallel_print(", max dimensions ");
print_dimensions(rank2,maxdim2);
parallel_print("\n");
}
}
can_compare = 0;
options->not_cmp = 1;
return can_compare;
}
/*-------------------------------------------------------------------------
* maximum dimensions; just give a warning
*-------------------------------------------------------------------------
*/
if (maxdim1 && maxdim2 && maxdim_diff==1 && obj1_name )
{
if (options->m_verbose) {
parallel_print( "Warning: different maximum dimensions\n");
parallel_print("<%s> has max dimensions ", obj1_name);
print_dimensions(rank1,maxdim1);
parallel_print("\n");
parallel_print("<%s> has max dimensions ", obj2_name);
print_dimensions(rank2,maxdim2);
parallel_print("\n");
}
}
if ( tclass1 == H5T_COMPOUND )
{
int nmembs1;
int nmembs2;
int j;
hid_t memb_type1;
hid_t memb_type2;
nmembs1 = H5Tget_nmembers(f_tid1);
nmembs2 = H5Tget_nmembers(f_tid2);
if ( nmembs1 != nmembs2 )
{
if ( (options->m_verbose||options->m_list_not_cmp) && obj1_name && obj2_name)
{
parallel_print("Not comparable: <%s> has %d members ", obj1_name, nmembs1);
parallel_print("<%s> has %d members ", obj2_name, nmembs2);
parallel_print("\n");
}
can_compare = 0;
options->not_cmp = 1;
return can_compare;
}
for (j = 0; j < nmembs1; j++)
{
memb_type1 = H5Tget_member_type(f_tid1, (unsigned)j);
memb_type2 = H5Tget_member_type(f_tid2, (unsigned)j);
if (diff_can_type(memb_type1,
memb_type2,
rank1,
rank2,
dims1,
dims2,
maxdim1,
maxdim2,
obj1_name,
obj2_name,
options,
1)!=1)
{
can_compare = 0;
options->not_cmp = 1;
H5Tclose(memb_type1);
H5Tclose(memb_type2);
return can_compare;
}
H5Tclose(memb_type1);
H5Tclose(memb_type2);
}
}
return can_compare;
}
/*------------------------------------------------------------------------- * Function: diff_dataset * * Purpose: check for comparable datasets and read into a compatible * memory type * * Return: Number of differences found * * Programmer: Pedro Vicente, [email protected] * * Date: May 9, 2003 * *------------------------------------------------------------------------- */ hsize_t diff_dataset( hid_t file1_id, hid_t file2_id, const char *obj1_name, const char *obj2_name, diff_opt_t *options) { hid_t did1 = -1; hid_t did2 = -1; hid_t dcpl1 = -1; hid_t dcpl2 = -1; hsize_t nfound = 0; /*------------------------------------------------------------------------- * open the handles *------------------------------------------------------------------------- */ /* disable error reporting */ H5E_BEGIN_TRY { /* Open the datasets */ if((did1 = H5Dopen2(file1_id, obj1_name, H5P_DEFAULT)) < 0) { parallel_print("Cannot open dataset <%s>\n", obj1_name); goto error; } if((did2 = H5Dopen2(file2_id, obj2_name, H5P_DEFAULT)) < 0) { parallel_print("Cannot open dataset <%s>\n", obj2_name); goto error; } /* enable error reporting */ } H5E_END_TRY; if((dcpl1 = H5Dget_create_plist(did1)) < 0) goto error; if((dcpl2 = H5Dget_create_plist(did2)) < 0) { goto error; } /*------------------------------------------------------------------------- * check if the dataset creation property list has filters that * are not registered in the current configuration * 1) the external filters GZIP and SZIP might not be available * 2) the internal filters might be turned off *------------------------------------------------------------------------- */ if ((h5tools_canreadf((options->m_verbose?obj1_name:NULL),dcpl1)==1) && (h5tools_canreadf((options->m_verbose?obj2_name:NULL),dcpl2)==1)) { nfound=diff_datasetid(did1, did2, obj1_name, obj2_name, options); } /*------------------------------------------------------------------------- * close *------------------------------------------------------------------------- */ /* disable error reporting */ H5E_BEGIN_TRY { H5Pclose(dcpl1); H5Pclose(dcpl2); H5Dclose(did1); H5Dclose(did2); /* enable error reporting */ } H5E_END_TRY; return nfound; error: options->err_stat=1; /* disable error reporting */ H5E_BEGIN_TRY { H5Pclose(dcpl1); H5Pclose(dcpl2); H5Dclose(did1); H5Dclose(did2); /* enable error reporting */ } H5E_END_TRY; return nfound; }
/*------------------------------------------------------------------------- * Function: diff_datasetid * * Purpose: check for comparable datasets and read into a compatible * memory type * * Return: Number of differences found * * Programmer: Pedro Vicente, [email protected] * * Date: May 9, 2003 * * Modifications: * * * October 2006: Read by hyperslabs for big datasets. * * A threshold of H5TOOLS_MALLOCSIZE (128 MB) is the limit upon which I/O hyperslab is done * i.e., if the memory needed to read a dataset is greater than this limit, * then hyperslab I/O is done instead of one operation I/O * For each dataset, the memory needed is calculated according to * * memory needed = number of elements * size of each element * * if the memory needed is lower than H5TOOLS_MALLOCSIZE, then the following operations * are done * * H5Dread( input_dataset1 ) * H5Dread( input_dataset2 ) * * with all elements in the datasets selected. If the memory needed is greater than * H5TOOLS_MALLOCSIZE, then the following operations are done instead: * * a strip mine is defined for each dimension k (a strip mine is defined as a * hyperslab whose size is memory manageable) according to the formula * * (1) strip_mine_size[k ] = MIN(dimension[k ], H5TOOLS_BUFSIZE / size of memory type) * * where H5TOOLS_BUFSIZE is a constant currently defined as 1MB. This formula assures * that for small datasets (small relative to the H5TOOLS_BUFSIZE constant), the strip * mine size k is simply defined as its dimension k, but for larger datasets the * hyperslab size is still memory manageable. * a cycle is done until the number of elements in the dataset is reached. In each * iteration, two parameters are defined for the function H5Sselect_hyperslab, * the start and size of each hyperslab, according to * * (2) hyperslab_size [k] = MIN(dimension[k] - hyperslab_offset[k], strip_mine_size [k]) * * where hyperslab_offset [k] is initially set to zero, and later incremented in * hyperslab_size[k] offsets. The reason for the operation * * dimension[k] - hyperslab_offset[k] * * in (2) is that, when using the strip mine size, it assures that the "remaining" part * of the dataset that does not fill an entire strip mine is processed. * *------------------------------------------------------------------------- */ hsize_t diff_datasetid( hid_t did1, hid_t did2, const char *obj1_name, const char *obj2_name, diff_opt_t *options) { hid_t sid1=-1; hid_t sid2=-1; hid_t f_tid1=-1; hid_t f_tid2=-1; hid_t m_tid1=-1; hid_t m_tid2=-1; size_t m_size1; size_t m_size2; H5T_sign_t sign1; H5T_sign_t sign2; int rank1; int rank2; hsize_t nelmts1; hsize_t nelmts2; hsize_t dims1[H5S_MAX_RANK]; hsize_t dims2[H5S_MAX_RANK]; hsize_t maxdim1[H5S_MAX_RANK]; hsize_t maxdim2[H5S_MAX_RANK]; const char *name1=NULL; /* relative names */ const char *name2=NULL; hsize_t storage_size1; hsize_t storage_size2; hsize_t nfound=0; /* number of differences found */ int can_compare=1; /* do diff or not */ void *buf1=NULL; void *buf2=NULL; void *sm_buf1=NULL; void *sm_buf2=NULL; hid_t sm_space; /*stripmine data space */ size_t need; /* bytes needed for malloc */ int i; unsigned int vl_data = 0; /*contains VL datatypes */ /* Get the dataspace handle */ if ( (sid1 = H5Dget_space(did1)) < 0 ) goto error; /* Get rank */ if ( (rank1 = H5Sget_simple_extent_ndims(sid1)) < 0 ) goto error; /* Get the dataspace handle */ if ( (sid2 = H5Dget_space(did2)) < 0 ) goto error; /* Get rank */ if ( (rank2 = H5Sget_simple_extent_ndims(sid2)) < 0 ) goto error; /* Get dimensions */ if ( H5Sget_simple_extent_dims(sid1,dims1,maxdim1) < 0 ) goto error; /* Get dimensions */ if ( H5Sget_simple_extent_dims(sid2,dims2,maxdim2) < 0 ) { goto error; } /*------------------------------------------------------------------------- * get the file data type *------------------------------------------------------------------------- */ /* Get the data type */ if ( (f_tid1 = H5Dget_type(did1)) < 0 ) goto error; /* Get the data type */ if ( (f_tid2 = H5Dget_type(did2)) < 0 ) { goto error; } /*------------------------------------------------------------------------- * check for empty datasets *------------------------------------------------------------------------- */ storage_size1=H5Dget_storage_size(did1); storage_size2=H5Dget_storage_size(did2); if (storage_size1==0 || storage_size2==0) { if ( (options->m_verbose||options->m_list_not_cmp) && obj1_name && obj2_name) parallel_print("Not comparable: <%s> or <%s> is an empty dataset\n", obj1_name, obj2_name); can_compare=0; options->not_cmp=1; } /*------------------------------------------------------------------------- * check for comparable TYPE and SPACE *------------------------------------------------------------------------- */ if (diff_can_type(f_tid1, f_tid2, rank1, rank2, dims1, dims2, maxdim1, maxdim2, obj1_name, obj2_name, options, 0)!=1) { can_compare=0; } /*------------------------------------------------------------------------- * memory type and sizes *------------------------------------------------------------------------- */ if ((m_tid1=h5tools_get_native_type(f_tid1)) < 0) goto error; if ((m_tid2=h5tools_get_native_type(f_tid2)) < 0) goto error; m_size1 = H5Tget_size( m_tid1 ); m_size2 = H5Tget_size( m_tid2 ); /*------------------------------------------------------------------------- * check for different signed/unsigned types *------------------------------------------------------------------------- */ if (can_compare) { sign1=H5Tget_sign(m_tid1); sign2=H5Tget_sign(m_tid2); if ( sign1 != sign2 ) { if ((options->m_verbose||options->m_list_not_cmp) && obj1_name && obj2_name) { parallel_print("Not comparable: <%s> has sign %s ", obj1_name, get_sign(sign1)); parallel_print("and <%s> has sign %s\n", obj2_name, get_sign(sign2)); } can_compare=0; options->not_cmp=1; } } /* Check if type is either VLEN-data or VLEN-string to reclaim any * VLEN memory buffer later */ if( TRUE == h5tools_detect_vlen(m_tid1) ) vl_data = TRUE; /*------------------------------------------------------------------------ * only attempt to compare if possible *------------------------------------------------------------------------- */ if(can_compare) /* it is possible to compare */ { /*----------------------------------------------------------------- * get number of elements *------------------------------------------------------------------ */ nelmts1 = 1; for(i = 0; i < rank1; i++) nelmts1 *= dims1[i]; nelmts2 = 1; for(i = 0; i < rank2; i++) nelmts2 *= dims2[i]; HDassert(nelmts1 == nelmts2); /*----------------------------------------------------------------- * "upgrade" the smaller memory size *------------------------------------------------------------------ */ if (FAIL == match_up_memsize (f_tid1, f_tid2, &m_tid1, &m_tid2, &m_size1, &m_size2)) goto error; /* print names */ if(obj1_name) name1 = diff_basename(obj1_name); if(obj2_name) name2 = diff_basename(obj2_name); /*---------------------------------------------------------------- * read/compare *----------------------------------------------------------------- */ need = (size_t)(nelmts1 * m_size1); /* bytes needed */ if(need < H5TOOLS_MALLOCSIZE) { buf1 = HDmalloc(need); buf2 = HDmalloc(need); } /* end if */ if(buf1 != NULL && buf2 != NULL) { if(H5Dread(did1, m_tid1, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf1) < 0) goto error; if(H5Dread(did2, m_tid2, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf2) < 0) goto error; /* array diff */ nfound = diff_array(buf1, buf2, nelmts1, (hsize_t)0, rank1, dims1, options, name1, name2, m_tid1, did1, did2); /* reclaim any VL memory, if necessary */ if(vl_data) { H5Dvlen_reclaim(m_tid1, sid1, H5P_DEFAULT, buf1); H5Dvlen_reclaim(m_tid2, sid2, H5P_DEFAULT, buf2); } /* end if */ } /* end if */ else /* possibly not enough memory, read/compare by hyperslabs */ { size_t p_type_nbytes = m_size1; /*size of memory type */ hsize_t p_nelmts = nelmts1; /*total selected elmts */ hsize_t elmtno; /*counter */ int carry; /*counter carry value */ /* stripmine info */ hsize_t sm_size[H5S_MAX_RANK]; /*stripmine size */ hsize_t sm_nbytes; /*bytes per stripmine */ hsize_t sm_nelmts; /*elements per stripmine*/ /* hyperslab info */ hsize_t hs_offset[H5S_MAX_RANK]; /*starting offset */ hsize_t hs_size[H5S_MAX_RANK]; /*size this pass */ hsize_t hs_nelmts; /*elements in request */ hsize_t zero[8]; /*vector of zeros */ /* * determine the strip mine size and allocate a buffer. The strip mine is * a hyperslab whose size is manageable. */ sm_nbytes = p_type_nbytes; for(i = rank1; i > 0; --i) { hsize_t size = H5TOOLS_BUFSIZE / sm_nbytes; if(size == 0) /* datum size > H5TOOLS_BUFSIZE */ size = 1; sm_size[i - 1] = MIN(dims1[i - 1], size); sm_nbytes *= sm_size[i - 1]; HDassert(sm_nbytes > 0); } /* end for */ /* malloc return code should be verified. * If fail, need to handle the error. * This else branch should be recoded as a separate function. * Note that there are many "goto error" within this branch * that fails to address freeing other objects created here. * E.g., sm_space. */ sm_buf1 = HDmalloc((size_t)sm_nbytes); HDassert(sm_buf1); sm_buf2 = HDmalloc((size_t)sm_nbytes); HDassert(sm_buf2); sm_nelmts = sm_nbytes / p_type_nbytes; sm_space = H5Screate_simple(1, &sm_nelmts, NULL); /* the stripmine loop */ HDmemset(hs_offset, 0, sizeof hs_offset); HDmemset(zero, 0, sizeof zero); for(elmtno = 0; elmtno < p_nelmts; elmtno += hs_nelmts) { /* calculate the hyperslab size */ if(rank1 > 0) { for(i = 0, hs_nelmts = 1; i < rank1; i++) { hs_size[i] = MIN(dims1[i] - hs_offset[i], sm_size[i]); hs_nelmts *= hs_size[i]; } /* end for */ if(H5Sselect_hyperslab(sid1, H5S_SELECT_SET, hs_offset, NULL, hs_size, NULL) < 0) goto error; if(H5Sselect_hyperslab(sid2, H5S_SELECT_SET, hs_offset, NULL, hs_size, NULL) < 0) goto error; if(H5Sselect_hyperslab(sm_space, H5S_SELECT_SET, zero, NULL, &hs_nelmts, NULL) < 0) goto error; } /* end if */ else hs_nelmts = 1; if(H5Dread(did1,m_tid1,sm_space,sid1,H5P_DEFAULT,sm_buf1) < 0) goto error; if(H5Dread(did2,m_tid2,sm_space,sid2,H5P_DEFAULT,sm_buf2) < 0) goto error; /* get array differences. in the case of hyperslab read, increment the number of differences found in each hyperslab and pass the position at the beggining for printing */ nfound += diff_array(sm_buf1, sm_buf2, hs_nelmts, elmtno, rank1, dims1, options, name1, name2, m_tid1, did1, did2); /* reclaim any VL memory, if necessary */ if(vl_data) { H5Dvlen_reclaim(m_tid1, sm_space, H5P_DEFAULT, sm_buf1); H5Dvlen_reclaim(m_tid1, sm_space, H5P_DEFAULT, sm_buf2); } /* end if */ /* calculate the next hyperslab offset */ for(i = rank1, carry = 1; i > 0 && carry; --i) { hs_offset[i - 1] += hs_size[i - 1]; if(hs_offset[i - 1] == dims1[i - 1]) hs_offset[i - 1] = 0; else carry = 0; } /* i */ } /* elmtno */ H5Sclose(sm_space); } /* hyperslab read */ } /*can_compare*/ /*------------------------------------------------------------------------- * close *------------------------------------------------------------------------- */ /* free */ if(buf1 != NULL) { HDfree(buf1); buf1 = NULL; } /* end if */ if(buf2 != NULL) { HDfree(buf2); buf2 = NULL; } /* end if */ if(sm_buf1 != NULL) { HDfree(sm_buf1); sm_buf1 = NULL; } /* end if */ if(sm_buf2 != NULL) { HDfree(sm_buf2); sm_buf2 = NULL; } /* end if */ H5E_BEGIN_TRY { H5Sclose(sid1); H5Sclose(sid2); H5Tclose(f_tid1); H5Tclose(f_tid2); H5Tclose(m_tid1); H5Tclose(m_tid2); } H5E_END_TRY; return nfound; error: options->err_stat=1; /* free */ if (buf1!=NULL) { /* reclaim any VL memory, if necessary */ if(vl_data) H5Dvlen_reclaim(m_tid1, sid1, H5P_DEFAULT, buf1); HDfree(buf1); buf1=NULL; } if (buf2!=NULL) { /* reclaim any VL memory, if necessary */ if(vl_data) H5Dvlen_reclaim(m_tid2, sid2, H5P_DEFAULT, buf2); HDfree(buf2); buf2=NULL; } if (sm_buf1!=NULL) { /* reclaim any VL memory, if necessary */ if(vl_data) H5Dvlen_reclaim(m_tid1, sm_space, H5P_DEFAULT, sm_buf1); HDfree(sm_buf1); sm_buf1=NULL; } if (sm_buf2!=NULL) { /* reclaim any VL memory, if necessary */ if(vl_data) H5Dvlen_reclaim(m_tid1, sm_space, H5P_DEFAULT, sm_buf2); HDfree(sm_buf2); sm_buf2=NULL; } /* disable error reporting */ H5E_BEGIN_TRY { H5Sclose(sid1); H5Sclose(sid2); H5Tclose(f_tid1); H5Tclose(f_tid2); H5Tclose(m_tid1); H5Tclose(m_tid2); /* enable error reporting */ } H5E_END_TRY; return nfound; }
/*------------------------------------------------------------------------- * Function: print_type * * Purpose: Print name of datatype * * Return: void * * Programmer: Pedro Vicente, [email protected] * * Date: May 9, 2003 * * Comments: Adapted from h5dump for H5T_INTEGER and H5T_FLOAT classes only * *------------------------------------------------------------------------- */ void print_type(hid_t type) { switch (H5Tget_class(type)) { default: return; case H5T_INTEGER: if (H5Tequal(type, H5T_STD_I8BE)) { parallel_print("H5T_STD_I8BE"); } else if (H5Tequal(type, H5T_STD_I8LE)) { parallel_print("H5T_STD_I8LE"); } else if (H5Tequal(type, H5T_STD_I16BE)) { parallel_print("H5T_STD_I16BE"); } else if (H5Tequal(type, H5T_STD_I16LE)) { parallel_print("H5T_STD_I16LE"); } else if (H5Tequal(type, H5T_STD_I32BE)) { parallel_print("H5T_STD_I32BE"); } else if (H5Tequal(type, H5T_STD_I32LE)) { parallel_print("H5T_STD_I32LE"); } else if (H5Tequal(type, H5T_STD_I64BE)) { parallel_print("H5T_STD_I64BE"); } else if (H5Tequal(type, H5T_STD_I64LE)) { parallel_print("H5T_STD_I64LE"); } else if (H5Tequal(type, H5T_STD_U8BE)) { parallel_print("H5T_STD_U8BE"); } else if (H5Tequal(type, H5T_STD_U8LE)) { parallel_print("H5T_STD_U8LE"); } else if (H5Tequal(type, H5T_STD_U16BE)) { parallel_print("H5T_STD_U16BE"); } else if (H5Tequal(type, H5T_STD_U16LE)) { parallel_print("H5T_STD_U16LE"); } else if (H5Tequal(type, H5T_STD_U32BE)) { parallel_print("H5T_STD_U32BE"); } else if (H5Tequal(type, H5T_STD_U32LE)) { parallel_print("H5T_STD_U32LE"); } else if (H5Tequal(type, H5T_STD_U64BE)) { parallel_print("H5T_STD_U64BE"); } else if (H5Tequal(type, H5T_STD_U64LE)) { parallel_print("H5T_STD_U64LE"); } else if (H5Tequal(type, H5T_NATIVE_SCHAR)) { parallel_print("H5T_NATIVE_SCHAR"); } else if (H5Tequal(type, H5T_NATIVE_UCHAR)) { parallel_print("H5T_NATIVE_UCHAR"); } else if (H5Tequal(type, H5T_NATIVE_SHORT)) { parallel_print("H5T_NATIVE_SHORT"); } else if (H5Tequal(type, H5T_NATIVE_USHORT)) { parallel_print("H5T_NATIVE_USHORT"); } else if (H5Tequal(type, H5T_NATIVE_INT)) { parallel_print("H5T_NATIVE_INT"); } else if (H5Tequal(type, H5T_NATIVE_UINT)) { parallel_print("H5T_NATIVE_UINT"); } else if (H5Tequal(type, H5T_NATIVE_LONG)) { parallel_print("H5T_NATIVE_LONG"); } else if (H5Tequal(type, H5T_NATIVE_ULONG)) { parallel_print("H5T_NATIVE_ULONG"); } else if (H5Tequal(type, H5T_NATIVE_LLONG)) { parallel_print("H5T_NATIVE_LLONG"); } else if (H5Tequal(type, H5T_NATIVE_ULLONG)) { parallel_print("H5T_NATIVE_ULLONG"); } else { parallel_print("undefined integer"); } break; case H5T_FLOAT: if (H5Tequal(type, H5T_IEEE_F32BE)) { parallel_print("H5T_IEEE_F32BE"); } else if (H5Tequal(type, H5T_IEEE_F32LE)) { parallel_print("H5T_IEEE_F32LE"); } else if (H5Tequal(type, H5T_IEEE_F64BE)) { parallel_print("H5T_IEEE_F64BE"); } else if (H5Tequal(type, H5T_IEEE_F64LE)) { parallel_print("H5T_IEEE_F64LE"); } else if (H5Tequal(type, H5T_NATIVE_FLOAT)) { parallel_print("H5T_NATIVE_FLOAT"); } else if (H5Tequal(type, H5T_NATIVE_DOUBLE)) { parallel_print("H5T_NATIVE_DOUBLE"); #if H5_SIZEOF_LONG_DOUBLE !=0 } else if (H5Tequal(type, H5T_NATIVE_LDOUBLE)) { parallel_print("H5T_NATIVE_LDOUBLE"); #endif } else { parallel_print("undefined float"); } break; }/*switch*/ }
/*------------------------------------------------------------------------- * Function: print_type * * Purpose: Print name of datatype * * Return: void * * Programmer: Pedro Vicente, [email protected] * * Date: May 9, 2003 * * Comments: Adapted from h5dump for H5T_INTEGER and H5T_FLOAT classes only * *------------------------------------------------------------------------- */ void print_type(hid_t type) { switch (H5Tget_class(type)) { case H5T_INTEGER: if (H5Tequal(type, H5T_STD_I8BE)) { parallel_print("H5T_STD_I8BE"); } else if (H5Tequal(type, H5T_STD_I8LE)) { parallel_print("H5T_STD_I8LE"); } else if (H5Tequal(type, H5T_STD_I16BE)) { parallel_print("H5T_STD_I16BE"); } else if (H5Tequal(type, H5T_STD_I16LE)) { parallel_print("H5T_STD_I16LE"); } else if (H5Tequal(type, H5T_STD_I32BE)) { parallel_print("H5T_STD_I32BE"); } else if (H5Tequal(type, H5T_STD_I32LE)) { parallel_print("H5T_STD_I32LE"); } else if (H5Tequal(type, H5T_STD_I64BE)) { parallel_print("H5T_STD_I64BE"); } else if (H5Tequal(type, H5T_STD_I64LE)) { parallel_print("H5T_STD_I64LE"); } else if (H5Tequal(type, H5T_STD_U8BE)) { parallel_print("H5T_STD_U8BE"); } else if (H5Tequal(type, H5T_STD_U8LE)) { parallel_print("H5T_STD_U8LE"); } else if (H5Tequal(type, H5T_STD_U16BE)) { parallel_print("H5T_STD_U16BE"); } else if (H5Tequal(type, H5T_STD_U16LE)) { parallel_print("H5T_STD_U16LE"); } else if (H5Tequal(type, H5T_STD_U32BE)) { parallel_print("H5T_STD_U32BE"); } else if (H5Tequal(type, H5T_STD_U32LE)) { parallel_print("H5T_STD_U32LE"); } else if (H5Tequal(type, H5T_STD_U64BE)) { parallel_print("H5T_STD_U64BE"); } else if (H5Tequal(type, H5T_STD_U64LE)) { parallel_print("H5T_STD_U64LE"); } else if (H5Tequal(type, H5T_NATIVE_SCHAR)) { parallel_print("H5T_NATIVE_SCHAR"); } else if (H5Tequal(type, H5T_NATIVE_UCHAR)) { parallel_print("H5T_NATIVE_UCHAR"); } else if (H5Tequal(type, H5T_NATIVE_SHORT)) { parallel_print("H5T_NATIVE_SHORT"); } else if (H5Tequal(type, H5T_NATIVE_USHORT)) { parallel_print("H5T_NATIVE_USHORT"); } else if (H5Tequal(type, H5T_NATIVE_INT)) { parallel_print("H5T_NATIVE_INT"); } else if (H5Tequal(type, H5T_NATIVE_UINT)) { parallel_print("H5T_NATIVE_UINT"); } else if (H5Tequal(type, H5T_NATIVE_LONG)) { parallel_print("H5T_NATIVE_LONG"); } else if (H5Tequal(type, H5T_NATIVE_ULONG)) { parallel_print("H5T_NATIVE_ULONG"); } else if (H5Tequal(type, H5T_NATIVE_LLONG)) { parallel_print("H5T_NATIVE_LLONG"); } else if (H5Tequal(type, H5T_NATIVE_ULLONG)) { parallel_print("H5T_NATIVE_ULLONG"); } else { parallel_print("undefined integer"); } break; case H5T_FLOAT: if (H5Tequal(type, H5T_IEEE_F32BE)) { parallel_print("H5T_IEEE_F32BE"); } else if (H5Tequal(type, H5T_IEEE_F32LE)) { parallel_print("H5T_IEEE_F32LE"); } else if (H5Tequal(type, H5T_IEEE_F64BE)) { parallel_print("H5T_IEEE_F64BE"); } else if (H5Tequal(type, H5T_IEEE_F64LE)) { parallel_print("H5T_IEEE_F64LE"); } else if (H5Tequal(type, H5T_NATIVE_FLOAT)) { parallel_print("H5T_NATIVE_FLOAT"); } else if (H5Tequal(type, H5T_NATIVE_DOUBLE)) { parallel_print("H5T_NATIVE_DOUBLE"); #if H5_SIZEOF_LONG_DOUBLE !=0 } else if (H5Tequal(type, H5T_NATIVE_LDOUBLE)) { parallel_print("H5T_NATIVE_LDOUBLE"); #endif } else { parallel_print("undefined float"); } break; case H5T_TIME: case H5T_STRING: case H5T_BITFIELD: case H5T_OPAQUE: case H5T_COMPOUND: case H5T_REFERENCE: case H5T_ENUM: case H5T_VLEN: case H5T_ARRAY: case H5T_NO_CLASS: case H5T_NCLASSES: default: return; } /* end switch */ }
/*-------------------------------------------------------------------------
* Function: H5tools_get_symlink_info
*
* Purpose: Get symbolic link (soft, external) info and its target object type
(dataset, group, named datatype) and path, if exist
*
* Patameters:
* - [IN] fileid : link file id
* - [IN] linkpath : link path
* - [OUT] link_info: returning target object info (h5tool_link_info_t)
*
* Return:
* 2 : given pathname is object
* 1 : Succed to get link info.
* 0 : Detected as a dangling link
* -1 : H5 API failed.
*
* NOTE:
* link_info->trg_path must be freed out of this function
*
* Programmer: Jonathan Kim
*
* Date: Feb 8, 2010
*-------------------------------------------------------------------------*/
int
H5tools_get_symlink_info(hid_t file_id, const char * linkpath, h5tool_link_info_t *link_info,
hbool_t get_obj_type)
{
htri_t l_ret;
H5O_info_t trg_oinfo;
hid_t fapl = H5P_DEFAULT;
hid_t lapl = H5P_DEFAULT;
int ret = -1; /* init to fail */
/* init */
link_info->trg_type = H5O_TYPE_UNKNOWN;
/* if path is root, return group type */
if(!HDstrcmp(linkpath,"/"))
{
link_info->trg_type = H5O_TYPE_GROUP;
ret = 2;
goto out;
}
/* check if link itself exist */
if(H5Lexists(file_id, linkpath, H5P_DEFAULT) <= 0) {
if(link_info->opt.msg_mode == 1)
parallel_print("Warning: link <%s> doesn't exist \n",linkpath);
goto out;
} /* end if */
/* get info from link */
if(H5Lget_info(file_id, linkpath, &(link_info->linfo), H5P_DEFAULT) < 0) {
if(link_info->opt.msg_mode == 1)
parallel_print("Warning: unable to get link info from <%s>\n",linkpath);
goto out;
} /* end if */
/* given path is hard link (object) */
if(link_info->linfo.type == H5L_TYPE_HARD) {
ret = 2;
goto out;
} /* end if */
/* trg_path must be freed out of this function when finished using */
link_info->trg_path = (char*)HDcalloc(link_info->linfo.u.val_size, sizeof(char));
HDassert(link_info->trg_path);
/* get link value */
if(H5Lget_val(file_id, linkpath, (void *)link_info->trg_path, link_info->linfo.u.val_size, H5P_DEFAULT) < 0) {
if(link_info->opt.msg_mode == 1)
parallel_print("Warning: unable to get link value from <%s>\n",linkpath);
goto out;
} /* end if */
/*-----------------------------------------------------
* if link type is external link use different lapl to
* follow object in other file
*/
if(link_info->linfo.type == H5L_TYPE_EXTERNAL) {
if((fapl = H5Pcreate(H5P_FILE_ACCESS)) < 0)
goto out;
if(H5Pset_fapl_sec2(fapl) < 0)
goto out;
if((lapl = H5Pcreate(H5P_LINK_ACCESS)) < 0)
goto out;
if(H5Pset_elink_fapl(lapl, fapl) < 0)
goto out;
} /* end if */
/* Check for retrieving object info */
if(get_obj_type) {
/*--------------------------------------------------------------
* if link's target object exist, get type
*/
/* check if target object exist */
l_ret = H5Oexists_by_name(file_id, linkpath, lapl);
/* detect dangling link */
if(l_ret == FALSE) {
ret = 0;
goto out;
} /* end if */
/* function failed */
else if(l_ret < 0)
goto out;
/* get target object info */
if(H5Oget_info_by_name(file_id, linkpath, &trg_oinfo, lapl) < 0) {
if(link_info->opt.msg_mode == 1)
parallel_print("Warning: unable to get object information for <%s>\n", linkpath);
goto out;
} /* end if */
/* check unknown type */
if(trg_oinfo.type < H5O_TYPE_GROUP || trg_oinfo.type >=H5O_TYPE_NTYPES) {
if(link_info->opt.msg_mode == 1)
parallel_print("Warning: target object of <%s> is unknown type\n", linkpath);
goto out;
} /* end if */
/* set target obj type to return */
link_info->trg_type = trg_oinfo.type;
link_info->objno = trg_oinfo.addr;
link_info->fileno = trg_oinfo.fileno;
} /* end if */
else
link_info->trg_type = H5O_TYPE_UNKNOWN;
/* succeed */
ret = 1;
out:
if(fapl != H5P_DEFAULT)
H5Pclose(fapl);
if(lapl != H5P_DEFAULT)
H5Pclose(lapl);
return ret;
} /* end H5tools_get_symlink_info() */
