summaryrefslogtreecommitdiffstats
path: root/tools/lib
diff options
context:
space:
mode:
Diffstat (limited to 'tools/lib')
-rw-r--r--tools/lib/h5diff.c1610
-rw-r--r--tools/lib/h5diff.h14
-rw-r--r--tools/lib/h5diff_array.c419
-rw-r--r--tools/lib/h5diff_attr.c489
-rw-r--r--tools/lib/h5diff_dset.c58
-rw-r--r--tools/lib/h5diff_util.c153
6 files changed, 1366 insertions, 1377 deletions
diff --git a/tools/lib/h5diff.c b/tools/lib/h5diff.c
index 3322d99..4fd9c10 100644
--- a/tools/lib/h5diff.c
+++ b/tools/lib/h5diff.c
@@ -20,12 +20,12 @@
/*
* Debug printf macros. The prefix allows output filtering by test scripts.
*/
-#ifdef debug
-#define h5diffdebug(x) fprintf(stderr, "h5diff debug: " x)
-#define h5diffdebug2(x1, x2) fprintf(stderr, "h5diff debug: " x1, x2)
-#define h5diffdebug3(x1, x2, x3) fprintf(stderr, "h5diff debug: " x1, x2, x3)
-#define h5diffdebug4(x1, x2, x3, x4) fprintf(stderr, "h5diff debug: " x1, x2, x3, x4)
-#define h5diffdebug5(x1, x2, x3, x4, x5) fprintf(stderr, "h5diff debug: " x1, x2, x3, x4, x5)
+#ifdef H5DIFF_DEBUG
+#define h5diffdebug(x) fprintf(stderr, "h5diff debug: " x)
+#define h5diffdebug2(x1, x2) fprintf(stderr, "h5diff debug: " x1, x2)
+#define h5diffdebug3(x1, x2, x3) fprintf(stderr, "h5diff debug: " x1, x2, x3)
+#define h5diffdebug4(x1, x2, x3, x4) fprintf(stderr, "h5diff debug: " x1, x2, x3, x4)
+#define h5diffdebug5(x1, x2, x3, x4, x5) fprintf(stderr, "h5diff debug: " x1, x2, x3, x4, x5)
#else
#define h5diffdebug(x)
#define h5diffdebug2(x1, x2)
@@ -46,7 +46,7 @@
int
print_objname (diff_opt_t * options, hsize_t nfound)
{
- return ((options->m_verbose || nfound) && !options->m_quiet) ? 1 : 0;
+ return ((options->m_verbose || nfound) && !options->m_quiet) ? 1 : 0;
}
#ifdef H5_HAVE_PARALLEL
@@ -65,9 +65,9 @@ print_objname (diff_opt_t * options, hsize_t nfound)
*/
void phdiff_dismiss_workers(void)
{
- int i;
- for(i=1; i<g_nTasks; i++)
- MPI_Send(NULL, 0, MPI_BYTE, i, MPI_TAG_END, MPI_COMM_WORLD);
+ int i;
+ for(i=1; i<g_nTasks; i++)
+ MPI_Send(NULL, 0, MPI_BYTE, i, MPI_TAG_END, MPI_COMM_WORLD);
}
@@ -87,31 +87,31 @@ void phdiff_dismiss_workers(void)
*/
void print_manager_output(void)
{
- /* If there was something we buffered, let's print it now */
- if( (outBuffOffset>0) && g_Parallel)
- {
- printf("%s", outBuff);
-
- if(overflow_file)
- {
- int tmp;
-
- rewind(overflow_file);
- while((tmp = getc(overflow_file)) >= 0)
- putchar(tmp);
-
- fclose(overflow_file);
- overflow_file = NULL;
- }
-
- fflush(stdout);
- memset(outBuff, 0, OUTBUFF_SIZE);
- outBuffOffset = 0;
- }
- else if( (outBuffOffset>0) && !g_Parallel)
- {
- fprintf(stderr, "h5diff error: outBuffOffset>0, but we're not in parallel!\n");
- }
+ /* If there was something we buffered, let's print it now */
+ if( (outBuffOffset>0) && g_Parallel)
+ {
+ printf("%s", outBuff);
+
+ if(overflow_file)
+ {
+ int tmp;
+
+ rewind(overflow_file);
+ while((tmp = getc(overflow_file)) >= 0)
+ putchar(tmp);
+
+ fclose(overflow_file);
+ overflow_file = NULL;
+ }
+
+ fflush(stdout);
+ memset(outBuff, 0, OUTBUFF_SIZE);
+ outBuffOffset = 0;
+ }
+ else if( (outBuffOffset>0) && !g_Parallel)
+ {
+ fprintf(stderr, "h5diff error: outBuffOffset>0, but we're not in parallel!\n");
+ }
}
/*-------------------------------------------------------------------------
@@ -131,21 +131,21 @@ void print_manager_output(void)
static void print_incoming_data(void)
{
- char data[PRINT_DATA_MAX_SIZE+1];
- int incomingMessage;
- MPI_Status Status;
-
- do
- {
- MPI_Iprobe(MPI_ANY_SOURCE, MPI_TAG_PRINT_DATA, MPI_COMM_WORLD, &incomingMessage, &Status);
- if(incomingMessage)
- {
- memset(data, 0, PRINT_DATA_MAX_SIZE+1);
- MPI_Recv(data, PRINT_DATA_MAX_SIZE, MPI_CHAR, Status.MPI_SOURCE, MPI_TAG_PRINT_DATA, MPI_COMM_WORLD, &Status);
-
- printf("%s", data);
- }
- } while(incomingMessage);
+ char data[PRINT_DATA_MAX_SIZE+1];
+ int incomingMessage;
+ MPI_Status Status;
+
+ do
+ {
+ MPI_Iprobe(MPI_ANY_SOURCE, MPI_TAG_PRINT_DATA, MPI_COMM_WORLD, &incomingMessage, &Status);
+ if(incomingMessage)
+ {
+ memset(data, 0, PRINT_DATA_MAX_SIZE+1);
+ MPI_Recv(data, PRINT_DATA_MAX_SIZE, MPI_CHAR, Status.MPI_SOURCE, MPI_TAG_PRINT_DATA, MPI_COMM_WORLD, &Status);
+
+ printf("%s", data);
+ }
+ } while(incomingMessage);
}
#endif
@@ -170,183 +170,180 @@ hsize_t h5diff(const char *fname1,
const char *objname2,
diff_opt_t *options)
{
- int nobjects1, nobjects2;
- trav_info_t *info1 = NULL;
- trav_info_t *info2 = NULL;
- hid_t file1_id=(-1), file2_id=(-1);
- char filenames[2][1024];
- hsize_t nfound = 0;
-
- memset(filenames, 0, 1024*2);
-
+ int nobjects1, nobjects2;
+ trav_info_t *info1 = NULL;
+ trav_info_t *info2 = NULL;
+ hid_t file1_id=(-1), file2_id=(-1);
+ char filenames[2][1024];
+ hsize_t nfound = 0;
+
+ memset(filenames, 0, 1024*2);
+
if (options->m_quiet &&
- (options->m_verbose || options->m_report))
+ (options->m_verbose || options->m_report))
{
printf("Error: -q (quiet mode) cannot be added to verbose or report modes\n");
options->err_stat=1;
return 0;
}
-
+
/*-------------------------------------------------------------------------
* open the files first; if they are not valid, no point in continuing
*-------------------------------------------------------------------------
*/
-
- /* disable error reporting */
- H5E_BEGIN_TRY
+
+ /* disable error reporting */
+ H5E_BEGIN_TRY
+ {
+ /* Open the files */
+ if ((file1_id = H5Fopen (fname1, H5F_ACC_RDONLY, H5P_DEFAULT)) < 0)
{
- /* Open the files */
- if ((file1_id = H5Fopen (fname1, H5F_ACC_RDONLY, H5P_DEFAULT)) < 0)
- {
- printf ("h5diff: <%s>: unable to open file\n", fname1);
- options->err_stat = 1;
-
+ printf ("h5diff: <%s>: unable to open file\n", fname1);
+ options->err_stat = 1;
+
#ifdef H5_HAVE_PARALLEL
- if(g_Parallel)
- {
- /* Let tasks know that they won't be needed */
- phdiff_dismiss_workers();
- }
+ if(g_Parallel)
+ {
+ /* Let tasks know that they won't be needed */
+ phdiff_dismiss_workers();
+ }
#endif
-
- goto out;
- }
- if ((file2_id = H5Fopen (fname2, H5F_ACC_RDONLY, H5P_DEFAULT)) < 0)
- {
- printf ("h5diff: <%s>: unable to open file\n", fname2);
- options->err_stat = 1;
-
+
+ goto out;
+ }
+ if ((file2_id = H5Fopen (fname2, H5F_ACC_RDONLY, H5P_DEFAULT)) < 0)
+ {
+ printf ("h5diff: <%s>: unable to open file\n", fname2);
+ options->err_stat = 1;
+
#ifdef H5_HAVE_PARALLEL
- if(g_Parallel)
- {
- /* Let tasks know that they won't be needed */
- phdiff_dismiss_workers();
- }
+ if(g_Parallel)
+ {
+ /* Let tasks know that they won't be needed */
+ phdiff_dismiss_workers();
+ }
#endif
-
- goto out;
- }
- /* enable error reporting */
+
+ goto out;
}
- H5E_END_TRY;
-
-
+ /* enable error reporting */
+ }
+ H5E_END_TRY;
+
/*-------------------------------------------------------------------------
* get the number of objects in the files
*-------------------------------------------------------------------------
*/
- nobjects1 = h5trav_getinfo (file1_id, NULL, 0);
- nobjects2 = h5trav_getinfo (file2_id, NULL, 0);
-
- if (nobjects1 < 0 || nobjects2 < 0)
- {
- printf ("Error: Could not get get file contents\n");
- options->err_stat = 1;
-#ifdef H5_HAVE_PARALLEL
- if(g_Parallel)
+ nobjects1 = h5trav_getinfo (file1_id, NULL, 0);
+ nobjects2 = h5trav_getinfo (file2_id, NULL, 0);
+
+ if (nobjects1 < 0 || nobjects2 < 0)
{
- /* Let tasks know that they won't be needed */
- phdiff_dismiss_workers();
- }
+ printf ("Error: Could not get get file contents\n");
+ options->err_stat = 1;
+#ifdef H5_HAVE_PARALLEL
+ if(g_Parallel)
+ {
+ /* Let tasks know that they won't be needed */
+ phdiff_dismiss_workers();
+ }
#endif
- goto out;
- }
-
+ goto out;
+ }
+
/*-------------------------------------------------------------------------
* get the list of objects in the files
*-------------------------------------------------------------------------
*/
-
- info1 = (trav_info_t *) malloc (nobjects1 * sizeof (trav_info_t));
- info2 = (trav_info_t *) malloc (nobjects2 * sizeof (trav_info_t));
- if (info1 == NULL || info2 == NULL)
- {
- printf ("Error: Not enough memory for object list\n");
- options->err_stat = 1;
- if (info1) h5trav_freeinfo (info1, nobjects1);
- if (info2) h5trav_freeinfo (info2, nobjects1);
-#ifdef H5_HAVE_PARALLEL
- if(g_Parallel)
+
+ info1 = (trav_info_t *) malloc (nobjects1 * sizeof (trav_info_t));
+ info2 = (trav_info_t *) malloc (nobjects2 * sizeof (trav_info_t));
+ if (info1 == NULL || info2 == NULL)
{
- /* Let tasks know that they won't be needed */
- phdiff_dismiss_workers();
- }
+ printf ("Error: Not enough memory for object list\n");
+ options->err_stat = 1;
+ if (info1) h5trav_freeinfo (info1, nobjects1);
+ if (info2) h5trav_freeinfo (info2, nobjects1);
+#ifdef H5_HAVE_PARALLEL
+ if(g_Parallel)
+ {
+ /* Let tasks know that they won't be needed */
+ phdiff_dismiss_workers();
+ }
#endif
- goto out;
- }
-
- h5trav_getinfo (file1_id, info1, 0);
- h5trav_getinfo (file2_id, info2, 0);
-
+ goto out;
+ }
+
+ h5trav_getinfo (file1_id, info1, 0);
+ h5trav_getinfo (file2_id, info2, 0);
+
/*-------------------------------------------------------------------------
* object name was supplied
*-------------------------------------------------------------------------
*/
-
- if (objname1)
- {
-
-#ifdef H5_HAVE_PARALLEL
- if(g_Parallel)
+
+ if (objname1)
{
- /* Let tasks know that they won't be needed */
- phdiff_dismiss_workers();
- }
+
+#ifdef H5_HAVE_PARALLEL
+ if(g_Parallel)
+ {
+ /* Let tasks know that they won't be needed */
+ phdiff_dismiss_workers();
+ }
#endif
- assert (objname2);
- options->cmn_objs = 1; /* eliminate warning */
- nfound = diff_compare (file1_id, fname1, objname1, nobjects1, info1,
- file2_id, fname2, objname2, nobjects2, info2,
- options);
- }
-
+ assert (objname2);
+ options->cmn_objs = 1; /* eliminate warning */
+ nfound = diff_compare (file1_id, fname1, objname1, nobjects1, info1,
+ file2_id, fname2, objname2, nobjects2, info2,
+ options);
+ }
+
/*-------------------------------------------------------------------------
* compare all
*-------------------------------------------------------------------------
*/
-
- else
- {
-
+
+ else
+ {
+
#ifdef H5_HAVE_PARALLEL
- if(g_Parallel)
- {
- int i;
-
+ if(g_Parallel)
+ {
+ int i;
+
if( (strlen(fname1) > 1024) || (strlen(fname2) > 1024))
{
- fprintf(stderr, "The parallel diff only supports path names up to 1024 characters\n");
- MPI_Abort(MPI_COMM_WORLD, 0);
+ fprintf(stderr, "The parallel diff only supports path names up to 1024 characters\n");
+ MPI_Abort(MPI_COMM_WORLD, 0);
}
-
+
strcpy(filenames[0], fname1);
strcpy(filenames[1], fname2);
-
+
/* Alert the worker tasks that there's going to be work. */
-
+
for(i=1; i<g_nTasks; i++)
- MPI_Send(filenames, 1024*2, MPI_CHAR, i, MPI_TAG_PARALLEL, MPI_COMM_WORLD);
- }
-#endif
- nfound = diff_match (file1_id, nobjects1, info1,
- file2_id, nobjects2, info2, options);
-
+ MPI_Send(filenames, 1024*2, MPI_CHAR, i, MPI_TAG_PARALLEL, MPI_COMM_WORLD);
}
-
-
- h5trav_freeinfo (info1, nobjects1);
- h5trav_freeinfo (info2, nobjects2);
-
+#endif
+ nfound = diff_match (file1_id, nobjects1, info1,
+ file2_id, nobjects2, info2, options);
+ }
+
+ h5trav_freeinfo (info1, nobjects1);
+ h5trav_freeinfo (info2, nobjects2);
+
out:
- /* close */
- H5E_BEGIN_TRY
- {
- H5Fclose (file1_id);
- H5Fclose (file2_id);
- }
- H5E_END_TRY;
-
- return nfound;
+ /* close */
+ H5E_BEGIN_TRY
+ {
+ H5Fclose (file1_id);
+ H5Fclose (file2_id);
+ }
+ H5E_END_TRY;
+
+ return nfound;
}
@@ -369,423 +366,425 @@ out:
*
*-------------------------------------------------------------------------
*/
-hsize_t
-diff_match (hid_t file1_id,
- int nobjects1,
- trav_info_t * info1,
- hid_t file2_id,
- int nobjects2, trav_info_t * info2, diff_opt_t * options)
+hsize_t diff_match (hid_t file1_id,
+ int nobjects1,
+ trav_info_t * info1,
+ hid_t file2_id,
+ int nobjects2,
+ trav_info_t * info2,
+ diff_opt_t * options)
{
- int more_names_exist = (nobjects1 > 0 && nobjects2 > 0) ? 1 : 0;
- trav_table_t *table = NULL;
- int cmp;
- int curr1 = 0;
- int curr2 = 0;
- unsigned infile[2];
- char c1, c2;
- hsize_t nfound = 0;
- int i;
-
- /*-------------------------------------------------------------------------
- * build the list
- *-------------------------------------------------------------------------
- */
- trav_table_init (&table);
-
- while (more_names_exist)
- {
- /* criteria is string compare */
- cmp = strcmp (info1[curr1].name, info2[curr2].name);
- if (cmp == 0)
- {
- infile[0] = 1;
- infile[1] = 1;
- trav_table_addflags (infile, info1[curr1].name, info1[curr1].type,
- table);
-
- curr1++;
- curr2++;
- }
- else if (cmp < 0)
+ int more_names_exist = (nobjects1 > 0 && nobjects2 > 0) ? 1 : 0;
+ trav_table_t *table = NULL;
+ int cmp;
+ int curr1 = 0;
+ int curr2 = 0;
+ unsigned infile[2];
+ char c1, c2;
+ hsize_t nfound = 0;
+ int i;
+
+/*-------------------------------------------------------------------------
+ * build the list
+ *-------------------------------------------------------------------------
+ */
+ trav_table_init (&table);
+
+ while (more_names_exist)
{
- infile[0] = 1;
- infile[1] = 0;
- trav_table_addflags (infile, info1[curr1].name, info1[curr1].type,
- table);
- curr1++;
- }
- else
+ /* criteria is string compare */
+ cmp = strcmp (info1[curr1].name, info2[curr2].name);
+ if (cmp == 0)
+ {
+ infile[0] = 1;
+ infile[1] = 1;
+ trav_table_addflags (infile, info1[curr1].name, info1[curr1].type,
+ table);
+
+ curr1++;
+ curr2++;
+ }
+ else if (cmp < 0)
+ {
+ infile[0] = 1;
+ infile[1] = 0;
+ trav_table_addflags (infile, info1[curr1].name, info1[curr1].type,
+ table);
+ curr1++;
+ }
+ else
+ {
+ infile[0] = 0;
+ infile[1] = 1;
+ trav_table_addflags (infile, info2[curr2].name, info2[curr2].type,
+ table);
+ curr2++;
+ }
+
+ more_names_exist = (curr1 < nobjects1 && curr2 < nobjects2) ? 1 : 0;
+
+
+ } /* end while */
+
+ /* list1 did not end */
+ if (curr1 < nobjects1)
{
- infile[0] = 0;
- infile[1] = 1;
- trav_table_addflags (infile, info2[curr2].name, info2[curr2].type,
- table);
- curr2++;
+ while (curr1 < nobjects1)
+ {
+ infile[0] = 1;
+ infile[1] = 0;
+ trav_table_addflags (infile, info1[curr1].name, info1[curr1].type,
+ table);
+ curr1++;
+ }
}
-
- more_names_exist = (curr1 < nobjects1 && curr2 < nobjects2) ? 1 : 0;
-
-
- } /* end while */
-
- /* list1 did not end */
- if (curr1 < nobjects1)
- {
- while (curr1 < nobjects1)
+
+ /* list2 did not end */
+ if (curr2 < nobjects2)
{
- infile[0] = 1;
- infile[1] = 0;
- trav_table_addflags (infile, info1[curr1].name, info1[curr1].type,
- table);
- curr1++;
+ while (curr2 < nobjects2)
+ {
+ infile[0] = 0;
+ infile[1] = 1;
+ trav_table_addflags (infile, info2[curr2].name, info2[curr2].type,
+ table);
+ curr2++;
+ }
}
- }
-
- /* list2 did not end */
- if (curr2 < nobjects2)
- {
- while (curr2 < nobjects2)
+
+/*-------------------------------------------------------------------------
+ * print the list
+ *-------------------------------------------------------------------------
+ */
+
+ if (options->m_verbose)
{
- infile[0] = 0;
- infile[1] = 1;
- trav_table_addflags (infile, info2[curr2].name, info2[curr2].type,
- table);
- curr2++;
+ printf ("\n");
+ printf ("file1 file2\n");
+ printf ("---------------------------------------\n");
+ for (i = 0; i < table->nobjs; i++)
+ {
+ c1 = (table->objs[i].flags[0]) ? 'x' : ' ';
+ c2 = (table->objs[i].flags[1]) ? 'x' : ' ';
+ printf ("%5c %6c %-15s\n", c1, c2, table->objs[i].name);
+ }
+ printf ("\n");
}
- }
-
- /*-------------------------------------------------------------------------
- * print the list
- *-------------------------------------------------------------------------
- */
-
- if (options->m_verbose)
- {
- printf ("\n");
- printf ("file1 file2\n");
- printf ("---------------------------------------\n");
- for (i = 0; i < table->nobjs; i++)
+
+
+/*-------------------------------------------------------------------------
+ * do the diff for common objects
+ *-------------------------------------------------------------------------
+ */
{
- c1 = (table->objs[i].flags[0]) ? 'x' : ' ';
- c2 = (table->objs[i].flags[1]) ? 'x' : ' ';
- printf ("%5c %6c %-15s\n", c1, c2, table->objs[i].name);
- }
- printf ("\n");
- }
-
-
- /*-------------------------------------------------------------------------
- * do the diff for common objects
- *-------------------------------------------------------------------------
- */
- {
#ifdef H5_HAVE_PARALLEL
- char* workerTasks = malloc((g_nTasks-1) * sizeof(char));
- int n;
- int busyTasks=0;
- struct diffs_found nFoundbyWorker;
- struct diff_args args;
- int havePrintToken = 1;
- MPI_Status Status;
-
- /*set all tasks as free */
- memset(workerTasks, 1, g_nTasks-1);
+ char* workerTasks = malloc((g_nTasks-1) * sizeof(char));
+ int n;
+ int busyTasks=0;
+ struct diffs_found nFoundbyWorker;
+ struct diff_args args;
+ int havePrintToken = 1;
+ MPI_Status Status;
+
+ /*set all tasks as free */
+ memset(workerTasks, 1, g_nTasks-1);
#endif
-
- for (i = 0; i < table->nobjs; i++)
- {
- if (table->objs[i].flags[0] && table->objs[i].flags[1])
- {
+
+ for (i = 0; i < table->nobjs; i++)
+ {
+ if (table->objs[i].flags[0] && table->objs[i].flags[1])
+ {
#ifdef H5_HAVE_PARALLEL
- int workerFound = 0;
+ int workerFound = 0;
#endif /* H5_HAVE_PARALLEL */
- options->cmn_objs = 1;
- if(!g_Parallel)
- {
- nfound += diff (file1_id,
- table->objs[i].name,
- file2_id,
- table->objs[i].name, options, table->objs[i].type);
- }
+ options->cmn_objs = 1;
+ if(!g_Parallel)
+ {
+ nfound += diff (file1_id,
+ table->objs[i].name,
+ file2_id,
+ table->objs[i].name, options, table->objs[i].type);
+ }
#ifdef H5_HAVE_PARALLEL
- else
- {
-h5diffdebug("beginning of big else block\n");
- /* We're in parallel mode */
- /* Since the data type of diff value is hsize_t which can
- * be arbitary large such that there is no MPI type that
- * matches it, the value is passed between processes as
- * an array of bytes in order to be portable. But this
- * may not work in non-homogeneous MPI environments.
- */
-
- /*Set up args to pass to worker task. */
- if(strlen(table->objs[i].name) > 255)
+ else
+ {
+ h5diffdebug("beginning of big else block\n");
+ /* We're in parallel mode */
+ /* Since the data type of diff value is hsize_t which can
+ * be arbitary large such that there is no MPI type that
+ * matches it, the value is passed between processes as
+ * an array of bytes in order to be portable. But this
+ * may not work in non-homogeneous MPI environments.
+ */
+
+ /*Set up args to pass to worker task. */
+ if(strlen(table->objs[i].name) > 255)
+ {
+ printf("The parallel diff only supports object names up to 255 characters\n");
+ MPI_Abort(MPI_COMM_WORLD, 0);
+ }
+
+ strcpy(args.name, table->objs[i].name);
+ args.options = *options;
+ args.type= table->objs[i].type;
+
+ h5diffdebug2("busyTasks=%d\n", busyTasks);
+ /* if there are any outstanding print requests, let's handle one. */
+ if(busyTasks > 0)
+ {
+ int incomingMessage;
+ /* check if any tasks freed up, and didn't need to print. */
+ MPI_Iprobe(MPI_ANY_SOURCE, MPI_TAG_DONE, MPI_COMM_WORLD, &incomingMessage, &Status);
+
+ /* first block*/
+ if(incomingMessage)
{
- printf("The parallel diff only supports object names up to 255 characters\n");
- MPI_Abort(MPI_COMM_WORLD, 0);
+ workerTasks[Status.MPI_SOURCE-1] = 1;
+ MPI_Recv(&nFoundbyWorker, sizeof(nFoundbyWorker), MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_DONE, MPI_COMM_WORLD, &Status);
+ nfound += nFoundbyWorker.nfound;
+ options->not_cmp = options->not_cmp | nFoundbyWorker.not_cmp;
+ busyTasks--;
}
-
- strcpy(args.name, table->objs[i].name);
- args.options = *options;
- args.type= table->objs[i].type;
-
-h5diffdebug2("busyTasks=%d\n", busyTasks);
- /* if there are any outstanding print requests, let's handle one. */
- if(busyTasks > 0)
+
+ /* check to see if the print token was returned. */
+ if(!havePrintToken)
{
- int incomingMessage;
- /* check if any tasks freed up, and didn't need to print. */
- MPI_Iprobe(MPI_ANY_SOURCE, MPI_TAG_DONE, MPI_COMM_WORLD, &incomingMessage, &Status);
-
- /* first block*/
- if(incomingMessage)
- {
- workerTasks[Status.MPI_SOURCE-1] = 1;
- MPI_Recv(&nFoundbyWorker, sizeof(nFoundbyWorker), MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_DONE, MPI_COMM_WORLD, &Status);
- nfound += nFoundbyWorker.nfound;
- options->not_cmp = options->not_cmp | nFoundbyWorker.not_cmp;
- busyTasks--;
- }
-
- /* check to see if the print token was returned. */
- if(!havePrintToken)
- {
- /* If we don't have the token, someone is probably sending us output */
- print_incoming_data();
-
- /* check incoming queue for token */
- MPI_Iprobe(MPI_ANY_SOURCE, MPI_TAG_TOK_RETURN, MPI_COMM_WORLD, &incomingMessage, &Status);
-
- /* incoming token implies free task. */
- if(incomingMessage)
- {
- workerTasks[Status.MPI_SOURCE-1] = 1;
- MPI_Recv(&nFoundbyWorker, sizeof(nFoundbyWorker), MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_TOK_RETURN, MPI_COMM_WORLD, &Status);
- nfound += nFoundbyWorker.nfound;
- options->not_cmp = options->not_cmp | nFoundbyWorker.not_cmp;
- busyTasks--;
- havePrintToken = 1;
- }
- }
-
- /* check to see if anyone needs the print token. */
- if(havePrintToken)
- {
- /* check incoming queue for print token requests */
- MPI_Iprobe(MPI_ANY_SOURCE, MPI_TAG_TOK_REQUEST, MPI_COMM_WORLD, &incomingMessage, &Status);
- if(incomingMessage)
- {
- MPI_Recv(NULL, 0, MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_TOK_REQUEST, MPI_COMM_WORLD, &Status);
- MPI_Send(NULL, 0, MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_PRINT_TOK, MPI_COMM_WORLD);
- havePrintToken = 0;
- }
- }
+ /* If we don't have the token, someone is probably sending us output */
+ print_incoming_data();
+
+ /* check incoming queue for token */
+ MPI_Iprobe(MPI_ANY_SOURCE, MPI_TAG_TOK_RETURN, MPI_COMM_WORLD, &incomingMessage, &Status);
+
+ /* incoming token implies free task. */
+ if(incomingMessage)
+ {
+ workerTasks[Status.MPI_SOURCE-1] = 1;
+ MPI_Recv(&nFoundbyWorker, sizeof(nFoundbyWorker), MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_TOK_RETURN, MPI_COMM_WORLD, &Status);
+ nfound += nFoundbyWorker.nfound;
+ options->not_cmp = options->not_cmp | nFoundbyWorker.not_cmp;
+ busyTasks--;
+ havePrintToken = 1;
+ }
}
-
- /* check array of tasks to see which ones are free.
- * Manager task never does work, so freeTasks[0] is really
- * worker task 0. */
-
- for(n=1; (n<g_nTasks) && !workerFound; n++)
+
+ /* check to see if anyone needs the print token. */
+ if(havePrintToken)
{
- if(workerTasks[n-1])
- {
- /* send file id's and names to first free worker */
- MPI_Send(&args, sizeof(struct diff_args), MPI_BYTE, n, MPI_TAG_ARGS, MPI_COMM_WORLD);
-
- /* increment counter for total number of prints. */
- busyTasks++;
-
- /* mark worker as busy */
- workerTasks[n-1] = 0;
- workerFound = 1;
- }
-
+ /* check incoming queue for print token requests */
+ MPI_Iprobe(MPI_ANY_SOURCE, MPI_TAG_TOK_REQUEST, MPI_COMM_WORLD, &incomingMessage, &Status);
+ if(incomingMessage)
+ {
+ MPI_Recv(NULL, 0, MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_TOK_REQUEST, MPI_COMM_WORLD, &Status);
+ MPI_Send(NULL, 0, MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_PRINT_TOK, MPI_COMM_WORLD);
+ havePrintToken = 0;
+ }
}
-
-
- h5diffdebug2("workerfound is %d \n", workerFound);
- if(!workerFound)
+ }
+
+ /* check array of tasks to see which ones are free.
+ * Manager task never does work, so freeTasks[0] is really
+ * worker task 0. */
+
+ for(n=1; (n<g_nTasks) && !workerFound; n++)
+ {
+ if(workerTasks[n-1])
{
- /* if they were all busy, we've got to wait for one free up before we can move on.
- * if we don't have the token, some task is currently printing so we'll wait for that task to return it. */
-
- if(!havePrintToken)
- {
- while(!havePrintToken) {
- int incomingMessage;
- print_incoming_data();
- MPI_Iprobe(MPI_ANY_SOURCE, MPI_TAG_TOK_RETURN, MPI_COMM_WORLD, &incomingMessage, &Status);
- if(incomingMessage)
- {
- MPI_Recv(&nFoundbyWorker, sizeof(nFoundbyWorker), MPI_BYTE, MPI_ANY_SOURCE, MPI_TAG_TOK_RETURN, MPI_COMM_WORLD, &Status);
- havePrintToken = 1;
- nfound += nFoundbyWorker.nfound;
- options->not_cmp = options->not_cmp | nFoundbyWorker.not_cmp;
- /* send this task the work unit. */
- MPI_Send(&args, sizeof(struct diff_args), MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_ARGS, MPI_COMM_WORLD);
- }
- }
- }
- /* if we do have the token, check for task to free up, or wait for a task to request it */
- else
- {
- /* But first print all the data in our incoming queue */
- print_incoming_data();
- MPI_Probe(MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &Status);
- if(Status.MPI_TAG == MPI_TAG_DONE)
- {
- MPI_Recv(&nFoundbyWorker, sizeof(nFoundbyWorker), MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_DONE, MPI_COMM_WORLD, &Status);
- nfound += nFoundbyWorker.nfound;
- options->not_cmp = options->not_cmp | nFoundbyWorker.not_cmp;
- MPI_Send(&args, sizeof(struct diff_args), MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_ARGS, MPI_COMM_WORLD);
- }
- else if(Status.MPI_TAG == MPI_TAG_TOK_REQUEST)
- {
- int incomingMessage;
- MPI_Recv(NULL, 0, MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_TOK_REQUEST, MPI_COMM_WORLD, &Status);
- MPI_Send(NULL, 0, MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_PRINT_TOK, MPI_COMM_WORLD);
-
- do
- {
- MPI_Iprobe(MPI_ANY_SOURCE, MPI_TAG_TOK_RETURN, MPI_COMM_WORLD, &incomingMessage, &Status);
-
- print_incoming_data();
- }
- while(!incomingMessage);
-
-
- MPI_Recv(&nFoundbyWorker, sizeof(nFoundbyWorker), MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_TOK_RETURN, MPI_COMM_WORLD, &Status);
- nfound += nFoundbyWorker.nfound;
- options->not_cmp = options->not_cmp | nFoundbyWorker.not_cmp;
- MPI_Send(&args, sizeof(struct diff_args), MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_ARGS, MPI_COMM_WORLD);
- }
- else
- {
- printf("ERROR: Invalid tag (%d) received \n", Status.MPI_TAG);
- MPI_Abort(MPI_COMM_WORLD, 0);
- MPI_Finalize();
- }
- }
+ /* send file id's and names to first free worker */
+ MPI_Send(&args, sizeof(struct diff_args), MPI_BYTE, n, MPI_TAG_ARGS, MPI_COMM_WORLD);
+
+ /* increment counter for total number of prints. */
+ busyTasks++;
+
+ /* mark worker as busy */
+ workerTasks[n-1] = 0;
+ workerFound = 1;
+ }
+
+ }
+
+
+ h5diffdebug2("workerfound is %d \n", workerFound);
+ if(!workerFound)
+ {
+ /* if they were all busy, we've got to wait for one free up before we can move on.
+ * if we don't have the token, some task is currently printing so we'll wait for that task to return it. */
+
+ if(!havePrintToken)
+ {
+ while(!havePrintToken) {
+ int incomingMessage;
+ print_incoming_data();
+ MPI_Iprobe(MPI_ANY_SOURCE, MPI_TAG_TOK_RETURN, MPI_COMM_WORLD, &incomingMessage, &Status);
+ if(incomingMessage)
+ {
+ MPI_Recv(&nFoundbyWorker, sizeof(nFoundbyWorker), MPI_BYTE, MPI_ANY_SOURCE, MPI_TAG_TOK_RETURN, MPI_COMM_WORLD, &Status);
+ havePrintToken = 1;
+ nfound += nFoundbyWorker.nfound;
+ options->not_cmp = options->not_cmp | nFoundbyWorker.not_cmp;
+ /* send this task the work unit. */
+ MPI_Send(&args, sizeof(struct diff_args), MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_ARGS, MPI_COMM_WORLD);
+ }
+ }
+ }
+ /* if we do have the token, check for task to free up, or wait for a task to request it */
+ else
+ {
+ /* But first print all the data in our incoming queue */
+ print_incoming_data();
+ MPI_Probe(MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &Status);
+ if(Status.MPI_TAG == MPI_TAG_DONE)
+ {
+ MPI_Recv(&nFoundbyWorker, sizeof(nFoundbyWorker), MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_DONE, MPI_COMM_WORLD, &Status);
+ nfound += nFoundbyWorker.nfound;
+ options->not_cmp = options->not_cmp | nFoundbyWorker.not_cmp;
+ MPI_Send(&args, sizeof(struct diff_args), MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_ARGS, MPI_COMM_WORLD);
+ }
+ else if(Status.MPI_TAG == MPI_TAG_TOK_REQUEST)
+ {
+ int incomingMessage;
+ MPI_Recv(NULL, 0, MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_TOK_REQUEST, MPI_COMM_WORLD, &Status);
+ MPI_Send(NULL, 0, MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_PRINT_TOK, MPI_COMM_WORLD);
+
+ do
+ {
+ MPI_Iprobe(MPI_ANY_SOURCE, MPI_TAG_TOK_RETURN, MPI_COMM_WORLD, &incomingMessage, &Status);
+
+ print_incoming_data();
+ }
+ while(!incomingMessage);
+
+
+ MPI_Recv(&nFoundbyWorker, sizeof(nFoundbyWorker), MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_TOK_RETURN, MPI_COMM_WORLD, &Status);
+ nfound += nFoundbyWorker.nfound;
+ options->not_cmp = options->not_cmp | nFoundbyWorker.not_cmp;
+ MPI_Send(&args, sizeof(struct diff_args), MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_ARGS, MPI_COMM_WORLD);
+ }
+ else
+ {
+ printf("ERROR: Invalid tag (%d) received \n", Status.MPI_TAG);
+ MPI_Abort(MPI_COMM_WORLD, 0);
+ MPI_Finalize();
+ }
}
+ }
}
#endif /* H5_HAVE_PARALLEL */
}
}
h5diffdebug("done with for loop\n");
-
+
#ifdef H5_HAVE_PARALLEL
if(g_Parallel)
{
- while(busyTasks > 0) /* make sure all tasks are done */
+ while(busyTasks > 0) /* make sure all tasks are done */
+ {
+ MPI_Probe(MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &Status);
+ if(Status.MPI_TAG == MPI_TAG_DONE)
+ {
+ MPI_Recv(&nFoundbyWorker, sizeof(nFoundbyWorker), MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_DONE, MPI_COMM_WORLD, &Status);
+ nfound += nFoundbyWorker.nfound;
+ options->not_cmp = options->not_cmp | nFoundbyWorker.not_cmp;
+ busyTasks--;
+ }
+ else if(Status.MPI_TAG == MPI_TAG_TOK_RETURN)
+ {
+ MPI_Recv(&nFoundbyWorker, sizeof(nFoundbyWorker), MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_DONE, MPI_COMM_WORLD, &Status);
+ nfound += nFoundbyWorker.nfound;
+ options->not_cmp = options->not_cmp | nFoundbyWorker.not_cmp;
+ busyTasks--;
+ havePrintToken = 1;
+ }
+ else if(Status.MPI_TAG == MPI_TAG_TOK_REQUEST)
+ {
+ MPI_Recv(NULL, 0, MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_TOK_REQUEST, MPI_COMM_WORLD, &Status);
+ if(havePrintToken)
+ {
+ int incomingMessage;
+ MPI_Send(NULL, 0, MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_PRINT_TOK, MPI_COMM_WORLD);
+ do
{
- MPI_Probe(MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &Status);
- if(Status.MPI_TAG == MPI_TAG_DONE)
- {
- MPI_Recv(&nFoundbyWorker, sizeof(nFoundbyWorker), MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_DONE, MPI_COMM_WORLD, &Status);
- nfound += nFoundbyWorker.nfound;
- options->not_cmp = options->not_cmp | nFoundbyWorker.not_cmp;
- busyTasks--;
- }
- else if(Status.MPI_TAG == MPI_TAG_TOK_RETURN)
- {
- MPI_Recv(&nFoundbyWorker, sizeof(nFoundbyWorker), MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_DONE, MPI_COMM_WORLD, &Status);
- nfound += nFoundbyWorker.nfound;
- options->not_cmp = options->not_cmp | nFoundbyWorker.not_cmp;
- busyTasks--;
- havePrintToken = 1;
- }
- else if(Status.MPI_TAG == MPI_TAG_TOK_REQUEST)
- {
- MPI_Recv(NULL, 0, MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_TOK_REQUEST, MPI_COMM_WORLD, &Status);
- if(havePrintToken)
- {
- int incomingMessage;
- MPI_Send(NULL, 0, MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_PRINT_TOK, MPI_COMM_WORLD);
- do
- {
- MPI_Iprobe(MPI_ANY_SOURCE, MPI_TAG_TOK_RETURN, MPI_COMM_WORLD, &incomingMessage, &Status);
-
- print_incoming_data();
- }
- while(!incomingMessage);
- MPI_Recv(&nFoundbyWorker, sizeof(nFoundbyWorker), MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_TOK_RETURN, MPI_COMM_WORLD, &Status);
- nfound += nFoundbyWorker.nfound;
- options->not_cmp = options->not_cmp | nFoundbyWorker.not_cmp;
- busyTasks--;
- }
- else /* someone else must have it...wait for them to return it, then give it to the task that just asked for it. */
- {
- int source = Status.MPI_SOURCE;
- int incomingMessage;
- do
- {
- MPI_Iprobe(MPI_ANY_SOURCE, MPI_TAG_TOK_RETURN, MPI_COMM_WORLD, &incomingMessage, &Status);
-
- print_incoming_data();
- }
- while(!incomingMessage);
-
-
- MPI_Recv(&nFoundbyWorker, sizeof(nFoundbyWorker), MPI_BYTE, MPI_ANY_SOURCE, MPI_TAG_TOK_RETURN, MPI_COMM_WORLD, &Status);
- nfound += nFoundbyWorker.nfound;
- options->not_cmp = options->not_cmp | nFoundbyWorker.not_cmp;
- busyTasks--;
- MPI_Send(NULL, 0, MPI_BYTE, source, MPI_TAG_PRINT_TOK, MPI_COMM_WORLD);
- }
- }
- else if(Status.MPI_TAG == MPI_TAG_TOK_RETURN)
- {
- MPI_Recv(&nFoundbyWorker, sizeof(nFoundbyWorker), MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_TOK_RETURN, MPI_COMM_WORLD, &Status);
- nfound += nFoundbyWorker.nfound;
- options->not_cmp = options->not_cmp | nFoundbyWorker.not_cmp;
- busyTasks--;
- havePrintToken = 1;
- }
- else if(Status.MPI_TAG == MPI_TAG_PRINT_DATA)
- {
- char data[PRINT_DATA_MAX_SIZE+1];
- memset(data, 0, PRINT_DATA_MAX_SIZE+1);
-
- MPI_Recv(data, PRINT_DATA_MAX_SIZE, MPI_CHAR, Status.MPI_SOURCE, MPI_TAG_PRINT_DATA, MPI_COMM_WORLD, &Status);
-
- printf("%s", data);
- }
- else
- {
- printf("ph5diff-manager: ERROR!! Invalid tag (%d) received \n", Status.MPI_TAG);
- MPI_Abort(MPI_COMM_WORLD, 0);
- }
+ MPI_Iprobe(MPI_ANY_SOURCE, MPI_TAG_TOK_RETURN, MPI_COMM_WORLD, &incomingMessage, &Status);
+
+ print_incoming_data();
}
-
- for(i=1; i<g_nTasks; i++)
- MPI_Send(NULL, 0, MPI_BYTE, i, MPI_TAG_END, MPI_COMM_WORLD);
-
- /* Print any final data waiting in our queue */
- print_incoming_data();
-
+ while(!incomingMessage);
+ MPI_Recv(&nFoundbyWorker, sizeof(nFoundbyWorker), MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_TOK_RETURN, MPI_COMM_WORLD, &Status);
+ nfound += nFoundbyWorker.nfound;
+ options->not_cmp = options->not_cmp | nFoundbyWorker.not_cmp;
+ busyTasks--;
+ }
+ else /* someone else must have it...wait for them to return it, then give it to the task that just asked for it. */
+ {
+ int source = Status.MPI_SOURCE;
+ int incomingMessage;
+ do
+ {
+ MPI_Iprobe(MPI_ANY_SOURCE, MPI_TAG_TOK_RETURN, MPI_COMM_WORLD, &incomingMessage, &Status);
+
+ print_incoming_data();
+ }
+ while(!incomingMessage);
+
+
+ MPI_Recv(&nFoundbyWorker, sizeof(nFoundbyWorker), MPI_BYTE, MPI_ANY_SOURCE, MPI_TAG_TOK_RETURN, MPI_COMM_WORLD, &Status);
+ nfound += nFoundbyWorker.nfound;
+ options->not_cmp = options->not_cmp | nFoundbyWorker.not_cmp;
+ busyTasks--;
+ MPI_Send(NULL, 0, MPI_BYTE, source, MPI_TAG_PRINT_TOK, MPI_COMM_WORLD);
+ }
+ }
+ else if(Status.MPI_TAG == MPI_TAG_TOK_RETURN)
+ {
+ MPI_Recv(&nFoundbyWorker, sizeof(nFoundbyWorker), MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_TOK_RETURN, MPI_COMM_WORLD, &Status);
+ nfound += nFoundbyWorker.nfound;
+ options->not_cmp = options->not_cmp | nFoundbyWorker.not_cmp;
+ busyTasks--;
+ havePrintToken = 1;
+ }
+ else if(Status.MPI_TAG == MPI_TAG_PRINT_DATA)
+ {
+ char data[PRINT_DATA_MAX_SIZE+1];
+ memset(data, 0, PRINT_DATA_MAX_SIZE+1);
+
+ MPI_Recv(data, PRINT_DATA_MAX_SIZE, MPI_CHAR, Status.MPI_SOURCE, MPI_TAG_PRINT_DATA, MPI_COMM_WORLD, &Status);
+
+ printf("%s", data);
+ }
+ else
+ {
+ printf("ph5diff-manager: ERROR!! Invalid tag (%d) received \n", Status.MPI_TAG);
+ MPI_Abort(MPI_COMM_WORLD, 0);
+ }
+ }
+
+ for(i=1; i<g_nTasks; i++)
+ MPI_Send(NULL, 0, MPI_BYTE, i, MPI_TAG_END, MPI_COMM_WORLD);
+
+ /* Print any final data waiting in our queue */
+ print_incoming_data();
+
}
-h5diffdebug("done with if block\n");
-
+ h5diffdebug("done with if block\n");
+
free(workerTasks);
#endif /* H5_HAVE_PARALLEL */
- }
- /* free table */
- trav_table_free (table);
-
-
- /*-------------------------------------------------------------------------
- * do the diff for the root.
- * this is a special case, we get an ID for the root group and call diff()
- * with this ID; it compares only the root group attributes
- *-------------------------------------------------------------------------
- */
-
- /* the manager can do this. */
- nfound += diff (file1_id, "/", file2_id, "/", options, H5G_GROUP);
-
- return nfound;
+ }
+
+ /* free table */
+ trav_table_free (table);
+
+
+/*-------------------------------------------------------------------------
+ * do the diff for the root.
+ * this is a special case, we get an ID for the root group and call diff()
+ * with this ID; it compares only the root group attributes
+ *-------------------------------------------------------------------------
+ */
+
+ /* the manager can do this. */
+ nfound += diff (file1_id, "/", file2_id, "/", options, H5G_GROUP);
+
+ return nfound;
}
@@ -803,62 +802,62 @@ h5diffdebug("done with if block\n");
*-------------------------------------------------------------------------
*/
-hsize_t
-diff_compare (hid_t file1_id,
- const char *file1_name,
- const char *obj1_name,
- int nobjects1,
- trav_info_t * info1,
- hid_t file2_id,
- const char *file2_name,
- const char *obj2_name,
- int nobjects2, trav_info_t * info2, diff_opt_t * options)
+hsize_t diff_compare (hid_t file1_id,
+ const char *file1_name,
+ const char *obj1_name,
+ int nobjects1,
+ trav_info_t * info1,
+ hid_t file2_id,
+ const char *file2_name,
+ const char *obj2_name,
+ int nobjects2,
+ trav_info_t * info2,
+ diff_opt_t * options)
{
-
- int f1 = 0, f2 = 0;
- hsize_t nfound = 0;
-
- int i = h5trav_getindex (obj1_name, nobjects1, info1);
- int j = h5trav_getindex (obj2_name, nobjects2, info2);
-
- if (i == -1)
- {
- parallel_print ("Object <%s> could not be found in <%s>\n", obj1_name,
- file1_name);
- f1 = 1;
- }
- if (j == -1)
- {
+ int f1 = 0, f2 = 0;
+ hsize_t nfound = 0;
+
+ int i = h5trav_getindex (obj1_name, nobjects1, info1);
+ int j = h5trav_getindex (obj2_name, nobjects2, info2);
+
+ if (i == -1)
+ {
+ parallel_print ("Object <%s> could not be found in <%s>\n", obj1_name,
+ file1_name);
+ f1 = 1;
+ }
+ if (j == -1)
+ {
parallel_print ("Object <%s> could not be found in <%s>\n", obj2_name,
file2_name);
f2 = 1;
- }
- if (f1 || f2)
- {
+ }
+ if (f1 || f2)
+ {
options->err_stat = 1;
return 0;
- }
-
- /* use the name with "/" first, as obtained by iterator function */
- obj1_name = info1[i].name;
- obj2_name = info2[j].name;
-
- /* objects are not the same type */
- if (info1[i].type != info2[j].type)
- {
- if (options->m_verbose)
- parallel_print
+ }
+
+ /* use the name with "/" first, as obtained by iterator function */
+ obj1_name = info1[i].name;
+ obj2_name = info2[j].name;
+
+ /* objects are not the same type */
+ if (info1[i].type != info2[j].type)
+ {
+ if (options->m_verbose)
+ parallel_print
("Comparison not possible: <%s> is of type %s and <%s> is of type %s\n",
- obj1_name, get_type (info1[i].type), obj2_name,
- get_type (info2[j].type));
- options->not_cmp=1;
- return 0;
- }
-
- nfound =
- diff (file1_id, obj1_name, file2_id, obj2_name, options, info1[i].type);
-
- return nfound;
+ obj1_name, get_type (info1[i].type), obj2_name,
+ get_type (info2[j].type));
+ options->not_cmp=1;
+ return 0;
+ }
+
+ nfound =
+ diff (file1_id, obj1_name, file2_id, obj2_name, options, info1[i].type);
+
+ return nfound;
}
@@ -881,219 +880,220 @@ diff_compare (hid_t file1_id,
*-------------------------------------------------------------------------
*/
-hsize_t
-diff (hid_t file1_id,
- const char *path1,
- hid_t file2_id, const char *path2, diff_opt_t * options, H5G_obj_t type)
+hsize_t diff (hid_t file1_id,
+ const char *path1,
+ hid_t file2_id,
+ const char *path2,
+ diff_opt_t * options,
+ H5G_obj_t type)
{
- hid_t type1_id=(-1);
- hid_t type2_id=(-1);
- hid_t grp1_id=(-1);
- hid_t grp2_id=(-1);
- int ret;
- H5G_stat_t sb1;
- H5G_stat_t sb2;
- hsize_t nfound = 0;
-
- switch (type)
+ hid_t type1_id=(-1);
+ hid_t type2_id=(-1);
+ hid_t grp1_id=(-1);
+ hid_t grp2_id=(-1);
+ int ret;
+ H5G_stat_t sb1;
+ H5G_stat_t sb2;
+ hsize_t nfound = 0;
+
+ switch (type)
+ {
+/*-------------------------------------------------------------------------
+ * H5G_DATASET
+ *-------------------------------------------------------------------------
+ */
+ case H5G_DATASET:
+
+/*-------------------------------------------------------------------------
+ * verbose, always print name
+ *-------------------------------------------------------------------------
+ */
+ if (options->m_verbose)
+ {
+ if (print_objname (options, (hsize_t)1))
+ parallel_print("Dataset: <%s> and <%s>\n", path1, path2);
+ nfound = diff_dataset (file1_id, file2_id, path1, path2, options);
+ /* always print the number of differences found */
+ print_found(nfound);
+ }
+ /*-------------------------------------------------------------------------
+ * non verbose, check first if we have differences
+ *-------------------------------------------------------------------------
+ */
+ else
+ {
+ if (options->m_quiet == 0)
+ {
+ /* shut up temporarily */
+ options->m_quiet = 1;
+ nfound = diff_dataset (file1_id, file2_id, path1, path2, options);
+ /* print again */
+ options->m_quiet = 0;
+ if (nfound)
{
+ if (print_objname (options, nfound))
+ parallel_print("Dataset: <%s> and <%s>\n", path1, path2);
+ nfound = diff_dataset (file1_id, file2_id, path1, path2, options);
+ /* print the number of differences found only when found
+ this is valid for the default mode and report mode */
+ print_found(nfound);
+ } /*if nfound */
+ } /*if quiet */
+
/*-------------------------------------------------------------------------
- * H5G_DATASET
+ * quiet mode, just count differences
*-------------------------------------------------------------------------
*/
- case H5G_DATASET:
-
+ else
+ {
+ nfound = diff_dataset (file1_id, file2_id, path1, path2, options);
+ }
+ } /*else verbose */
+
+ break;
+
/*-------------------------------------------------------------------------
- * verbose, always print name
+ * H5G_TYPE
*-------------------------------------------------------------------------
*/
- if (options->m_verbose)
- {
- if (print_objname (options, (hsize_t)1))
- parallel_print("Dataset: <%s> and <%s>\n", path1, path2);
- nfound = diff_dataset (file1_id, file2_id, path1, path2, options);
- /* always print the number of differences found */
- print_found(nfound);
- }
+ case H5G_TYPE:
+ if ((type1_id = H5Topen (file1_id, path1)) < 0)
+ goto out;
+ if ((type2_id = H5Topen (file2_id, path2)) < 0)
+ goto out;
+
+ if ((ret = H5Tequal (type1_id, type2_id)) < 0)
+ goto out;
+
+ /* if H5Tequal is > 0 then the datatypes refer to the same datatype */
+ nfound = (ret > 0) ? 0 : 1;
+
+ if (print_objname (options, nfound))
+ parallel_print("Datatype: <%s> and <%s>\n", path1, path2);
+
+ /* always print the number of differences found in verbose mode */
+ if (options->m_verbose)
+ print_found(nfound);
+
/*-------------------------------------------------------------------------
- * non verbose, check first if we have differences
+ * compare attributes
+ * the if condition refers to cases when the dataset is a referenced object
*-------------------------------------------------------------------------
*/
- else
- {
- if (options->m_quiet == 0)
- {
- /* shut up temporarily */
- options->m_quiet = 1;
- nfound = diff_dataset (file1_id, file2_id, path1, path2, options);
- /* print again */
- options->m_quiet = 0;
- if (nfound)
- {
- if (print_objname (options, nfound))
- parallel_print("Dataset: <%s> and <%s>\n", path1, path2);
- nfound = diff_dataset (file1_id, file2_id, path1, path2, options);
- /* print the number of differences found only when found
- this is valid for the default mode and report mode */
- print_found(nfound);
- } /*if nfound */
- } /*if quiet */
-
+ if (path1)
+ diff_attr (type1_id, type2_id, path1, path2, options);
+
+ if (H5Tclose (type1_id) < 0)
+ goto out;
+ if (H5Tclose (type2_id) < 0)
+ goto out;
+
+ break;
+
/*-------------------------------------------------------------------------
- * quiet mode, just count differences
+ * H5G_GROUP
*-------------------------------------------------------------------------
*/
- else
- {
- nfound = diff_dataset (file1_id, file2_id, path1, path2, options);
- }
- } /*else verbose */
-
- break;
-
- /*-------------------------------------------------------------------------
- * H5G_TYPE
- *-------------------------------------------------------------------------
- */
- case H5G_TYPE:
- if ((type1_id = H5Topen (file1_id, path1)) < 0)
- goto out;
- if ((type2_id = H5Topen (file2_id, path2)) < 0)
- goto out;
-
- if ((ret = H5Tequal (type1_id, type2_id)) < 0)
- goto out;
-
- /* if H5Tequal is > 0 then the datatypes refer to the same datatype */
- nfound = (ret > 0) ? 0 : 1;
-
- if (print_objname (options, nfound))
- parallel_print("Datatype: <%s> and <%s>\n", path1, path2);
-
- /* always print the number of differences found in verbose mode */
- if (options->m_verbose)
- print_found(nfound);
-
- /*-------------------------------------------------------------------------
- * compare attributes
- * the if condition refers to cases when the dataset is a referenced object
- *-------------------------------------------------------------------------
- */
- if (path1)
- diff_attr (type1_id, type2_id, path1, path2, options);
-
- if (H5Tclose (type1_id) < 0)
- goto out;
- if (H5Tclose (type2_id) < 0)
- goto out;
-
- break;
-
- /*-------------------------------------------------------------------------
- * H5G_GROUP
- *-------------------------------------------------------------------------
- */
case H5G_GROUP:
- if ((grp1_id = H5Gopen (file1_id, path1)) < 0)
- goto out;
- if ((grp2_id = H5Gopen (file2_id, path2)) < 0)
- goto out;
-
- ret = HDstrcmp (path1, path2);
-
- /* if "path1" != "path2" then the groups are "different" */
- nfound = (ret != 0) ? 1 : 0;
-
- if (print_objname (options, nfound))
- parallel_print("Group: <%s> and <%s>\n", path1, path2);
-
- /* always print the number of differences found in verbose mode */
- if (options->m_verbose)
- print_found(nfound);
-
- /*-------------------------------------------------------------------------
- * compare attributes
- * the if condition refers to cases when the dataset is a referenced object
- *-------------------------------------------------------------------------
- */
- if (path1)
- diff_attr (grp1_id, grp2_id, path1, path2, options);
-
- if (H5Gclose (grp1_id) < 0)
- goto out;
- if (H5Gclose (grp2_id) < 0)
- goto out;
-
- break;
-
-
- /*-------------------------------------------------------------------------
- * H5G_LINK
- *-------------------------------------------------------------------------
- */
+ if ((grp1_id = H5Gopen (file1_id, path1)) < 0)
+ goto out;
+ if ((grp2_id = H5Gopen (file2_id, path2)) < 0)
+ goto out;
+
+ ret = HDstrcmp (path1, path2);
+
+ /* if "path1" != "path2" then the groups are "different" */
+ nfound = (ret != 0) ? 1 : 0;
+
+ if (print_objname (options, nfound))
+ parallel_print("Group: <%s> and <%s>\n", path1, path2);
+
+ /* always print the number of differences found in verbose mode */
+ if (options->m_verbose)
+ print_found(nfound);
+
+ /*-------------------------------------------------------------------------
+ * compare attributes
+ * the if condition refers to cases when the dataset is a referenced object
+ *-------------------------------------------------------------------------
+ */
+ if (path1)
+ diff_attr (grp1_id, grp2_id, path1, path2, options);
+
+ if (H5Gclose (grp1_id) < 0)
+ goto out;
+ if (H5Gclose (grp2_id) < 0)
+ goto out;
+
+ break;
+
+
+ /*-------------------------------------------------------------------------
+ * H5G_LINK
+ *-------------------------------------------------------------------------
+ */
case H5G_LINK:
- {
- char *buf1 = NULL;
- char *buf2 = NULL;
-
- if (H5Gget_objinfo (file1_id, path1, FALSE, &sb1) < 0)
- goto out;
- if (H5Gget_objinfo (file1_id, path1, FALSE, &sb2) < 0)
- goto out;
-
- buf1 = HDmalloc (sb1.u.slink.linklen);
- buf2 = HDmalloc (sb2.u.slink.linklen);
-
- if (H5Gget_linkval (file1_id, path1, sb1.u.slink.linklen, buf1) < 0)
- goto out;
- if (H5Gget_linkval (file2_id, path2, sb1.u.slink.linklen, buf2) < 0)
- goto out;
-
- ret = HDstrcmp (buf1, buf2);
-
- /* if "buf1" != "buf2" then the links are "different" */
- nfound = (ret != 0) ? 1 : 0;
-
- if (print_objname (options, nfound))
- parallel_print("Soft Link: <%s> and <%s>\n", path1, path2);
-
- /* always print the number of differences found in verbose mode */
- if (options->m_verbose)
- print_found(nfound);
-
- HDfree (buf1);
- HDfree (buf2);
- }
- break;
-
+ {
+ char *buf1 = NULL;
+ char *buf2 = NULL;
+
+ if (H5Gget_objinfo (file1_id, path1, FALSE, &sb1) < 0)
+ goto out;
+ if (H5Gget_objinfo (file1_id, path1, FALSE, &sb2) < 0)
+ goto out;
+
+ buf1 = HDmalloc (sb1.u.slink.linklen);
+ buf2 = HDmalloc (sb2.u.slink.linklen);
+
+ if (H5Gget_linkval (file1_id, path1, sb1.u.slink.linklen, buf1) < 0)
+ goto out;
+ if (H5Gget_linkval (file2_id, path2, sb1.u.slink.linklen, buf2) < 0)
+ goto out;
+
+ ret = HDstrcmp (buf1, buf2);
+
+ /* if "buf1" != "buf2" then the links are "different" */
+ nfound = (ret != 0) ? 1 : 0;
+
+ if (print_objname (options, nfound))
+ parallel_print("Soft Link: <%s> and <%s>\n", path1, path2);
+
+ /* always print the number of differences found in verbose mode */
+ if (options->m_verbose)
+ print_found(nfound);
+
+ HDfree (buf1);
+ HDfree (buf2);
+ }
+ break;
+
default:
- nfound = 0;
- if (options->m_verbose)
- {
- parallel_print("Comparison not supported: <%s> and <%s> are of type %s\n",
- path1, path2, get_type (type));
- options->not_cmp=1;
- }
-
- break;
- }
-
-
+ nfound = 0;
+ if (options->m_verbose)
+ {
+ parallel_print("Comparison not supported: <%s> and <%s> are of type %s\n",
+ path1, path2, get_type (type));
+ options->not_cmp=1;
+ }
+
+ break;
+ } /* switch */
+
+
out:
-
- /* close */
- /* disable error reporting */
- H5E_BEGIN_TRY
- {
- H5Tclose (type1_id);
- H5Tclose (type2_id);
- H5Gclose (grp1_id);
- H5Tclose (grp2_id);
- /* enable error reporting */
- }
- H5E_END_TRY;
-
- return nfound;
+
+ /* close */
+ /* disable error reporting */
+ H5E_BEGIN_TRY
+ {
+ H5Tclose (type1_id);
+ H5Tclose (type2_id);
+ H5Gclose (grp1_id);
+ H5Tclose (grp2_id);
+ /* enable error reporting */
+ }
+ H5E_END_TRY;
+ return nfound;
}
diff --git a/tools/lib/h5diff.h b/tools/lib/h5diff.h
index ffe7101..c8536b4 100644
--- a/tools/lib/h5diff.h
+++ b/tools/lib/h5diff.h
@@ -18,12 +18,6 @@
#include "hdf5.h"
#include "h5trav.h"
-
-#if 0
-#define H5DIFF_DEBUG
-#endif
-
-
/*-------------------------------------------------------------------------
* command line options
*-------------------------------------------------------------------------
@@ -167,14 +161,6 @@ const char* get_sign(H5T_sign_t sign);
void print_dims( int r, hsize_t *d );
int print_objname(diff_opt_t *options, hsize_t nfound);
-
-#if defined (H5DIFF_DEBUG)
-void print_sizes( const char *obj1, const char *obj2,
- hid_t f_type1, hid_t f_type2,
- hid_t m_type1, hid_t m_type2 );
-#endif
-
-
hsize_t diff_native_uchar(unsigned char *mem1,
unsigned char *mem2,
hsize_t i,
diff --git a/tools/lib/h5diff_array.c b/tools/lib/h5diff_array.c
index 677072c..ed74fd3 100644
--- a/tools/lib/h5diff_array.c
+++ b/tools/lib/h5diff_array.c
@@ -35,13 +35,12 @@
/* with -p option */
#define F_FORMAT_P "%-15.10g %-15.10g %-15.10g %-14.10g\n"
-#define I_FORMAT_P "%-15d %-15d %-15d %-14f\n"
-/*#define I_FORMAT_P "%-15d %-15d %-15d %-14d\n"*/
-#define UI_FORMAT_P "%-15u %-15u %-15u %-14u\n"
-#define LI_FORMAT_P "%-15ld %-15ld %-15ld %-14ld\n"
-#define ULI_FORMAT_P "%-15lu %-15lu %-15lu %-14lu\n"
-#define LLI_FORMAT_P "%-15"H5_PRINTF_LL_WIDTH"d %-15"H5_PRINTF_LL_WIDTH"d %-15"H5_PRINTF_LL_WIDTH"d\n"
-#define ULLI_FORMAT_P "%-15"H5_PRINTF_LL_WIDTH"u %-15"H5_PRINTF_LL_WIDTH"u %-15"H5_PRINTF_LL_WIDTH"u\n"
+#define I_FORMAT_P "%-15d %-15d %-15d %-14f\n"
+#define UI_FORMAT_P "%-15u %-15u %-15u %-14f\n"
+#define LI_FORMAT_P "%-15ld %-15ld %-15ld %-14f\n"
+#define ULI_FORMAT_P "%-15lu %-15lu %-15lu %-14f\n"
+#define LLI_FORMAT_P "%-15"H5_PRINTF_LL_WIDTH"d %-15"H5_PRINTF_LL_WIDTH"d %-15"H5_PRINTF_LL_WIDTH"d %-14"H5_PRINTF_LL_WIDTH"f\n"
+#define ULLI_FORMAT_P "%-15"H5_PRINTF_LL_WIDTH"u %-15"H5_PRINTF_LL_WIDTH"u %-15"H5_PRINTF_LL_WIDTH"d %-14"H5_PRINTF_LL_WIDTH"u\n"
#define SPACES " "
@@ -129,22 +128,6 @@ void print_pos( int *ph, /* print header */
}
-static
-void print_schar( int *ph, diff_opt_t *options, hsize_t i, hsize_t *acc, hsize_t *pos,
- int rank, const char *obj1, const char *obj2,
- char temp1_char, char temp2_char)
-{
- if ( print_data(options) )
- {
- print_pos(ph,0,i,acc,pos,rank,obj1,obj2);
- parallel_print(SPACES);
- parallel_print(I_FORMAT,temp1_char,temp2_char,abs(temp1_char-temp2_char));
- }
-
-}
-
-
-
/*-------------------------------------------------------------------------
* Function: diff_array
*
@@ -761,13 +744,16 @@ hsize_t diff_datum(void *_mem1,
/* !-d and -p */
else if (!options->d && options->p)
{
- if ( temp1_char!=0 && abs(1-temp2_char/temp1_char) > options->percent )
+ PER(temp1_char,temp2_char);
+ if ( per > options->percent )
{
if ( print_data(options) )
{
print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
parallel_print(SPACES);
- parallel_print(I_FORMAT_P,temp1_char,temp2_char,abs(temp1_char-temp2_char),abs(1-temp2_char/temp1_char));
+ parallel_print(I_FORMAT_P,temp1_char,temp2_char,
+ abs(temp1_char-temp2_char),
+ per);
}
nfound++;
}
@@ -775,14 +761,16 @@ hsize_t diff_datum(void *_mem1,
/* -d and -p */
else if ( options->d && options->p)
{
- if ( temp1_char!=0 && abs(1-temp2_char/temp1_char) > options->percent &&
- abs(temp1_char-temp2_char) > options->delta )
+ PER(temp1_char,temp2_char);
+ if ( per > options->percent && abs(temp1_char-temp2_char) > options->delta )
{
if ( print_data(options) )
{
print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
parallel_print(SPACES);
- parallel_print(I_FORMAT_P,temp1_char,temp2_char,abs(temp1_char-temp2_char), abs(1-temp2_char/temp1_char));
+ parallel_print(I_FORMAT_P,temp1_char,temp2_char,
+ abs(temp1_char-temp2_char),
+ per);
}
nfound++;
}
@@ -829,13 +817,16 @@ hsize_t diff_datum(void *_mem1,
/* !-d and -p */
else if (!options->d && options->p)
{
- if ( temp1_uchar!=0 && abs(1-temp2_uchar/temp1_uchar) > options->percent )
+ PER(temp1_uchar,temp2_uchar);
+ if ( per > options->percent )
{
if ( print_data(options) )
{
print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
parallel_print(SPACES);
- parallel_print(I_FORMAT_P,temp1_uchar,temp2_uchar,abs(temp1_uchar-temp2_uchar), abs(1-temp2_uchar/temp1_uchar));
+ parallel_print(I_FORMAT_P,temp1_uchar,temp2_uchar,
+ abs(temp1_uchar-temp2_uchar),
+ per);
}
nfound++;
}
@@ -843,14 +834,16 @@ hsize_t diff_datum(void *_mem1,
/* -d and -p */
else if ( options->d && options->p)
{
- if ( temp1_uchar!=0 && abs(1-temp2_uchar/temp1_uchar) > options->percent &&
- abs(temp1_uchar-temp2_uchar) > options->delta )
+ PER(temp1_uchar,temp2_uchar);
+ if ( per > options->percent && abs(temp1_uchar-temp2_uchar) > options->delta )
{
if ( print_data(options) )
{
print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
parallel_print(SPACES);
- parallel_print(I_FORMAT_P,temp1_uchar,temp2_uchar,abs(temp1_uchar-temp2_uchar), abs(1-temp2_uchar/temp1_uchar));
+ parallel_print(I_FORMAT_P,temp1_uchar,temp2_uchar,
+ abs(temp1_uchar-temp2_uchar),
+ per);
}
nfound++;
}
@@ -862,7 +855,6 @@ hsize_t diff_datum(void *_mem1,
print_pos(ph,0,i,acc,pos,rank,obj1,obj2);
parallel_print(SPACES);
parallel_print(I_FORMAT,temp1_uchar,temp2_uchar,abs(temp1_uchar-temp2_uchar));
-
}
nfound++;
}
@@ -900,13 +892,16 @@ hsize_t diff_datum(void *_mem1,
/* !-d and -p */
else if (!options->d && options->p)
{
- if ( temp1_short!=0 && abs(1-temp2_short/temp1_short) > options->percent )
+ PER(temp1_short,temp2_short);
+ if ( per > options->percent )
{
if ( print_data(options) )
{
print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
parallel_print(SPACES);
- parallel_print(I_FORMAT_P,temp1_short,temp2_short,abs(temp1_short-temp2_short), abs(1-temp2_short/temp1_short));
+ parallel_print(I_FORMAT_P,temp1_short,temp2_short,
+ abs(temp1_short-temp2_short),
+ per);
}
nfound++;
}
@@ -914,14 +909,16 @@ hsize_t diff_datum(void *_mem1,
/* -d and -p */
else if ( options->d && options->p)
{
- if ( temp1_short!=0 && abs(1-temp2_short/temp1_short) > options->percent &&
- abs(temp1_short-temp2_short) > options->delta )
+ PER(temp1_short,temp2_short);
+ if ( per > options->percent && abs(temp1_short-temp2_short) > options->delta )
{
if ( print_data(options) )
{
print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
parallel_print(SPACES);
- parallel_print(I_FORMAT_P,temp1_short,temp2_short,abs(temp1_short-temp2_short), abs(1-temp2_short/temp1_short));
+ parallel_print(I_FORMAT_P,temp1_short,temp2_short,
+ abs(temp1_short-temp2_short),
+ per);
}
nfound++;
}
@@ -971,15 +968,16 @@ hsize_t diff_datum(void *_mem1,
/* !-d and -p */
else if (!options->d && options->p)
{
- if ( temp1_ushort!=0 && abs(1-temp2_ushort/temp1_ushort) > options->percent )
+ PER(temp1_ushort,temp2_ushort);
+ if ( per > options->percent )
{
-
if ( print_data(options) )
{
print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
-
parallel_print(SPACES);
- parallel_print(I_FORMAT_P,temp1_ushort,temp2_ushort,abs(temp1_ushort-temp2_ushort), abs(1-temp2_ushort/temp1_ushort));
+ parallel_print(I_FORMAT_P,temp1_ushort,temp2_ushort,
+ abs(temp1_ushort-temp2_ushort),
+ per);
}
nfound++;
}
@@ -987,23 +985,22 @@ hsize_t diff_datum(void *_mem1,
/* -d and -p */
else if ( options->d && options->p)
{
- if ( temp1_ushort!=0 && abs(1-temp2_ushort/temp1_ushort) > options->percent &&
- abs(temp1_ushort-temp2_ushort) > options->delta )
+ PER(temp1_ushort,temp2_ushort);
+ if ( per > options->percent && abs(temp1_ushort-temp2_ushort) > options->delta )
{
-
if ( print_data(options) )
{
print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
-
parallel_print(SPACES);
- parallel_print(I_FORMAT_P,temp1_ushort,temp2_ushort,abs(temp1_ushort-temp2_ushort), abs(1-temp2_ushort/temp1_ushort));
+ parallel_print(I_FORMAT_P,temp1_ushort,temp2_ushort,
+ abs(temp1_ushort-temp2_ushort),
+ per);
}
nfound++;
}
}
else if (temp1_ushort != temp2_ushort)
{
-
if ( print_data(options) )
{
print_pos(ph,0,i,acc,pos,rank,obj1,obj2);
@@ -1012,8 +1009,6 @@ hsize_t diff_datum(void *_mem1,
}
nfound++;
}
-
-
} /*H5T_NATIVE_USHORT*/
@@ -1035,7 +1030,6 @@ hsize_t diff_datum(void *_mem1,
{
if (abs(temp1_int-temp2_int) > options->delta)
{
-
if ( print_data(options) )
{
print_pos(ph,0,i,acc,pos,rank,obj1,obj2);
@@ -1048,7 +1042,6 @@ hsize_t diff_datum(void *_mem1,
/* !-d and -p */
else if (!options->d && options->p)
{
-
PER(temp1_int,temp2_int);
if ( per > options->percent )
{
@@ -1057,7 +1050,9 @@ hsize_t diff_datum(void *_mem1,
print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
parallel_print(SPACES);
- parallel_print(I_FORMAT_P,temp1_int,temp2_int,abs(temp1_int-temp2_int),per);
+ parallel_print(I_FORMAT_P,temp1_int,temp2_int,
+ abs(temp1_int-temp2_int),
+ per);
}
nfound++;
}
@@ -1068,20 +1063,19 @@ hsize_t diff_datum(void *_mem1,
PER(temp1_int,temp2_int);
if ( per > options->percent && abs(temp1_int-temp2_int) > options->delta )
{
-
if ( print_data(options) )
{
print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
-
parallel_print(SPACES);
- parallel_print(I_FORMAT_P,temp1_int,temp2_int,abs(temp1_int-temp2_int), abs(1-temp2_int/temp1_int));
+ parallel_print(I_FORMAT_P,temp1_int,temp2_int,
+ abs(temp1_int-temp2_int),
+ per);
}
nfound++;
}
}
else if (temp1_int != temp2_int)
{
-
if ( print_data(options) )
{
print_pos(ph,0,i,acc,pos,rank,obj1,obj2);
@@ -1090,8 +1084,6 @@ hsize_t diff_datum(void *_mem1,
}
nfound++;
}
-
-
} /*H5T_NATIVE_INT*/
@@ -1113,7 +1105,6 @@ hsize_t diff_datum(void *_mem1,
{
if (abs((int)(temp1_uint-temp2_uint)) > options->delta)
{
-
if ( print_data(options) )
{
print_pos(ph,0,i,acc,pos,rank,obj1,obj2);
@@ -1126,15 +1117,16 @@ hsize_t diff_datum(void *_mem1,
/* !-d and -p */
else if (!options->d && options->p)
{
- if ( temp1_uint!=0 && abs((int)(1-temp2_uint/temp1_uint)) > options->percent )
+ PER(temp1_uint,temp2_uint);
+ if ( per > options->percent )
{
-
if ( print_data(options) )
{
print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
-
parallel_print(SPACES);
- parallel_print(I_FORMAT_P,temp1_uint,temp2_uint,abs((int)(temp1_uint-temp2_uint)), abs((int)(1-temp2_uint/temp1_uint)));
+ parallel_print(I_FORMAT_P,temp1_uint,temp2_uint,
+ abs((int)(temp1_uint-temp2_uint)),
+ per);
}
nfound++;
}
@@ -1142,27 +1134,25 @@ hsize_t diff_datum(void *_mem1,
/* -d and -p */
else if ( options->d && options->p)
{
- if ( temp1_uint!=0 && abs((int)(1-temp2_uint/temp1_uint)) > options->percent &&
- abs((int)(temp1_uint-temp2_uint)) > options->delta )
+ PER(temp1_uint,temp2_uint);
+ if ( per > options->percent && abs((int)(temp1_uint-temp2_uint)) > options->delta )
{
-
if ( print_data(options) )
{
print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
-
parallel_print(SPACES);
- parallel_print(I_FORMAT_P,temp1_uint,temp2_uint,abs((int)(temp1_uint-temp2_uint)), abs((int)(1-temp2_uint/temp1_uint)));
+ parallel_print(I_FORMAT_P,temp1_uint,temp2_uint,
+ abs((int)(temp1_uint-temp2_uint)),
+ per);
}
nfound++;
}
}
else if (temp1_uint != temp2_uint)
{
-
if ( print_data(options) )
{
print_pos(ph,0,i,acc,pos,rank,obj1,obj2);
-
parallel_print(SPACES);
parallel_print(UI_FORMAT,temp1_uint,temp2_uint,abs((int)(temp1_uint-temp2_uint)));
}
@@ -1189,7 +1179,6 @@ hsize_t diff_datum(void *_mem1,
{
if (labs(temp1_long-temp2_long) > (long)options->delta)
{
-
if ( print_data(options) )
{
print_pos(ph,0,i,acc,pos,rank,obj1,obj2);
@@ -1202,14 +1191,16 @@ hsize_t diff_datum(void *_mem1,
/* !-d and -p */
else if (!options->d && options->p)
{
- if ( temp1_long!=0 && labs(1-temp2_long/temp1_long) > (long)options->percent )
+ PER(temp1_long,temp2_long);
+ if ( per > options->percent )
{
-
if ( print_data(options) )
{
print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
parallel_print(SPACES);
- parallel_print(LI_FORMAT_P,temp1_long,temp2_long,labs(temp1_long-temp2_long), labs(1-temp2_long/temp1_long));
+ parallel_print(LI_FORMAT_P,temp1_long,temp2_long,
+ labs(temp1_long-temp2_long),
+ per);
}
nfound++;
}
@@ -1217,22 +1208,22 @@ hsize_t diff_datum(void *_mem1,
/* -d and -p */
else if ( options->d && options->p)
{
- if ( temp1_long!=0 && labs(1-temp2_long/temp1_long) > (long)options->percent &&
- labs(temp1_long-temp2_long) > (long)options->delta )
+ PER(temp1_long,temp2_long);
+ if ( per > options->percent && labs(temp1_long-temp2_long) > (long)options->delta )
{
-
if ( print_data(options) )
{
print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
parallel_print(SPACES);
- parallel_print(LI_FORMAT_P,temp1_long,temp2_long,labs(temp1_long-temp2_long), labs(1-temp2_long/temp1_long));
+ parallel_print(LI_FORMAT_P,temp1_long,temp2_long,
+ labs(temp1_long-temp2_long),
+ per);
}
nfound++;
}
}
else if (temp1_long != temp2_long)
{
-
if ( print_data(options) )
{
print_pos(ph,0,i,acc,pos,rank,obj1,obj2);
@@ -1241,9 +1232,6 @@ hsize_t diff_datum(void *_mem1,
}
nfound++;
}
-
-
-
} /*H5T_NATIVE_LONG*/
/*-------------------------------------------------------------------------
@@ -1264,7 +1252,6 @@ hsize_t diff_datum(void *_mem1,
{
if (labs((long)(temp1_ulong-temp2_ulong)) > (long)options->delta)
{
-
if ( print_data(options) )
{
print_pos(ph,0,i,acc,pos,rank,obj1,obj2);
@@ -1277,14 +1264,16 @@ hsize_t diff_datum(void *_mem1,
/* !-d and -p */
else if (!options->d && options->p)
{
- if ( temp1_ulong!=0 && labs((long)(1-temp2_ulong/temp1_ulong)) > (long)options->percent )
+ PER(temp1_ulong,temp2_ulong);
+ if ( per > options->percent )
{
-
if ( print_data(options) )
{
print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
parallel_print(SPACES);
- parallel_print(ULI_FORMAT_P,temp1_ulong,temp2_ulong,labs((long)(temp1_ulong-temp2_ulong)), labs((long)(1-temp2_ulong/temp1_ulong)));
+ parallel_print(ULI_FORMAT_P,temp1_ulong,temp2_ulong,
+ labs((long)(temp1_ulong-temp2_ulong)),
+ per);
}
nfound++;
}
@@ -1292,22 +1281,22 @@ hsize_t diff_datum(void *_mem1,
/* -d and -p */
else if ( options->d && options->p)
{
- if ( temp1_ulong!=0 && labs((long)(1-temp2_ulong/temp1_ulong)) > (long)options->percent &&
- labs((long)(temp1_ulong-temp2_ulong)) > (long)options->delta )
+ PER(temp1_ulong,temp2_ulong);
+ if ( per > options->percent && labs((long)(temp1_ulong-temp2_ulong)) > (long)options->delta )
{
-
if ( print_data(options) )
{
print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
parallel_print(SPACES);
- parallel_print(ULI_FORMAT_P,temp1_ulong,temp2_ulong,labs((long)(temp1_ulong-temp2_ulong)), labs((long)(1-temp2_ulong/temp1_ulong)));
+ parallel_print(ULI_FORMAT_P,temp1_ulong,temp2_ulong,
+ labs((long)(temp1_ulong-temp2_ulong)),
+ per);
}
nfound++;
}
}
else if (temp1_ulong != temp2_ulong)
{
-
if ( print_data(options) )
{
print_pos(ph,0,i,acc,pos,rank,obj1,obj2);
@@ -1338,7 +1327,6 @@ hsize_t diff_datum(void *_mem1,
{
if (labs((long)(temp1_llong-temp2_llong)) > (long)options->delta)
{
-
if ( print_data(options) )
{
print_pos(ph,0,i,acc,pos,rank,obj1,obj2);
@@ -1352,16 +1340,16 @@ hsize_t diff_datum(void *_mem1,
/* !-d and -p */
else if (!options->d && options->p)
{
- if ( temp1_llong!=0 && labs((long)(1-temp2_llong/temp1_llong)) > (long)options->percent )
+ PER(temp1_llong,temp2_llong);
+ if ( per > options->percent )
{
-
if ( print_data(options) )
{
print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
parallel_print(SPACES);
parallel_print(LLI_FORMAT_P,temp1_llong,temp2_llong,
(long_long)labs((long)(temp1_llong-temp2_llong)),
- (long_long)labs((long)(1-temp2_llong/temp1_llong)));
+ per);
}
nfound++;
}
@@ -1369,36 +1357,32 @@ hsize_t diff_datum(void *_mem1,
/* -d and -p */
else if ( options->d && options->p)
{
- if ( temp1_llong!=0 && labs((long)(1-temp2_llong/temp1_llong)) > (long)options->percent &&
- labs((long)(temp1_llong-temp2_llong)) > (long)options->delta )
+ PER(temp1_llong,temp2_llong);
+ if ( per > options->percent && labs((long)(temp1_llong-temp2_llong)) > (long)options->delta )
{
-
if ( print_data(options) )
{
print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
parallel_print(SPACES);
parallel_print(LLI_FORMAT_P,temp1_llong,temp2_llong,
(long_long)labs((long)(temp1_llong-temp2_llong)),
- (long_long)labs((long)(1-temp2_llong/temp1_llong)));
+ per);
}
nfound++;
}
}
else if (temp1_llong != temp2_llong)
{
-
if ( print_data(options) )
{
print_pos(ph,0,i,acc,pos,rank,obj1,obj2);
-
parallel_print(SPACES);
parallel_print(LLI_FORMAT,temp1_llong,temp2_llong,
(long_long)labs((long)(temp1_llong-temp2_llong)));
}
nfound++;
}
-
-
+
} /*H5T_NATIVE_LLONG*/
/*-------------------------------------------------------------------------
@@ -1419,7 +1403,6 @@ hsize_t diff_datum(void *_mem1,
{
if (labs((long)(temp1_ullong-temp2_ullong)) > (long)options->delta)
{
-
if ( print_data(options) )
{
print_pos(ph,0,i,acc,pos,rank,obj1,obj2);
@@ -1468,7 +1451,6 @@ hsize_t diff_datum(void *_mem1,
}
else if (temp1_ullong != temp2_ullong)
{
-
if ( print_data(options) )
{
print_pos(ph,0,i,acc,pos,rank,obj1,obj2);
@@ -1495,7 +1477,6 @@ hsize_t diff_datum(void *_mem1,
float temp1_float;
float temp2_float;
assert(type_size==sizeof(float));
-
memcpy(&temp1_float, mem1, sizeof(float));
memcpy(&temp2_float, mem2, sizeof(float));
@@ -1504,7 +1485,6 @@ hsize_t diff_datum(void *_mem1,
{
if (fabs(temp1_float-temp2_float) > options->delta)
{
-
if ( print_data(options) )
{
print_pos(ph,0,i,acc,pos,rank,obj1,obj2);
@@ -1536,7 +1516,6 @@ hsize_t diff_datum(void *_mem1,
if ( temp1_float!=0 && fabs(1-temp2_float/temp1_float) > options->percent &&
fabs(temp1_float-temp2_float) > options->delta )
{
-
if ( print_data(options) )
{
print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
@@ -1580,7 +1559,6 @@ hsize_t diff_datum(void *_mem1,
{
if (fabs(temp1_double-temp2_double) > options->delta)
{
-
if ( print_data(options) )
{
print_pos(ph,0,i,acc,pos,rank,obj1,obj2);
@@ -1595,7 +1573,6 @@ hsize_t diff_datum(void *_mem1,
{
if ( temp1_double!=0 && fabs(1-temp2_double/temp1_double) > options->percent )
{
-
if ( print_data(options) )
{
print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
@@ -1615,7 +1592,6 @@ hsize_t diff_datum(void *_mem1,
if ( print_data(options) )
{
print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
-
parallel_print(SPACES);
parallel_print(F_FORMAT_P,temp1_double,temp2_double,fabs(temp1_double-temp2_double), fabs(1-temp2_double/temp1_double));
}
@@ -1624,18 +1600,14 @@ hsize_t diff_datum(void *_mem1,
}
else if (temp1_double != temp2_double)
{
-
if ( print_data(options) )
{
print_pos(ph,0,i,acc,pos,rank,obj1,obj2);
-
parallel_print(SPACES);
parallel_print(F_FORMAT,temp1_double,temp2_double,fabs(temp1_double-temp2_double));
-
}
nfound++;
}
-
} /*H5T_NATIVE_DOUBLE*/
@@ -1760,12 +1732,8 @@ static int diff_region(hid_t region1_id,
int ndims1 = H5Sget_simple_extent_ndims(region1_id);
int ndims2 = H5Sget_simple_extent_ndims(region2_id);
int ret=0;
-
-#if defined (H5DIFF_DEBUG)
- int i;
-#endif
-
- /*
+
+/*
* These two functions fail if the region does not have blocks or points,
* respectively. They do not currently know how to translate from one to
* the other.
@@ -1887,6 +1855,7 @@ hsize_t diff_native_uchar(unsigned char *mem1,
hsize_t nfound=0; /* differences found */
unsigned char temp1_uchar;
unsigned char temp2_uchar;
+ float per;
memcpy(&temp1_uchar, mem1, sizeof(unsigned char));
memcpy(&temp2_uchar, mem2, sizeof(unsigned char));
@@ -1909,13 +1878,16 @@ hsize_t diff_native_uchar(unsigned char *mem1,
/* !-d and -p */
else if (!options->d && options->p)
{
- if ( temp1_uchar!=0 && abs(1-temp2_uchar/temp1_uchar) > options->percent )
+ PER(temp1_uchar,temp2_uchar);
+ if ( per > options->percent )
{
if ( print_data(options) )
{
print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
parallel_print(SPACES);
- parallel_print(I_FORMAT_P,temp1_uchar,temp2_uchar,abs(temp1_uchar-temp2_uchar), abs(1-temp2_uchar/temp1_uchar));
+ parallel_print(I_FORMAT_P,temp1_uchar,temp2_uchar,
+ abs(temp1_uchar-temp2_uchar),
+ per);
}
nfound++;
}
@@ -1923,14 +1895,16 @@ hsize_t diff_native_uchar(unsigned char *mem1,
/* -d and -p */
else if ( options->d && options->p)
{
- if ( temp1_uchar!=0 && abs(1-temp2_uchar/temp1_uchar) > options->percent &&
- abs(temp1_uchar-temp2_uchar) > options->delta )
+ PER(temp1_uchar,temp2_uchar);
+ if ( per > options->percent && abs(temp1_uchar-temp2_uchar) > options->delta )
{
if ( print_data(options) )
{
print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
parallel_print(SPACES);
- parallel_print(I_FORMAT_P,temp1_uchar,temp2_uchar,abs(temp1_uchar-temp2_uchar), abs(1-temp2_uchar/temp1_uchar));
+ parallel_print(I_FORMAT_P,temp1_uchar,temp2_uchar,
+ abs(temp1_uchar-temp2_uchar),
+ per);
}
nfound++;
}
@@ -1976,12 +1950,12 @@ hsize_t diff_float(unsigned char *mem1,
float temp1_float;
float temp2_float;
hsize_t i;
+ float per;
/* -d and !-p */
if (options->d && !options->p)
{
-
for ( i = 0; i < nelmts; i++)
{
memcpy(&temp1_float, mem1, sizeof(float));
@@ -2007,19 +1981,20 @@ hsize_t diff_float(unsigned char *mem1,
/* !-d and -p */
else if (!options->d && options->p)
{
-
for ( i = 0; i < nelmts; i++)
{
memcpy(&temp1_float, mem1, sizeof(float));
memcpy(&temp2_float, mem2, sizeof(float));
- if ( temp1_float!=0 && fabs(1-temp2_float/temp1_float) > options->percent )
+ PER(temp1_float,temp2_float);
+ if ( per > options->percent )
{
if ( print_data(options) )
{
print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
parallel_print(SPACES);
- parallel_print(F_FORMAT_P,temp1_float,temp2_float,fabs(temp1_float-temp2_float),
+ parallel_print(F_FORMAT_P,temp1_float,temp2_float,
+ fabs(temp1_float-temp2_float),
fabs(1-temp2_float/temp1_float));
}
nfound++;
@@ -2040,14 +2015,15 @@ hsize_t diff_float(unsigned char *mem1,
memcpy(&temp1_float, mem1, sizeof(float));
memcpy(&temp2_float, mem2, sizeof(float));
- if ( temp1_float!=0 && fabs(1-temp2_float/temp1_float) > options->percent &&
- fabs(temp1_float-temp2_float) > options->delta )
+ PER(temp1_float,temp2_float);
+ if ( per > options->percent && fabs(temp1_float-temp2_float) > options->delta )
{
if ( print_data(options) )
{
print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
parallel_print(SPACES);
- parallel_print(F_FORMAT_P,temp1_float,temp2_float,fabs(temp1_float-temp2_float),
+ parallel_print(F_FORMAT_P,temp1_float,temp2_float,
+ fabs(temp1_float-temp2_float),
fabs(1-temp2_float/temp1_float));
}
nfound++;
@@ -2115,6 +2091,7 @@ hsize_t diff_double(unsigned char *mem1,
double temp1_double;
double temp2_double;
hsize_t i;
+ float per;
/* -d and !-p */
@@ -2128,7 +2105,6 @@ hsize_t diff_double(unsigned char *mem1,
if (fabs(temp1_double-temp2_double) > options->delta)
{
-
if ( print_data(options) )
{
print_pos(ph,0,i,acc,pos,rank,obj1,obj2);
@@ -2153,13 +2129,15 @@ hsize_t diff_double(unsigned char *mem1,
memcpy(&temp1_double, mem1, sizeof(double));
memcpy(&temp2_double, mem2, sizeof(double));
- if ( temp1_double!=0 && fabs(1-temp2_double/temp1_double) > options->percent )
+ PER(temp1_double,temp2_double);
+ if ( per > options->percent )
{
if ( print_data(options) )
{
print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
parallel_print(SPACES);
- parallel_print(F_FORMAT_P,temp1_double,temp2_double,fabs(temp1_double-temp2_double),
+ parallel_print(F_FORMAT_P,temp1_double,temp2_double,
+ fabs(temp1_double-temp2_double),
fabs(1-temp2_double/temp1_double));
}
nfound++;
@@ -2180,14 +2158,15 @@ hsize_t diff_double(unsigned char *mem1,
memcpy(&temp1_double, mem1, sizeof(double));
memcpy(&temp2_double, mem2, sizeof(double));
- if ( temp1_double!=0 && fabs(1-temp2_double/temp1_double) > options->percent &&
- fabs(temp1_double-temp2_double) > options->delta )
+ PER(temp1_double,temp2_double);
+ if ( per > options->percent && fabs(temp1_double-temp2_double) > options->delta )
{
if ( print_data(options) )
{
print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
parallel_print(SPACES);
- parallel_print(F_FORMAT_P,temp1_double,temp2_double,fabs(temp1_double-temp2_double),
+ parallel_print(F_FORMAT_P,temp1_double,temp2_double,
+ fabs(temp1_double-temp2_double),
fabs(1-temp2_double/temp1_double));
}
nfound++;
@@ -2253,6 +2232,7 @@ hsize_t diff_schar(unsigned char *mem1,
char temp1_char;
char temp2_char;
hsize_t i;
+ float per;
/* -d and !-p */
@@ -2290,14 +2270,16 @@ hsize_t diff_schar(unsigned char *mem1,
memcpy(&temp1_char, mem1, sizeof(char));
memcpy(&temp2_char, mem2, sizeof(char));
- if ( temp1_char!=0 && abs(1-temp2_char/temp1_char) > options->percent )
+ PER(temp1_char,temp2_char);
+ if ( per > options->percent )
{
if ( print_data(options) )
{
print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
parallel_print(SPACES);
- parallel_print(I_FORMAT_P,temp1_char,temp2_char,abs(temp1_char-temp2_char),
- abs(1-temp2_char/temp1_char));
+ parallel_print(I_FORMAT_P,temp1_char,temp2_char,
+ abs(temp1_char-temp2_char),
+ per);
}
nfound++;
}
@@ -2317,15 +2299,16 @@ hsize_t diff_schar(unsigned char *mem1,
memcpy(&temp1_char, mem1, sizeof(char));
memcpy(&temp2_char, mem2, sizeof(char));
- if ( temp1_char!=0 && abs(1-temp2_char/temp1_char) > options->percent &&
- abs(temp1_char-temp2_char) > options->delta )
+ PER(temp1_char,temp2_char);
+ if ( per > options->percent && abs(temp1_char-temp2_char) > options->delta )
{
if ( print_data(options) )
{
print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
parallel_print(SPACES);
- parallel_print(I_FORMAT_P,temp1_char,temp2_char,abs(temp1_char-temp2_char),
- abs(1-temp2_char/temp1_char));
+ parallel_print(I_FORMAT_P,temp1_char,temp2_char,
+ abs(temp1_char-temp2_char),
+ per);
}
nfound++;
}
@@ -2393,6 +2376,7 @@ hsize_t diff_uchar(unsigned char *mem1,
unsigned char temp1_uchar;
unsigned char temp2_uchar;
hsize_t i;
+ float per;
/* -d and !-p */
@@ -2431,14 +2415,16 @@ hsize_t diff_uchar(unsigned char *mem1,
memcpy(&temp1_uchar, mem1, sizeof(unsigned char));
memcpy(&temp2_uchar, mem2, sizeof(unsigned char));
- if ( temp1_uchar!=0 && abs(1-temp2_uchar/temp1_uchar) > options->percent )
+ PER(temp1_uchar,temp2_uchar);
+ if ( per > options->percent )
{
if ( print_data(options) )
{
print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
parallel_print(SPACES);
- parallel_print(I_FORMAT_P,temp1_uchar,temp2_uchar,abs(temp1_uchar-temp2_uchar),
- abs(1-temp2_uchar/temp1_uchar));
+ parallel_print(I_FORMAT_P,temp1_uchar,temp2_uchar,
+ abs(temp1_uchar-temp2_uchar),
+ per);
}
nfound++;
}
@@ -2458,15 +2444,16 @@ hsize_t diff_uchar(unsigned char *mem1,
memcpy(&temp1_uchar, mem1, sizeof(unsigned char));
memcpy(&temp2_uchar, mem2, sizeof(unsigned char));
- if ( temp1_uchar!=0 && abs(1-temp2_uchar/temp1_uchar) > options->percent &&
- abs(temp1_uchar-temp2_uchar) > options->delta )
+ PER(temp1_uchar,temp2_uchar);
+ if ( per > options->percent && abs(temp1_uchar-temp2_uchar) > options->delta )
{
if ( print_data(options) )
{
print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
parallel_print(SPACES);
- parallel_print(I_FORMAT_P,temp1_uchar,temp2_uchar,abs(temp1_uchar-temp2_uchar),
- abs(1-temp2_uchar/temp1_uchar));
+ parallel_print(I_FORMAT_P,temp1_uchar,temp2_uchar,
+ abs(temp1_uchar-temp2_uchar),
+ per);
}
nfound++;
}
@@ -2532,6 +2519,7 @@ hsize_t diff_short(unsigned char *mem1,
short temp1_short;
short temp2_short;
hsize_t i;
+ float per;
/* -d and !-p */
@@ -2570,14 +2558,16 @@ hsize_t diff_short(unsigned char *mem1,
memcpy(&temp1_short, mem1, sizeof(short));
memcpy(&temp2_short, mem2, sizeof(short));
- if ( temp1_short!=0 && abs(1-temp2_short/temp1_short) > options->percent )
+ PER(temp1_short,temp2_short);
+ if ( per > options->percent )
{
if ( print_data(options) )
{
print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
parallel_print(SPACES);
- parallel_print(I_FORMAT_P,temp1_short,temp2_short,abs(temp1_short-temp2_short),
- abs(1-temp2_short/temp1_short));
+ parallel_print(I_FORMAT_P,temp1_short,temp2_short,
+ abs(temp1_short-temp2_short),
+ per);
}
nfound++;
}
@@ -2599,15 +2589,16 @@ hsize_t diff_short(unsigned char *mem1,
memcpy(&temp1_short, mem1, sizeof(short));
memcpy(&temp2_short, mem2, sizeof(short));
- if ( temp1_short!=0 && abs(1-temp2_short/temp1_short) > options->percent &&
- abs(temp1_short-temp2_short) > options->delta )
+ PER(temp1_short,temp2_short);
+ if ( per > options->percent && abs(temp1_short-temp2_short) > options->delta )
{
if ( print_data(options) )
{
print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
parallel_print(SPACES);
- parallel_print(I_FORMAT_P,temp1_short,temp2_short,abs(temp1_short-temp2_short),
- abs(1-temp2_short/temp1_short));
+ parallel_print(I_FORMAT_P,temp1_short,temp2_short,
+ abs(temp1_short-temp2_short),
+ per);
}
nfound++;
}
@@ -2674,6 +2665,7 @@ hsize_t diff_ushort(unsigned char *mem1,
unsigned short temp1_ushort;
unsigned short temp2_ushort;
hsize_t i;
+ float per;
/* -d and !-p */
if (options->d && !options->p)
@@ -2711,14 +2703,16 @@ hsize_t diff_ushort(unsigned char *mem1,
memcpy(&temp1_ushort, mem1, sizeof(unsigned short));
memcpy(&temp2_ushort, mem2, sizeof(unsigned short));
- if ( temp1_ushort!=0 && abs(1-temp2_ushort/temp1_ushort) > options->percent )
+ PER(temp1_ushort,temp2_ushort);
+ if ( per > options->percent )
{
if ( print_data(options) )
{
print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
parallel_print(SPACES);
- parallel_print(I_FORMAT_P,temp1_ushort,temp2_ushort,abs(temp1_ushort-temp2_ushort),
- abs(1-temp2_ushort/temp1_ushort));
+ parallel_print(I_FORMAT_P,temp1_ushort,temp2_ushort,
+ abs(temp1_ushort-temp2_ushort),
+ per);
}
nfound++;
}
@@ -2740,15 +2734,16 @@ hsize_t diff_ushort(unsigned char *mem1,
memcpy(&temp1_ushort, mem1, sizeof(unsigned short));
memcpy(&temp2_ushort, mem2, sizeof(unsigned short));
- if ( temp1_ushort!=0 && abs(1-temp2_ushort/temp1_ushort) > options->percent &&
- abs(temp1_ushort-temp2_ushort) > options->delta )
+ PER(temp1_ushort,temp2_ushort);
+ if ( per > options->percent && abs(temp1_ushort-temp2_ushort) > options->delta )
{
if ( print_data(options) )
{
print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
parallel_print(SPACES);
- parallel_print(I_FORMAT_P,temp1_ushort,temp2_ushort,abs(temp1_ushort-temp2_ushort),
- abs(1-temp2_ushort/temp1_ushort));
+ parallel_print(I_FORMAT_P,temp1_ushort,temp2_ushort,
+ abs(temp1_ushort-temp2_ushort),
+ per);
}
nfound++;
}
@@ -2861,7 +2856,9 @@ hsize_t diff_int(unsigned char *mem1,
{
print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
parallel_print(SPACES);
- parallel_print(I_FORMAT_P,temp1_int,temp2_int,abs(temp1_int-temp2_int),per);
+ parallel_print(I_FORMAT_P,temp1_int,temp2_int,
+ abs(temp1_int-temp2_int),
+ per);
}
nfound++;
}
@@ -2890,7 +2887,9 @@ hsize_t diff_int(unsigned char *mem1,
{
print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
parallel_print(SPACES);
- parallel_print(I_FORMAT_P,temp1_int,temp2_int,abs(temp1_int-temp2_int),per);
+ parallel_print(I_FORMAT_P,temp1_int,temp2_int,
+ abs(temp1_int-temp2_int),
+ per);
}
nfound++;
}
@@ -2955,10 +2954,10 @@ hsize_t diff_uint(unsigned char *mem1,
{
hsize_t nfound=0; /* number of differences found */
- unsigned int temp1_uint;
- unsigned int temp2_uint;
+ unsigned int temp1_uint;
+ unsigned int temp2_uint;
hsize_t i;
-
+ float per;
/* -d and !-p */
if (options->d && !options->p)
@@ -2969,7 +2968,7 @@ hsize_t diff_uint(unsigned char *mem1,
memcpy(&temp1_uint, mem1, sizeof(unsigned int));
memcpy(&temp2_uint, mem2, sizeof(unsigned int));
- if (abs((int)(temp1_uint-temp2_uint)) > options->delta)
+ if (abs(temp1_uint-temp2_uint) > options->delta)
{
if ( print_data(options) )
{
@@ -2996,14 +2995,16 @@ hsize_t diff_uint(unsigned char *mem1,
memcpy(&temp1_uint, mem1, sizeof(unsigned int));
memcpy(&temp2_uint, mem2, sizeof(unsigned int));
- if ( temp1_uint!=0 && abs(1-temp2_uint/temp1_uint) > options->percent )
+ PER(temp1_uint,temp2_uint);
+ if ( per > options->percent )
{
if ( print_data(options) )
{
print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
parallel_print(SPACES);
- parallel_print(I_FORMAT_P,temp1_uint,temp2_uint,abs(temp1_uint-temp2_uint),
- abs(1-temp2_uint/temp1_uint));
+ parallel_print(I_FORMAT_P,temp1_uint,temp2_uint,
+ abs(temp1_uint-temp2_uint),
+ per);
}
nfound++;
}
@@ -3025,15 +3026,16 @@ hsize_t diff_uint(unsigned char *mem1,
memcpy(&temp1_uint, mem1, sizeof(unsigned int));
memcpy(&temp2_uint, mem2, sizeof(unsigned int));
- if ( temp1_uint!=0 && abs(1-temp2_uint/temp1_uint) > options->percent &&
- abs(temp1_uint-temp2_uint) > options->delta )
+ PER(temp1_uint,temp2_uint);
+ if ( per > options->percent && abs(temp1_uint-temp2_uint) > options->delta )
{
if ( print_data(options) )
{
print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
parallel_print(SPACES);
- parallel_print(I_FORMAT_P,temp1_uint,temp2_uint,abs(temp1_uint-temp2_uint),
- abs(1-temp2_uint/temp1_uint));
+ parallel_print(I_FORMAT_P,temp1_uint,temp2_uint,
+ abs(temp1_uint-temp2_uint),
+ per);
}
nfound++;
}
@@ -3101,6 +3103,7 @@ hsize_t diff_long(unsigned char *mem1,
long temp1_long;
long temp2_long;
hsize_t i;
+ float per;
/* -d and !-p */
if (options->d && !options->p)
@@ -3129,9 +3132,7 @@ hsize_t diff_long(unsigned char *mem1,
if (options->n && nfound>=options->count)
return nfound;
}
-
}
-
}
/* !-d and -p */
@@ -3142,15 +3143,17 @@ hsize_t diff_long(unsigned char *mem1,
{
memcpy(&temp1_long, mem1, sizeof(long));
memcpy(&temp2_long, mem2, sizeof(long));
-
- if ( temp1_long!=0 && labs(1-temp2_long/temp1_long) > options->percent )
+
+ PER(temp1_long,temp2_long);
+ if ( per > options->percent )
{
if ( print_data(options) )
{
print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
parallel_print(SPACES);
- parallel_print(LI_FORMAT_P,temp1_long,temp2_long,labs(temp1_long-temp2_long),
- labs(1-temp2_long/temp1_long));
+ parallel_print(LI_FORMAT_P,temp1_long,temp2_long,
+ labs(temp1_long-temp2_long),
+ per);
}
nfound++;
}
@@ -3172,15 +3175,16 @@ hsize_t diff_long(unsigned char *mem1,
memcpy(&temp1_long, mem1, sizeof(long));
memcpy(&temp2_long, mem2, sizeof(long));
- if ( temp1_long!=0 && labs(1-temp2_long/temp1_long) > options->percent &&
- labs(temp1_long-temp2_long) > options->delta )
+ PER(temp1_long,temp2_long);
+ if ( per > options->percent && labs(temp1_long-temp2_long) > options->delta )
{
if ( print_data(options) )
{
print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
parallel_print(SPACES);
- parallel_print(LI_FORMAT_P,temp1_long,temp2_long,labs(temp1_long-temp2_long),
- labs(1-temp2_long/temp1_long));
+ parallel_print(LI_FORMAT_P,temp1_long,temp2_long,
+ labs(temp1_long-temp2_long),
+ per);
}
nfound++;
}
@@ -3249,6 +3253,7 @@ hsize_t diff_ulong(unsigned char *mem1,
unsigned long temp1_ulong;
unsigned long temp2_ulong;
hsize_t i;
+ float per;
/* -d and !-p */
@@ -3292,14 +3297,16 @@ hsize_t diff_ulong(unsigned char *mem1,
memcpy(&temp1_ulong, mem1, sizeof(unsigned long));
memcpy(&temp2_ulong, mem2, sizeof(unsigned long));
- if ( temp1_ulong!=0 && labs(1-temp2_ulong/temp1_ulong) > options->percent )
+ PER(temp1_ulong,temp2_ulong);
+ if ( per > options->percent )
{
if ( print_data(options) )
{
print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
parallel_print(SPACES);
- parallel_print(LI_FORMAT_P,temp1_ulong,temp2_ulong,labs(temp1_ulong-temp2_ulong),
- labs(1-temp2_ulong/temp1_ulong));
+ parallel_print(LI_FORMAT_P,temp1_ulong,temp2_ulong,
+ labs(temp1_ulong-temp2_ulong),
+ per);
}
nfound++;
}
@@ -3321,15 +3328,16 @@ hsize_t diff_ulong(unsigned char *mem1,
memcpy(&temp1_ulong, mem1, sizeof(unsigned long));
memcpy(&temp2_ulong, mem2, sizeof(unsigned long));
- if ( temp1_ulong!=0 && labs(1-temp2_ulong/temp1_ulong) > options->percent &&
- labs(temp1_ulong-temp2_ulong) > options->delta )
+ PER(temp1_ulong,temp2_ulong);
+ if ( per > options->percent && labs(temp1_ulong-temp2_ulong) > options->delta )
{
if ( print_data(options) )
{
print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
parallel_print(SPACES);
- parallel_print(LI_FORMAT_P,temp1_ulong,temp2_ulong,labs(temp1_ulong-temp2_ulong),
- labs(1-temp2_ulong/temp1_ulong));
+ parallel_print(LI_FORMAT_P,temp1_ulong,temp2_ulong,
+ labs(temp1_ulong-temp2_ulong),
+ per);
}
nfound++;
}
@@ -3397,6 +3405,7 @@ hsize_t diff_llong(unsigned char *mem1,
long_long temp1_llong;
long_long temp2_llong;
hsize_t i;
+ float per;
/* -d and !-p */
if (options->d && !options->p)
@@ -3435,7 +3444,8 @@ hsize_t diff_llong(unsigned char *mem1,
memcpy(&temp1_llong, mem1, sizeof(long_long));
memcpy(&temp2_llong, mem2, sizeof(long_long));
- if ( temp1_llong!=0 && labs((long)(1-temp2_llong/temp1_llong)) > options->percent )
+ PER(temp1_llong,temp2_llong);
+ if ( per > options->percent )
{
if ( print_data(options) )
{
@@ -3443,7 +3453,7 @@ hsize_t diff_llong(unsigned char *mem1,
parallel_print(SPACES);
parallel_print(LLI_FORMAT_P,temp1_llong,temp2_llong,
(long_long)labs((long)(temp1_llong-temp2_llong)),
- (long_long)labs((long)(1-temp2_llong/temp1_llong)));
+ per);
}
nfound++;
}
@@ -3465,8 +3475,8 @@ hsize_t diff_llong(unsigned char *mem1,
memcpy(&temp1_llong, mem1, sizeof(long_long));
memcpy(&temp2_llong, mem2, sizeof(long_long));
- if ( temp1_llong!=0 && labs((long)(1-temp2_llong/temp1_llong)) > options->percent &&
- labs((long)(temp1_llong-temp2_llong)) > options->delta )
+ PER(temp1_llong,temp2_llong);
+ if ( per > options->percent && labs((long)(temp1_llong-temp2_llong)) > options->delta )
{
if ( print_data(options) )
{
@@ -3474,7 +3484,7 @@ hsize_t diff_llong(unsigned char *mem1,
parallel_print(SPACES);
parallel_print(LLI_FORMAT_P,temp1_llong,temp2_llong,
(long_long)labs((long)(temp1_llong-temp2_llong)),
- (long_long)labs((long)(1-temp2_llong/temp1_llong)));
+ per);
}
nfound++;
}
@@ -3665,3 +3675,4 @@ hsize_t diff_ullong(unsigned char *mem1,
+
diff --git a/tools/lib/h5diff_attr.c b/tools/lib/h5diff_attr.c
index 439bc9c..13acc28 100644
--- a/tools/lib/h5diff_attr.c
+++ b/tools/lib/h5diff_attr.c
@@ -16,7 +16,6 @@
#include "h5diff.h"
#include "H5private.h"
-
/*-------------------------------------------------------------------------
* Function: diff_attr
*
@@ -37,227 +36,207 @@
*-------------------------------------------------------------------------
*/
-int diff_attr(hid_t loc1_id,
- hid_t loc2_id,
- const char *path1,
- const char *path2,
- diff_opt_t *options
- )
+int 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];
- int n1, n2, i, j;
- int ret=0;
- hsize_t nfound;
- int cmp=1;
-
- if ((n1 = H5Aget_num_attrs(loc1_id))<0)
- goto error;
- if ((n2 = H5Aget_num_attrs(loc2_id))<0)
- goto error;
-
- if (n1!=n2)
- return 1;
-
- for ( i = 0; i < n1; i++)
- {
-
- /* reset buffers for every attribute, we might goto out and call free */
- buf1=NULL;
- buf2=NULL;
-
- /*-------------------------------------------------------------------------
+ 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];
+ int n1, n2, i, j;
+ int ret=0;
+ hsize_t nfound;
+ int cmp=1;
+
+ if ((n1 = H5Aget_num_attrs(loc1_id))<0)
+ goto error;
+ if ((n2 = H5Aget_num_attrs(loc2_id))<0)
+ goto error;
+
+ if (n1!=n2)
+ return 1;
+
+ for ( i = 0; i < n1; i++)
+ {
+ /* reset buffers for every attribute, we might goto out and call free */
+ buf1=NULL;
+ buf2=NULL;
+
+ /*-------------------------------------------------------------------------
* open
*-------------------------------------------------------------------------
*/
- /* open attribute */
- if ((attr1_id = H5Aopen_idx(loc1_id, (unsigned)i))<0)
- goto error;
- if ((attr2_id = H5Aopen_idx(loc2_id, (unsigned)i))<0)
- goto error;
-
- /* get name */
- if (H5Aget_name( attr1_id, 255, name1 )<0)
- goto error;
- if (H5Aget_name( attr2_id, 255, name2 )<0)
- goto error;
-
- if (HDstrcmp(name1,name2)!=0)
- {
- if (options->m_verbose)
- {
- parallel_print("Different name for attributes: <%s> and <%s>\n", name1, name2);
- }
- H5Aclose(attr1_id);
- H5Aclose(attr2_id);
- ret=1;
- continue;
- }
-
- /* get the file datatype */
- if ((ftype1_id = H5Aget_type( attr1_id )) < 0 )
- goto error;
- if ((ftype2_id = H5Aget_type( attr2_id )) < 0 )
- goto error;
-
- /* get the dataspace handle */
- 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;
-
-
+ /* open attribute */
+ if ((attr1_id = H5Aopen_idx(loc1_id, (unsigned)i))<0)
+ goto error;
+ if ((attr2_id = H5Aopen_idx(loc2_id, (unsigned)i))<0)
+ goto error;
+
+ /* get name */
+ if (H5Aget_name( attr1_id, 255, name1 )<0)
+ goto error;
+ if (H5Aget_name( attr2_id, 255, name2 )<0)
+ goto error;
+
+ if (HDstrcmp(name1,name2)!=0)
+ {
+ if (options->m_verbose)
+ {
+ parallel_print("Different name for attributes: <%s> and <%s>\n", name1, name2);
+ }
+ H5Aclose(attr1_id);
+ H5Aclose(attr2_id);
+ ret=1;
+ continue;
+ }
+
+ /* get the file datatype */
+ if ((ftype1_id = H5Aget_type( attr1_id )) < 0 )
+ goto error;
+ if ((ftype2_id = H5Aget_type( attr2_id )) < 0 )
+ goto error;
+
+ /* get the dataspace handle */
+ 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 (diff_can_type(ftype1_id,
- ftype2_id,
- rank1,
- rank2,
- dims1,
- dims2,
- NULL,
- NULL,
- name1,
- name2,
- options)!=1)
- {
- cmp=0;
- options->not_cmp=1;
- }
+
+ if (diff_can_type(ftype1_id,
+ ftype2_id,
+ rank1,
+ rank2,
+ dims1,
+ dims2,
+ NULL,
+ NULL,
+ name1,
+ name2,
+ options)!=1)
+ {
+ cmp=0;
+ options->not_cmp=1;
+ }
/*-------------------------------------------------------------------------
* only attempt to compare if possible
*-------------------------------------------------------------------------
*/
- if (cmp)
- {
-
- /*-------------------------------------------------------------------------
- * read to memory
- *-------------------------------------------------------------------------
- */
- nelmts1=1;
- for (j=0; j<rank1; j++)
- nelmts1*=dims1[j];
-
- 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;
-
- assert(msize1==msize2);
-
- 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)
- {
- parallel_print( "Attribute: <%s> and <%s>\n",np1,np2);
- nfound = diff_array(buf1,
- buf2,
- nelmts1,
- 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,
- rank1,
- dims1,
- options,
- np1,
- np2,
- mtype1_id,
- attr1_id,
- attr2_id);
- /* print again */
- options->m_quiet=0;
- if (nfound)
- {
- parallel_print( "Attribute: <%s> and <%s>\n",np1,np2);
- nfound = diff_array(buf1,
- buf2,
- nelmts1,
- rank1,
- dims1,
- options,
- np1,
- np2,
- mtype1_id,
- attr1_id,
- attr2_id);
- print_found(nfound);
- } /*if*/
- } /*if*/
- /* in quiet mode, just count differences */
- else
+ if (cmp)
{
+
+ /*-------------------------------------------------------------------------
+ * read to memory
+ *-------------------------------------------------------------------------
+ */
+ nelmts1=1;
+ for (j=0; j<rank1; j++)
+ nelmts1*=dims1[j];
+
+ 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;
+
+ assert(msize1==msize2);
+
+ 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)
+ {
+ parallel_print( "Attribute: <%s> and <%s>\n",np1,np2);
+ nfound = diff_array(buf1,
+ buf2,
+ nelmts1,
+ 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,
+ rank1,
+ dims1,
+ options,
+ np1,
+ np2,
+ mtype1_id,
+ attr1_id,
+ attr2_id);
+ /* print again */
+ options->m_quiet=0;
+ if (nfound)
+ {
+ parallel_print( "Attribute: <%s> and <%s>\n",np1,np2);
nfound = diff_array(buf1,
buf2,
nelmts1,
@@ -269,51 +248,67 @@ int diff_attr(hid_t loc1_id,
mtype1_id,
attr1_id,
attr2_id);
- } /*else quiet */
- } /*else verbose */
+ print_found(nfound);
+ } /*if*/
+ } /*if*/
+ /* in quiet mode, just count differences */
+ else
+ {
+ nfound = diff_array(buf1,
+ buf2,
+ nelmts1,
+ rank1,
+ dims1,
+ options,
+ np1,
+ np2,
+ mtype1_id,
+ attr1_id,
+ attr2_id);
+ } /*else quiet */
+ } /*else verbose */
}/*cmp*/
-
-
+
/*-------------------------------------------------------------------------
* close
*-------------------------------------------------------------------------
*/
-
- if (H5Tclose(ftype1_id)<0) goto error;
- if (H5Tclose(ftype2_id)<0) goto error;
- if (H5Tclose(mtype1_id)<0) goto error;
- if (H5Tclose(mtype2_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 (buf1)
- HDfree(buf1);
- if (buf2)
- HDfree(buf2);
- } /* i */
-
- return ret;
-
+
+ if (H5Tclose(ftype1_id)<0) goto error;
+ if (H5Tclose(ftype2_id)<0) goto error;
+ if (H5Tclose(mtype1_id)<0) goto error;
+ if (H5Tclose(mtype2_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 (buf1)
+ HDfree(buf1);
+ if (buf2)
+ HDfree(buf2);
+ } /* i */
+
+ return ret;
+
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 0;
+ 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 0;
}
diff --git a/tools/lib/h5diff_dset.c b/tools/lib/h5diff_dset.c
index 868eedf..8802067 100644
--- a/tools/lib/h5diff_dset.c
+++ b/tools/lib/h5diff_dset.c
@@ -17,6 +17,60 @@
#include "H5private.h"
#include "h5tools.h"
+
+/*-------------------------------------------------------------------------
+ * Function: print_sizes
+ *
+ * Purpose: Print datatype sizes
+ *
+ *-------------------------------------------------------------------------
+ */
+#if defined (H5DIFF_DEBUG)
+void print_sizes( const char *obj1, const char *obj2,
+ hid_t f_type1, hid_t f_type2,
+ hid_t m_type1, hid_t m_type2 )
+{
+ 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_type1 );
+ f_size2 = H5Tget_size( f_type2 );
+ m_size1 = H5Tget_size( m_type1 );
+ m_size2 = H5Tget_size( m_type2 );
+
+ printf("\n");
+ printf("------------------\n");
+ printf("sizeof(char) %u\n", sizeof(char) );
+ printf("sizeof(short) %u\n", sizeof(short) );
+ printf("sizeof(int) %u\n", sizeof(int) );
+ printf("sizeof(long) %u\n", sizeof(long) );
+ printf("<%s> ------------------\n", obj1);
+ printf("type on file ");
+ print_type(f_type1);
+ printf("\n");
+ printf("size on file %u\n", f_size1 );
+
+ printf("type on memory ");
+ print_type(m_type1);
+ printf("\n");
+ printf("size on memory %u\n", m_size1 );
+
+ printf("<%s> ------------------\n", obj2);
+ printf("type on file ");
+ print_type(f_type2);
+ printf("\n");
+ printf("size on file %u\n", f_size2 );
+
+ printf("type on memory ");
+ print_type(m_type2);
+ printf("\n");
+ printf("size on memory %u\n", m_size2 );
+ printf("\n");
+}
+#endif /* H5DIFF_DEBUG */
+
+
+
/*-------------------------------------------------------------------------
* Function: diff_dataset
*
@@ -112,12 +166,8 @@ error:
} H5E_END_TRY;
return nfound;
-
}
-
-
-
/*-------------------------------------------------------------------------
* Function: diff_datasetid
*
diff --git a/tools/lib/h5diff_util.c b/tools/lib/h5diff_util.c
index 100057f..6334d8d 100644
--- a/tools/lib/h5diff_util.c
+++ b/tools/lib/h5diff_util.c
@@ -18,10 +18,10 @@
/* global variables */
int g_nTasks = 1;
-unsigned char g_Parallel = 0; /*0 for serial, 1 for parallel */
-char outBuff[OUTBUFF_SIZE];
-int outBuffOffset;
-FILE* overflow_file = NULL;
+unsigned char g_Parallel = 0; /*0 for serial, 1 for parallel */
+char outBuff[OUTBUFF_SIZE];
+int outBuffOffset;
+FILE* overflow_file = NULL;
/*-------------------------------------------------------------------------
* Function: parallel_print
@@ -36,57 +36,57 @@ FILE* overflow_file = NULL;
*/
void parallel_print(const char* format, ...)
{
- int bytes_written;
- va_list ap;
-
- va_start(ap, format);
-
- if(!g_Parallel)
- vprintf(format, ap);
- else
- {
-
- if(overflow_file == NULL) /*no overflow has occurred yet */
- {
+ int bytes_written;
+ va_list ap;
+
+ va_start(ap, format);
+
+ if(!g_Parallel)
+ vprintf(format, ap);
+ else
+ {
+
+ if(overflow_file == NULL) /*no overflow has occurred yet */
+ {
#if 0
-printf("calling HDvsnprintf: OUTBUFF_SIZE=%ld, outBuffOffset=%ld, ", (long)OUTBUFF_SIZE, (long)outBuffOffset);
+ printf("calling HDvsnprintf: OUTBUFF_SIZE=%ld, outBuffOffset=%ld, ", (long)OUTBUFF_SIZE, (long)outBuffOffset);
#endif
- bytes_written = HDvsnprintf(outBuff+outBuffOffset, OUTBUFF_SIZE-outBuffOffset, format, ap);
+ bytes_written = HDvsnprintf(outBuff+outBuffOffset, OUTBUFF_SIZE-outBuffOffset, format, ap);
#if 0
-printf("bytes_written=%ld\n", (long)bytes_written);
+ printf("bytes_written=%ld\n", (long)bytes_written);
#endif
- va_end(ap);
- va_start(ap, format);
-
+ va_end(ap);
+ va_start(ap, format);
+
#if 0
-printf("Result: bytes_written=%ld, OUTBUFF_SIZE-outBuffOffset=%ld\n", (long)bytes_written, (long)OUTBUFF_SIZE-outBuffOffset);
+ printf("Result: bytes_written=%ld, OUTBUFF_SIZE-outBuffOffset=%ld\n", (long)bytes_written, (long)OUTBUFF_SIZE-outBuffOffset);
#endif
-
- if ((bytes_written < 0) ||
+
+ if ((bytes_written < 0) ||
#ifdef H5_VSNPRINTF_WORKS
- (bytes_written >= (OUTBUFF_SIZE-outBuffOffset))
+ (bytes_written >= (OUTBUFF_SIZE-outBuffOffset))
#else
- ((bytes_written+1) == (OUTBUFF_SIZE-outBuffOffset))
+ ((bytes_written+1) == (OUTBUFF_SIZE-outBuffOffset))
#endif
- )
- {
- /* Terminate the outbuff at the end of the previous output */
- outBuff[outBuffOffset] = '\0';
-
- overflow_file = HDtmpfile();
- if(overflow_file == NULL)
- fprintf(stderr, "Warning: Could not create overflow file. Output may be truncated.\n");
- else
- bytes_written = HDvfprintf(overflow_file, format, ap);
- }
- else
- outBuffOffset += bytes_written;
- }
- else
- bytes_written = HDvfprintf(overflow_file, format, ap);
-
- }
- va_end(ap);
+ )
+ {
+ /* Terminate the outbuff at the end of the previous output */
+ outBuff[outBuffOffset] = '\0';
+
+ overflow_file = HDtmpfile();
+ if(overflow_file == NULL)
+ fprintf(stderr, "Warning: Could not create overflow file. Output may be truncated.\n");
+ else
+ bytes_written = HDvfprintf(overflow_file, format, ap);
+ }
+ else
+ outBuffOffset += bytes_written;
+ }
+ else
+ bytes_written = HDvfprintf(overflow_file, format, ap);
+
+ }
+ va_end(ap);
}
@@ -214,8 +214,6 @@ void print_type(hid_t type)
}/*switch*/
}
-
-
/*-------------------------------------------------------------------------
* Function: diff_basename
*
@@ -356,62 +354,11 @@ get_class(H5T_class_t tclass)
*/
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);
+ 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_sizes
- *
- * Purpose: Print datatype sizes
- *
- *-------------------------------------------------------------------------
- */
-#if defined (H5DIFF_DEBUG)
-void print_sizes( const char *obj1, const char *obj2,
- hid_t f_type1, hid_t f_type2,
- hid_t m_type1, hid_t m_type2 )
-{
- 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_type1 );
- f_size2 = H5Tget_size( f_type2 );
- m_size1 = H5Tget_size( m_type1 );
- m_size2 = H5Tget_size( m_type2 );
-
- printf("\n");
- printf("------------------\n");
- printf("sizeof(char) %u\n", sizeof(char) );
- printf("sizeof(short) %u\n", sizeof(short) );
- printf("sizeof(int) %u\n", sizeof(int) );
- printf("sizeof(long) %u\n", sizeof(long) );
- printf("<%s> ------------------\n", obj1);
- printf("type on file ");
- print_type(f_type1);
- printf("\n");
- printf("size on file %u\n", f_size1 );
-
- printf("type on memory ");
- print_type(m_type1);
- printf("\n");
- printf("size on memory %u\n", m_size1 );
-
- printf("<%s> ------------------\n", obj2);
- printf("type on file ");
- print_type(f_type2);
- printf("\n");
- printf("size on file %u\n", f_size2 );
-
- printf("type on memory ");
- print_type(m_type2);
- printf("\n");
- printf("size on memory %u\n", m_size2 );
- printf("\n");
-}
-#endif /* H5DIFF_DEBUG */
-