Clang-format of source files

1 files changed, 188 insertions, 203 deletions

diff --git a/tools/test/perform/perf.c b/tools/test/perform/perf.c
index 5b78c52..22aca04 100644
--- a/tools/test/perform/perf.c
+++ b/tools/test/perform/perf.c
@@ -44,17 +44,17 @@
 #endif
 
 #if defined(H5_TIME_WITH_SYS_TIME)
-#   include <sys/time.h>
-#   include <time.h>
+#include <sys/time.h>
+#include <time.h>
 #elif defined(H5_HAVE_SYS_TIME_H)
-#   include <sys/time.h>
+#include <sys/time.h>
 #else
-#   include <time.h>
+#include <time.h>
 #endif
 
 #include <mpi.h>
-#ifndef MPI_FILE_NULL           /*MPIO may be defined in mpi.h already       */
-#   include <mpio.h>
+#ifndef MPI_FILE_NULL /*MPIO may be defined in mpi.h already       */
+#include <mpio.h>
 #endif
 
 /* Macro definitions */
@@ -62,50 +62,46 @@
  * if val is false (0), print mesg and if fatal is true (non-zero), die.
  */
 #define H5FATAL 1
-#define VRFY(val, mesg, fatal) do {                                            \
-    if (!val) {                                                                \
-        printf("Proc %d: ", mynod);                 \
-        printf("*** Assertion failed (%s) at line %4d in %s\n",                \
-        mesg, (int)__LINE__, __FILE__);                  \
-        if (fatal){                     \
-            fflush(stdout);                   \
-            goto die_jar_jar_die;                 \
-        }                       \
-    }                                                                          \
-} while(0)
-#define RANK 1
+#define VRFY(val, mesg, fatal)                                                                               \
+    do {                                                                                                     \
+        if (!val) {                                                                                          \
+            printf("Proc %d: ", mynod);                                                                      \
+            printf("*** Assertion failed (%s) at line %4d in %s\n", mesg, (int)__LINE__, __FILE__);          \
+            if (fatal) {                                                                                     \
+                fflush(stdout);                                                                              \
+                goto die_jar_jar_die;                                                                        \
+            }                                                                                                \
+        }                                                                                                    \
+    } while (0)
+#define RANK     1
 #define MAX_PATH 1024
 
-hsize_t dims[RANK];     /* dataset dim sizes */
+hsize_t dims[RANK]; /* dataset dim sizes */
 hsize_t block[RANK], stride[RANK], count[RANK];
 hsize_t start[RANK];
-hid_t fid;                  /* HDF5 file ID */
-hid_t acc_tpl;    /* File access templates */
-hid_t sid;       /* Dataspace ID */
-hid_t file_dataspace;  /* File dataspace ID */
-hid_t mem_dataspace;  /* memory dataspace ID */
-hid_t dataset;    /* Dataset ID */
-hsize_t opt_alignment  = 1;
-hsize_t opt_threshold  = 1;
-int  opt_split_vfd  = 0;
-char  *meta_ext, *raw_ext;  /* holds the meta and raw file extension if */
-        /* opt_split_vfd is set */
-
+hid_t   fid;            /* HDF5 file ID */
+hid_t   acc_tpl;        /* File access templates */
+hid_t   sid;            /* Dataspace ID */
+hid_t   file_dataspace; /* File dataspace ID */
+hid_t   mem_dataspace;  /* memory dataspace ID */
+hid_t   dataset;        /* Dataset ID */
+hsize_t opt_alignment = 1;
+hsize_t opt_threshold = 1;
+int     opt_split_vfd = 0;
+char *  meta_ext, *raw_ext; /* holds the meta and raw file extension if */
+                            /* opt_split_vfd is set */
 
 /* DEFAULT VALUES FOR OPTIONS */
-int64_t opt_block     = 1048576*16;
-int     opt_iter      = 1;
-int     opt_stripe    = -1;
-int     opt_correct   = 0;
-int     amode         = O_RDWR | O_CREAT;
-char    opt_file[256] = "perftest.out";
+int64_t opt_block        = 1048576 * 16;
+int     opt_iter         = 1;
+int     opt_stripe       = -1;
+int     opt_correct      = 0;
+int     amode            = O_RDWR | O_CREAT;
+char    opt_file[256]    = "perftest.out";
 char    opt_pvfstab[256] = "notset";
-int     opt_pvfstab_set = 0;
+int     opt_pvfstab_set  = 0;
 
-const char *FILENAME[] = {
-   opt_file,
-   NULL
-};
+const char *FILENAME[] = {opt_file, NULL};
 
 /* function prototypes */
 static int parse_args(int argc, char **argv);
@@ -115,42 +111,44 @@ static int parse_args(int argc, char **argv);
 extern char *optarg;
 #endif
 
-int main(int argc, char **argv)
+int
+main(int argc, char **argv)
 {
-    char *buf, *tmp, *buf2 = NULL, *tmp2 = NULL, *check;
-    int i, j, mynod=0, nprocs=1, my_correct = 1, correct, myerrno;
-    double stim, etim;
-    double write_tim = 0;
-    double read_tim = 0;
-    double read_bw, write_bw;
-    double max_read_tim, max_write_tim;
-    double min_read_tim, min_write_tim;
-    double ave_read_tim, ave_write_tim;
+    char *  buf, *tmp, *buf2 = NULL, *tmp2 = NULL, *check;
+    int     i, j, mynod = 0, nprocs = 1, my_correct = 1, correct, myerrno;
+    double  stim, etim;
+    double  write_tim = 0;
+    double  read_tim  = 0;
+    double  read_bw, write_bw;
+    double  max_read_tim, max_write_tim;
+    double  min_read_tim, min_write_tim;
+    double  ave_read_tim, ave_write_tim;
     int64_t iter_jump = 0;
-    char filename[MAX_PATH];
-    herr_t ret;           /* Generic return value */
+    char    filename[MAX_PATH];
+    herr_t  ret; /* Generic return value */
 
     /* startup MPI and determine the rank of this process */
-    MPI_Init(&argc,&argv);
+    MPI_Init(&argc, &argv);
     MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
     MPI_Comm_rank(MPI_COMM_WORLD, &mynod);
 
     /* parse the command line arguments */
     parse_args(argc, argv);
 
-    if (mynod == 0) printf("# Using hdf5-io calls.\n");
+    if (mynod == 0)
+        printf("# Using hdf5-io calls.\n");
 
-    /* kindof a weird hack- if the location of the pvfstab file was
-     * specified on the command line, then spit out this location into
-     * the appropriate environment variable: */
+        /* kindof a weird hack- if the location of the pvfstab file was
+         * specified on the command line, then spit out this location into
+         * the appropriate environment variable: */
 
 #if H5_HAVE_SETENV
-/* no setenv or unsetenv */
+    /* no setenv or unsetenv */
     if (opt_pvfstab_set) {
-            if((setenv("PVFSTAB_FILE", opt_pvfstab, 1)) < 0){
-                    perror("setenv");
-                    goto die_jar_jar_die;
-            }
+        if ((setenv("PVFSTAB_FILE", opt_pvfstab, 1)) < 0) {
+            perror("setenv");
+            goto die_jar_jar_die;
+        }
     }
 #endif
 
@@ -160,55 +158,56 @@ int main(int argc, char **argv)
     iter_jump = nprocs * opt_block;
 
     /* setup a buffer of data to write */
-    if (!(tmp = (char *) malloc((size_t)opt_block + 256))) {
-            perror("malloc");
-            goto die_jar_jar_die;
+    if (!(tmp = (char *)malloc((size_t)opt_block + 256))) {
+        perror("malloc");
+        goto die_jar_jar_die;
     }
-    buf = tmp + 128 - (((long)tmp) % 128);  /* align buffer */
+    buf = tmp + 128 - (((long)tmp) % 128); /* align buffer */
 
     if (opt_correct) {
-            /* do the same buffer setup for verifiable data */
-            if (!(tmp2 = (char *) malloc((size_t)opt_block + 256))) {
-                    perror("malloc2");
-                    goto die_jar_jar_die;
-             }
-            buf2 = tmp + 128 - (((long)tmp) % 128);
+        /* do the same buffer setup for verifiable data */
+        if (!(tmp2 = (char *)malloc((size_t)opt_block + 256))) {
+            perror("malloc2");
+            goto die_jar_jar_die;
+        }
+        buf2 = tmp + 128 - (((long)tmp) % 128);
     }
 
     /* setup file access template with parallel IO access. */
-    if (opt_split_vfd){
-    hid_t mpio_pl;
-
-    mpio_pl = H5Pcreate (H5P_FILE_ACCESS);
-    VRFY((acc_tpl >= 0), "", H5FATAL);
-    ret = H5Pset_fapl_mpio(mpio_pl, MPI_COMM_WORLD, MPI_INFO_NULL);
-    VRFY((ret >= 0), "", H5FATAL);
-
-    /* set optional allocation alignment */
-    if (opt_alignment*opt_threshold != 1){
-        ret = H5Pset_alignment(acc_tpl, opt_threshold, opt_alignment );
-        VRFY((ret >= 0), "H5Pset_alignment succeeded", !H5FATAL);
-    }
+    if (opt_split_vfd) {
+        hid_t mpio_pl;
+
+        mpio_pl = H5Pcreate(H5P_FILE_ACCESS);
+        VRFY((acc_tpl >= 0), "", H5FATAL);
+        ret = H5Pset_fapl_mpio(mpio_pl, MPI_COMM_WORLD, MPI_INFO_NULL);
+        VRFY((ret >= 0), "", H5FATAL);
+
+        /* set optional allocation alignment */
+        if (opt_alignment * opt_threshold != 1) {
+            ret = H5Pset_alignment(acc_tpl, opt_threshold, opt_alignment);
+            VRFY((ret >= 0), "H5Pset_alignment succeeded", !H5FATAL);
+        }
 
-    /* setup file access template */
-    acc_tpl = H5Pcreate (H5P_FILE_ACCESS);
-    VRFY((acc_tpl >= 0), "", H5FATAL);
-    ret = H5Pset_fapl_split(acc_tpl, meta_ext, mpio_pl, raw_ext, mpio_pl);
-    VRFY((ret >= 0), "H5Pset_fapl_split succeeded", H5FATAL);
-    ret = H5Pclose(mpio_pl);
-    VRFY((ret >= 0), "H5Pclose mpio_pl succeeded", H5FATAL);
-    }else{
-    /* setup file access template */
-    acc_tpl = H5Pcreate (H5P_FILE_ACCESS);
-    VRFY((acc_tpl >= 0), "", H5FATAL);
-    ret = H5Pset_fapl_mpio(acc_tpl, MPI_COMM_WORLD, MPI_INFO_NULL);
-    VRFY((ret >= 0), "", H5FATAL);
-
-    /* set optional allocation alignment */
-    if (opt_alignment*opt_threshold != 1){
-        ret = H5Pset_alignment(acc_tpl, opt_threshold, opt_alignment );
-        VRFY((ret >= 0), "H5Pset_alignment succeeded", !H5FATAL);
+        /* setup file access template */
+        acc_tpl = H5Pcreate(H5P_FILE_ACCESS);
+        VRFY((acc_tpl >= 0), "", H5FATAL);
+        ret = H5Pset_fapl_split(acc_tpl, meta_ext, mpio_pl, raw_ext, mpio_pl);
+        VRFY((ret >= 0), "H5Pset_fapl_split succeeded", H5FATAL);
+        ret = H5Pclose(mpio_pl);
+        VRFY((ret >= 0), "H5Pclose mpio_pl succeeded", H5FATAL);
     }
+    else {
+        /* setup file access template */
+        acc_tpl = H5Pcreate(H5P_FILE_ACCESS);
+        VRFY((acc_tpl >= 0), "", H5FATAL);
+        ret = H5Pset_fapl_mpio(acc_tpl, MPI_COMM_WORLD, MPI_INFO_NULL);
+        VRFY((ret >= 0), "", H5FATAL);
+
+        /* set optional allocation alignment */
+        if (opt_alignment * opt_threshold != 1) {
+            ret = H5Pset_alignment(acc_tpl, opt_threshold, opt_alignment);
+            VRFY((ret >= 0), "H5Pset_alignment succeeded", !H5FATAL);
+        }
     }
 
     h5_fixname_no_suffix(FILENAME[0], acc_tpl, filename, sizeof filename);
@@ -219,14 +218,13 @@ int main(int argc, char **argv)
 
     /* define a contiquous dataset of opt_iter*nprocs*opt_block chars */
     dims[0] = (hsize_t)opt_iter * (hsize_t)nprocs * (hsize_t)opt_block;
-    sid = H5Screate_simple(RANK, dims, NULL);
+    sid     = H5Screate_simple(RANK, dims, NULL);
     VRFY((sid >= 0), "H5Screate_simple succeeded", H5FATAL);
-    dataset = H5Dcreate2(fid, "Dataset1", H5T_NATIVE_CHAR, sid,
-            H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
+    dataset = H5Dcreate2(fid, "Dataset1", H5T_NATIVE_CHAR, sid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
     VRFY((dataset >= 0), "H5Dcreate2 succeeded", H5FATAL);
 
     /* create the memory dataspace and the file dataspace */
-    dims[0] = (hsize_t)opt_block;
+    dims[0]       = (hsize_t)opt_block;
     mem_dataspace = H5Screate_simple(RANK, dims, NULL);
     VRFY((mem_dataspace >= 0), "", H5FATAL);
     file_dataspace = H5Dget_space(dataset);
@@ -235,48 +233,46 @@ int main(int argc, char **argv)
     /* now each process writes a block of opt_block chars in round robbin
      * fashion until the whole dataset is covered.
      */
-    for(j=0; j < opt_iter; j++) {
+    for (j = 0; j < opt_iter; j++) {
         /* setup a file dataspace selection */
-        start[0] = (hsize_t)((j * iter_jump) + (mynod * opt_block));
+        start[0]  = (hsize_t)((j * iter_jump) + (mynod * opt_block));
         stride[0] = block[0] = (hsize_t)opt_block;
-        count[0]= 1;
-        ret=H5Sselect_hyperslab(file_dataspace, H5S_SELECT_SET, start, stride, count, block);
+        count[0]             = 1;
+        ret = H5Sselect_hyperslab(file_dataspace, H5S_SELECT_SET, start, stride, count, block);
         VRFY((ret >= 0), "H5Sset_hyperslab succeeded", H5FATAL);
 
-            if (opt_correct) /* fill in buffer for iteration */ {
-                    for (i=mynod+j, check=buf; i<opt_block; i++,check++) *check=(char)i;
-            }
+        if (opt_correct) /* fill in buffer for iteration */ {
+            for (i = mynod + j, check = buf; i < opt_block; i++, check++)
+                *check = (char)i;
+        }
 
-            /* discover the starting time of the operation */
-       MPI_Barrier(MPI_COMM_WORLD);
-       stim = MPI_Wtime();
+        /* discover the starting time of the operation */
+        MPI_Barrier(MPI_COMM_WORLD);
+        stim = MPI_Wtime();
 
         /* write data */
-        ret = H5Dwrite(dataset, H5T_NATIVE_CHAR, mem_dataspace, file_dataspace,
-                H5P_DEFAULT, buf);
+        ret = H5Dwrite(dataset, H5T_NATIVE_CHAR, mem_dataspace, file_dataspace, H5P_DEFAULT, buf);
         VRFY((ret >= 0), "H5Dwrite dataset1 succeeded", !H5FATAL);
 
-            /* discover the ending time of the operation */
-       etim = MPI_Wtime();
+        /* discover the ending time of the operation */
+        etim = MPI_Wtime();
 
-       write_tim += (etim - stim);
+        write_tim += (etim - stim);
 
-            /* we are done with this "write" iteration */
+        /* we are done with this "write" iteration */
     }
 
     /* close dataset and file */
-    ret=H5Dclose(dataset);
+    ret = H5Dclose(dataset);
     VRFY((ret >= 0), "H5Dclose succeeded", H5FATAL);
-    ret=H5Fclose(fid);
+    ret = H5Fclose(fid);
     VRFY((ret >= 0), "H5Fclose succeeded", H5FATAL);
 
-
-
     /* wait for everyone to synchronize at this point */
     MPI_Barrier(MPI_COMM_WORLD);
 
     /* reopen the file for reading */
-    fid=H5Fopen(filename,H5F_ACC_RDONLY,acc_tpl);
+    fid = H5Fopen(filename, H5F_ACC_RDONLY, acc_tpl);
     VRFY((fid >= 0), "", H5FATAL);
 
     /* open the dataset */
@@ -288,119 +284,111 @@ int main(int argc, char **argv)
      */
 
     /* we are going to repeat the read the same pattern the write used */
-    for (j=0; j < opt_iter; j++) {
+    for (j = 0; j < opt_iter; j++) {
         /* setup a file dataspace selection */
-        start[0] = (hsize_t)((j * iter_jump) + (mynod * opt_block));
+        start[0]  = (hsize_t)((j * iter_jump) + (mynod * opt_block));
         stride[0] = block[0] = (hsize_t)opt_block;
-        count[0]= 1;
-        ret=H5Sselect_hyperslab(file_dataspace, H5S_SELECT_SET, start, stride, count, block);
+        count[0]             = 1;
+        ret = H5Sselect_hyperslab(file_dataspace, H5S_SELECT_SET, start, stride, count, block);
         VRFY((ret >= 0), "H5Sset_hyperslab succeeded", H5FATAL);
-            /* seek to the appropriate spot give the current iteration and
-             * rank within the MPI processes */
+        /* seek to the appropriate spot give the current iteration and
+         * rank within the MPI processes */
 
-            /* discover the start time */
-       MPI_Barrier(MPI_COMM_WORLD);
-       stim = MPI_Wtime();
+        /* discover the start time */
+        MPI_Barrier(MPI_COMM_WORLD);
+        stim = MPI_Wtime();
 
         /* read in the file data */
-        if (!opt_correct){
+        if (!opt_correct) {
             ret = H5Dread(dataset, H5T_NATIVE_CHAR, mem_dataspace, file_dataspace, H5P_DEFAULT, buf);
         }
-        else{
+        else {
             ret = H5Dread(dataset, H5T_NATIVE_CHAR, mem_dataspace, file_dataspace, H5P_DEFAULT, buf2);
         }
         myerrno = errno;
 
         /* discover the end time */
-       etim = MPI_Wtime();
-       read_tim += (etim - stim);
+        etim = MPI_Wtime();
+        read_tim += (etim - stim);
         VRFY((ret >= 0), "H5Dwrite dataset1 succeeded", !H5FATAL);
 
-
-       if (ret < 0) HDfprintf(stderr, "node %d, read error, loc = %" PRId64 ": %s\n",
-                    mynod, mynod*opt_block, strerror(myerrno));
+        if (ret < 0)
+            HDfprintf(stderr, "node %d, read error, loc = %" PRId64 ": %s\n", mynod, mynod * opt_block,
+                      strerror(myerrno));
 
         /* if the user wanted to check correctness, compare the write
          * buffer to the read buffer */
         if (opt_correct && memcmp(buf, buf2, (size_t)opt_block)) {
-                HDfprintf(stderr, "node %d, correctness test failed\n", mynod);
-                my_correct = 0;
-                MPI_Allreduce(&my_correct, &correct, 1, MPI_INT, MPI_MIN,
-                        MPI_COMM_WORLD);
+            HDfprintf(stderr, "node %d, correctness test failed\n", mynod);
+            my_correct = 0;
+            MPI_Allreduce(&my_correct, &correct, 1, MPI_INT, MPI_MIN, MPI_COMM_WORLD);
         }
 
         /* we are done with this read iteration */
     }
 
     /* close dataset and file */
-    ret=H5Dclose(dataset);
+    ret = H5Dclose(dataset);
     VRFY((ret >= 0), "H5Dclose succeeded", H5FATAL);
-    ret=H5Fclose(fid);
+    ret = H5Fclose(fid);
     VRFY((ret >= 0), "H5Fclose succeeded", H5FATAL);
-    ret=H5Pclose(acc_tpl);
+    ret = H5Pclose(acc_tpl);
     VRFY((ret >= 0), "H5Pclose succeeded", H5FATAL);
 
     /* compute the read and write times */
-    MPI_Allreduce(&read_tim, &max_read_tim, 1, MPI_DOUBLE, MPI_MAX,
-            MPI_COMM_WORLD);
-    MPI_Allreduce(&read_tim, &min_read_tim, 1, MPI_DOUBLE, MPI_MIN,
-            MPI_COMM_WORLD);
-    MPI_Allreduce(&read_tim, &ave_read_tim, 1, MPI_DOUBLE, MPI_SUM,
-            MPI_COMM_WORLD);
+    MPI_Allreduce(&read_tim, &max_read_tim, 1, MPI_DOUBLE, MPI_MAX, MPI_COMM_WORLD);
+    MPI_Allreduce(&read_tim, &min_read_tim, 1, MPI_DOUBLE, MPI_MIN, MPI_COMM_WORLD);
+    MPI_Allreduce(&read_tim, &ave_read_tim, 1, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
 
     /* calculate the average from the sum */
     ave_read_tim = ave_read_tim / nprocs;
 
-    MPI_Allreduce(&write_tim, &max_write_tim, 1, MPI_DOUBLE, MPI_MAX,
-            MPI_COMM_WORLD);
-    MPI_Allreduce(&write_tim, &min_write_tim, 1, MPI_DOUBLE, MPI_MIN,
-            MPI_COMM_WORLD);
-    MPI_Allreduce(&write_tim, &ave_write_tim, 1, MPI_DOUBLE, MPI_SUM,
-            MPI_COMM_WORLD);
+    MPI_Allreduce(&write_tim, &max_write_tim, 1, MPI_DOUBLE, MPI_MAX, MPI_COMM_WORLD);
+    MPI_Allreduce(&write_tim, &min_write_tim, 1, MPI_DOUBLE, MPI_MIN, MPI_COMM_WORLD);
+    MPI_Allreduce(&write_tim, &ave_write_tim, 1, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
 
     /* calculate the average from the sum */
     ave_write_tim = ave_write_tim / nprocs;
 
     /* print out the results on one node */
     if (mynod == 0) {
-       read_bw = (double)((int64_t)(opt_block*nprocs*opt_iter))/(max_read_tim*1000000.0);
-       write_bw = (double)((int64_t)(opt_block*nprocs*opt_iter))/(max_write_tim*1000000.0);
+        read_bw  = (double)((int64_t)(opt_block * nprocs * opt_iter)) / (max_read_tim * 1000000.0);
+        write_bw = (double)((int64_t)(opt_block * nprocs * opt_iter)) / (max_write_tim * 1000000.0);
 
-                    printf("nr_procs = %d, nr_iter = %d, blk_sz = %ld\n", nprocs,
-            opt_iter, (long)opt_block);
+        printf("nr_procs = %d, nr_iter = %d, blk_sz = %ld\n", nprocs, opt_iter, (long)opt_block);
 
-                    printf("# total_size = %ld\n", (long)(opt_block*nprocs*opt_iter));
+        printf("# total_size = %ld\n", (long)(opt_block * nprocs * opt_iter));
 
-                    printf("# Write:  min_time = %f, max_time = %f, mean_time = %f\n",
-                            min_write_tim, max_write_tim, ave_write_tim);
-                    printf("# Read:  min_time = %f, max_time = %f, mean_time = %f\n",
-                            min_read_tim, max_read_tim, ave_read_tim);
+        printf("# Write:  min_time = %f, max_time = %f, mean_time = %f\n", min_write_tim, max_write_tim,
+               ave_write_tim);
+        printf("# Read:  min_time = %f, max_time = %f, mean_time = %f\n", min_read_tim, max_read_tim,
+               ave_read_tim);
 
-       printf("Write bandwidth = %f Mbytes/sec\n", write_bw);
-       printf("Read bandwidth = %f Mbytes/sec\n", read_bw);
+        printf("Write bandwidth = %f Mbytes/sec\n", write_bw);
+        printf("Read bandwidth = %f Mbytes/sec\n", read_bw);
 
-            if (opt_correct) {
-                    printf("Correctness test %s.\n", correct ? "passed" : "failed");
-            }
+        if (opt_correct) {
+            printf("Correctness test %s.\n", correct ? "passed" : "failed");
+        }
     }
 
-
 die_jar_jar_die:
 
 #if H5_HAVE_SETENV
-/* no setenv or unsetenv */
+    /* no setenv or unsetenv */
     /* clear the environment variable if it was set earlier */
-    if  (opt_pvfstab_set){
-            unsetenv("PVFSTAB_FILE");
+    if (opt_pvfstab_set) {
+        unsetenv("PVFSTAB_FILE");
     }
 #endif
 
     free(tmp);
-    if (opt_correct) free(tmp2);
+    if (opt_correct)
+        free(tmp2);
 
     MPI_Finalize();
 
-    return(0);
+    return (0);
 }
 
 static int
@@ -432,32 +420,30 @@ parse_args(int argc, char **argv)
                        * e.g., -a4096/512  allocate at 4096 bytes
                        * boundary if request size >= 512.
                        */
-                {
-                    char *p;
+            {
+                char *p;
 
-                    opt_alignment = (hsize_t)HDatoi(optarg);
-                    if(NULL != (p = (char*)HDstrchr(optarg, '/')))
-                        opt_threshold = (hsize_t)HDatoi(p + 1);
-                }
-                HDfprintf(stdout,
-                    "alignment/threshold=%" PRIuHSIZE "/%" PRIuHSIZE "\n",
-                     opt_alignment, opt_threshold);
+                opt_alignment = (hsize_t)HDatoi(optarg);
+                if (NULL != (p = (char *)HDstrchr(optarg, '/')))
+                    opt_threshold = (hsize_t)HDatoi(p + 1);
+            }
+                HDfprintf(stdout, "alignment/threshold=%" PRIuHSIZE "/%" PRIuHSIZE "\n", opt_alignment,
+                          opt_threshold);
                 break;
             case '2': /* use 2-files, i.e., split file driver */
-                opt_split_vfd=1;
+                opt_split_vfd = 1;
                 /* get meta and raw file extension. */
                 /* syntax is <raw_ext>,<meta_ext> */
                 meta_ext = raw_ext = optarg;
-                while (*raw_ext != '\0'){
-                    if (*raw_ext == ','){
+                while (*raw_ext != '\0') {
+                    if (*raw_ext == ',') {
                         *raw_ext = '\0';
                         raw_ext++;
                         break;
                     }
                     raw_ext++;
                 }
-                printf("split-file-vfd used: %s,%s\n",
-                    meta_ext, raw_ext);
+                printf("split-file-vfd used: %s,%s\n", meta_ext, raw_ext);
                 break;
             case 'c': /* correctness */
                 opt_correct = 1;
@@ -468,7 +454,7 @@ parse_args(int argc, char **argv)
         }
     }
 
-    return(0);
+    return (0);
 }
 
 /*
@@ -479,13 +465,12 @@ parse_args(int argc, char **argv)
  * End:
  */
 
-#else /* H5_HAVE_PARALLEL */
+#else  /* H5_HAVE_PARALLEL */
 /* dummy program since H5_HAVE_PARALLEL is not configured in */
 int
 main(int H5_ATTR_UNUSED argc, char H5_ATTR_UNUSED **argv)
 {
     printf("No parallel performance because parallel is not configured in\n");
-    return(0);
+    return (0);
 }
 #endif /* H5_HAVE_PARALLEL */
-