[svn-r22013] HDFFV-7560:

Merge 1.8 and h5dump/tools and tests based on tools library from trunk.
Reduced warnings.

HDFFV-7949:
Remove duplicated functions in h5ls

Tested: local linux,h5committest

11 files changed, 120 insertions, 104 deletions

diff --git a/perform/pio_engine.c b/perform/pio_engine.c
index 511492b..0e3190c 100644
--- a/perform/pio_engine.c
+++ b/perform/pio_engine.c
@@ -320,22 +320,22 @@ do_pio(parameters param)
     /* Need barrier to make sure everyone starts at the same time */
     MPI_Barrier(pio_comm_g);
 
-    set_time(res.timers, HDF5_GROSS_WRITE_FIXED_DIMS, START);
+    set_time(res.timers, HDF5_GROSS_WRITE_FIXED_DIMS, TSTART);
     hrc = do_fopen(&param, fname, &fd, PIO_CREATE | PIO_WRITE);
 
     VRFY((hrc == SUCCESS), "do_fopen failed");
 
-    set_time(res.timers, HDF5_FINE_WRITE_FIXED_DIMS, START);
+    set_time(res.timers, HDF5_FINE_WRITE_FIXED_DIMS, TSTART);
     hrc = do_write(&res, &fd, &param, ndsets, nbytes, buf_size, buffer);
     hrc == SUCCESS;
-    set_time(res.timers, HDF5_FINE_WRITE_FIXED_DIMS, STOP);
+    set_time(res.timers, HDF5_FINE_WRITE_FIXED_DIMS, TSTOP);
 
     VRFY((hrc == SUCCESS), "do_write failed");
 
     /* Close file for write */
     hrc = do_fclose(iot, &fd);
 
-    set_time(res.timers, HDF5_GROSS_WRITE_FIXED_DIMS, STOP);
+    set_time(res.timers, HDF5_GROSS_WRITE_FIXED_DIMS, TSTOP);
     VRFY((hrc == SUCCESS), "do_fclose failed");
 
     if (!param.h5_write_only) {
@@ -349,20 +349,20 @@ do_pio(parameters param)
         MPI_Barrier(pio_comm_g);
 
         /* Open file for read */
-        set_time(res.timers, HDF5_GROSS_READ_FIXED_DIMS, START);
+        set_time(res.timers, HDF5_GROSS_READ_FIXED_DIMS, TSTART);
         hrc = do_fopen(&param, fname, &fd, PIO_READ);
 
         VRFY((hrc == SUCCESS), "do_fopen failed");
 
-        set_time(res.timers, HDF5_FINE_READ_FIXED_DIMS, START);
+        set_time(res.timers, HDF5_FINE_READ_FIXED_DIMS, TSTART);
         hrc = do_read(&res, &fd, &param, ndsets, nbytes, buf_size, buffer);
-        set_time(res.timers, HDF5_FINE_READ_FIXED_DIMS, STOP);
+        set_time(res.timers, HDF5_FINE_READ_FIXED_DIMS, TSTOP);
         VRFY((hrc == SUCCESS), "do_read failed");
 
         /* Close file for read */
         hrc = do_fclose(iot, &fd);
 
-        set_time(res.timers, HDF5_GROSS_READ_FIXED_DIMS, STOP);
+        set_time(res.timers, HDF5_GROSS_READ_FIXED_DIMS, TSTOP);
         VRFY((hrc == SUCCESS), "do_fclose failed");
     }
 
@@ -968,7 +968,7 @@ do_write(results *res, file_descr *fd, parameters *parms, long ndsets,
     } /* end else */
 
     /* Start "raw data" write timer */
-    set_time(res->timers, HDF5_RAW_WRITE_FIXED_DIMS, START);
+    set_time(res->timers, HDF5_RAW_WRITE_FIXED_DIMS, TSTART);
 
     while (nbytes_xfer < bytes_count){
         /* Write */
@@ -1399,7 +1399,7 @@ do_write(results *res, file_descr *fd, parameters *parms, long ndsets,
     } /* end while */
 
     /* Stop "raw data" write timer */
-    set_time(res->timers, HDF5_RAW_WRITE_FIXED_DIMS, STOP);
+    set_time(res->timers, HDF5_RAW_WRITE_FIXED_DIMS, TSTOP);
 
     /* Calculate write time */
 
@@ -1899,7 +1899,7 @@ do_read(results *res, file_descr *fd, parameters *parms, long ndsets,
     } /* end else */
 
     /* Start "raw data" read timer */
-    set_time(res->timers, HDF5_RAW_READ_FIXED_DIMS, START);
+    set_time(res->timers, HDF5_RAW_READ_FIXED_DIMS, TSTART);
 
     while (nbytes_xfer < bytes_count){
         /* Read */
@@ -2354,7 +2354,7 @@ do_read(results *res, file_descr *fd, parameters *parms, long ndsets,
     } /* end while */
 
     /* Stop "raw data" read timer */
-    set_time(res->timers, HDF5_RAW_READ_FIXED_DIMS, STOP);
+    set_time(res->timers, HDF5_RAW_READ_FIXED_DIMS, TSTOP);
 
     /* Calculate read time */
 
@@ -3115,9 +3115,9 @@ int MPI_File_read_at(MPI_File fh, MPI_Offset offset, void *buf,
     int count, MPI_Datatype datatype, MPI_Status *status)
 {
     int err;
-    set_time(timer_g, HDF5_MPI_READ, START);
+    set_time(timer_g, HDF5_MPI_READ, TSTART);
     err=PMPI_File_read_at(fh, offset, buf, count, datatype, status);
-    set_time(timer_g, HDF5_MPI_READ, STOP);
+    set_time(timer_g, HDF5_MPI_READ, TSTOP);
     return err;
 }
 
@@ -3126,9 +3126,9 @@ int MPI_File_read_at_all(MPI_File fh, MPI_Offset offset, void *buf,
     int count, MPI_Datatype datatype, MPI_Status *status)
 {
     int err;
-    set_time(timer_g, HDF5_MPI_READ, START);
+    set_time(timer_g, HDF5_MPI_READ, TSTART);
     err=PMPI_File_read_at_all(fh, offset, buf, count, datatype, status);
-    set_time(timer_g, HDF5_MPI_READ, STOP);
+    set_time(timer_g, HDF5_MPI_READ, TSTOP);
     return err;
 }
 
@@ -3136,9 +3136,9 @@ int MPI_File_write_at(MPI_File fh, MPI_Offset offset, void *buf,
     int count, MPI_Datatype datatype, MPI_Status *status)
 {
     int err;
-    set_time(timer_g, HDF5_MPI_WRITE, START);
+    set_time(timer_g, HDF5_MPI_WRITE, TSTART);
     err=PMPI_File_write_at(fh, offset, buf, count, datatype, status);
-    set_time(timer_g, HDF5_MPI_WRITE, STOP);
+    set_time(timer_g, HDF5_MPI_WRITE, TSTOP);
     return err;
 }
 
@@ -3146,9 +3146,9 @@ int MPI_File_write_at_all(MPI_File fh, MPI_Offset offset, void *buf,
     int count, MPI_Datatype datatype, MPI_Status *status)
 {
     int err;
-    set_time(timer_g, HDF5_MPI_WRITE, START);
+    set_time(timer_g, HDF5_MPI_WRITE, TSTART);
     err=PMPI_File_write_at_all(fh, offset, buf, count, datatype, status);
-    set_time(timer_g, HDF5_MPI_WRITE, STOP);
+    set_time(timer_g, HDF5_MPI_WRITE, TSTOP);
     return err;
 }
 
diff --git a/perform/pio_perf.c b/perform/pio_perf.c
index 411fb12..337e982 100644
--- a/perform/pio_perf.c
+++ b/perform/pio_perf.c
@@ -339,6 +339,11 @@ main(int argc, char **argv)
     int exit_value = EXIT_SUCCESS;
     struct options *opts = NULL;
 
+#ifndef STANDALONE
+    /* Initialize h5tools lib */
+    h5tools_init();
+#endif
+
     output = stdout;
 
     /* initialize MPI and get the maximum num of processors we started with */
diff --git a/perform/pio_perf.h b/perform/pio_perf.h
index 6f510ca..094b31d 100644
--- a/perform/pio_perf.h
+++ b/perform/pio_perf.h
@@ -19,6 +19,7 @@
 #ifndef STANDALONE
 #include "H5private.h"
 #include "h5test.h"
+#include "h5tools.h"
 #include "h5tools_utils.h"
 #else
 #include "pio_standalone.h"
diff --git a/perform/pio_timer.c b/perform/pio_timer.c
index 9c8abb7..aba219e 100644
--- a/perform/pio_timer.c
+++ b/perform/pio_timer.c
@@ -43,15 +43,15 @@ pio_time   *timer_g;            /* timer: global for stub functions     */
  * Function:  sub_time
  * Purpose:   Struct two time values, and return the difference, in microseconds
  *
- * 	      Note that the function assumes that a > b
+ *         Note that the function assumes that a > b
  * Programmer: Leon Arber, 1/27/06
  */
 static double sub_time(struct timeval* a, struct timeval* b)
 {
     return (((double)a->tv_sec +
      ((double)a->tv_usec) / MICROSECOND) -
-	((double)b->tv_sec +
-	 ((double)b->tv_usec) / MICROSECOND));
+  ((double)b->tv_sec +
+   ((double)b->tv_usec) / MICROSECOND));
 }
 
 
@@ -89,7 +89,7 @@ pio_time_new(clock_type type)
 void
 pio_time_destroy(pio_time *pt)
 {
-    free(pt);
+    HDfree(pt);
     /* reset the global timer pointer too. */
     timer_g = NULL;
 }
@@ -134,37 +134,37 @@ set_time(pio_time *pt, timer_type t, int start_stop)
 {
     if (pt) {
         if (pt->type == MPI_TIMER) {
-            if (start_stop == START) {
+            if (start_stop == TSTART) {
                 pt->mpi_timer[t] = MPI_Wtime();
 
-		/* When we start the timer for HDF5_FINE_WRITE_FIXED_DIMS or HDF5_FINE_READ_FIXED_DIMS
-		 * we compute the time it took to only open the file */
-		if(t == HDF5_FINE_WRITE_FIXED_DIMS)
-		    pt->total_time[HDF5_FILE_WRITE_OPEN] += pt->mpi_timer[t] - pt->mpi_timer[HDF5_GROSS_WRITE_FIXED_DIMS];
-		else if(t == HDF5_FINE_READ_FIXED_DIMS)
-		    pt->total_time[HDF5_FILE_READ_OPEN] += pt->mpi_timer[t] - pt->mpi_timer[HDF5_GROSS_READ_FIXED_DIMS];
+    /* When we start the timer for HDF5_FINE_WRITE_FIXED_DIMS or HDF5_FINE_READ_FIXED_DIMS
+     * we compute the time it took to only open the file */
+    if(t == HDF5_FINE_WRITE_FIXED_DIMS)
+        pt->total_time[HDF5_FILE_WRITE_OPEN] += pt->mpi_timer[t] - pt->mpi_timer[HDF5_GROSS_WRITE_FIXED_DIMS];
+    else if(t == HDF5_FINE_READ_FIXED_DIMS)
+        pt->total_time[HDF5_FILE_READ_OPEN] += pt->mpi_timer[t] - pt->mpi_timer[HDF5_GROSS_READ_FIXED_DIMS];
 
             } else {
                 pt->total_time[t] += MPI_Wtime() - pt->mpi_timer[t];
-		pt->mpi_timer[t] = MPI_Wtime();
-
-		/* When we stop the timer for HDF5_GROSS_WRITE_FIXED_DIMS or HDF5_GROSS_READ_FIXED_DIMS
-		 * we compute the time it took to close the file after the last read/write finished */
-		if(t == HDF5_GROSS_WRITE_FIXED_DIMS)
-		    pt->total_time[HDF5_FILE_WRITE_CLOSE] += pt->mpi_timer[t] - pt->mpi_timer[HDF5_FINE_WRITE_FIXED_DIMS];
-		else if(t == HDF5_GROSS_READ_FIXED_DIMS)
-		    pt->total_time[HDF5_FILE_READ_CLOSE] += pt->mpi_timer[t] - pt->mpi_timer[HDF5_FINE_READ_FIXED_DIMS];
+    pt->mpi_timer[t] = MPI_Wtime();
+
+    /* When we stop the timer for HDF5_GROSS_WRITE_FIXED_DIMS or HDF5_GROSS_READ_FIXED_DIMS
+     * we compute the time it took to close the file after the last read/write finished */
+    if(t == HDF5_GROSS_WRITE_FIXED_DIMS)
+        pt->total_time[HDF5_FILE_WRITE_CLOSE] += pt->mpi_timer[t] - pt->mpi_timer[HDF5_FINE_WRITE_FIXED_DIMS];
+    else if(t == HDF5_GROSS_READ_FIXED_DIMS)
+        pt->total_time[HDF5_FILE_READ_CLOSE] += pt->mpi_timer[t] - pt->mpi_timer[HDF5_FINE_READ_FIXED_DIMS];
             }
         } else {
-            if (start_stop == START) {
+            if (start_stop == TSTART) {
                 HDgettimeofday(&pt->sys_timer[t], NULL);
 
-		/* When we start the timer for HDF5_FINE_WRITE_FIXED_DIMS or HDF5_FINE_READ_FIXED_DIMS
-		 * we compute the time it took to only open the file */
-		if(t == HDF5_FINE_WRITE_FIXED_DIMS)
-		    pt->total_time[HDF5_FILE_WRITE_OPEN] += sub_time(&(pt->sys_timer[t]), &(pt->sys_timer[HDF5_GROSS_WRITE_FIXED_DIMS]));
-		else if(t == HDF5_FINE_READ_FIXED_DIMS)
-		    pt->total_time[HDF5_FILE_READ_OPEN] += sub_time(&(pt->sys_timer[t]), &(pt->sys_timer[HDF5_GROSS_READ_FIXED_DIMS]));
+    /* When we start the timer for HDF5_FINE_WRITE_FIXED_DIMS or HDF5_FINE_READ_FIXED_DIMS
+     * we compute the time it took to only open the file */
+    if(t == HDF5_FINE_WRITE_FIXED_DIMS)
+        pt->total_time[HDF5_FILE_WRITE_OPEN] += sub_time(&(pt->sys_timer[t]), &(pt->sys_timer[HDF5_GROSS_WRITE_FIXED_DIMS]));
+    else if(t == HDF5_FINE_READ_FIXED_DIMS)
+        pt->total_time[HDF5_FILE_READ_OPEN] += sub_time(&(pt->sys_timer[t]), &(pt->sys_timer[HDF5_GROSS_READ_FIXED_DIMS]));
 
 
             } else {
@@ -178,12 +178,12 @@ set_time(pio_time *pt, timer_type t, int start_stop)
                     ((double)pt->sys_timer[t].tv_sec +
                             ((double)pt->sys_timer[t].tv_usec) / MICROSECOND);*/
 
-		/* When we stop the timer for HDF5_GROSS_WRITE_FIXED_DIMS or HDF5_GROSS_READ_FIXED_DIMS
-		 * we compute the time it took to close the file after the last read/write finished */
-		if(t == HDF5_GROSS_WRITE_FIXED_DIMS)
-		    pt->total_time[HDF5_FILE_WRITE_CLOSE] += sub_time(&(pt->sys_timer[t]), &(pt->sys_timer[HDF5_FINE_WRITE_FIXED_DIMS]));
-		else if(t == HDF5_GROSS_READ_FIXED_DIMS)
-		    pt->total_time[HDF5_FILE_READ_CLOSE] += sub_time(&(pt->sys_timer[t]), &(pt->sys_timer[HDF5_FINE_READ_FIXED_DIMS]));
+    /* When we stop the timer for HDF5_GROSS_WRITE_FIXED_DIMS or HDF5_GROSS_READ_FIXED_DIMS
+     * we compute the time it took to close the file after the last read/write finished */
+    if(t == HDF5_GROSS_WRITE_FIXED_DIMS)
+        pt->total_time[HDF5_FILE_WRITE_CLOSE] += sub_time(&(pt->sys_timer[t]), &(pt->sys_timer[HDF5_FINE_WRITE_FIXED_DIMS]));
+    else if(t == HDF5_GROSS_READ_FIXED_DIMS)
+        pt->total_time[HDF5_FILE_READ_CLOSE] += sub_time(&(pt->sys_timer[t]), &(pt->sys_timer[HDF5_FINE_READ_FIXED_DIMS]));
 
             }
         }
@@ -231,7 +231,7 @@ set_time(pio_time *pt, timer_type t, int start_stop)
             }
 
             fprintf(output, "    Proc %d: %s %s: %.2f\n", myrank, msg,
-                    (start_stop == START ? "Start" : "Stop"),
+                    (start_stop == TSTART ? "Start" : "Stop"),
                     pt->total_time[t]);
         }
     }
diff --git a/perform/pio_timer.h b/perform/pio_timer.h
index 943521a..a5ee6d7 100644
--- a/perform/pio_timer.h
+++ b/perform/pio_timer.h
@@ -53,8 +53,8 @@ typedef enum clock_type_ {
 
 /* Miscellaneous identifiers */
 enum {
-    START,          /* Start a specified timer              */
-    STOP            /* Stop a specified timer               */
+    TSTART,          /* Start a specified timer              */
+    TSTOP            /* Stop a specified timer               */
 };
 
 /* The performance time structure */
diff --git a/perform/sio_engine.c b/perform/sio_engine.c
index e892bcc..df2e21e 100644
--- a/perform/sio_engine.c
+++ b/perform/sio_engine.c
@@ -22,7 +22,7 @@
 #include <stdlib.h>
 #include <fcntl.h>
 #ifdef H5_HAVE_UNISTD_H
-#	include <unistd.h>
+#  include <unistd.h>
 #endif
 #include <errno.h>
 
@@ -233,18 +233,18 @@ do_sio(parameters param)
         HDfprintf(output, "data filename=%s\n",
              fname);
 
-    set_time(res.timers, HDF5_GROSS_WRITE_FIXED_DIMS, START);
+    set_time(res.timers, HDF5_GROSS_WRITE_FIXED_DIMS, TSTART);
     hrc = do_fopen(&param, fname, &fd, SIO_CREATE | SIO_WRITE);
     VRFY((hrc == SUCCESS), "do_fopen failed");
 
-    set_time(res.timers, HDF5_FINE_WRITE_FIXED_DIMS, START);
+    set_time(res.timers, HDF5_FINE_WRITE_FIXED_DIMS, TSTART);
     hrc = do_write(&res, &fd, &param, buffer);
-    set_time(res.timers, HDF5_FINE_WRITE_FIXED_DIMS, STOP);
+    set_time(res.timers, HDF5_FINE_WRITE_FIXED_DIMS, TSTOP);
     VRFY((hrc == SUCCESS), "do_write failed");
 
     /* Close file for write */
     hrc = do_fclose(iot, &fd);
-    set_time(res.timers, HDF5_GROSS_WRITE_FIXED_DIMS, STOP);
+    set_time(res.timers, HDF5_GROSS_WRITE_FIXED_DIMS, TSTOP);
     VRFY((hrc == SUCCESS), "do_fclose failed");
 
     if (!param.h5_write_only) {
@@ -253,19 +253,19 @@ do_sio(parameters param)
          */
 
         /* Open file for read */
-        set_time(res.timers, HDF5_GROSS_READ_FIXED_DIMS, START);
+        set_time(res.timers, HDF5_GROSS_READ_FIXED_DIMS, TSTART);
         hrc = do_fopen(&param, fname, &fd, SIO_READ);
         VRFY((hrc == SUCCESS), "do_fopen failed");
 
-        set_time(res.timers, HDF5_FINE_READ_FIXED_DIMS, START);
+        set_time(res.timers, HDF5_FINE_READ_FIXED_DIMS, TSTART);
         hrc = do_read(&res, &fd, &param, buffer);
-        set_time(res.timers, HDF5_FINE_READ_FIXED_DIMS, STOP);
+        set_time(res.timers, HDF5_FINE_READ_FIXED_DIMS, TSTOP);
         VRFY((hrc == SUCCESS), "do_read failed");
 
         /* Close file for read */
         hrc = do_fclose(iot, &fd);
 
-        set_time(res.timers, HDF5_GROSS_READ_FIXED_DIMS, STOP);
+        set_time(res.timers, HDF5_GROSS_READ_FIXED_DIMS, TSTOP);
         VRFY((hrc == SUCCESS), "do_fclose failed");
     }
 
@@ -551,7 +551,7 @@ do_write(results *res, file_descr *fd, parameters *parms, void *buffer)
     }
 
     /* Start "raw data" write timer */
-    set_time(res->timers, HDF5_RAW_WRITE_FIXED_DIMS, START);
+    set_time(res->timers, HDF5_RAW_WRITE_FIXED_DIMS, TSTART);
 
     /* Perform write */
     hrc = dset_write(rank-1, fd, parms, buffer);
@@ -563,7 +563,7 @@ do_write(results *res, file_descr *fd, parameters *parms, void *buffer)
 
 
     /* Stop "raw data" write timer */
-    set_time(res->timers, HDF5_RAW_WRITE_FIXED_DIMS, STOP);
+    set_time(res->timers, HDF5_RAW_WRITE_FIXED_DIMS, TSTOP);
 
     /* Calculate write time */
 
@@ -628,7 +628,7 @@ static herr_t dset_write(int local_dim, file_descr *fd, parameters *parms, void
     int cur_dim = order[local_dim]-1;
     int         ret_code = SUCCESS;
     int         k;
-    hsize_t	dims[MAX_DIMS], maxdims[MAX_DIMS];
+    hsize_t  dims[MAX_DIMS], maxdims[MAX_DIMS];
     long i,j;
     herr_t hrc;
 
@@ -855,7 +855,7 @@ do_read(results *res, file_descr *fd, parameters *parms, void *buffer)
     } /* end switch */
 
     /* Start "raw data" read timer */
-    set_time(res->timers, HDF5_RAW_READ_FIXED_DIMS, START);
+    set_time(res->timers, HDF5_RAW_READ_FIXED_DIMS, TSTART);
     hrc = dset_read(rank-1, fd, parms, buffer, buffer2);
 
     if (hrc < 0) {
@@ -864,7 +864,7 @@ do_read(results *res, file_descr *fd, parameters *parms, void *buffer)
     }
 
     /* Stop "raw data" read timer */
-    set_time(res->timers, HDF5_RAW_READ_FIXED_DIMS, STOP);
+    set_time(res->timers, HDF5_RAW_READ_FIXED_DIMS, TSTOP);
 
     /* Calculate read time */
 
diff --git a/perform/sio_perf.c b/perform/sio_perf.c
index d852a45..16e1750 100644
--- a/perform/sio_perf.c
+++ b/perform/sio_perf.c
@@ -343,6 +343,11 @@ main(int argc, char **argv)
     int exit_value = EXIT_SUCCESS;
     struct options *opts = NULL;
 
+#ifndef STANDALONE
+    /* Initialize h5tools lib */
+    h5tools_init();
+#endif
+    
     output = stdout;
 
     opts = parse_command_line(argc, argv);
diff --git a/perform/sio_perf.h b/perform/sio_perf.h
index 2417b6f..3e4456a 100644
--- a/perform/sio_perf.h
+++ b/perform/sio_perf.h
@@ -19,6 +19,7 @@
 #ifndef STANDALONE
 #include "H5private.h"
 #include "h5test.h"
+#include "h5tools.h"
 #include "h5tools_utils.h"
 #else
 #include "sio_standalone.h"
@@ -49,24 +50,24 @@ typedef enum vfdtype_ {
 } vfdtype;
 
 typedef struct parameters_ {
-    iotype	io_type;        /* The type of IO test to perform       */
+    iotype  io_type;        /* The type of IO test to perform       */
     vfdtype     vfd;
-    long	num_files;      /* Number of files to create            */
-    long	num_dsets;      /* Number of datasets to create         */
-    off_t	num_bytes;      /* Number of bytes in each dset         */
+    long  num_files;      /* Number of files to create            */
+    long  num_dsets;      /* Number of datasets to create         */
+    off_t  num_bytes;      /* Number of bytes in each dset         */
     int         num_iters;      /* Number of times to loop doing the IO */
     int         rank;           /* Rank of dataset */
-    off_t 	dset_size[MAX_DIMS]; /* Dataset size             */
-    size_t 	buf_size[MAX_DIMS]; /* Buffer size               */
-    size_t 	chk_size[MAX_DIMS]; /* Chunk size               */
-    int  	order[MAX_DIMS]; /* Buffer size               */
-    hsize_t 	h5_align;       /* HDF5 object alignment                */
-    hsize_t 	h5_thresh;      /* HDF5 object alignment threshold      */
-    int 	h5_use_chunks;  /* Make HDF5 dataset chunked            */
-    int 	h5_extendable;  /* Make HDF5 dataset chunked            */
-    int    	h5_write_only;  /* Perform the write tests only         */
+    off_t   dset_size[MAX_DIMS]; /* Dataset size             */
+    size_t   buf_size[MAX_DIMS]; /* Buffer size               */
+    size_t   chk_size[MAX_DIMS]; /* Chunk size               */
+    int    order[MAX_DIMS]; /* Buffer size               */
+    hsize_t   h5_align;       /* HDF5 object alignment                */
+    hsize_t   h5_thresh;      /* HDF5 object alignment threshold      */
+    int   h5_use_chunks;  /* Make HDF5 dataset chunked            */
+    int   h5_extendable;  /* Make HDF5 dataset chunked            */
+    int      h5_write_only;  /* Perform the write tests only         */
     unsigned    h5_use_mpi_posix;   /* VFD for HDF5 I/O  */
-    int 	verify;    	/* Verify data correctness              */
+    int   verify;      /* Verify data correctness              */
 } parameters;
 
 typedef struct results_ {
diff --git a/perform/sio_timer.c b/perform/sio_timer.c
index f188a10..f233de3 100644
--- a/perform/sio_timer.c
+++ b/perform/sio_timer.c
@@ -39,15 +39,15 @@ sio_time   *timer_g;            /* timer: global for stub functions     */
  * Function:  sub_time

  * Purpose:   Struct two time values, and return the difference, in microseconds

  *

- * 	      Note that the function assumes that a > b

+ *         Note that the function assumes that a > b

  * Programmer: Leon Arber, 1/27/06

  */

 static double sub_time(struct timeval* a, struct timeval* b)

 {

     return (((double)a->tv_sec +

      ((double)a->tv_usec) / MICROSECOND) -

-	((double)b->tv_sec +

-	 ((double)b->tv_usec) / MICROSECOND));

+  ((double)b->tv_sec +

+   ((double)b->tv_usec) / MICROSECOND));

 }

 

 

@@ -82,7 +82,7 @@ sio_time_new(void)
 void

 sio_time_destroy(sio_time *pt)

 {

-    free(pt);

+    HDfree(pt);

     /* reset the global timer pointer too. */

     timer_g = NULL;

 }

@@ -100,15 +100,15 @@ sio_time *
 set_time(sio_time *pt, timer_type t, int start_stop)

 {

     if (pt) {

-            if (start_stop == START) {

+            if (start_stop == TSTART) {

                 HDgettimeofday(&pt->sys_timer[t], NULL);

 

-		/* When we start the timer for HDF5_FINE_WRITE_FIXED_DIMS or HDF5_FINE_READ_FIXED_DIMS

-		 * we compute the time it took to only open the file */

-		if(t == HDF5_FINE_WRITE_FIXED_DIMS)

-		    pt->total_time[HDF5_FILE_WRITE_OPEN] += sub_time(&(pt->sys_timer[t]), &(pt->sys_timer[HDF5_GROSS_WRITE_FIXED_DIMS]));

-		else if(t == HDF5_FINE_READ_FIXED_DIMS)

-		    pt->total_time[HDF5_FILE_READ_OPEN] += sub_time(&(pt->sys_timer[t]), &(pt->sys_timer[HDF5_GROSS_READ_FIXED_DIMS]));

+    /* When we start the timer for HDF5_FINE_WRITE_FIXED_DIMS or HDF5_FINE_READ_FIXED_DIMS

+     * we compute the time it took to only open the file */

+    if(t == HDF5_FINE_WRITE_FIXED_DIMS)

+        pt->total_time[HDF5_FILE_WRITE_OPEN] += sub_time(&(pt->sys_timer[t]), &(pt->sys_timer[HDF5_GROSS_WRITE_FIXED_DIMS]));

+    else if(t == HDF5_FINE_READ_FIXED_DIMS)

+        pt->total_time[HDF5_FILE_READ_OPEN] += sub_time(&(pt->sys_timer[t]), &(pt->sys_timer[HDF5_GROSS_READ_FIXED_DIMS]));

 

 

             } else {

@@ -122,12 +122,12 @@ set_time(sio_time *pt, timer_type t, int start_stop)
                     ((double)pt->sys_timer[t].tv_sec +

                             ((double)pt->sys_timer[t].tv_usec) / MICROSECOND);*/

 

-		/* When we stop the timer for HDF5_GROSS_WRITE_FIXED_DIMS or HDF5_GROSS_READ_FIXED_DIMS

-		 * we compute the time it took to close the file after the last read/write finished */

-		if(t == HDF5_GROSS_WRITE_FIXED_DIMS)

-		    pt->total_time[HDF5_FILE_WRITE_CLOSE] += sub_time(&(pt->sys_timer[t]), &(pt->sys_timer[HDF5_FINE_WRITE_FIXED_DIMS]));

-		else if(t == HDF5_GROSS_READ_FIXED_DIMS)

-		    pt->total_time[HDF5_FILE_READ_CLOSE] += sub_time(&(pt->sys_timer[t]), &(pt->sys_timer[HDF5_FINE_READ_FIXED_DIMS]));

+    /* When we stop the timer for HDF5_GROSS_WRITE_FIXED_DIMS or HDF5_GROSS_READ_FIXED_DIMS

+     * we compute the time it took to close the file after the last read/write finished */

+    if(t == HDF5_GROSS_WRITE_FIXED_DIMS)

+        pt->total_time[HDF5_FILE_WRITE_CLOSE] += sub_time(&(pt->sys_timer[t]), &(pt->sys_timer[HDF5_FINE_WRITE_FIXED_DIMS]));

+    else if(t == HDF5_GROSS_READ_FIXED_DIMS)

+        pt->total_time[HDF5_FILE_READ_CLOSE] += sub_time(&(pt->sys_timer[t]), &(pt->sys_timer[HDF5_FINE_READ_FIXED_DIMS]));

 

             }

 

@@ -171,7 +171,7 @@ set_time(sio_time *pt, timer_type t, int start_stop)
             }

 

             fprintf(output, "    %s %s: %.2f\n", msg,

-                    (start_stop == START ? "Start" : "Stop"),

+                    (start_stop == TSTART ? "Start" : "Stop"),

                     pt->total_time[t]);

         }

     }

diff --git a/perform/sio_timer.h b/perform/sio_timer.h
index 1fa880d..04432af 100644
--- a/perform/sio_timer.h
+++ b/perform/sio_timer.h
@@ -27,7 +27,7 @@
 #endif
 
 #ifdef H5_HAVE_WINSOCK_H
-#	include <winsock2.h>
+#  include <winsock2.h>
 #endif /* H5_HAVE_WINSOCK_H */
 
 /* The different types of timers we can have */
@@ -52,8 +52,8 @@ typedef enum timer_type_ {
 
 /* Miscellaneous identifiers */
 enum {
-    START,          /* Start a specified timer              */
-    STOP            /* Stop a specified timer               */
+    TSTART,          /* Start a specified timer              */
+    TSTOP            /* Stop a specified timer               */
 };
 
 /* The performance time structure */
diff --git a/perform/zip_perf.c b/perform/zip_perf.c
index 897fc7e..b13e0ec 100644
--- a/perform/zip_perf.c
+++ b/perform/zip_perf.c
@@ -23,6 +23,7 @@
 
 /* our header files */
 #include "h5test.h"
+#include "h5tools.h"
 #include "h5tools_utils.h"
 
 #ifdef H5_HAVE_FILTER_DEFLATE
@@ -574,6 +575,9 @@ main(int argc, char **argv)
 
     prog = argv[0];
 
+    /* Initialize h5tools lib */
+    h5tools_init();
+
     while ((opt = get_option(argc, (const char **)argv, s_opts, l_opts)) > 0) {
         switch ((char)opt) {
         case '0': case '1': case '2':