Rename HD(f)printf() to (f)printf() (#3194)

5 files changed, 439 insertions, 439 deletions

diff --git a/tools/src/h5perf/pio_engine.c b/tools/src/h5perf/pio_engine.c
index 2238aac..e6f0834 100644
--- a/tools/src/h5perf/pio_engine.c
+++ b/tools/src/h5perf/pio_engine.c
@@ -62,8 +62,8 @@
     }
 #define ERRMSG(mesg)                                                                                         \
     {                                                                                                        \
-        HDfprintf(stderr, "Proc %d: ", pio_mpi_rank_g);                                                      \
-        HDfprintf(stderr, "*** Assertion failed (%s) at line %4d in %s\n", mesg, (int)__LINE__, __FILE__);   \
+        fprintf(stderr, "Proc %d: ", pio_mpi_rank_g);                                                        \
+        fprintf(stderr, "*** Assertion failed (%s) at line %4d in %s\n", mesg, (int)__LINE__, __FILE__);     \
     }
 
 /* verify: if val is false (0), print mesg. */
@@ -184,7 +184,7 @@ do_pio(parameters param)
             break;
         default:
             /* unknown request */
-            HDfprintf(stderr, "Unknown IO type request (%d)\n", iot);
+            fprintf(stderr, "Unknown IO type request (%d)\n", iot);
             GOTOERROR(FAIL);
     }
 
@@ -203,66 +203,66 @@ do_pio(parameters param)
     }
 
     if (param.num_files < 0) {
-        HDfprintf(stderr, "number of files must be >= 0 (%ld)\n", param.num_files);
+        fprintf(stderr, "number of files must be >= 0 (%ld)\n", param.num_files);
         GOTOERROR(FAIL);
     }
 
     if (ndsets < 0) {
-        HDfprintf(stderr, "number of datasets per file must be >= 0 (%ld)\n", ndsets);
+        fprintf(stderr, "number of datasets per file must be >= 0 (%ld)\n", ndsets);
         GOTOERROR(FAIL);
     }
 
     if (param.num_procs <= 0) {
-        HDfprintf(stderr, "maximum number of process to use must be > 0 (%d)\n", param.num_procs);
+        fprintf(stderr, "maximum number of process to use must be > 0 (%d)\n", param.num_procs);
         GOTOERROR(FAIL);
     }
 
     /* Validate transfer buffer size & block size*/
     if (blk_size <= 0) {
-        HDfprintf(stderr, "Transfer block size (%zu) must be > 0\n", blk_size);
+        fprintf(stderr, "Transfer block size (%zu) must be > 0\n", blk_size);
         GOTOERROR(FAIL);
     }
     if (buf_size <= 0) {
-        HDfprintf(stderr, "Transfer buffer size (%zu) must be > 0\n", buf_size);
+        fprintf(stderr, "Transfer buffer size (%zu) must be > 0\n", buf_size);
         GOTOERROR(FAIL);
     }
     if ((buf_size % blk_size) != 0) {
-        HDfprintf(stderr,
-                  "Transfer buffer size (%zu) must be a multiple of the "
-                  "interleaved I/O block size (%zu)\n",
-                  buf_size, blk_size);
+        fprintf(stderr,
+                "Transfer buffer size (%zu) must be a multiple of the "
+                "interleaved I/O block size (%zu)\n",
+                buf_size, blk_size);
         GOTOERROR(FAIL);
     }
     if ((snbytes % pio_mpi_nprocs_g) != 0) {
-        HDfprintf(stderr,
-                  "Dataset size (%lld) must be a multiple of the "
-                  "number of processes (%d)\n",
-                  (long long)snbytes, pio_mpi_nprocs_g);
+        fprintf(stderr,
+                "Dataset size (%lld) must be a multiple of the "
+                "number of processes (%d)\n",
+                (long long)snbytes, pio_mpi_nprocs_g);
         GOTOERROR(FAIL);
     }
 
     if (!param.dim2d) {
         if (((size_t)(snbytes / pio_mpi_nprocs_g) % buf_size) != 0) {
-            HDfprintf(stderr,
-                      "Dataset size/process (%lld) must be a multiple of the "
-                      "transfer buffer size (%zu)\n",
-                      (long long)(snbytes / pio_mpi_nprocs_g), buf_size);
+            fprintf(stderr,
+                    "Dataset size/process (%lld) must be a multiple of the "
+                    "transfer buffer size (%zu)\n",
+                    (long long)(snbytes / pio_mpi_nprocs_g), buf_size);
             GOTOERROR(FAIL);
         }
     }
     else {
         if (((size_t)snbytes % buf_size) != 0) {
-            HDfprintf(stderr,
-                      "Dataset side size (%lld) must be a multiple of the "
-                      "transfer buffer size (%zu)\n",
-                      (long long)snbytes, buf_size);
+            fprintf(stderr,
+                    "Dataset side size (%lld) must be a multiple of the "
+                    "transfer buffer size (%zu)\n",
+                    (long long)snbytes, buf_size);
             GOTOERROR(FAIL);
         }
     }
 
     /* Allocate transfer buffer */
     if ((buffer = malloc(bsize)) == NULL) {
-        HDfprintf(stderr, "malloc for transfer buffer size (%zu) failed\n", bsize);
+        fprintf(stderr, "malloc for transfer buffer size (%zu) failed\n", bsize);
         GOTOERROR(FAIL);
     }
 
@@ -273,7 +273,7 @@ do_pio(parameters param)
 
         /* output all of the times for all iterations */
         if (myrank == 0)
-            HDfprintf(output, "Timer details:\n");
+            fprintf(output, "Timer details:\n");
     }
 
     for (nf = 1; nf <= param.num_files; nf++) {
@@ -286,7 +286,7 @@ do_pio(parameters param)
         HDsnprintf(base_name, sizeof(base_name), "#pio_tmp_%lu", nf);
         pio_create_filename(iot, base_name, fname, FILENAME_MAX);
         if (pio_debug_level > 0)
-            HDfprintf(output, "rank %d: data filename=%s\n", pio_mpi_rank_g, fname);
+            fprintf(output, "rank %d: data filename=%s\n", pio_mpi_rank_g, fname);
 
         /* Need barrier to make sure everyone starts at the same time */
         MPI_Barrier(pio_comm_g);
@@ -621,17 +621,17 @@ do_write(results *res, file_descr *fd, parameters *parms, long ndsets, off_t nby
     if (pio_debug_level >= 4) {
         HDprint_rank(output);
         if (!parms->dim2d) {
-            HDfprintf(output,
-                      "Debug(do_write): "
-                      "buf_size=%zu, bytes_begin=%lld, bytes_count=%lld\n",
-                      buf_size, (long long)bytes_begin[0], (long long)bytes_count);
+            fprintf(output,
+                    "Debug(do_write): "
+                    "buf_size=%zu, bytes_begin=%lld, bytes_count=%lld\n",
+                    buf_size, (long long)bytes_begin[0], (long long)bytes_count);
         }
         else {
-            HDfprintf(output,
-                      "Debug(do_write): "
-                      "linear buf_size=%zu, bytes_begin=(%lld,%lld), bytes_count=%lld\n",
-                      buf_size * blk_size, (long long)bytes_begin[0], (long long)bytes_begin[1],
-                      (long long)bytes_count);
+            fprintf(output,
+                    "Debug(do_write): "
+                    "linear buf_size=%zu, bytes_begin=(%lld,%lld), bytes_count=%lld\n",
+                    buf_size * blk_size, (long long)bytes_begin[0], (long long)bytes_begin[1],
+                    (long long)bytes_count);
         }
     }
 
@@ -831,7 +831,7 @@ do_write(results *res, file_descr *fd, parameters *parms, long ndsets, off_t nby
             /* Create the dataset transfer property list */
             h5dxpl = H5Pcreate(H5P_DATASET_XFER);
             if (h5dxpl < 0) {
-                HDfprintf(stderr, "HDF5 Property List Create failed\n");
+                fprintf(stderr, "HDF5 Property List Create failed\n");
                 GOTOERROR(FAIL);
             }
 
@@ -839,7 +839,7 @@ do_write(results *res, file_descr *fd, parameters *parms, long ndsets, off_t nby
             if (parms->collective) {
                 hrc = H5Pset_dxpl_mpio(h5dxpl, H5FD_MPIO_COLLECTIVE);
                 if (hrc < 0) {
-                    HDfprintf(stderr, "HDF5 Property List Set failed\n");
+                    fprintf(stderr, "HDF5 Property List Set failed\n");
                     GOTOERROR(FAIL);
                 } /* end if */
             }     /* end if */
@@ -864,7 +864,7 @@ do_write(results *res, file_descr *fd, parameters *parms, long ndsets, off_t nby
             case PHDF5:
                 h5dcpl = H5Pcreate(H5P_DATASET_CREATE);
                 if (h5dcpl < 0) {
-                    HDfprintf(stderr, "HDF5 Property List Create failed\n");
+                    fprintf(stderr, "HDF5 Property List Create failed\n");
                     GOTOERROR(FAIL);
                 }
                 /* 1D dataspace */
@@ -875,7 +875,7 @@ do_write(results *res, file_descr *fd, parameters *parms, long ndsets, off_t nby
                         h5dims[0] = blk_size;
                         hrc       = H5Pset_chunk(h5dcpl, 1, h5dims);
                         if (hrc < 0) {
-                            HDfprintf(stderr, "HDF5 Property List Set failed\n");
+                            fprintf(stderr, "HDF5 Property List Set failed\n");
                             GOTOERROR(FAIL);
                         } /* end if */
                     }     /* end if */
@@ -888,7 +888,7 @@ do_write(results *res, file_descr *fd, parameters *parms, long ndsets, off_t nby
                         h5dims[1] = blk_size;
                         hrc       = H5Pset_chunk(h5dcpl, 2, h5dims);
                         if (hrc < 0) {
-                            HDfprintf(stderr, "HDF5 Property List Set failed\n");
+                            fprintf(stderr, "HDF5 Property List Set failed\n");
                             GOTOERROR(FAIL);
                         } /* end if */
                     }     /* end if */
@@ -898,14 +898,14 @@ do_write(results *res, file_descr *fd, parameters *parms, long ndsets, off_t nby
                 h5ds_id = H5DCREATE(fd->h5fd, dname, ELMT_H5_TYPE, h5dset_space_id, h5dcpl);
 
                 if (h5ds_id < 0) {
-                    HDfprintf(stderr, "HDF5 Dataset Create failed\n");
+                    fprintf(stderr, "HDF5 Dataset Create failed\n");
                     GOTOERROR(FAIL);
                 }
 
                 hrc = H5Pclose(h5dcpl);
                 /* verifying the close of the dcpl */
                 if (hrc < 0) {
-                    HDfprintf(stderr, "HDF5 Property List Close failed\n");
+                    fprintf(stderr, "HDF5 Property List Close failed\n");
                     GOTOERROR(FAIL);
                 }
                 break;
@@ -1407,7 +1407,7 @@ do_write(results *res, file_descr *fd, parameters *parms, long ndsets, off_t nby
             hrc = H5Dclose(h5ds_id);
 
             if (hrc < 0) {
-                HDfprintf(stderr, "HDF5 Dataset Close failed\n");
+                fprintf(stderr, "HDF5 Dataset Close failed\n");
                 GOTOERROR(FAIL);
             }
 
@@ -1464,7 +1464,7 @@ done:
     if (h5dset_space_id != -1) {
         hrc = H5Sclose(h5dset_space_id);
         if (hrc < 0) {
-            HDfprintf(stderr, "HDF5 Dataset Space Close failed\n");
+            fprintf(stderr, "HDF5 Dataset Space Close failed\n");
             ret_code = FAIL;
         }
         else {
@@ -1475,7 +1475,7 @@ done:
     if (h5mem_space_id != -1) {
         hrc = H5Sclose(h5mem_space_id);
         if (hrc < 0) {
-            HDfprintf(stderr, "HDF5 Memory Space Close failed\n");
+            fprintf(stderr, "HDF5 Memory Space Close failed\n");
             ret_code = FAIL;
         }
         else {
@@ -1486,7 +1486,7 @@ done:
     if (h5dxpl != -1) {
         hrc = H5Pclose(h5dxpl);
         if (hrc < 0) {
-            HDfprintf(stderr, "HDF5 Dataset Transfer Property List Close failed\n");
+            fprintf(stderr, "HDF5 Dataset Transfer Property List Close failed\n");
             ret_code = FAIL;
         }
         else {
@@ -1631,17 +1631,17 @@ do_read(results *res, file_descr *fd, parameters *parms, long ndsets, off_t nbyt
     if (pio_debug_level >= 4) {
         HDprint_rank(output);
         if (!parms->dim2d) {
-            HDfprintf(output,
-                      "Debug(do_write): "
-                      "buf_size=%zu, bytes_begin=%lld, bytes_count=%lld\n",
-                      buf_size, (long long)bytes_begin[0], (long long)bytes_count);
+            fprintf(output,
+                    "Debug(do_write): "
+                    "buf_size=%zu, bytes_begin=%lld, bytes_count=%lld\n",
+                    buf_size, (long long)bytes_begin[0], (long long)bytes_count);
         }
         else {
-            HDfprintf(output,
-                      "Debug(do_write): "
-                      "linear buf_size=%zu, bytes_begin=(%lld,%lld), bytes_count=%lld\n",
-                      buf_size * blk_size, (long long)bytes_begin[0], (long long)bytes_begin[1],
-                      (long long)bytes_count);
+            fprintf(output,
+                    "Debug(do_write): "
+                    "linear buf_size=%zu, bytes_begin=(%lld,%lld), bytes_count=%lld\n",
+                    buf_size * blk_size, (long long)bytes_begin[0], (long long)bytes_begin[1],
+                    (long long)bytes_count);
         }
     }
 
@@ -1839,7 +1839,7 @@ do_read(results *res, file_descr *fd, parameters *parms, long ndsets, off_t nbyt
             /* Create the dataset transfer property list */
             h5dxpl = H5Pcreate(H5P_DATASET_XFER);
             if (h5dxpl < 0) {
-                HDfprintf(stderr, "HDF5 Property List Create failed\n");
+                fprintf(stderr, "HDF5 Property List Create failed\n");
                 GOTOERROR(FAIL);
             }
 
@@ -1847,7 +1847,7 @@ do_read(results *res, file_descr *fd, parameters *parms, long ndsets, off_t nbyt
             if (parms->collective) {
                 hrc = H5Pset_dxpl_mpio(h5dxpl, H5FD_MPIO_COLLECTIVE);
                 if (hrc < 0) {
-                    HDfprintf(stderr, "HDF5 Property List Set failed\n");
+                    fprintf(stderr, "HDF5 Property List Set failed\n");
                     GOTOERROR(FAIL);
                 } /* end if */
             }     /* end if */
@@ -1873,7 +1873,7 @@ do_read(results *res, file_descr *fd, parameters *parms, long ndsets, off_t nbyt
                 HDsnprintf(dname, sizeof(dname), "Dataset_%ld", ndset);
                 h5ds_id = H5DOPEN(fd->h5fd, dname);
                 if (h5ds_id < 0) {
-                    HDfprintf(stderr, "HDF5 Dataset open failed\n");
+                    fprintf(stderr, "HDF5 Dataset open failed\n");
                     GOTOERROR(FAIL);
                 }
                 break;
@@ -2369,17 +2369,17 @@ do_read(results *res, file_descr *fd, parameters *parms, long ndsets, off_t nbyt
                         if (++nerror < 20) {
                             /* report at most 20 errors */
                             HDprint_rank(output);
-                            HDfprintf(output,
-                                      "read data error, expected (%d), "
-                                      "got (%d)\n",
-                                      pio_mpi_rank_g + 1, (int)*(ucharptr - 1));
+                            fprintf(output,
+                                    "read data error, expected (%d), "
+                                    "got (%d)\n",
+                                    pio_mpi_rank_g + 1, (int)*(ucharptr - 1));
                         } /* end if */
                     }     /* end if */
                 }         /* end for */
                 if (nerror >= 20) {
                     HDprint_rank(output);
-                    HDfprintf(output, "...");
-                    HDfprintf(output, "total read data errors=%d\n", nerror);
+                    fprintf(output, "...");
+                    fprintf(output, "total read data errors=%d\n", nerror);
                 } /* end if */
             }     /* if (parms->verify) */
 
@@ -2395,7 +2395,7 @@ do_read(results *res, file_descr *fd, parameters *parms, long ndsets, off_t nbyt
             hrc = H5Dclose(h5ds_id);
 
             if (hrc < 0) {
-                HDfprintf(stderr, "HDF5 Dataset Close failed\n");
+                fprintf(stderr, "HDF5 Dataset Close failed\n");
                 GOTOERROR(FAIL);
             }
 
@@ -2452,7 +2452,7 @@ done:
     if (h5dset_space_id != -1) {
         hrc = H5Sclose(h5dset_space_id);
         if (hrc < 0) {
-            HDfprintf(stderr, "HDF5 Dataset Space Close failed\n");
+            fprintf(stderr, "HDF5 Dataset Space Close failed\n");
             ret_code = FAIL;
         }
         else {
@@ -2463,7 +2463,7 @@ done:
     if (h5mem_space_id != -1) {
         hrc = H5Sclose(h5mem_space_id);
         if (hrc < 0) {
-            HDfprintf(stderr, "HDF5 Memory Space Close failed\n");
+            fprintf(stderr, "HDF5 Memory Space Close failed\n");
             ret_code = FAIL;
         }
         else {
@@ -2474,7 +2474,7 @@ done:
     if (h5dxpl != -1) {
         hrc = H5Pclose(h5dxpl);
         if (hrc < 0) {
-            HDfprintf(stderr, "HDF5 Dataset Transfer Property List Close failed\n");
+            fprintf(stderr, "HDF5 Dataset Transfer Property List Close failed\n");
             ret_code = FAIL;
         }
         else {
@@ -2505,7 +2505,7 @@ do_fopen(parameters *param, char *fname, file_descr *fd /*out*/, int flags)
                 fd->posixfd = POSIXOPEN(fname, O_RDONLY);
 
             if (fd->posixfd < 0) {
-                HDfprintf(stderr, "POSIX File Open failed(%s)\n", fname);
+                fprintf(stderr, "POSIX File Open failed(%s)\n", fname);
                 GOTOERROR(FAIL);
             }
 
@@ -2528,7 +2528,7 @@ do_fopen(parameters *param, char *fname, file_descr *fd /*out*/, int flags)
                                     &fd->mpifd);
 
                 if (mrc != MPI_SUCCESS) {
-                    HDfprintf(stderr, "MPI File Open failed(%s)\n", fname);
+                    fprintf(stderr, "MPI File Open failed(%s)\n", fname);
                     GOTOERROR(FAIL);
                 }
 
@@ -2536,14 +2536,14 @@ do_fopen(parameters *param, char *fname, file_descr *fd /*out*/, int flags)
                 /*filesize , set size to 0 explicitedly.    */
                 mrc = MPI_File_set_size(fd->mpifd, (MPI_Offset)0);
                 if (mrc != MPI_SUCCESS) {
-                    HDfprintf(stderr, "MPI_File_set_size failed\n");
+                    fprintf(stderr, "MPI_File_set_size failed\n");
                     GOTOERROR(FAIL);
                 }
             }
             else {
                 mrc = MPI_File_open(pio_comm_g, fname, MPI_MODE_RDONLY, h5_io_info_g, &fd->mpifd);
                 if (mrc != MPI_SUCCESS) {
-                    HDfprintf(stderr, "MPI File Open failed(%s)\n", fname);
+                    fprintf(stderr, "MPI File Open failed(%s)\n", fname);
                     GOTOERROR(FAIL);
                 }
             }
@@ -2552,19 +2552,19 @@ do_fopen(parameters *param, char *fname, file_descr *fd /*out*/, int flags)
 
         case PHDF5:
             if ((acc_tpl = H5Pcreate(H5P_FILE_ACCESS)) < 0) {
-                HDfprintf(stderr, "HDF5 Property List Create failed\n");
+                fprintf(stderr, "HDF5 Property List Create failed\n");
                 GOTOERROR(FAIL);
             }
 
             /* Set the file driver to the MPI-IO driver */
             if (H5Pset_fapl_mpio(acc_tpl, pio_comm_g, h5_io_info_g) < 0) {
-                HDfprintf(stderr, "HDF5 Property List Set failed\n");
+                fprintf(stderr, "HDF5 Property List Set failed\n");
                 GOTOERROR(FAIL);
             }
 
             /* Set the alignment of objects in HDF5 file */
             if (H5Pset_alignment(acc_tpl, param->h5_thresh, param->h5_align) < 0) {
-                HDfprintf(stderr, "HDF5 Property List Set failed\n");
+                fprintf(stderr, "HDF5 Property List Set failed\n");
                 GOTOERROR(FAIL);
             }
 
@@ -2574,13 +2574,13 @@ do_fopen(parameters *param, char *fname, file_descr *fd /*out*/, int flags)
             else
                 fd->h5fd = H5Fopen(fname, H5F_ACC_RDONLY, acc_tpl);
             if (fd->h5fd < 0) {
-                HDfprintf(stderr, "HDF5 File Create failed(%s)\n", fname);
+                fprintf(stderr, "HDF5 File Create failed(%s)\n", fname);
                 GOTOERROR(FAIL);
             }
 
             /* verifying the close of the acc_tpl */
             if (H5Pclose(acc_tpl) < 0) {
-                HDfprintf(stderr, "HDF5 Property List Close failed\n");
+                fprintf(stderr, "HDF5 Property List Close failed\n");
                 GOTOERROR(FAIL);
             }
 
@@ -2611,7 +2611,7 @@ do_fclose(iotype iot, file_descr *fd /*out*/)
             rc = POSIXCLOSE(fd->posixfd);
 
             if (rc != 0) {
-                HDfprintf(stderr, "POSIX File Close failed\n");
+                fprintf(stderr, "POSIX File Close failed\n");
                 GOTOERROR(FAIL);
             }
 
@@ -2622,7 +2622,7 @@ do_fclose(iotype iot, file_descr *fd /*out*/)
             mrc = MPI_File_close(&fd->mpifd);
 
             if (mrc != MPI_SUCCESS) {
-                HDfprintf(stderr, "MPI File close failed\n");
+                fprintf(stderr, "MPI File close failed\n");
                 GOTOERROR(FAIL);
             }
 
@@ -2633,7 +2633,7 @@ do_fclose(iotype iot, file_descr *fd /*out*/)
             hrc = H5Fclose(fd->h5fd);
 
             if (hrc < 0) {
-                HDfprintf(stderr, "HDF5 File Close failed\n");
+                fprintf(stderr, "HDF5 File Close failed\n");
                 GOTOERROR(FAIL);
             }
 
diff --git a/tools/src/h5perf/pio_perf.c b/tools/src/h5perf/pio_perf.c
index d2f5a80..393a250 100644
--- a/tools/src/h5perf/pio_perf.c
+++ b/tools/src/h5perf/pio_perf.c
@@ -224,12 +224,12 @@ main(int argc, char *argv[])
     ret = MPI_Comm_size(MPI_COMM_WORLD, &comm_world_nprocs_g);
 
     if (ret != MPI_SUCCESS) {
-        HDfprintf(stderr, "%s: MPI_Comm_size call failed\n", progname);
+        fprintf(stderr, "%s: MPI_Comm_size call failed\n", progname);
 
         if (ret == MPI_ERR_COMM)
-            HDfprintf(stderr, "invalid MPI communicator\n");
+            fprintf(stderr, "invalid MPI communicator\n");
         else
-            HDfprintf(stderr, "invalid argument\n");
+            fprintf(stderr, "invalid argument\n");
 
         exit_value = EXIT_FAILURE;
         goto finish;
@@ -238,12 +238,12 @@ main(int argc, char *argv[])
     ret = MPI_Comm_rank(MPI_COMM_WORLD, &comm_world_rank_g);
 
     if (ret != MPI_SUCCESS) {
-        HDfprintf(stderr, "%s: MPI_Comm_rank call failed\n", progname);
+        fprintf(stderr, "%s: MPI_Comm_rank call failed\n", progname);
 
         if (ret == MPI_ERR_COMM)
-            HDfprintf(stderr, "invalid MPI communicator\n");
+            fprintf(stderr, "invalid MPI communicator\n");
         else
-            HDfprintf(stderr, "invalid argument\n");
+            fprintf(stderr, "invalid argument\n");
 
         exit_value = EXIT_FAILURE;
         goto finish;
@@ -261,7 +261,7 @@ main(int argc, char *argv[])
 
     if (opts->output_file) {
         if ((output = HDfopen(opts->output_file, "w")) == NULL) {
-            HDfprintf(stderr, "%s: cannot open output file\n", progname);
+            fprintf(stderr, "%s: cannot open output file\n", progname);
             perror(opts->output_file);
             goto finish;
         }
@@ -805,7 +805,7 @@ h5_set_info_object(void)
 
                 /* actually set the darned thing */
                 if (MPI_SUCCESS != MPI_Info_set(h5_io_info_g, namep, valp)) {
-                    HDprintf("MPI_Info_set failed\n");
+                    printf("MPI_Info_set failed\n");
                     ret_value = -1;
                 }
             }
@@ -834,17 +834,17 @@ h5_dump_info_object(MPI_Info info)
     int  flag;
     int  i, nkeys;
 
-    HDprintf("Dumping MPI Info Object (up to %d bytes per item):\n", MPI_MAX_INFO_VAL);
+    printf("Dumping MPI Info Object (up to %d bytes per item):\n", MPI_MAX_INFO_VAL);
     if (info == MPI_INFO_NULL) {
-        HDprintf("object is MPI_INFO_NULL\n");
+        printf("object is MPI_INFO_NULL\n");
     }
     else {
         MPI_Info_get_nkeys(info, &nkeys);
-        HDprintf("object has %d items\n", nkeys);
+        printf("object has %d items\n", nkeys);
         for (i = 0; i < nkeys; i++) {
             MPI_Info_get_nthkey(info, i, key);
             MPI_Info_get(info, key, MPI_MAX_INFO_VAL, value, &flag);
-            HDprintf("%s=%s\n", key, value);
+            printf("%s=%s\n", key, value);
         }
     }
 }
@@ -926,8 +926,8 @@ create_comm_world(int num_procs, int *doing_pio)
     MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
 
     if (num_procs > nprocs) {
-        HDfprintf(stderr, "number of process(%d) must be <= number of processes in MPI_COMM_WORLD(%d)\n",
-                  num_procs, nprocs);
+        fprintf(stderr, "number of process(%d) must be <= number of processes in MPI_COMM_WORLD(%d)\n",
+                num_procs, nprocs);
         goto error_done;
     }
 
@@ -936,7 +936,7 @@ create_comm_world(int num_procs, int *doing_pio)
     mrc   = MPI_Comm_split(MPI_COMM_WORLD, color, myrank, &pio_comm_g);
 
     if (mrc != MPI_SUCCESS) {
-        HDfprintf(stderr, "MPI_Comm_split failed\n");
+        fprintf(stderr, "MPI_Comm_split failed\n");
         goto error_done;
     }
 
@@ -1095,28 +1095,28 @@ recover_size_and_print(long long val, const char *end)
     if (val >= ONE_KB && (val % ONE_KB) == 0) {
         if (val >= ONE_MB && (val % ONE_MB) == 0) {
             if (val >= ONE_GB && (val % ONE_GB) == 0)
-                HDfprintf(output,
-                          "%lld"
-                          "GB%s",
-                          val / ONE_GB, end);
+                fprintf(output,
+                        "%lld"
+                        "GB%s",
+                        val / ONE_GB, end);
             else
-                HDfprintf(output,
-                          "%lld"
-                          "MB%s",
-                          val / ONE_MB, end);
+                fprintf(output,
+                        "%lld"
+                        "MB%s",
+                        val / ONE_MB, end);
         }
         else {
-            HDfprintf(output,
-                      "%lld"
-                      "KB%s",
-                      val / ONE_KB, end);
+            fprintf(output,
+                    "%lld"
+                    "KB%s",
+                    val / ONE_KB, end);
         }
     }
     else {
-        HDfprintf(output,
-                  "%lld"
-                  "%s",
-                  val, end);
+        fprintf(output,
+                "%lld"
+                "%s",
+                val, end);
     }
 }
 
@@ -1124,12 +1124,12 @@ static void
 print_io_api(long io_types)
 {
     if (io_types & PIO_POSIX)
-        HDfprintf(output, "posix ");
+        fprintf(output, "posix ");
     if (io_types & PIO_MPI)
-        HDfprintf(output, "mpiio ");
+        fprintf(output, "mpiio ");
     if (io_types & PIO_HDF5)
-        HDfprintf(output, "phdf5 ");
-    HDfprintf(output, "\n");
+        fprintf(output, "phdf5 ");
+    fprintf(output, "\n");
 }
 
 static void
@@ -1138,34 +1138,34 @@ report_parameters(struct options *opts)
     int rank = comm_world_rank_g;
 
     print_version("HDF5 Library"); /* print library version */
-    HDfprintf(output, "rank %d: ==== Parameters ====\n", rank);
+    fprintf(output, "rank %d: ==== Parameters ====\n", rank);
 
-    HDfprintf(output, "rank %d: IO API=", rank);
+    fprintf(output, "rank %d: IO API=", rank);
     print_io_api(opts->io_types);
 
-    HDfprintf(output, "rank %d: Number of files=%ld\n", rank, opts->num_files);
-    HDfprintf(output, "rank %d: Number of datasets=%ld\n", rank, opts->num_dsets);
-    HDfprintf(output, "rank %d: Number of iterations=%d\n", rank, opts->num_iters);
-    HDfprintf(output, "rank %d: Number of processes=%d:%d\n", rank, opts->min_num_procs, opts->max_num_procs);
+    fprintf(output, "rank %d: Number of files=%ld\n", rank, opts->num_files);
+    fprintf(output, "rank %d: Number of datasets=%ld\n", rank, opts->num_dsets);
+    fprintf(output, "rank %d: Number of iterations=%d\n", rank, opts->num_iters);
+    fprintf(output, "rank %d: Number of processes=%d:%d\n", rank, opts->min_num_procs, opts->max_num_procs);
 
     if (opts->dim2d) {
-        HDfprintf(output, "rank %d: Number of bytes per process per dataset=", rank);
+        fprintf(output, "rank %d: Number of bytes per process per dataset=", rank);
         recover_size_and_print((long long)(opts->num_bpp * opts->num_bpp * opts->min_num_procs), ":");
         recover_size_and_print((long long)(opts->num_bpp * opts->num_bpp * opts->max_num_procs), "\n");
 
-        HDfprintf(output, "rank %d: Size of dataset(s)=", rank);
+        fprintf(output, "rank %d: Size of dataset(s)=", rank);
         recover_size_and_print((long long)(opts->num_bpp * opts->min_num_procs), "x");
         recover_size_and_print((long long)(opts->num_bpp * opts->min_num_procs), ":");
         recover_size_and_print((long long)(opts->num_bpp * opts->max_num_procs), "x");
         recover_size_and_print((long long)(opts->num_bpp * opts->max_num_procs), "\n");
 
-        HDfprintf(output, "rank %d: File size=", rank);
+        fprintf(output, "rank %d: File size=", rank);
         recover_size_and_print((long long)(squareo(opts->num_bpp * opts->min_num_procs) * opts->num_dsets),
                                ":");
         recover_size_and_print((long long)(squareo(opts->num_bpp * opts->max_num_procs) * opts->num_dsets),
                                "\n");
 
-        HDfprintf(output, "rank %d: Transfer buffer size=", rank);
+        fprintf(output, "rank %d: Transfer buffer size=", rank);
         if (opts->interleaved) {
             recover_size_and_print((long long)opts->min_xfer_size, "x");
             recover_size_and_print((long long)opts->blk_size, ":");
@@ -1178,66 +1178,66 @@ report_parameters(struct options *opts)
             recover_size_and_print((long long)opts->blk_size, "x");
             recover_size_and_print((long long)opts->max_xfer_size, "\n");
         }
-        HDfprintf(output, "rank %d: Block size=", rank);
+        fprintf(output, "rank %d: Block size=", rank);
         recover_size_and_print((long long)opts->blk_size, "x");
         recover_size_and_print((long long)opts->blk_size, "\n");
     }
     else {
-        HDfprintf(output, "rank %d: Number of bytes per process per dataset=", rank);
+        fprintf(output, "rank %d: Number of bytes per process per dataset=", rank);
         recover_size_and_print((long long)opts->num_bpp, "\n");
 
-        HDfprintf(output, "rank %d: Size of dataset(s)=", rank);
+        fprintf(output, "rank %d: Size of dataset(s)=", rank);
         recover_size_and_print((long long)(opts->num_bpp * opts->min_num_procs), ":");
         recover_size_and_print((long long)(opts->num_bpp * opts->max_num_procs), "\n");
 
-        HDfprintf(output, "rank %d: File size=", rank);
+        fprintf(output, "rank %d: File size=", rank);
         recover_size_and_print((long long)(opts->num_bpp * opts->min_num_procs * opts->num_dsets), ":");
         recover_size_and_print((long long)(opts->num_bpp * opts->max_num_procs * opts->num_dsets), "\n");
 
-        HDfprintf(output, "rank %d: Transfer buffer size=", rank);
+        fprintf(output, "rank %d: Transfer buffer size=", rank);
         recover_size_and_print((long long)opts->min_xfer_size, ":");
         recover_size_and_print((long long)opts->max_xfer_size, "\n");
-        HDfprintf(output, "rank %d: Block size=", rank);
+        fprintf(output, "rank %d: Block size=", rank);
         recover_size_and_print((long long)opts->blk_size, "\n");
     }
 
-    HDfprintf(output, "rank %d: Block Pattern in Dataset=", rank);
+    fprintf(output, "rank %d: Block Pattern in Dataset=", rank);
     if (opts->interleaved)
-        HDfprintf(output, "Interleaved\n");
+        fprintf(output, "Interleaved\n");
     else
-        HDfprintf(output, "Contiguous\n");
+        fprintf(output, "Contiguous\n");
 
-    HDfprintf(output, "rank %d: I/O Method for MPI and HDF5=", rank);
+    fprintf(output, "rank %d: I/O Method for MPI and HDF5=", rank);
     if (opts->collective)
-        HDfprintf(output, "Collective\n");
+        fprintf(output, "Collective\n");
     else
-        HDfprintf(output, "Independent\n");
+        fprintf(output, "Independent\n");
 
-    HDfprintf(output, "rank %d: Geometry=", rank);
+    fprintf(output, "rank %d: Geometry=", rank);
     if (opts->dim2d)
-        HDfprintf(output, "2D\n");
+        fprintf(output, "2D\n");
     else
-        HDfprintf(output, "1D\n");
+        fprintf(output, "1D\n");
 
-    HDfprintf(output, "rank %d: VFL used for HDF5 I/O=%s\n", rank, "MPI-IO driver");
+    fprintf(output, "rank %d: VFL used for HDF5 I/O=%s\n", rank, "MPI-IO driver");
 
-    HDfprintf(output, "rank %d: Data storage method in HDF5=", rank);
+    fprintf(output, "rank %d: Data storage method in HDF5=", rank);
     if (opts->h5_use_chunks)
-        HDfprintf(output, "Chunked\n");
+        fprintf(output, "Chunked\n");
     else
-        HDfprintf(output, "Contiguous\n");
+        fprintf(output, "Contiguous\n");
 
     {
         char *prefix = HDgetenv("HDF5_PARAPREFIX");
 
-        HDfprintf(output, "rank %d: Env HDF5_PARAPREFIX=%s\n", rank, (prefix ? prefix : "not set"));
+        fprintf(output, "rank %d: Env HDF5_PARAPREFIX=%s\n", rank, (prefix ? prefix : "not set"));
     }
 
-    HDfprintf(output, "rank %d: ", rank);
+    fprintf(output, "rank %d: ", rank);
     h5_dump_info_object(h5_io_info_g);
 
-    HDfprintf(output, "rank %d: ==== End of Parameters ====\n", rank);
-    HDfprintf(output, "\n");
+    fprintf(output, "rank %d: ==== End of Parameters ====\n", rank);
+    fprintf(output, "\n");
 }
 
 /*
@@ -1305,7 +1305,7 @@ parse_command_line(int argc, const char *const *argv)
                         cl_opts->io_types |= PIO_POSIX;
                     }
                     else {
-                        HDfprintf(stderr, "pio_perf: invalid --api option %s\n", buf);
+                        fprintf(stderr, "pio_perf: invalid --api option %s\n", buf);
                         HDexit(EXIT_FAILURE);
                     }
 
@@ -1353,7 +1353,7 @@ parse_command_line(int argc, const char *const *argv)
 
                         for (j = 0; j < 10 && buf[j] != '\0'; ++j)
                             if (!isdigit(buf[j])) {
-                                HDfprintf(stderr, "pio_perf: invalid --debug option %s\n", buf);
+                                fprintf(stderr, "pio_perf: invalid --debug option %s\n", buf);
                                 HDexit(EXIT_FAILURE);
                             }
 
@@ -1379,7 +1379,7 @@ parse_command_line(int argc, const char *const *argv)
                                 cl_opts->verify = TRUE;
                                 break;
                             default:
-                                HDfprintf(stderr, "pio_perf: invalid --debug option %s\n", buf);
+                                fprintf(stderr, "pio_perf: invalid --debug option %s\n", buf);
                                 HDexit(EXIT_FAILURE);
                         }
                     }
@@ -1523,7 +1523,7 @@ parse_size_directive(const char *size)
                 s *= ONE_GB;
                 break;
             default:
-                HDfprintf(stderr, "Illegal size specifier '%c'\n", *endptr);
+                fprintf(stderr, "Illegal size specifier '%c'\n", *endptr);
                 HDexit(EXIT_FAILURE);
         }
     }
@@ -1546,124 +1546,124 @@ usage(const char *prog)
 
     if (myrank == 0) {
         print_version(prog);
-        HDprintf("usage: %s [OPTIONS]\n", prog);
-        HDprintf("  OPTIONS\n");
-        HDprintf("     -h, --help                  Print a usage message and exit\n");
-        HDprintf("     -a S, --align=S             Alignment of objects in HDF5 file [default: 1]\n");
-        HDprintf("     -A AL, --api=AL             Which APIs to test [default: all of them]\n");
+        printf("usage: %s [OPTIONS]\n", prog);
+        printf("  OPTIONS\n");
+        printf("     -h, --help                  Print a usage message and exit\n");
+        printf("     -a S, --align=S             Alignment of objects in HDF5 file [default: 1]\n");
+        printf("     -A AL, --api=AL             Which APIs to test [default: all of them]\n");
 #if 0
-        HDprintf("     -b, --binary                The elusive binary option\n");
+        printf("     -b, --binary                The elusive binary option\n");
 #endif /* 0 */
-        HDprintf("     -B S, --block-size=S        Block size within transfer buffer\n");
-        HDprintf("                                 (see below for description)\n");
-        HDprintf("                                 [default: half the number of bytes per process\n");
-        HDprintf("                                           per dataset]\n");
-        HDprintf("     -c, --chunk                 Create HDF5 datasets using chunked storage\n");
-        HDprintf("                                 [default: contiguous storage]\n");
-        HDprintf("     -C, --collective            Use collective I/O for MPI and HDF5 APIs\n");
-        HDprintf("                                 [default: independent I/O)\n");
-        HDprintf("     -d N, --num-dsets=N         Number of datasets per file [default: 1]\n");
-        HDprintf("     -D DL, --debug=DL           Indicate the debugging level\n");
-        HDprintf("                                 [default: no debugging]\n");
-        HDprintf("     -e S, --num-bytes=S         Number of bytes per process per dataset\n");
-        HDprintf("                                 (see below for description)\n");
-        HDprintf("                                 [default: 256K for 1D, 8K for 2D]\n");
-        HDprintf("     -F N, --num-files=N         Number of files [default: 1]\n");
-        HDprintf("     -g, --geometry              Use 2D geometry [default: 1D geometry]\n");
-        HDprintf("     -i N, --num-iterations=N    Number of iterations to perform [default: 1]\n");
-        HDprintf("     -I, --interleaved           Interleaved access pattern\n");
-        HDprintf("                                 (see below for example)\n");
-        HDprintf("                                 [default: Contiguous access pattern]\n");
-        HDprintf("     -o F, --output=F            Output raw data into file F [default: none]\n");
-        HDprintf("     -p N, --min-num-processes=N Minimum number of processes to use [default: 1]\n");
-        HDprintf("     -P N, --max-num-processes=N Maximum number of processes to use\n");
-        HDprintf("                                 [default: all MPI_COMM_WORLD processes ]\n");
-        HDprintf("     -T S, --threshold=S         Threshold for alignment of objects in HDF5 file\n");
-        HDprintf("                                 [default: 1]\n");
-        HDprintf("     -w, --write-only            Perform write tests not the read tests\n");
-        HDprintf("     -x S, --min-xfer-size=S     Minimum transfer buffer size\n");
-        HDprintf("                                 (see below for description)\n");
-        HDprintf("                                 [default: half the number of bytes per process\n");
-        HDprintf("                                           per dataset]\n");
-        HDprintf("     -X S, --max-xfer-size=S     Maximum transfer buffer size\n");
-        HDprintf("                                 [default: the number of bytes per process per\n");
-        HDprintf("                                           dataset]\n");
-        HDprintf("\n");
-        HDprintf("  F  - is a filename.\n");
-        HDprintf("  N  - is an integer >=0.\n");
-        HDprintf("  S  - is a size specifier, an integer >=0 followed by a size indicator:\n");
-        HDprintf("          K - Kilobyte (%d)\n", ONE_KB);
-        HDprintf("          M - Megabyte (%d)\n", ONE_MB);
-        HDprintf("          G - Gigabyte (%d)\n", ONE_GB);
-        HDprintf("\n");
-        HDprintf("      Example: '37M' is 37 megabytes or %d bytes\n", 37 * ONE_MB);
-        HDprintf("\n");
-        HDprintf("  AL - is an API list. Valid values are:\n");
-        HDprintf("          phdf5 - Parallel HDF5\n");
-        HDprintf("          mpiio - MPI-I/O\n");
-        HDprintf("          posix - POSIX\n");
-        HDprintf("\n");
-        HDprintf("      Example: --api=mpiio,phdf5\n");
-        HDprintf("\n");
-        HDprintf("  Dataset size:\n");
-        HDprintf("      Depending on the selected geometry, each test dataset is either a linear\n");
-        HDprintf("      array of size bytes-per-process * num-processes, or a square array of size\n");
-        HDprintf("      (bytes-per-process * num-processes) x (bytes-per-process * num-processes).\n");
-        HDprintf("\n");
-        HDprintf("  Block size vs. Transfer buffer size:\n");
-        HDprintf("      buffer-size controls the size of the memory buffer, which is broken into\n");
-        HDprintf("      blocks and written to the file. Depending on the selected geometry, each\n");
-        HDprintf("      block can be a linear array of size block-size or a square array of size\n");
-        HDprintf("      block-size x block-size. The arrangement in which blocks are written is\n");
-        HDprintf("      determined by the access pattern.\n");
-        HDprintf("\n");
-        HDprintf("      In 1D geometry, the transfer buffer is a linear array of size buffer-size.\n");
-        HDprintf("      In 2D geometry, it is a rectangular array of size block-size x buffer-size\n");
-        HDprintf("      or buffer-size x block-size if interleaved pattern is selected.\n");
-        HDprintf("\n");
-        HDprintf("  Interleaved and Contiguous patterns in 1D geometry:\n");
-        HDprintf("      When contiguous access pattern is chosen, the dataset is evenly divided\n");
-        HDprintf("      into num-processes regions and each process writes data to its own region.\n");
-        HDprintf("      When interleaved blocks are written to a dataset, space for the first\n");
-        HDprintf("      block of the first process is allocated in the dataset, then space is\n");
-        HDprintf("      allocated for the first block of the second process, etc. until space is\n");
-        HDprintf("      allocated for the first block of each process, then space is allocated for\n");
-        HDprintf("      the second block of the first process, the second block of the second\n");
-        HDprintf("      process, etc.\n");
-        HDprintf("\n");
-        HDprintf("      For example, with a 3 process run, 512KB bytes-per-process, 256KB transfer\n");
-        HDprintf("        buffer size, and 64KB block size, each process must issue 2 transfer\n");
-        HDprintf("        requests to complete access to the dataset.\n");
-        HDprintf("          Contiguous blocks of the first transfer request are written like so:\n");
-        HDprintf("              1111----2222----3333----\n");
-        HDprintf("          Interleaved blocks of the first transfer request are written like so:\n");
-        HDprintf("              123123123123------------\n");
-        HDprintf("        The actual number of I/O operations involved in a transfer request\n");
-        HDprintf("        depends on the access pattern and communication mode.\n");
-        HDprintf("        When using independent I/O with interleaved pattern, each process\n");
-        HDprintf("        performs 4 small non-contiguous I/O operations per transfer request.\n");
-        HDprintf("        If collective I/O is turned on, the combined content of the buffers of\n");
-        HDprintf("        the 3 processes will be written using one collective I/O operation\n");
-        HDprintf("        per transfer request.\n");
-        HDprintf("\n");
-        HDprintf("      For information about access patterns in 2D geometry, please refer to the\n");
-        HDprintf("      HDF5 Reference Manual.\n");
-        HDprintf("\n");
-        HDprintf("  DL - is a list of debugging flags. Valid values are:\n");
-        HDprintf("          1 - Minimal\n");
-        HDprintf("          2 - Not quite everything\n");
-        HDprintf("          3 - Everything\n");
-        HDprintf("          4 - The kitchen sink\n");
-        HDprintf("          r - Raw data I/O throughput information\n");
-        HDprintf("          t - Times as well as throughputs\n");
-        HDprintf("          v - Verify data correctness\n");
-        HDprintf("\n");
-        HDprintf("      Example: --debug=2,r,t\n");
-        HDprintf("\n");
-        HDprintf("  Environment variables:\n");
-        HDprintf("  HDF5_NOCLEANUP   Do not remove data files if set [default remove]\n");
-        HDprintf("  HDF5_MPI_INFO    MPI INFO object key=value separated by ;\n");
-        HDprintf("  HDF5_PARAPREFIX  Parallel data files prefix\n");
+        printf("     -B S, --block-size=S        Block size within transfer buffer\n");
+        printf("                                 (see below for description)\n");
+        printf("                                 [default: half the number of bytes per process\n");
+        printf("                                           per dataset]\n");
+        printf("     -c, --chunk                 Create HDF5 datasets using chunked storage\n");
+        printf("                                 [default: contiguous storage]\n");
+        printf("     -C, --collective            Use collective I/O for MPI and HDF5 APIs\n");
+        printf("                                 [default: independent I/O)\n");
+        printf("     -d N, --num-dsets=N         Number of datasets per file [default: 1]\n");
+        printf("     -D DL, --debug=DL           Indicate the debugging level\n");
+        printf("                                 [default: no debugging]\n");
+        printf("     -e S, --num-bytes=S         Number of bytes per process per dataset\n");
+        printf("                                 (see below for description)\n");
+        printf("                                 [default: 256K for 1D, 8K for 2D]\n");
+        printf("     -F N, --num-files=N         Number of files [default: 1]\n");
+        printf("     -g, --geometry              Use 2D geometry [default: 1D geometry]\n");
+        printf("     -i N, --num-iterations=N    Number of iterations to perform [default: 1]\n");
+        printf("     -I, --interleaved           Interleaved access pattern\n");
+        printf("                                 (see below for example)\n");
+        printf("                                 [default: Contiguous access pattern]\n");
+        printf("     -o F, --output=F            Output raw data into file F [default: none]\n");
+        printf("     -p N, --min-num-processes=N Minimum number of processes to use [default: 1]\n");
+        printf("     -P N, --max-num-processes=N Maximum number of processes to use\n");
+        printf("                                 [default: all MPI_COMM_WORLD processes ]\n");
+        printf("     -T S, --threshold=S         Threshold for alignment of objects in HDF5 file\n");
+        printf("                                 [default: 1]\n");
+        printf("     -w, --write-only            Perform write tests not the read tests\n");
+        printf("     -x S, --min-xfer-size=S     Minimum transfer buffer size\n");
+        printf("                                 (see below for description)\n");
+        printf("                                 [default: half the number of bytes per process\n");
+        printf("                                           per dataset]\n");
+        printf("     -X S, --max-xfer-size=S     Maximum transfer buffer size\n");
+        printf("                                 [default: the number of bytes per process per\n");
+        printf("                                           dataset]\n");
+        printf("\n");
+        printf("  F  - is a filename.\n");
+        printf("  N  - is an integer >=0.\n");
+        printf("  S  - is a size specifier, an integer >=0 followed by a size indicator:\n");
+        printf("          K - Kilobyte (%d)\n", ONE_KB);
+        printf("          M - Megabyte (%d)\n", ONE_MB);
+        printf("          G - Gigabyte (%d)\n", ONE_GB);
+        printf("\n");
+        printf("      Example: '37M' is 37 megabytes or %d bytes\n", 37 * ONE_MB);
+        printf("\n");
+        printf("  AL - is an API list. Valid values are:\n");
+        printf("          phdf5 - Parallel HDF5\n");
+        printf("          mpiio - MPI-I/O\n");
+        printf("          posix - POSIX\n");
+        printf("\n");
+        printf("      Example: --api=mpiio,phdf5\n");
+        printf("\n");
+        printf("  Dataset size:\n");
+        printf("      Depending on the selected geometry, each test dataset is either a linear\n");
+        printf("      array of size bytes-per-process * num-processes, or a square array of size\n");
+        printf("      (bytes-per-process * num-processes) x (bytes-per-process * num-processes).\n");
+        printf("\n");
+        printf("  Block size vs. Transfer buffer size:\n");
+        printf("      buffer-size controls the size of the memory buffer, which is broken into\n");
+        printf("      blocks and written to the file. Depending on the selected geometry, each\n");
+        printf("      block can be a linear array of size block-size or a square array of size\n");
+        printf("      block-size x block-size. The arrangement in which blocks are written is\n");
+        printf("      determined by the access pattern.\n");
+        printf("\n");
+        printf("      In 1D geometry, the transfer buffer is a linear array of size buffer-size.\n");
+        printf("      In 2D geometry, it is a rectangular array of size block-size x buffer-size\n");
+        printf("      or buffer-size x block-size if interleaved pattern is selected.\n");
+        printf("\n");
+        printf("  Interleaved and Contiguous patterns in 1D geometry:\n");
+        printf("      When contiguous access pattern is chosen, the dataset is evenly divided\n");
+        printf("      into num-processes regions and each process writes data to its own region.\n");
+        printf("      When interleaved blocks are written to a dataset, space for the first\n");
+        printf("      block of the first process is allocated in the dataset, then space is\n");
+        printf("      allocated for the first block of the second process, etc. until space is\n");
+        printf("      allocated for the first block of each process, then space is allocated for\n");
+        printf("      the second block of the first process, the second block of the second\n");
+        printf("      process, etc.\n");
+        printf("\n");
+        printf("      For example, with a 3 process run, 512KB bytes-per-process, 256KB transfer\n");
+        printf("        buffer size, and 64KB block size, each process must issue 2 transfer\n");
+        printf("        requests to complete access to the dataset.\n");
+        printf("          Contiguous blocks of the first transfer request are written like so:\n");
+        printf("              1111----2222----3333----\n");
+        printf("          Interleaved blocks of the first transfer request are written like so:\n");
+        printf("              123123123123------------\n");
+        printf("        The actual number of I/O operations involved in a transfer request\n");
+        printf("        depends on the access pattern and communication mode.\n");
+        printf("        When using independent I/O with interleaved pattern, each process\n");
+        printf("        performs 4 small non-contiguous I/O operations per transfer request.\n");
+        printf("        If collective I/O is turned on, the combined content of the buffers of\n");
+        printf("        the 3 processes will be written using one collective I/O operation\n");
+        printf("        per transfer request.\n");
+        printf("\n");
+        printf("      For information about access patterns in 2D geometry, please refer to the\n");
+        printf("      HDF5 Reference Manual.\n");
+        printf("\n");
+        printf("  DL - is a list of debugging flags. Valid values are:\n");
+        printf("          1 - Minimal\n");
+        printf("          2 - Not quite everything\n");
+        printf("          3 - Everything\n");
+        printf("          4 - The kitchen sink\n");
+        printf("          r - Raw data I/O throughput information\n");
+        printf("          t - Times as well as throughputs\n");
+        printf("          v - Verify data correctness\n");
+        printf("\n");
+        printf("      Example: --debug=2,r,t\n");
+        printf("\n");
+        printf("  Environment variables:\n");
+        printf("  HDF5_NOCLEANUP   Do not remove data files if set [default remove]\n");
+        printf("  HDF5_MPI_INFO    MPI INFO object key=value separated by ;\n");
+        printf("  HDF5_PARAPREFIX  Parallel data files prefix\n");
         fflush(stdout);
     } /* end if */
 } /* end usage() */
@@ -1680,7 +1680,7 @@ usage(const char *prog)
 int
 main(void)
 {
-    HDprintf("No parallel IO performance because parallel is not configured\n");
+    printf("No parallel IO performance because parallel is not configured\n");
     return EXIT_SUCCESS;
 } /* end main */
 
diff --git a/tools/src/h5perf/pio_perf.h b/tools/src/h5perf/pio_perf.h
index 05f8d5b..54fbb52 100644
--- a/tools/src/h5perf/pio_perf.h
+++ b/tools/src/h5perf/pio_perf.h
@@ -86,10 +86,10 @@ extern int        pio_debug_level;     /* The debug level:
                                         *   4 - Even More Debugging (timer stuff)
                                         */
 
-#define HDprint_rank(f)      /* print rank in MPI_COMM_WORLD */ HDfprintf(f, "%d: ", comm_world_rank_g);
-#define HDprint_size(f)      /* print size of MPI_COMM_WORLD */ HDfprintf(f, "%d", comm_world_nprocs_g);
+#define HDprint_rank(f)      /* print rank in MPI_COMM_WORLD */ fprintf(f, "%d: ", comm_world_rank_g);
+#define HDprint_size(f)      /* print size of MPI_COMM_WORLD */ fprintf(f, "%d", comm_world_nprocs_g);
 #define HDprint_rank_size(f) /* print rank/size of MPI_COMM_WORLD */                                         \
-    HDfprintf(f, "%d/%d: ", comm_world_rank_g, comm_world_nprocs_g);
+    fprintf(f, "%d/%d: ", comm_world_rank_g, comm_world_nprocs_g);
 
 #ifdef __cplusplus
 extern "C" {
diff --git a/tools/src/h5perf/sio_engine.c b/tools/src/h5perf/sio_engine.c
index ca7d4ae..24c3f06 100644
--- a/tools/src/h5perf/sio_engine.c
+++ b/tools/src/h5perf/sio_engine.c
@@ -44,7 +44,7 @@
     }
 #define ERRMSG(mesg)                                                                                         \
     {                                                                                                        \
-        HDfprintf(stderr, "*** Assertion failed (%s) at line %4d in %s\n", mesg, (int)__LINE__, __FILE__);   \
+        fprintf(stderr, "*** Assertion failed (%s) at line %4d in %s\n", mesg, (int)__LINE__, __FILE__);     \
     }
 
 /* verify: if val is false (0), print mesg. */
@@ -158,7 +158,7 @@ do_sio(parameters param, results *res)
             break;
         default:
             /* unknown request */
-            HDfprintf(stderr, "Unknown IO type request (%d)\n", (int)iot);
+            fprintf(stderr, "Unknown IO type request (%d)\n", (int)iot);
             GOTOERROR(FAIL);
     }
 
@@ -173,29 +173,29 @@ do_sio(parameters param, results *res)
 
         /* Validate transfer buffer size */
         if (param.buf_size[i] <= 0) {
-            HDfprintf(stderr, "Transfer buffer size[%d] (%zu) must be > 0\n", i, buf_size[i]);
+            fprintf(stderr, "Transfer buffer size[%d] (%zu) must be > 0\n", i, buf_size[i]);
             GOTOERROR(FAIL);
         }
 
         if ((param.dset_size[i] % param.buf_size[i]) != 0) {
-            HDfprintf(stderr,
-                      "Dataset size[%d] (%lld) must be a multiple of the "
-                      "transfer buffer size[%d] (%zu)\n",
-                      param.rank, (long long)param.dset_size[i], param.rank, param.buf_size[i]);
+            fprintf(stderr,
+                    "Dataset size[%d] (%lld) must be a multiple of the "
+                    "transfer buffer size[%d] (%zu)\n",
+                    param.rank, (long long)param.dset_size[i], param.rank, param.buf_size[i]);
             GOTOERROR(FAIL);
         }
     }
 
     /* Allocate transfer buffer */
     if ((buffer = (char *)malloc(linear_buf_size)) == NULL) {
-        HDfprintf(stderr, "malloc for transfer buffer size (%zu) failed\n", linear_buf_size);
+        fprintf(stderr, "malloc for transfer buffer size (%zu) failed\n", linear_buf_size);
         GOTOERROR(FAIL);
     }
 
     if (sio_debug_level >= 4)
 
         /* output all of the times for all iterations */
-        HDfprintf(output, "Timer details:\n");
+        fprintf(output, "Timer details:\n");
 
     /*
      * Write performance measurement
@@ -206,7 +206,7 @@ do_sio(parameters param, results *res)
     sio_create_filename(iot, base_name, fname, FILENAME_MAX, &param);
 
     if (sio_debug_level > 0)
-        HDfprintf(output, "data filename=%s\n", fname);
+        fprintf(output, "data filename=%s\n", fname);
 
     io_time_set(res->timers, HDF5_GROSS_WRITE_FIXED_DIMS, TSTART);
     hrc = do_fopen(&param, fname, &fd, SIO_CREATE | SIO_WRITE);
@@ -310,7 +310,7 @@ sio_create_filename(iotype iot, const char *base_name, char *fullname, size_t si
             break;
         default:
             /* unknown request */
-            HDfprintf(stderr, "Unknown IO type request (%d)\n", (int)iot);
+            fprintf(stderr, "Unknown IO type request (%d)\n", (int)iot);
             assert(0 && "Unknown IO type");
             break;
     }
@@ -486,14 +486,14 @@ do_write(results *res, file_descr *fd, parameters *parms, void *buffer)
             /* Create the dataset transfer property list */
             h5dxpl = H5Pcreate(H5P_DATASET_XFER);
             if (h5dxpl < 0) {
-                HDfprintf(stderr, "HDF5 Property List Create failed\n");
+                fprintf(stderr, "HDF5 Property List Create failed\n");
                 GOTOERROR(FAIL);
             }
 
             break;
 
         default:
-            HDfprintf(stderr, "Unknown IO type request (%d)\n", (int)parms->io_type);
+            fprintf(stderr, "Unknown IO type request (%d)\n", (int)parms->io_type);
             GOTOERROR(FAIL);
             break;
     } /* end switch */
@@ -507,7 +507,7 @@ do_write(results *res, file_descr *fd, parameters *parms, void *buffer)
             h5dcpl = H5Pcreate(H5P_DATASET_CREATE);
 
             if (h5dcpl < 0) {
-                HDfprintf(stderr, "HDF5 Property List Create failed\n");
+                fprintf(stderr, "HDF5 Property List Create failed\n");
                 GOTOERROR(FAIL);
             }
 
@@ -515,7 +515,7 @@ do_write(results *res, file_descr *fd, parameters *parms, void *buffer)
                 /* Set the chunk size to be the same as the buffer size */
                 hrc = H5Pset_chunk(h5dcpl, rank, h5chunk);
                 if (hrc < 0) {
-                    HDfprintf(stderr, "HDF5 Property List Set failed\n");
+                    fprintf(stderr, "HDF5 Property List Set failed\n");
                     GOTOERROR(FAIL);
                 } /* end if */
             }     /* end if */
@@ -525,21 +525,21 @@ do_write(results *res, file_descr *fd, parameters *parms, void *buffer)
                 H5Dcreate2(fd->h5fd, dname, ELMT_H5_TYPE, h5dset_space_id, H5P_DEFAULT, h5dcpl, H5P_DEFAULT);
 
             if (h5ds_id < 0) {
-                HDfprintf(stderr, "HDF5 Dataset Create failed\n");
+                fprintf(stderr, "HDF5 Dataset Create failed\n");
                 GOTOERROR(FAIL);
             }
 
             hrc = H5Pclose(h5dcpl);
             /* verifying the close of the dcpl */
             if (hrc < 0) {
-                HDfprintf(stderr, "HDF5 Property List Close failed\n");
+                fprintf(stderr, "HDF5 Property List Close failed\n");
                 GOTOERROR(FAIL);
             }
             break;
 
         default:
             /* unknown request */
-            HDfprintf(stderr, "Unknown IO type request (%d)\n", (int)parms->io_type);
+            fprintf(stderr, "Unknown IO type request (%d)\n", (int)parms->io_type);
             GOTOERROR(FAIL);
             break;
     }
@@ -551,7 +551,7 @@ do_write(results *res, file_descr *fd, parameters *parms, void *buffer)
     hrc = dset_write(rank - 1, fd, parms, buffer);
 
     if (hrc < 0) {
-        HDfprintf(stderr, "Error in dataset write\n");
+        fprintf(stderr, "Error in dataset write\n");
         GOTOERROR(FAIL);
     }
 
@@ -565,7 +565,7 @@ do_write(results *res, file_descr *fd, parameters *parms, void *buffer)
         hrc = H5Dclose(h5ds_id);
 
         if (hrc < 0) {
-            HDfprintf(stderr, "HDF5 Dataset Close failed\n");
+            fprintf(stderr, "HDF5 Dataset Close failed\n");
             GOTOERROR(FAIL);
         }
 
@@ -578,7 +578,7 @@ done:
     if (h5dset_space_id != -1) {
         hrc = H5Sclose(h5dset_space_id);
         if (hrc < 0) {
-            HDfprintf(stderr, "HDF5 Dataset Space Close failed\n");
+            fprintf(stderr, "HDF5 Dataset Space Close failed\n");
             ret_code = FAIL;
         }
         else {
@@ -589,7 +589,7 @@ done:
     if (h5mem_space_id != -1) {
         hrc = H5Sclose(h5mem_space_id);
         if (hrc < 0) {
-            HDfprintf(stderr, "HDF5 Memory Space Close failed\n");
+            fprintf(stderr, "HDF5 Memory Space Close failed\n");
             ret_code = FAIL;
         }
         else {
@@ -600,7 +600,7 @@ done:
     if (h5dxpl != -1) {
         hrc = H5Pclose(h5dxpl);
         if (hrc < 0) {
-            HDfprintf(stderr, "HDF5 Dataset Transfer Property List Close failed\n");
+            fprintf(stderr, "HDF5 Dataset Transfer Property List Close failed\n");
             ret_code = FAIL;
         }
         else {
@@ -683,7 +683,7 @@ dset_write(int local_dim, file_descr *fd, parameters *parms, void *buffer)
 
                 default:
                     /* unknown request */
-                    HDfprintf(stderr, "Unknown IO type request (%d)\n", (int)parms->io_type);
+                    fprintf(stderr, "Unknown IO type request (%d)\n", (int)parms->io_type);
                     assert(0 && "Unknown IO type");
                     break;
             } /* switch (parms->io_type) */
@@ -777,7 +777,7 @@ do_read(results *res, file_descr *fd, parameters *parms, void *buffer)
 
     /* Allocate data verification buffer */
     if (NULL == (buffer2 = (char *)malloc(linear_buf_size))) {
-        HDfprintf(stderr, "malloc for data verification buffer size (%zu) failed\n", linear_buf_size);
+        fprintf(stderr, "malloc for data verification buffer size (%zu) failed\n", linear_buf_size);
         GOTOERROR(FAIL);
     } /* end if */
 
@@ -828,14 +828,14 @@ do_read(results *res, file_descr *fd, parameters *parms, void *buffer)
             /* Create the dataset transfer property list */
             h5dxpl = H5Pcreate(H5P_DATASET_XFER);
             if (h5dxpl < 0) {
-                HDfprintf(stderr, "HDF5 Property List Create failed\n");
+                fprintf(stderr, "HDF5 Property List Create failed\n");
                 GOTOERROR(FAIL);
             }
             break;
 
         default:
             /* unknown request */
-            HDfprintf(stderr, "Unknown IO type request (%d)\n", (int)parms->io_type);
+            fprintf(stderr, "Unknown IO type request (%d)\n", (int)parms->io_type);
             GOTOERROR(FAIL);
             break;
     } /* end switch */
@@ -849,14 +849,14 @@ do_read(results *res, file_descr *fd, parameters *parms, void *buffer)
             HDsnprintf(dname, sizeof(dname), "Dataset_%ld", (long)parms->num_bytes);
             h5ds_id = H5Dopen2(fd->h5fd, dname, H5P_DEFAULT);
             if (h5ds_id < 0) {
-                HDfprintf(stderr, "HDF5 Dataset open failed\n");
+                fprintf(stderr, "HDF5 Dataset open failed\n");
                 GOTOERROR(FAIL);
             }
             break;
 
         default:
             /* unknown request */
-            HDfprintf(stderr, "Unknown IO type request (%d)\n", (int)parms->io_type);
+            fprintf(stderr, "Unknown IO type request (%d)\n", (int)parms->io_type);
             GOTOERROR(FAIL);
             break;
     } /* end switch */
@@ -866,7 +866,7 @@ do_read(results *res, file_descr *fd, parameters *parms, void *buffer)
     hrc = dset_read(rank - 1, fd, parms, buffer, buffer2);
 
     if (hrc < 0) {
-        HDfprintf(stderr, "Error in dataset read\n");
+        fprintf(stderr, "Error in dataset read\n");
         GOTOERROR(FAIL);
     }
 
@@ -880,7 +880,7 @@ do_read(results *res, file_descr *fd, parameters *parms, void *buffer)
         hrc = H5Dclose(h5ds_id);
 
         if (hrc < 0) {
-            HDfprintf(stderr, "HDF5 Dataset Close failed\n");
+            fprintf(stderr, "HDF5 Dataset Close failed\n");
             GOTOERROR(FAIL);
         }
 
@@ -893,7 +893,7 @@ done:
     if (h5dset_space_id != -1) {
         hrc = H5Sclose(h5dset_space_id);
         if (hrc < 0) {
-            HDfprintf(stderr, "HDF5 Dataset Space Close failed\n");
+            fprintf(stderr, "HDF5 Dataset Space Close failed\n");
             ret_code = FAIL;
         }
         else {
@@ -904,7 +904,7 @@ done:
     if (h5mem_space_id != -1) {
         hrc = H5Sclose(h5mem_space_id);
         if (hrc < 0) {
-            HDfprintf(stderr, "HDF5 Memory Space Close failed\n");
+            fprintf(stderr, "HDF5 Memory Space Close failed\n");
             ret_code = FAIL;
         }
         else {
@@ -915,7 +915,7 @@ done:
     if (h5dxpl != -1) {
         hrc = H5Pclose(h5dxpl);
         if (hrc < 0) {
-            HDfprintf(stderr, "HDF5 Dataset Transfer Property List Close failed\n");
+            fprintf(stderr, "HDF5 Dataset Transfer Property List Close failed\n");
             ret_code = FAIL;
         }
         else {
@@ -981,7 +981,7 @@ dset_read(int local_dim, file_descr *fd, parameters *parms, void *buffer, const
 
                 default:
                     /* unknown request */
-                    HDfprintf(stderr, "Unknown IO type request (%d)\n", (int)parms->io_type);
+                    fprintf(stderr, "Unknown IO type request (%d)\n", (int)parms->io_type);
                     assert(0 && "Unknown IO type");
                     break;
             } /* switch (parms->io_type) */
@@ -1065,7 +1065,7 @@ do_fopen(parameters *param, char *fname, file_descr *fd /*out*/, int flags)
                 fd->posixfd = POSIXOPEN(fname, O_RDONLY);
 
             if (fd->posixfd < 0) {
-                HDfprintf(stderr, "POSIX File Open failed(%s)\n", fname);
+                fprintf(stderr, "POSIX File Open failed(%s)\n", fname);
                 GOTOERROR(FAIL);
             }
 
@@ -1076,7 +1076,7 @@ do_fopen(parameters *param, char *fname, file_descr *fd /*out*/, int flags)
             fapl = set_vfd(param);
 
             if (fapl < 0) {
-                HDfprintf(stderr, "HDF5 Property List Create failed\n");
+                fprintf(stderr, "HDF5 Property List Create failed\n");
                 GOTOERROR(FAIL);
             }
 
@@ -1097,14 +1097,14 @@ do_fopen(parameters *param, char *fname, file_descr *fd /*out*/, int flags)
             }
 
             if (fd->h5fd < 0) {
-                HDfprintf(stderr, "HDF5 File Create failed(%s)\n", fname);
+                fprintf(stderr, "HDF5 File Create failed(%s)\n", fname);
                 GOTOERROR(FAIL);
             }
             break;
 
         default:
             /* unknown request */
-            HDfprintf(stderr, "Unknown IO type request (%d)\n", (int)param->io_type);
+            fprintf(stderr, "Unknown IO type request (%d)\n", (int)param->io_type);
             GOTOERROR(FAIL);
             break;
     }
@@ -1227,7 +1227,7 @@ do_fclose(iotype iot, file_descr *fd /*out*/)
             rc = POSIXCLOSE(fd->posixfd);
 
             if (rc != 0) {
-                HDfprintf(stderr, "POSIX File Close failed\n");
+                fprintf(stderr, "POSIX File Close failed\n");
                 GOTOERROR(FAIL);
             }
 
@@ -1238,7 +1238,7 @@ do_fclose(iotype iot, file_descr *fd /*out*/)
             hrc = H5Fclose(fd->h5fd);
 
             if (hrc < 0) {
-                HDfprintf(stderr, "HDF5 File Close failed\n");
+                fprintf(stderr, "HDF5 File Close failed\n");
                 GOTOERROR(FAIL);
             }
 
@@ -1247,7 +1247,7 @@ do_fclose(iotype iot, file_descr *fd /*out*/)
 
         default:
             /* unknown request */
-            HDfprintf(stderr, "Unknown IO type request (%d)\n", (int)iot);
+            fprintf(stderr, "Unknown IO type request (%d)\n", (int)iot);
             GOTOERROR(FAIL);
             break;
     }
@@ -1325,7 +1325,7 @@ do_cleanupfile(iotype iot, char *filename)
 
             default:
                 /* unknown request */
-                HDfprintf(stderr, "Unknown IO type request (%d)\n", (int)iot);
+                fprintf(stderr, "Unknown IO type request (%d)\n", (int)iot);
                 assert(0 && "Unknown IO type");
                 break;
         }
diff --git a/tools/src/h5perf/sio_perf.c b/tools/src/h5perf/sio_perf.c
index 870318e..5d88cd2 100644
--- a/tools/src/h5perf/sio_perf.c
+++ b/tools/src/h5perf/sio_perf.c
@@ -203,7 +203,7 @@ main(int argc, char *argv[])
 
     if (opts->output_file) {
         if ((output = HDfopen(opts->output_file, "w")) == NULL) {
-            HDfprintf(stderr, "%s: cannot open output file\n", progname);
+            fprintf(stderr, "%s: cannot open output file\n", progname);
             HDperror(opts->output_file);
             goto finish;
         }
@@ -327,7 +327,7 @@ run_test(iotype iot, parameters parms, struct options *opts)
             break;
         default:
             /* unknown request */
-            HDfprintf(stderr, "Unknown IO type request (%d)\n", (int)iot);
+            fprintf(stderr, "Unknown IO type request (%d)\n", (int)iot);
             assert(0 && "Unknown IO tpe");
             break;
     }
@@ -662,28 +662,28 @@ recover_size_and_print(long long val, const char *end)
     if (val >= ONE_KB && (val % ONE_KB) == 0) {
         if (val >= ONE_MB && (val % ONE_MB) == 0) {
             if (val >= ONE_GB && (val % ONE_GB) == 0)
-                HDfprintf(output,
-                          "%lld"
-                          "GB%s",
-                          val / ONE_GB, end);
+                fprintf(output,
+                        "%lld"
+                        "GB%s",
+                        val / ONE_GB, end);
             else
-                HDfprintf(output,
-                          "%lld"
-                          "MB%s",
-                          val / ONE_MB, end);
+                fprintf(output,
+                        "%lld"
+                        "MB%s",
+                        val / ONE_MB, end);
         }
         else {
-            HDfprintf(output,
-                      "%lld"
-                      "KB%s",
-                      val / ONE_KB, end);
+            fprintf(output,
+                    "%lld"
+                    "KB%s",
+                    val / ONE_KB, end);
         }
     }
     else {
-        HDfprintf(output,
-                  "%lld"
-                  "%s",
-                  val, end);
+        fprintf(output,
+                "%lld"
+                "%s",
+                val, end);
     }
 }
 
@@ -691,10 +691,10 @@ static void
 print_io_api(long io_types)
 {
     if (io_types & SIO_POSIX)
-        HDfprintf(output, "posix ");
+        fprintf(output, "posix ");
     if (io_types & SIO_HDF5)
-        HDfprintf(output, "hdf5 ");
-    HDfprintf(output, "\n");
+        fprintf(output, "hdf5 ");
+    fprintf(output, "\n");
 }
 
 static void
@@ -704,95 +704,95 @@ report_parameters(struct options *opts)
     rank = opts->dset_rank;
 
     print_version("HDF5 Library"); /* print library version */
-    HDfprintf(output, "==== Parameters ====\n");
+    fprintf(output, "==== Parameters ====\n");
 
-    HDfprintf(output, "IO API=");
+    fprintf(output, "IO API=");
     print_io_api(opts->io_types);
 
-    HDfprintf(output, "Number of iterations=%d\n", opts->num_iters);
+    fprintf(output, "Number of iterations=%d\n", opts->num_iters);
 
-    HDfprintf(output, "Dataset size=");
+    fprintf(output, "Dataset size=");
 
     for (i = 0; i < rank; i++)
         recover_size_and_print((long long)opts->dset_size[i], " ");
-    HDfprintf(output, "\n");
+    fprintf(output, "\n");
 
-    HDfprintf(output, "Transfer buffer size=");
+    fprintf(output, "Transfer buffer size=");
     for (i = 0; i < rank; i++)
         recover_size_and_print((long long)opts->buf_size[i], " ");
-    HDfprintf(output, "\n");
+    fprintf(output, "\n");
 
     if (opts->page_size) {
-        HDfprintf(output, "Page Aggregation Enabled. Page size = %zu\n", opts->page_size);
+        fprintf(output, "Page Aggregation Enabled. Page size = %zu\n", opts->page_size);
         if (opts->page_buffer_size)
-            HDfprintf(output, "Page Buffering Enabled. Page Buffer size = %zu\n", opts->page_buffer_size);
+            fprintf(output, "Page Buffering Enabled. Page Buffer size = %zu\n", opts->page_buffer_size);
         else
-            HDfprintf(output, "Page Buffering Disabled\n");
+            fprintf(output, "Page Buffering Disabled\n");
     }
     else
-        HDfprintf(output, "Page Aggregation Disabled\n");
+        fprintf(output, "Page Aggregation Disabled\n");
 
-    HDfprintf(output, "Dimension access order=");
+    fprintf(output, "Dimension access order=");
     for (i = 0; i < rank; i++)
         recover_size_and_print((long long)opts->order[i], " ");
-    HDfprintf(output, "\n");
+    fprintf(output, "\n");
 
     if (opts->io_types & SIO_HDF5) {
 
-        HDfprintf(output, "HDF5 data storage method=");
+        fprintf(output, "HDF5 data storage method=");
 
         if (opts->h5_use_chunks) {
 
-            HDfprintf(output, "Chunked\n");
-            HDfprintf(output, "HDF5 chunk size=");
+            fprintf(output, "Chunked\n");
+            fprintf(output, "HDF5 chunk size=");
             for (i = 0; i < rank; i++)
                 recover_size_and_print((long long)opts->chk_size[i], " ");
-            HDfprintf(output, "\n");
+            fprintf(output, "\n");
 
-            HDfprintf(output, "HDF5 dataset dimensions=");
+            fprintf(output, "HDF5 dataset dimensions=");
             if (opts->h5_extendable) {
-                HDfprintf(output, "Extendable\n");
+                fprintf(output, "Extendable\n");
             }
             else {
-                HDfprintf(output, "Fixed\n");
+                fprintf(output, "Fixed\n");
             }
         }
         else {
-            HDfprintf(output, "Contiguous\n");
+            fprintf(output, "Contiguous\n");
         }
 
-        HDfprintf(output, "HDF5 file driver=");
+        fprintf(output, "HDF5 file driver=");
         if (opts->vfd == sec2) {
-            HDfprintf(output, "sec2\n");
+            fprintf(output, "sec2\n");
         }
         else if (opts->vfd == stdio) {
-            HDfprintf(output, "stdio\n");
+            fprintf(output, "stdio\n");
         }
         else if (opts->vfd == core) {
-            HDfprintf(output, "core\n");
+            fprintf(output, "core\n");
         }
         else if (opts->vfd == split) {
-            HDfprintf(output, "split\n");
+            fprintf(output, "split\n");
         }
         else if (opts->vfd == multi) {
-            HDfprintf(output, "multi\n");
+            fprintf(output, "multi\n");
         }
         else if (opts->vfd == family) {
-            HDfprintf(output, "family\n");
+            fprintf(output, "family\n");
         }
         else if (opts->vfd == direct) {
-            HDfprintf(output, "direct\n");
+            fprintf(output, "direct\n");
         }
     }
 
     {
         char *prefix = HDgetenv("HDF5_PREFIX");
 
-        HDfprintf(output, "Env HDF5_PREFIX=%s\n", (prefix ? prefix : "not set"));
+        fprintf(output, "Env HDF5_PREFIX=%s\n", (prefix ? prefix : "not set"));
     }
 
-    HDfprintf(output, "==== End of Parameters ====\n");
-    HDfprintf(output, "\n");
+    fprintf(output, "==== End of Parameters ====\n");
+    fprintf(output, "\n");
 }
 
 /*
@@ -872,7 +872,7 @@ parse_command_line(int argc, const char *const *argv)
                         cl_opts->io_types |= SIO_POSIX;
                     }
                     else {
-                        HDfprintf(stderr, "sio_perf: invalid --api option %s\n", buf);
+                        fprintf(stderr, "sio_perf: invalid --api option %s\n", buf);
                         HDexit(EXIT_FAILURE);
                     }
 
@@ -936,7 +936,7 @@ parse_command_line(int argc, const char *const *argv)
 
                         for (j = 0; j < 10 && buf[j] != '\0'; ++j)
                             if (!HDisdigit(buf[j])) {
-                                HDfprintf(stderr, "sio_perf: invalid --debug option %s\n", buf);
+                                fprintf(stderr, "sio_perf: invalid --debug option %s\n", buf);
                                 HDexit(EXIT_FAILURE);
                             }
 
@@ -962,7 +962,7 @@ parse_command_line(int argc, const char *const *argv)
                                 cl_opts->verify = TRUE;
                                 break;
                             default:
-                                HDfprintf(stderr, "sio_perf: invalid --debug option %s\n", buf);
+                                fprintf(stderr, "sio_perf: invalid --debug option %s\n", buf);
                                 HDexit(EXIT_FAILURE);
                         }
                     }
@@ -1034,7 +1034,7 @@ parse_command_line(int argc, const char *const *argv)
                     cl_opts->vfd = direct;
                 }
                 else {
-                    HDfprintf(stderr, "sio_perf: invalid --api option %s\n", H5_optarg);
+                    fprintf(stderr, "sio_perf: invalid --api option %s\n", H5_optarg);
                     HDexit(EXIT_FAILURE);
                 }
                 break;
@@ -1198,7 +1198,7 @@ parse_size_directive(const char *size)
                 break;
 
             default:
-                HDfprintf(stderr, "Illegal size specifier '%c'\n", *endptr);
+                fprintf(stderr, "Illegal size specifier '%c'\n", *endptr);
                 HDexit(EXIT_FAILURE);
         }
     }
@@ -1216,70 +1216,70 @@ static void
 usage(const char *prog)
 {
     print_version(prog);
-    HDprintf("usage: %s [OPTIONS]\n", prog);
-    HDprintf("  OPTIONS\n");
-    HDprintf("     -h                Print an usage message and exit\n");
-    HDprintf("     -A AL             Which APIs to test\n");
-    HDprintf("                       [default: all of them]\n");
-    HDprintf("     -c SL             Selects chunked storage and defines chunks dimensions\n");
-    HDprintf("                       and sizes\n");
-    HDprintf("                       [default: Off]\n");
-    HDprintf("     -e SL             Dimensions and sizes of dataset\n");
-    HDprintf("                       [default: 100,200]\n");
-    HDprintf("     -i N              Number of iterations to perform\n");
-    HDprintf("                       [default: 1]\n");
-    HDprintf("     -r NL             Dimension access order (see below for description)\n");
-    HDprintf("                       [default: 1,2]\n");
-    HDprintf("     -t                Selects extendable dimensions for HDF5 dataset\n");
-    HDprintf("                       [default: Off]\n");
-    HDprintf("     -v VFD            Selects file driver for HDF5 access\n");
-    HDprintf("                       [default: sec2]\n");
-    HDprintf("     -w                Perform write tests, not the read tests\n");
-    HDprintf("                       [default: Off]\n");
-    HDprintf("     -x SL             Dimensions and sizes of the transfer buffer\n");
-    HDprintf("                       [default: 10,20]\n");
-    HDprintf("\n");
-    HDprintf("  N  - is an integer > 0.\n");
-    HDprintf("\n");
-    HDprintf("  S  - is a size specifier, an integer > 0 followed by a size indicator:\n");
-    HDprintf("          K - Kilobyte (%d)\n", ONE_KB);
-    HDprintf("          M - Megabyte (%d)\n", ONE_MB);
-    HDprintf("          G - Gigabyte (%d)\n", ONE_GB);
-    HDprintf("\n");
-    HDprintf("      Example: '37M' is 37 megabytes or %d bytes\n", 37 * ONE_MB);
-    HDprintf("\n");
-    HDprintf("  AL - is an API list. Valid values are:\n");
-    HDprintf("          hdf5 - HDF5\n");
-    HDprintf("          posix - POSIX\n");
-    HDprintf("\n");
-    HDprintf("      Example: -A posix,hdf5\n");
-    HDprintf("\n");
-    HDprintf("  NL - is list of integers (N) separated by commas.\n");
-    HDprintf("\n");
-    HDprintf("      Example: 1,2,3\n");
-    HDprintf("\n");
-    HDprintf("  SL - is list of size specifiers (S) separated by commas.\n");
-    HDprintf("\n");
-    HDprintf("      Example: 2K,2K,3K\n");
-    HDprintf("\n");
-    HDprintf("      The example defines an object (dataset, transfer buffer) with three\n");
-    HDprintf("      dimensions. Be aware that as the number of dimensions increases, the\n");
-    HDprintf("      the total size of the object increases exponentially.\n");
-    HDprintf("\n");
-    HDprintf("  VFD  - is an HDF5 file driver specifier. Valid values are:\n");
-    HDprintf("          sec2, stdio, core, split, multi, family, direct\n");
-    HDprintf("\n");
-    HDprintf("  Dimension access order:\n");
-    HDprintf("      Data access starts at the cardinal origin of the dataset using the\n");
-    HDprintf("      transfer buffer. The next access occurs on a dataset region next to\n");
-    HDprintf("      the previous one. For a multidimensional dataset, there are several\n");
-    HDprintf("      directions as to where to proceed. This can be specified in the dimension\n");
-    HDprintf("      access order. For example, -r 1,2 states that the tool should traverse\n");
-    HDprintf("      dimension 1 first, and then dimension 2.\n");
-    HDprintf("\n");
-    HDprintf("  Environment variables:\n");
-    HDprintf("      HDF5_NOCLEANUP   Do not remove data files if set [default remove]\n");
-    HDprintf("      HDF5_PREFIX      Data file prefix\n");
-    HDprintf("\n");
+    printf("usage: %s [OPTIONS]\n", prog);
+    printf("  OPTIONS\n");
+    printf("     -h                Print an usage message and exit\n");
+    printf("     -A AL             Which APIs to test\n");
+    printf("                       [default: all of them]\n");
+    printf("     -c SL             Selects chunked storage and defines chunks dimensions\n");
+    printf("                       and sizes\n");
+    printf("                       [default: Off]\n");
+    printf("     -e SL             Dimensions and sizes of dataset\n");
+    printf("                       [default: 100,200]\n");
+    printf("     -i N              Number of iterations to perform\n");
+    printf("                       [default: 1]\n");
+    printf("     -r NL             Dimension access order (see below for description)\n");
+    printf("                       [default: 1,2]\n");
+    printf("     -t                Selects extendable dimensions for HDF5 dataset\n");
+    printf("                       [default: Off]\n");
+    printf("     -v VFD            Selects file driver for HDF5 access\n");
+    printf("                       [default: sec2]\n");
+    printf("     -w                Perform write tests, not the read tests\n");
+    printf("                       [default: Off]\n");
+    printf("     -x SL             Dimensions and sizes of the transfer buffer\n");
+    printf("                       [default: 10,20]\n");
+    printf("\n");
+    printf("  N  - is an integer > 0.\n");
+    printf("\n");
+    printf("  S  - is a size specifier, an integer > 0 followed by a size indicator:\n");
+    printf("          K - Kilobyte (%d)\n", ONE_KB);
+    printf("          M - Megabyte (%d)\n", ONE_MB);
+    printf("          G - Gigabyte (%d)\n", ONE_GB);
+    printf("\n");
+    printf("      Example: '37M' is 37 megabytes or %d bytes\n", 37 * ONE_MB);
+    printf("\n");
+    printf("  AL - is an API list. Valid values are:\n");
+    printf("          hdf5 - HDF5\n");
+    printf("          posix - POSIX\n");
+    printf("\n");
+    printf("      Example: -A posix,hdf5\n");
+    printf("\n");
+    printf("  NL - is list of integers (N) separated by commas.\n");
+    printf("\n");
+    printf("      Example: 1,2,3\n");
+    printf("\n");
+    printf("  SL - is list of size specifiers (S) separated by commas.\n");
+    printf("\n");
+    printf("      Example: 2K,2K,3K\n");
+    printf("\n");
+    printf("      The example defines an object (dataset, transfer buffer) with three\n");
+    printf("      dimensions. Be aware that as the number of dimensions increases, the\n");
+    printf("      the total size of the object increases exponentially.\n");
+    printf("\n");
+    printf("  VFD  - is an HDF5 file driver specifier. Valid values are:\n");
+    printf("          sec2, stdio, core, split, multi, family, direct\n");
+    printf("\n");
+    printf("  Dimension access order:\n");
+    printf("      Data access starts at the cardinal origin of the dataset using the\n");
+    printf("      transfer buffer. The next access occurs on a dataset region next to\n");
+    printf("      the previous one. For a multidimensional dataset, there are several\n");
+    printf("      directions as to where to proceed. This can be specified in the dimension\n");
+    printf("      access order. For example, -r 1,2 states that the tool should traverse\n");
+    printf("      dimension 1 first, and then dimension 2.\n");
+    printf("\n");
+    printf("  Environment variables:\n");
+    printf("      HDF5_NOCLEANUP   Do not remove data files if set [default remove]\n");
+    printf("      HDF5_PREFIX      Data file prefix\n");
+    printf("\n");
     HDfflush(stdout);
 } /* end usage() */