[svn-r22004] Reduced warnings and fixed conflicts resulting from including h5tools.h

Tested: local linux

11 files changed, 139 insertions, 136 deletions

diff --git a/perform/pio_engine.c b/perform/pio_engine.c
index abb72fa..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");
     }
 
@@ -413,7 +413,7 @@ done:
     static char *
 pio_create_filename(iotype iot, const char *base_name, char *fullname, size_t size)
 {
-    const char *prefix, *suffix="";
+    const char *prefix, *suffix = "";
     char *ptr, last = '\0';
     size_t i, j;
 
@@ -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 9cbd65d..337e982 100644
--- a/perform/pio_perf.c
+++ b/perform/pio_perf.c
@@ -288,14 +288,14 @@ struct options {
     unsigned interleaved;       /* Interleaved vs. contiguous blocks    */
     unsigned collective;        /* Collective vs. independent I/O       */
     unsigned dim2d;             /* 1D vs. 2D geometry                   */
-    int print_times;         /* print times as well as throughputs   */
-    int print_raw;           /* print raw data throughput info       */
+    int print_times;       	/* print times as well as throughputs   */
+    int print_raw;         	/* print raw data throughput info       */
     off_t h5_alignment;         /* alignment in HDF5 file               */
     off_t h5_threshold;         /* threshold for alignment in HDF5 file */
-    int h5_use_chunks;       /* Make HDF5 dataset chunked            */
-    int h5_write_only;          /* Perform the write tests only         */
+    int h5_use_chunks;     	/* Make HDF5 dataset chunked            */
+    int h5_write_only;        	/* Perform the write tests only         */
     unsigned h5_use_mpi_posix;  /* Use MPI-posix VFD for HDF5 I/O (instead of MPI-I/O VFD) */
-    int verify;            /* Verify data correctness              */
+    int verify;        		/* Verify data correctness              */
 };
 
 typedef struct _minmax {
@@ -683,7 +683,7 @@ run_test(iotype iot, parameters parms, struct options *opts)
     /*
      * Show various statistics
      */
-    /* Write statistics  */
+    /* Write statistics	*/
     /* Print the raw data throughput if desired */
     if (opts->print_raw) {
         /* accumulate and output the max, min, and average "raw write" times */
@@ -749,7 +749,7 @@ run_test(iotype iot, parameters parms, struct options *opts)
     }
 
     if (!parms.h5_write_only) {
-        /* Read statistics  */
+        /* Read statistics	*/
         /* Print the raw data throughput if desired */
         if (opts->print_raw) {
             /* accumulate and output the max, min, and average "raw read" times */
@@ -1103,10 +1103,10 @@ print_indent(register int indent)
     MPI_Comm_rank(pio_comm_g, &myrank);
 
     if (myrank == 0) {
-  indent *= TAB_SPACE;
+	indent *= TAB_SPACE;
 
-  for (; indent > 0; --indent)
-      fputc(' ', output);
+	for (; indent > 0; --indent)
+	    fputc(' ', output);
     }
 }
 
@@ -1131,11 +1131,11 @@ static void
 print_io_api(long io_types)
 {
     if (io_types & PIO_POSIX)
-  HDfprintf(output, "posix ");
+	HDfprintf(output, "posix ");
     if (io_types & PIO_MPI)
-  HDfprintf(output, "mpiio ");
+	HDfprintf(output, "mpiio ");
     if (io_types & PIO_HDF5)
-  HDfprintf(output, "phdf5 ");
+	HDfprintf(output, "phdf5 ");
     HDfprintf(output, "\n");
 }
 
@@ -1144,7 +1144,7 @@ report_parameters(struct options *opts)
 {
     int rank = comm_world_rank_g;
 
-    print_version("HDF5 Library");  /* print library version */
+    print_version("HDF5 Library");	/* print library version */
     HDfprintf(output, "rank %d: ==== Parameters ====\n", rank);
 
     HDfprintf(output, "rank %d: IO API=", rank);
@@ -1565,7 +1565,7 @@ parse_size_directive(const char *size)
  * Return:      Nothing
  * Programmer:  Bill Wendling, 31. October 2001
  * Modifications:
- *   Added 2D testing (Christian Chilan, 10. August 2005)
+ * 	Added 2D testing (Christian Chilan, 10. August 2005)
  */
 static void
 usage(const char *prog)
@@ -1575,7 +1575,7 @@ usage(const char *prog)
     MPI_Comm_rank(pio_comm_g, &myrank);
 
     if (myrank == 0) {
-  print_version(prog);
+	print_version(prog);
         printf("usage: %s [OPTIONS]\n", prog);
         printf("  OPTIONS\n");
         printf("     -h, --help                  Print a usage message and exit\n");
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 8900e2e..16e1750 100644
--- a/perform/sio_perf.c
+++ b/perform/sio_perf.c
@@ -295,15 +295,15 @@ struct options {
     int buf_rank;             /* Rank                   */
     int order_rank;             /* Rank                   */
     int chk_rank;             /* Rank                   */
-    int print_times;         /* print times as well as throughputs   */
-    int print_raw;           /* print raw data throughput info       */
+    int print_times;       	/* print times as well as throughputs   */
+    int print_raw;         	/* print raw data throughput info       */
     off_t h5_alignment;         /* alignment in HDF5 file               */
     off_t h5_threshold;         /* threshold for alignment in HDF5 file */
-    int h5_use_chunks;       /* Make HDF5 dataset chunked            */
-    int h5_write_only;          /* Perform the write tests only         */
-    int h5_extendable;          /* Perform the write tests only         */
+    int h5_use_chunks;     	/* Make HDF5 dataset chunked            */
+    int h5_write_only;        	/* Perform the write tests only         */
+    int h5_extendable;        	/* Perform the write tests only         */
     unsigned h5_use_mpi_posix;  /* Use MPI-posix VFD for HDF5 I/O (instead of MPI-I/O VFD) */
-    int verify;            /* Verify data correctness              */
+    int verify;        		/* Verify data correctness              */
     vfdtype     vfd;            /* File driver */
 
 };
@@ -558,7 +558,7 @@ run_test(iotype iot, parameters parms, struct options *opts)
     /*
      * Show various statistics
      */
-    /* Write statistics  */
+    /* Write statistics	*/
     /* Print the raw data throughput if desired */
     if (opts->print_raw) {
         /* accumulate and output the max, min, and average "raw write" times */
@@ -604,7 +604,7 @@ run_test(iotype iot, parameters parms, struct options *opts)
     output_results(opts,"Write Open-Close",write_gross_mm_table,parms.num_iters,raw_size);
 
     if (!parms.h5_write_only) {
-        /* Read statistics  */
+        /* Read statistics	*/
         /* Print the raw data throughput if desired */
         if (opts->print_raw) {
             /* accumulate and output the max, min, and average "raw read" times */
@@ -815,10 +815,10 @@ output_report(const char *fmt, ...)
 static void
 print_indent(register int indent)
 {
-  indent *= TAB_SPACE;
+	indent *= TAB_SPACE;
 
-  for (; indent > 0; --indent)
-      fputc(' ', output);
+	for (; indent > 0; --indent)
+	    fputc(' ', output);
 }
 
 static void
@@ -842,9 +842,9 @@ static void
 print_io_api(long io_types)
 {
     if (io_types & SIO_POSIX)
-  HDfprintf(output, "posix ");
+	HDfprintf(output, "posix ");
     if (io_types & SIO_HDF5)
-  HDfprintf(output, "hdf5 ");
+	HDfprintf(output, "hdf5 ");
     HDfprintf(output, "\n");
 }
 
@@ -854,7 +854,7 @@ report_parameters(struct options *opts)
     int i, rank;
     rank = opts->dset_rank;
 
-    print_version("HDF5 Library");  /* print library version */
+    print_version("HDF5 Library");	/* print library version */
     HDfprintf(output, "==== Parameters ====\n");
 
     HDfprintf(output, "IO API=");
@@ -1348,7 +1348,7 @@ parse_size_directive(const char *size)
 static void
 usage(const char *prog)
 {
-  print_version(prog);
+	print_version(prog);
         printf("usage: %s [OPTIONS]\n", prog);
         printf("  OPTIONS\n");
         printf("     -h                Print an usage message and exit\n");
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 4e1f043..585dc13 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