mirror of
https://github.com/HDFGroup/hdf5.git
synced 2024-12-15 07:40:23 +08:00
HDFFV-9055 Handle H5T_ARRAY types
Create variables just for diff_array function Whitespace updates
This commit is contained in:
Allen Byrne
parent
2e1b6a2a4d
commit
4d53a7100c
@ -44,6 +44,7 @@ hsize_t diff_dataset( hid_t file1_id,
|
||||
hid_t dcpl2 = -1;
|
||||
hsize_t nfound = 0;
|
||||
|
||||
h5difftrace("diff_dataset start\n");
|
||||
/*-------------------------------------------------------------------------
|
||||
* open the handles
|
||||
*-------------------------------------------------------------------------
|
||||
@ -52,13 +53,11 @@ hsize_t diff_dataset( hid_t file1_id,
|
||||
H5E_BEGIN_TRY
|
||||
{
|
||||
/* Open the datasets */
|
||||
if((did1 = H5Dopen2(file1_id, obj1_name, H5P_DEFAULT)) < 0)
|
||||
{
|
||||
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)
|
||||
{
|
||||
if((did2 = H5Dopen2(file2_id, obj2_name, H5P_DEFAULT)) < 0) {
|
||||
parallel_print("Cannot open dataset <%s>\n", obj2_name);
|
||||
goto error;
|
||||
}
|
||||
@ -78,15 +77,9 @@ hsize_t diff_dataset( hid_t file1_id,
|
||||
* 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);
|
||||
}
|
||||
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);
|
||||
else
|
||||
goto error;
|
||||
|
||||
@ -94,20 +87,12 @@ hsize_t diff_dataset( hid_t file1_id,
|
||||
* close
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
/* disable error reporting */
|
||||
H5E_BEGIN_TRY {
|
||||
H5Pclose(dcpl1);
|
||||
H5Pclose(dcpl2);
|
||||
H5Dclose(did1);
|
||||
H5Dclose(did2);
|
||||
/* enable error reporting */
|
||||
} H5E_END_TRY;
|
||||
|
||||
|
||||
return nfound;
|
||||
goto done;
|
||||
|
||||
error:
|
||||
options->err_stat=1;
|
||||
options->err_stat = 1;
|
||||
|
||||
done:
|
||||
/* disable error reporting */
|
||||
H5E_BEGIN_TRY {
|
||||
H5Pclose(dcpl1);
|
||||
@ -117,6 +102,7 @@ error:
|
||||
/* enable error reporting */
|
||||
} H5E_END_TRY;
|
||||
|
||||
h5difftrace("diff_dataset end\n");
|
||||
return nfound;
|
||||
}
|
||||
|
||||
@ -188,20 +174,24 @@ hsize_t diff_datasetid( hid_t did1,
|
||||
hid_t sid2=-1;
|
||||
hid_t f_tid1=-1;
|
||||
hid_t f_tid2=-1;
|
||||
hid_t dam_tid=-1; /* m_tid for diff_array function */
|
||||
hid_t m_tid1=-1;
|
||||
hid_t m_tid2=-1;
|
||||
hid_t dcpl1 = -1;
|
||||
hid_t dcpl2 = -1;
|
||||
H5D_layout_t stl1 = -1;
|
||||
H5D_layout_t stl2 = -1;
|
||||
size_t dam_size; /* m_size for diff_array function */
|
||||
size_t m_size1;
|
||||
size_t m_size2;
|
||||
H5T_sign_t sign1;
|
||||
H5T_sign_t sign2;
|
||||
int rank1;
|
||||
int rank2;
|
||||
hsize_t danelmts; /* nelmts for diff_array function */
|
||||
hsize_t nelmts1;
|
||||
hsize_t nelmts2;
|
||||
hsize_t *dadims; /* dims for diff_array function */
|
||||
hsize_t dims1[H5S_MAX_RANK];
|
||||
hsize_t dims2[H5S_MAX_RANK];
|
||||
hsize_t maxdim1[H5S_MAX_RANK];
|
||||
@ -223,30 +213,29 @@ hsize_t diff_datasetid( hid_t did1,
|
||||
|
||||
h5difftrace("diff_datasetid start\n");
|
||||
/* Get the dataspace handle */
|
||||
if ( (sid1 = H5Dget_space(did1)) < 0 )
|
||||
if((sid1 = H5Dget_space(did1)) < 0)
|
||||
goto error;
|
||||
|
||||
/* Get rank */
|
||||
if ( (rank1 = H5Sget_simple_extent_ndims(sid1)) < 0 )
|
||||
if((rank1 = H5Sget_simple_extent_ndims(sid1)) < 0)
|
||||
goto error;
|
||||
|
||||
/* Get the dataspace handle */
|
||||
if ( (sid2 = H5Dget_space(did2)) < 0 )
|
||||
if((sid2 = H5Dget_space(did2)) < 0 )
|
||||
goto error;
|
||||
|
||||
/* Get rank */
|
||||
if ( (rank2 = H5Sget_simple_extent_ndims(sid2)) < 0 )
|
||||
if((rank2 = H5Sget_simple_extent_ndims(sid2)) < 0)
|
||||
goto error;
|
||||
|
||||
/* Get dimensions */
|
||||
if ( H5Sget_simple_extent_dims(sid1,dims1,maxdim1) < 0 )
|
||||
if(H5Sget_simple_extent_dims(sid1, dims1, maxdim1) < 0)
|
||||
goto error;
|
||||
|
||||
/* Get dimensions */
|
||||
if ( H5Sget_simple_extent_dims(sid2,dims2,maxdim2) < 0 )
|
||||
{
|
||||
if(H5Sget_simple_extent_dims(sid2, dims2, maxdim2) < 0)
|
||||
goto error;
|
||||
}
|
||||
h5diffdebug3("rank: %ld - %ld\n", rank1, rank2);
|
||||
|
||||
/*-------------------------------------------------------------------------
|
||||
* get the file data type
|
||||
@ -254,15 +243,12 @@ hsize_t diff_datasetid( hid_t did1,
|
||||
*/
|
||||
|
||||
/* Get the data type */
|
||||
if ( (f_tid1 = H5Dget_type(did1)) < 0 )
|
||||
if((f_tid1 = H5Dget_type(did1)) < 0)
|
||||
goto error;
|
||||
|
||||
/* Get the data type */
|
||||
if ( (f_tid2 = H5Dget_type(did2)) < 0 )
|
||||
{
|
||||
if((f_tid2 = H5Dget_type(did2)) < 0)
|
||||
goto error;
|
||||
}
|
||||
|
||||
|
||||
/*-------------------------------------------------------------------------
|
||||
* get the storage layout type
|
||||
@ -284,22 +270,20 @@ hsize_t diff_datasetid( hid_t did1,
|
||||
*/
|
||||
h5difftrace("check for empty datasets\n");
|
||||
|
||||
storage_size1=H5Dget_storage_size(did1);
|
||||
storage_size2=H5Dget_storage_size(did2);
|
||||
storage_size1 = H5Dget_storage_size(did1);
|
||||
storage_size2 = H5Dget_storage_size(did2);
|
||||
h5diffdebug3("storage size: %ld - %ld\n", storage_size1, storage_size2);
|
||||
|
||||
if (storage_size1==0 || storage_size2==0)
|
||||
{
|
||||
if (stl1==H5D_VIRTUAL || stl2==H5D_VIRTUAL)
|
||||
{
|
||||
if ( (options->m_verbose||options->m_list_not_cmp) && obj1_name && obj2_name)
|
||||
if(storage_size1 == 0 || storage_size2 == 0) {
|
||||
if(stl1 == H5D_VIRTUAL || stl2 == H5D_VIRTUAL) {
|
||||
if((options->m_verbose||options->m_list_not_cmp) && obj1_name && obj2_name)
|
||||
parallel_print("Warning: <%s> or <%s> is a virtual dataset\n", obj1_name, obj2_name);
|
||||
}
|
||||
else
|
||||
{
|
||||
if ( (options->m_verbose||options->m_list_not_cmp) && obj1_name && obj2_name)
|
||||
else {
|
||||
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;
|
||||
can_compare = 0;
|
||||
options->not_cmp = 1;
|
||||
}
|
||||
}
|
||||
|
||||
@ -307,72 +291,59 @@ hsize_t diff_datasetid( hid_t did1,
|
||||
* 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;
|
||||
}
|
||||
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
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
h5difftrace("check for memory type and sizes\n");
|
||||
if ((m_tid1=h5tools_get_native_type(f_tid1)) < 0)
|
||||
if((m_tid1 = H5Tget_native_type(f_tid1, H5T_DIR_DEFAULT)) < 0)
|
||||
goto error;
|
||||
|
||||
if ((m_tid2=h5tools_get_native_type(f_tid2)) < 0)
|
||||
if((m_tid2 = H5Tget_native_type(f_tid2, H5T_DIR_DEFAULT)) < 0)
|
||||
goto error;
|
||||
|
||||
m_size1 = H5Tget_size( m_tid1 );
|
||||
m_size2 = H5Tget_size( m_tid2 );
|
||||
m_size1 = H5Tget_size(m_tid1);
|
||||
m_size2 = H5Tget_size(m_tid2);
|
||||
h5diffdebug3("type size: %ld - %ld\n", m_size1, m_size2);
|
||||
|
||||
/*-------------------------------------------------------------------------
|
||||
* check for different signed/unsigned types
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
if (can_compare)
|
||||
{
|
||||
if(can_compare) {
|
||||
h5difftrace("can_compare for sign\n");
|
||||
sign1=H5Tget_sign(m_tid1);
|
||||
sign2=H5Tget_sign(m_tid2);
|
||||
if ( sign1 != sign2 )
|
||||
{
|
||||
sign1 = H5Tget_sign(m_tid1);
|
||||
sign2 = H5Tget_sign(m_tid2);
|
||||
if(sign1 != sign2) {
|
||||
h5difftrace("sign1 != sign2\n");
|
||||
if ((options->m_verbose||options->m_list_not_cmp) && obj1_name && obj2_name)
|
||||
{
|
||||
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;
|
||||
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) )
|
||||
if(TRUE == h5tools_detect_vlen(m_tid1))
|
||||
vl_data = TRUE;
|
||||
|
||||
/*------------------------------------------------------------------------
|
||||
* only attempt to compare if possible
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
if(can_compare) /* it is possible to compare */
|
||||
{
|
||||
if(can_compare) { /* it is possible to compare */
|
||||
h5difftrace("can_compare attempt\n");
|
||||
H5T_class_t tclass = H5Tget_class(f_tid1);
|
||||
|
||||
/*-----------------------------------------------------------------
|
||||
* get number of elements
|
||||
@ -386,19 +357,44 @@ hsize_t diff_datasetid( hid_t did1,
|
||||
for(i = 0; i < rank2; i++)
|
||||
nelmts2 *= dims2[i];
|
||||
|
||||
h5diffdebug3("nelmts: %ld - %ld\n", nelmts1, nelmts2);
|
||||
HDassert(nelmts1 == nelmts2);
|
||||
|
||||
/*-----------------------------------------------------------------
|
||||
* "upgrade" the smaller memory size
|
||||
*------------------------------------------------------------------
|
||||
*/
|
||||
h5difftrace("upgrade the smaller memory size?\n");
|
||||
|
||||
if (FAIL == match_up_memsize (f_tid1, f_tid2,
|
||||
&m_tid1, &m_tid2,
|
||||
&m_size1, &m_size2))
|
||||
goto error;
|
||||
|
||||
if(tclass != H5T_ARRAY) {
|
||||
/*-----------------------------------------------------------------
|
||||
* "upgrade" the smaller memory size
|
||||
*------------------------------------------------------------------
|
||||
*/
|
||||
h5difftrace("upgrade the smaller memory size?\n");
|
||||
if (FAIL == match_up_memsize (f_tid1, f_tid2,
|
||||
&m_tid1, &m_tid2,
|
||||
&m_size1, &m_size2))
|
||||
goto error;
|
||||
h5diffdebug3("m_size: %ld - %ld\n", m_size1, m_size2);
|
||||
dadims = dims1;
|
||||
dam_size = m_size1;
|
||||
dam_tid = m_tid1;
|
||||
danelmts = nelmts1;
|
||||
need = (size_t)(nelmts1 * m_size1); /* bytes needed */
|
||||
}
|
||||
else {
|
||||
h5diffdebug3("Array dims: %d - %d\n", dims1[0], dims2[0]);
|
||||
/* Compare the smallest array, but create the largest buffer */
|
||||
if(m_size1 <= m_size2) {
|
||||
dadims = dims1;
|
||||
dam_size = m_size1;
|
||||
dam_tid = m_tid1;
|
||||
danelmts = nelmts1;
|
||||
need = (size_t)(nelmts2 * m_size2); /* bytes needed */
|
||||
}
|
||||
else {
|
||||
dadims = dims2;
|
||||
dam_size = m_size2;
|
||||
dam_tid = m_tid2;
|
||||
danelmts = nelmts2;
|
||||
need = (size_t)(nelmts1 * m_size1); /* bytes needed */
|
||||
}
|
||||
}
|
||||
/* print names */
|
||||
if(obj1_name)
|
||||
name1 = diff_basename(obj1_name);
|
||||
@ -410,7 +406,6 @@ hsize_t diff_datasetid( hid_t did1,
|
||||
* read/compare
|
||||
*-----------------------------------------------------------------
|
||||
*/
|
||||
need = (size_t)(nelmts1 * m_size1); /* bytes needed */
|
||||
if(need < H5TOOLS_MALLOCSIZE) {
|
||||
buf1 = HDmalloc(need);
|
||||
buf2 = HDmalloc(need);
|
||||
@ -420,12 +415,13 @@ hsize_t diff_datasetid( hid_t did1,
|
||||
h5difftrace("buf1 != NULL && buf2 != NULL\n");
|
||||
if(H5Dread(did1, m_tid1, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf1) < 0)
|
||||
goto error;
|
||||
h5difftrace("H5Dread did2\n");
|
||||
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);
|
||||
nfound = diff_array(buf1, buf2, danelmts, (hsize_t)0, rank1, dadims,
|
||||
options, name1, name2, dam_tid, did1, did2);
|
||||
|
||||
/* reclaim any VL memory, if necessary */
|
||||
if(vl_data) {
|
||||
@ -433,10 +429,9 @@ hsize_t diff_datasetid( hid_t did1,
|
||||
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 */
|
||||
else { /* possibly not enough memory, read/compare by hyperslabs */
|
||||
size_t p_type_nbytes = dam_size; /*size of memory type */
|
||||
hsize_t p_nelmts = danelmts; /*total selected elmts */
|
||||
hsize_t elmtno; /*counter */
|
||||
int carry; /*counter carry value */
|
||||
|
||||
@ -462,7 +457,7 @@ hsize_t diff_datasetid( hid_t did1,
|
||||
|
||||
if(size == 0) /* datum size > H5TOOLS_BUFSIZE */
|
||||
size = 1;
|
||||
sm_size[i - 1] = MIN(dims1[i - 1], size);
|
||||
sm_size[i - 1] = MIN(dadims[i - 1], size);
|
||||
sm_nbytes *= sm_size[i - 1];
|
||||
HDassert(sm_nbytes > 0);
|
||||
} /* end for */
|
||||
@ -490,7 +485,7 @@ hsize_t diff_datasetid( hid_t did1,
|
||||
/* 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_size[i] = MIN(dadims[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)
|
||||
@ -503,15 +498,15 @@ hsize_t diff_datasetid( hid_t did1,
|
||||
else
|
||||
hs_nelmts = 1;
|
||||
|
||||
if(H5Dread(did1,m_tid1,sm_space,sid1,H5P_DEFAULT,sm_buf1) < 0)
|
||||
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)
|
||||
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 */
|
||||
found in each hyperslab and pass the position at the beginning for printing */
|
||||
nfound += diff_array(sm_buf1, sm_buf2, hs_nelmts, elmtno, rank1,
|
||||
dims1, options, name1, name2, m_tid1, did1, did2);
|
||||
dadims, options, name1, name2, dam_tid, did1, did2);
|
||||
|
||||
/* reclaim any VL memory, if necessary */
|
||||
if(vl_data) {
|
||||
@ -522,7 +517,7 @@ hsize_t diff_datasetid( hid_t did1,
|
||||
/* 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])
|
||||
if(hs_offset[i - 1] == dadims[i - 1])
|
||||
hs_offset[i - 1] = 0;
|
||||
else
|
||||
carry = 0;
|
||||
@ -574,37 +569,33 @@ error:
|
||||
options->err_stat=1;
|
||||
|
||||
/* free */
|
||||
if (buf1!=NULL)
|
||||
{
|
||||
if(buf1 != NULL) {
|
||||
/* reclaim any VL memory, if necessary */
|
||||
if(vl_data)
|
||||
H5Dvlen_reclaim(m_tid1, sid1, H5P_DEFAULT, buf1);
|
||||
HDfree(buf1);
|
||||
buf1=NULL;
|
||||
buf1 = NULL;
|
||||
}
|
||||
if (buf2!=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;
|
||||
buf2 = NULL;
|
||||
}
|
||||
if (sm_buf1!=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;
|
||||
sm_buf1 = NULL;
|
||||
}
|
||||
if (sm_buf2!=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;
|
||||
sm_buf2 = NULL;
|
||||
}
|
||||
|
||||
/* disable error reporting */
|
||||
@ -652,75 +643,55 @@ int diff_can_type( hid_t f_tid1, /* file data type */
|
||||
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 maxdim_diff = 0; /* maximum dimensions are different */
|
||||
int dim_diff = 0; /* current dimensions are different */
|
||||
int i;
|
||||
int can_compare = 1; /* return value */
|
||||
int can_compare = 1; /* return value */
|
||||
|
||||
h5difftrace("diff_can_type start\n");
|
||||
/*-------------------------------------------------------------------------
|
||||
* check for the same class
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
if ((tclass1=H5Tget_class(f_tid1)) < 0)
|
||||
if((tclass1 = H5Tget_class(f_tid1)) < 0)
|
||||
return -1;
|
||||
if((tclass2 = H5Tget_class(f_tid2)) < 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 )
|
||||
{
|
||||
|
||||
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) );
|
||||
|
||||
obj1_name, get_class(tclass1),
|
||||
obj2_name, get_class(tclass2));
|
||||
}
|
||||
|
||||
else
|
||||
|
||||
{
|
||||
|
||||
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) );
|
||||
|
||||
obj1_name, get_class(tclass1),
|
||||
obj2_name, get_class(tclass2));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
can_compare = 0;
|
||||
options->not_cmp = 1;
|
||||
return can_compare;
|
||||
goto done;
|
||||
}
|
||||
|
||||
/*-------------------------------------------------------------------------
|
||||
* check for non supported classes
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
HDassert(tclass1==tclass2);
|
||||
switch (tclass1)
|
||||
{
|
||||
HDassert(tclass1 == tclass2);
|
||||
switch (tclass1) {
|
||||
case H5T_TIME:
|
||||
if ( (options->m_verbose||options->m_list_not_cmp) && obj1_name && obj2_name) {
|
||||
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) );
|
||||
obj1_name, obj2_name, get_class(tclass2));
|
||||
} /* end if */
|
||||
can_compare = 0;
|
||||
options->not_cmp = 1;
|
||||
return can_compare;
|
||||
goto done;
|
||||
|
||||
case H5T_INTEGER:
|
||||
case H5T_FLOAT:
|
||||
@ -735,6 +706,7 @@ int diff_can_type( hid_t f_tid1, /* file data type */
|
||||
case H5T_NO_CLASS:
|
||||
case H5T_NCLASSES:
|
||||
default:
|
||||
h5diffdebug2("diff_can_type class - %s\n", get_class(tclass1));
|
||||
break;
|
||||
} /* end switch */
|
||||
|
||||
@ -742,17 +714,11 @@ int diff_can_type( hid_t f_tid1, /* file data type */
|
||||
* check for equal file datatype; warning only
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
if ( (H5Tequal(f_tid1, f_tid2)==0) &&
|
||||
(options->m_verbose) && obj1_name && obj2_name)
|
||||
{
|
||||
|
||||
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 )
|
||||
{
|
||||
if(cl == H5T_INTEGER || cl == H5T_FLOAT) {
|
||||
parallel_print("<%s> has file datatype ", obj1_name);
|
||||
print_type(f_tid1);
|
||||
parallel_print("\n");
|
||||
@ -760,110 +726,85 @@ int diff_can_type( hid_t f_tid1, /* file data type */
|
||||
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)
|
||||
{
|
||||
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);
|
||||
print_dimensions(rank1, dims1);
|
||||
parallel_print(", max dimensions ");
|
||||
print_dimensions(rank1,maxdim1);
|
||||
print_dimensions(rank1, maxdim1);
|
||||
parallel_print("\n" );
|
||||
parallel_print("and <%s> has rank %d, dimensions ", obj2_name, rank2);
|
||||
print_dimensions(rank2,dims2);
|
||||
print_dimensions(rank2, dims2);
|
||||
parallel_print(", max dimensions ");
|
||||
print_dimensions(rank2,maxdim2);
|
||||
print_dimensions(rank2, maxdim2);
|
||||
parallel_print("\n");
|
||||
}
|
||||
|
||||
can_compare = 0;
|
||||
options->not_cmp = 1;
|
||||
return can_compare;
|
||||
goto done;
|
||||
}
|
||||
|
||||
/*-------------------------------------------------------------------------
|
||||
* check for different dimensions
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
HDassert(rank1==rank2);
|
||||
for ( i=0; i<rank1; i++)
|
||||
{
|
||||
if (maxdim1 && maxdim2)
|
||||
{
|
||||
if ( maxdim1[i] != maxdim2[i] )
|
||||
maxdim_diff=1;
|
||||
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;
|
||||
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)
|
||||
{
|
||||
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)
|
||||
{
|
||||
print_dimensions(rank1, dims1);
|
||||
if(maxdim1 && maxdim2) {
|
||||
parallel_print(", max dimensions ");
|
||||
print_dimensions(rank1,maxdim1);
|
||||
print_dimensions(rank1, maxdim1);
|
||||
parallel_print("\n" );
|
||||
parallel_print("and <%s> has rank %d, dimensions ", obj2_name, rank2);
|
||||
print_dimensions(rank2,dims2);
|
||||
print_dimensions(rank2, dims2);
|
||||
parallel_print(", max dimensions ");
|
||||
print_dimensions(rank2,maxdim2);
|
||||
print_dimensions(rank2, maxdim2);
|
||||
parallel_print("\n");
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
can_compare = 0;
|
||||
options->not_cmp = 1;
|
||||
return can_compare;
|
||||
|
||||
|
||||
|
||||
goto done;
|
||||
}
|
||||
|
||||
/*-------------------------------------------------------------------------
|
||||
* maximum dimensions; just give a warning
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
if (maxdim1 && maxdim2 && maxdim_diff==1 && obj1_name )
|
||||
{
|
||||
if (options->m_verbose) {
|
||||
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);
|
||||
print_dimensions(rank1, maxdim1);
|
||||
parallel_print("\n");
|
||||
parallel_print("<%s> has max dimensions ", obj2_name);
|
||||
print_dimensions(rank2,maxdim2);
|
||||
print_dimensions(rank2, maxdim2);
|
||||
parallel_print("\n");
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
if ( tclass1 == H5T_COMPOUND )
|
||||
{
|
||||
|
||||
if(tclass1 == H5T_COMPOUND) {
|
||||
int nmembs1;
|
||||
int nmembs2;
|
||||
int j;
|
||||
@ -873,67 +814,40 @@ int diff_can_type( hid_t f_tid1, /* file data type */
|
||||
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)
|
||||
{
|
||||
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;
|
||||
goto done;
|
||||
}
|
||||
|
||||
for (j = 0; j < nmembs1; j++)
|
||||
{
|
||||
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)
|
||||
{
|
||||
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;
|
||||
goto done;
|
||||
}
|
||||
|
||||
H5Tclose(memb_type1);
|
||||
H5Tclose(memb_type2);
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
done:
|
||||
h5diffdebug2("diff_can_type end - %d\n", can_compare);
|
||||
return can_compare;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
/*-------------------------------------------------------------------------
|
||||
* Function: print_sizes
|
||||
*
|
||||
|
||||
Loading…
Reference in New Issue
Block a user