/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Copyright by the Board of Trustees of the University of Illinois. * * All rights reserved. * * * * This file is part of HDF5. The full HDF5 copyright notice, including * * terms governing use, modification, and redistribution, is contained in * * the files COPYING and Copyright.html. COPYING can be found at the root * * of the source code distribution tree; Copyright.html can be found at the * * root level of an installed copy of the electronic HDF5 document set and * * is linked from the top-level documents page. It can also be found at * * http://hdf.ncsa.uiuc.edu/HDF5/doc/Copyright.html. If you do not have * * access to either file, you may request a copy from hdfhelp@ncsa.uiuc.edu. * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ #include "h5diff.h" #include "H5private.h" #include "h5tools.h" /*------------------------------------------------------------------------- * Function: diff_dataset * * Purpose: check for comparable datasets and read into a compatible * memory type * * Return: Number of differences found * * Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu * * Date: May 9, 2003 * *------------------------------------------------------------------------- */ int diff_dataset( hid_t file1_id, hid_t file2_id, const char *obj1_name, const char *obj2_name, diff_opt_t *options ) { hid_t dset1_id =-1; hid_t dset2_id =-1; hid_t dcpl1_id=-1; hid_t dcpl2_id=-1; int gout=0, nfound=0; /* disable error reporting */ H5E_BEGIN_TRY { /*------------------------------------------------------------------------- * open the handles *------------------------------------------------------------------------- */ /* Open the datasets */ if ( (dset1_id = H5Dopen(file1_id,obj1_name)) < 0 ) { printf("Cannot open dataset <%s>\n", obj1_name ); gout=1; } if ( (dset2_id = H5Dopen(file2_id,obj2_name)) < 0 ) { printf("Cannot open dataset <%s>\n", obj2_name ); gout=1; } /* enable error reporting */ } H5E_END_TRY; if (gout) goto out; if ((dcpl1_id=H5Dget_create_plist(dset1_id))<0) goto out; if ((dcpl2_id=H5Dget_create_plist(dset2_id))<0) goto out; /*------------------------------------------------------------------------- * 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->verbose?obj1_name:NULL),dcpl1_id)==1) && (h5tools_canreadf((options->verbose?obj2_name:NULL),dcpl2_id)==1)) { nfound=diff_datasetid(dset1_id, dset2_id, obj1_name, obj2_name, options); } /*------------------------------------------------------------------------- * close *------------------------------------------------------------------------- */ out: /* disable error reporting */ H5E_BEGIN_TRY { H5Pclose(dcpl1_id); H5Pclose(dcpl2_id); H5Dclose(dset1_id); H5Dclose(dset2_id); /* 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, pvn@ncsa.uiuc.edu * * Date: May 9, 2003 * *------------------------------------------------------------------------- */ int diff_datasetid( hid_t dset1_id, hid_t dset2_id, const char *obj1_name, const char *obj2_name, diff_opt_t *options ) { hid_t space1_id =-1; hid_t space2_id =-1; hid_t f_type1=-1, f_type2=-1; /* file data type */ hid_t m_type1=-1, m_type2=-1; /* memory data type */ size_t m_size1, m_size2; /* size of type in memory */ H5T_sign_t sign1, sign2; /* sign of type */ int rank1, rank2; void *buf1=NULL, *buf2=NULL; hsize_t nelmts1, 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]; int nfound=0; /* number of differences found */ const char *name1=NULL; /* relative names */ const char *name2=NULL; hsize_t storage_size1; hsize_t storage_size2; H5S_class_t space_type1, space_type2; int i; if (obj1_name) name1=diff_basename(obj1_name); if (obj2_name) name2=diff_basename(obj2_name); /*------------------------------------------------------------------------- * Get the file data type *------------------------------------------------------------------------- */ /* Get the data type */ if ( (f_type1 = H5Dget_type(dset1_id)) < 0 ) goto out; /* Get the data type */ if ( (f_type2 = H5Dget_type(dset2_id)) < 0 ) goto out; /*------------------------------------------------------------------------- * Get the file data space *------------------------------------------------------------------------- */ /* Get the dataspace handle */ if ( (space1_id = H5Dget_space(dset1_id)) < 0 ) goto out; if ( (space2_id = H5Dget_space(dset2_id)) < 0 ) goto out; /* Get space type */ space_type1 = H5Sget_simple_extent_type(space1_id); space_type2 = H5Sget_simple_extent_type(space2_id); /* get dimensions */ if(space_type1 == H5S_NULL && space_type2 == H5S_NULL) { if(options->verbose) { /*printf( "Dataset: <%s> and <%s>\n",name1,name2);*/ /*sprintf(name1,"%s of <%s>",name1,path1); sprintf(name2,"%s of <%s>",name2,path2);*/ printf( "type %s %s difference\n",name1,name2); if ( !(H5Tequal(f_type1, f_type2)) && options->verbose) { printf("\t"); print_type(f_type1); printf("\t\t"); print_type(f_type2); printf("\n"); } printf("1 differences found\n"); nfound = 1; } goto out; } /* Get rank */ if ( (rank1 = H5Sget_simple_extent_ndims(space1_id)) < 0 ) goto out; if ( (rank2 = H5Sget_simple_extent_ndims(space2_id)) < 0 ) goto out; /* Get dimensions */ if ( H5Sget_simple_extent_dims(space1_id,dims1,maxdim1) < 0 ) goto out; if ( H5Sget_simple_extent_dims(space2_id,dims2,maxdim2) < 0 ) goto out; /*------------------------------------------------------------------------- * Get the file data type *------------------------------------------------------------------------- */ /* Get the data type */ if ( (f_type1 = H5Dget_type(dset1_id)) < 0 ) goto out; /* Get the data type */ if ( (f_type2 = H5Dget_type(dset2_id)) < 0 ) goto out; /*------------------------------------------------------------------------- * check for empty datasets *------------------------------------------------------------------------- */ storage_size1=H5Dget_storage_size(dset1_id); storage_size2=H5Dget_storage_size(dset2_id); if (storage_size1<=0 && storage_size2<=0) { if (options->verbose && obj1_name && obj2_name) printf("<%s> and <%s> are empty datasets\n", obj1_name, obj2_name); goto out; } /*------------------------------------------------------------------------- * check for comparable TYPE and SPACE *------------------------------------------------------------------------- */ if (diff_can_type(f_type1, f_type2, rank1, rank2, dims1, dims2, maxdim1, maxdim2, obj1_name, obj2_name, options)!=1) goto out; /*------------------------------------------------------------------------- * 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]; } assert(nelmts1==nelmts2); /*------------------------------------------------------------------------- * check for equal file datatype; warning only *------------------------------------------------------------------------- */ if ( (H5Tequal(f_type1, f_type2)==0) && options->verbose && obj1_name) { printf("Warning: Different storage datatype\n"); printf("<%s> has file datatype ", obj1_name); print_type(f_type1); printf("\n"); printf("<%s> has file datatype ", obj2_name); print_type(f_type2); printf("\n"); } /*------------------------------------------------------------------------- * memory type and sizes *------------------------------------------------------------------------- */ m_type1 = H5Tget_native_type( f_type1 , H5T_DIR_DEFAULT); m_type2 = H5Tget_native_type( f_type2 , H5T_DIR_DEFAULT); m_size1 = H5Tget_size( m_type1 ); m_size2 = H5Tget_size( m_type2 ); #if defined (H5DIFF_DEBUG) if (obj1_name) print_sizes(obj1_name,obj2_name,f_type1,f_type2,m_type1,m_type2); #endif /*------------------------------------------------------------------------- * check for different signed/unsigned types *------------------------------------------------------------------------- */ sign1=H5Tget_sign(m_type1); sign2=H5Tget_sign(m_type2); if ( sign1 != sign2 ) { if (options->verbose && obj1_name) { printf("Comparison not supported: <%s> has sign %s ", obj1_name, get_sign(sign1)); printf("and <%s> has sign %s\n", obj2_name, get_sign(sign2)); } goto out; } /*------------------------------------------------------------------------- * "upgrade" the smaller memory size *------------------------------------------------------------------------- */ if ( m_size1 != m_size2 ) { if ( m_size1 < m_size2 ) { H5Tclose(m_type1); m_type1 = H5Tget_native_type( f_type2 , H5T_DIR_DEFAULT); m_size1 = H5Tget_size( m_type1 ); } else { H5Tclose(m_type2); m_type2 = H5Tget_native_type( f_type1 , H5T_DIR_DEFAULT); m_size2 = H5Tget_size( m_type2 ); } #if defined (H5DIFF_DEBUG) printf("WARNING: Size was upgraded\n"); if (obj1_name) print_sizes(obj1_name,obj2_name,f_type1,f_type2,m_type1,m_type2); #endif } assert(m_size1==m_size2); buf1 = (void *) HDmalloc((unsigned) (nelmts1*m_size1)); buf2 = (void *) HDmalloc((unsigned) (nelmts2*m_size2)); if ( buf1 == NULL || buf2 == NULL ) { printf( "cannot read into memory\n" ); goto out; } /*------------------------------------------------------------------------- * read *------------------------------------------------------------------------- */ if ( H5Dread(dset1_id,m_type1,H5S_ALL,H5S_ALL,H5P_DEFAULT,buf1) < 0 ) goto out; if ( H5Dread(dset2_id,m_type2,H5S_ALL,H5S_ALL,H5P_DEFAULT,buf2) < 0 ) goto out; /*------------------------------------------------------------------------- * array compare *------------------------------------------------------------------------- */ nfound = diff_array(buf1, buf2, nelmts1, rank1, dims1, options, name1, name2, m_type1, dset1_id, dset2_id); if (options->verbose && nfound) printf("%d differences found\n", nfound ); /*------------------------------------------------------------------------- * compare attributes * the if condition refers to cases when the dataset is a referenced object *------------------------------------------------------------------------- */ if (obj1_name) nfound=diff_attr(dset1_id,dset2_id,obj1_name,obj2_name,options); /*------------------------------------------------------------------------- * close *------------------------------------------------------------------------- */ out: if ( buf1) HDfree(buf1); if ( buf2) HDfree(buf2); /* close */ /* disable error reporting */ H5E_BEGIN_TRY { H5Sclose(space1_id); H5Sclose(space2_id); H5Tclose(f_type1); H5Tclose(f_type2); H5Tclose(m_type1); H5Tclose(m_type2); /* enable error reporting */ } H5E_END_TRY; return nfound; } /*------------------------------------------------------------------------- * Function: diff_can_type * * Purpose: check for comparable TYPE and SPACE * * Return: * 1, can compare * 0, cannot compare * -1, error * * Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu * * Date: November 3, 2003 * *------------------------------------------------------------------------- */ int diff_can_type( hid_t f_type1, /* file data type */ hid_t f_type2, /* 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 ) { 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; /*------------------------------------------------------------------------- * check for the same class *------------------------------------------------------------------------- */ if ((tclass1=H5Tget_class(f_type1))<0) return -1; if ((tclass2=H5Tget_class(f_type2))<0) return -1; if ( tclass1 != tclass2 ) { if (options->verbose && obj1_name) { printf("Comparison not possible: <%s> is of class %s and <%s> is of class %s\n", obj1_name, get_class(tclass1), obj2_name, get_class(tclass2) ); } return 0; } /*------------------------------------------------------------------------- * check for non supported classes *------------------------------------------------------------------------- */ assert(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->verbose && obj1_name ) printf("Comparison not supported: <%s> and <%s> are of class %s\n", obj1_name,obj2_name,get_class(tclass2) ); return 0; } /*------------------------------------------------------------------------- * check for equal file datatype; warning only *------------------------------------------------------------------------- */ if ( (H5Tequal(f_type1, f_type2)==0) && options->verbose && obj1_name) { printf("Warning: Different storage datatype\n"); printf("<%s> has file datatype ", obj1_name); print_type(f_type1); printf("\n"); printf("<%s> has file datatype ", obj2_name); print_type(f_type2); printf("\n"); } /*------------------------------------------------------------------------- * check for the same rank *------------------------------------------------------------------------- */ if ( rank1 != rank2 ) { if (options->verbose && obj1_name) { printf("Comparison not supported: <%s> has rank %d, dimensions ", obj1_name, rank1); print_dims(rank1,dims1); printf(", max dimensions "); print_dims(rank1,maxdim1); printf("\n" ); printf("<%s> has rank %d, dimensions ", obj2_name, rank2); print_dims(rank2,dims2); printf(", max dimensions "); print_dims(rank2,maxdim2); } return 0; } /*------------------------------------------------------------------------- * check for different dimensions *------------------------------------------------------------------------- */ assert(rank1==rank2); for ( i=0; iverbose && obj1_name) { printf("Comparison not supported: <%s> has rank %d, dimensions ", obj1_name, rank1); print_dims(rank1,dims1); if (maxdim1 && maxdim2) { printf(", max dimensions "); print_dims(rank1,maxdim1); printf("\n" ); printf("<%s> has rank %d, dimensions ", obj2_name, rank2); print_dims(rank2,dims2); printf(", max dimensions "); print_dims(rank2,maxdim2); } } return 0; } /*------------------------------------------------------------------------- * maximum dimensions; just give a warning *------------------------------------------------------------------------- */ if (maxdim1 && maxdim2 && maxdim_diff==1 && obj1_name ) { if (options->verbose) { printf( "Warning: Different maximum dimensions\n"); printf("<%s> has max dimensions ", obj1_name); print_dims(rank1,maxdim1); printf("\n"); printf("<%s> has max dimensions ", obj2_name); print_dims(rank2,maxdim2); printf("\n"); } } return 1; }