Fix Werror issues, whitespace, casts and unused vars

3 files changed, 278 insertions, 281 deletions

diff --git a/testpar/t_bigio.c b/testpar/t_bigio.c
index 9ca077c..65f785b 100644
--- a/testpar/t_bigio.c
+++ b/testpar/t_bigio.c
@@ -14,7 +14,7 @@ const char *FILENAME[2]={ "bigio_test.h5",
 /* Define some handy debugging shorthands, routines, ... */
 /* debugging tools */
 
-#define MAINPROCESS     (!mpi_rank) /* define process 0 as main process */
+#define MAIN_PROCESS (mpi_rank_g == 0) /* define process 0 as main process */
 
 /* Constants definitions */
 #define RANK        2
@@ -40,16 +40,15 @@ typedef hsize_t B_DATATYPE;
 
 int facc_type = FACC_MPIO;        /*Test file access type */
 int dxfer_coll_type = DXFER_COLLECTIVE_IO;
-size_t bigcount = DXFER_BIGCOUNT;
+size_t bigcount = (size_t)DXFER_BIGCOUNT;
 int nerrors = 0;
-int mpi_size, mpi_rank;
+static int mpi_size_g, mpi_rank_g;
 
 hsize_t space_dim1 = SPACE_DIM1 * 256; // 4096
 hsize_t space_dim2 = SPACE_DIM2;
 
 static void coll_chunktest(const char* filename, int chunk_factor, int select_factor,
                            int api_option, int file_selection, int mem_selection, int mode);
-hid_t create_faccess_plist(MPI_Comm comm, MPI_Info info, int l_facc_type);
 
 /*
  * Setup the coordinates for point selection.
@@ -246,7 +245,7 @@ ccslab_set(int mpi_rank,
     stride[1] =  1;
     count[0]  =  space_dim1;
     count[1]  =  space_dim2;
-    start[0]  =  mpi_rank*count[0];
+    start[0]  =  (hsize_t)mpi_rank*count[0];
     start[1]  =  0;
 
     break;
@@ -255,11 +254,11 @@ ccslab_set(int mpi_rank,
     /* Each process takes several disjoint blocks. */
     block[0]  =  1;
     block[1]  =  1;
-        stride[0] =  3;
-        stride[1] =  3;
-        count[0]  =  space_dim1/(stride[0]*block[0]);
-        count[1]  =  (space_dim2)/(stride[1]*block[1]);
-    start[0]  =  space_dim1*mpi_rank;
+    stride[0] =  3;
+    stride[1] =  3;
+    count[0]  =  space_dim1/(stride[0]*block[0]);
+    count[1]  =  (space_dim2)/(stride[1]*block[1]);
+    start[0]  =  space_dim1*(hsize_t)mpi_rank;
     start[1]  =  0;
 
     break;
@@ -273,7 +272,7 @@ ccslab_set(int mpi_rank,
     stride[1] =  1;
     count[0]  =  ((mpi_rank >= MAX(1,(mpi_size-2)))?0:space_dim1);
     count[1]  =  space_dim2;
-    start[0]  =  mpi_rank*count[0];
+    start[0]  =  (hsize_t)mpi_rank*count[0];
     start[1]  =  0;
 
     break;
@@ -284,14 +283,14 @@ ccslab_set(int mpi_rank,
          half of the domain. */
 
         block[0]  = 1;
-    count[0]  = 2;
-        stride[0] = space_dim1*mpi_size/4+1;
+        count[0]  = 2;
+        stride[0] = (hsize_t)(space_dim1*(hsize_t)mpi_size/4+1);
         block[1]  = space_dim2;
         count[1]  = 1;
         start[1]  = 0;
         stride[1] = 1;
-    if((mpi_rank *3)<(mpi_size*2)) start[0]  = mpi_rank;
-    else start[0] = 1 + space_dim1*mpi_size/2 + (mpi_rank-2*mpi_size/3);
+        if((mpi_rank *3)<(mpi_size*2)) start[0]  = (hsize_t)mpi_rank;
+        else start[0] = 1 + space_dim1*(hsize_t)mpi_size/2 + (hsize_t)(mpi_rank-2*mpi_size/3);
         break;
 
     case BYROW_SELECTINCHUNK:
@@ -299,18 +298,18 @@ ccslab_set(int mpi_rank,
 
         block[0] = 1;
         count[0] = 1;
-    start[0] = mpi_rank*space_dim1;
+        start[0] = (hsize_t)mpi_rank*space_dim1;
         stride[0]= 1;
-    block[1] = space_dim2;
-    count[1] = 1;
-    stride[1]= 1;
-    start[1] = 0;
+        block[1] = space_dim2;
+        count[1] = 1;
+        stride[1]= 1;
+        start[1] = 0;
 
         break;
 
     default:
     /* Unknown mode.  Set it to cover the whole dataset. */
-    block[0]  = space_dim1*mpi_size;
+    block[0]  = space_dim1*(hsize_t)mpi_size;
     block[1]  = space_dim2;
     stride[0] = block[0];
     stride[1] = block[1];
@@ -478,75 +477,72 @@ static void
 dataset_big_write(void)
 {
 
-    hid_t xfer_plist;        /* Dataset transfer properties list */
-    hid_t sid;           /* Dataspace ID */
-    hid_t file_dataspace;    /* File dataspace ID */
-    hid_t mem_dataspace;    /* memory dataspace ID */
+    hid_t xfer_plist;                 /* Dataset transfer properties list */
+    hid_t sid;                        /* Dataspace ID */
+    hid_t file_dataspace;             /* File dataspace ID */
+    hid_t mem_dataspace;              /* memory dataspace ID */
     hid_t dataset;
-    hid_t datatype;        /* Datatype ID */
-    hsize_t dims[RANK];       /* dataset dim sizes */
-    hsize_t start[RANK];            /* for hyperslab setting */
-    hsize_t count[RANK], stride[RANK];        /* for hyperslab setting */
-    hsize_t block[RANK];            /* for hyperslab setting */
+    hsize_t dims[RANK];               /* dataset dim sizes */
+    hsize_t start[RANK];              /* for hyperslab setting */
+    hsize_t count[RANK],stride[RANK]; /* for hyperslab setting */
+    hsize_t block[RANK];              /* for hyperslab setting */
     hsize_t *coords = NULL;
-    int i;
-    herr_t ret;             /* Generic return value */
-    hid_t fid;                  /* HDF5 file ID */
-    hid_t acc_tpl;        /* File access templates */
-    hsize_t h;
+    herr_t ret;                       /* Generic return value */
+    hid_t fid;                        /* HDF5 file ID */
+    hid_t acc_tpl;                    /* File access templates */
     size_t num_points;
     B_DATATYPE * wdata;
 
 
     /* allocate memory for data buffer */
     wdata = (B_DATATYPE *)HDmalloc(bigcount*sizeof(B_DATATYPE));
-    VRFY((wdata != NULL), "wdata malloc succeeded");
+    VRFY_G((wdata != NULL), "wdata malloc succeeded");
 
     /* setup file access template */
     acc_tpl = H5Pcreate (H5P_FILE_ACCESS);
-    VRFY((acc_tpl >= 0), "H5P_FILE_ACCESS");
+    VRFY_G((acc_tpl >= 0), "H5P_FILE_ACCESS");
     H5Pset_fapl_mpio(acc_tpl, MPI_COMM_WORLD, MPI_INFO_NULL);
 
     /* create the file collectively */
     fid = H5Fcreate(FILENAME[0], H5F_ACC_TRUNC, H5P_DEFAULT, acc_tpl);
-    VRFY((fid >= 0), "H5Fcreate succeeded");
+    VRFY_G((fid >= 0), "H5Fcreate succeeded");
 
     /* Release file-access template */
     ret = H5Pclose(acc_tpl);
-    VRFY((ret >= 0), "");
+    VRFY_G((ret >= 0), "");
 
 
     /* Each process takes a slabs of rows. */
-    if (mpi_rank == 0)
+    if (mpi_rank_g == 0)
         HDprintf("\nTesting Dataset1 write by ROW\n");
     /* Create a large dataset */
     dims[0] = bigcount;
-    dims[1] = mpi_size;
+    dims[1] = (hsize_t)mpi_size_g;
 
     sid = H5Screate_simple (RANK, dims, NULL);
-    VRFY((sid >= 0), "H5Screate_simple succeeded");
+    VRFY_G((sid >= 0), "H5Screate_simple succeeded");
     dataset = H5Dcreate2(fid, DATASET1, H5T_NATIVE_LLONG, sid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
-    VRFY((dataset >= 0), "H5Dcreate2 succeeded");
+    VRFY_G((dataset >= 0), "H5Dcreate2 succeeded");
     H5Sclose(sid);
 
-    block[0] = dims[0]/mpi_size;
+    block[0] = dims[0]/(hsize_t)mpi_size_g;
     block[1] = dims[1];
     stride[0] = block[0];
     stride[1] = block[1];
     count[0] = 1;
     count[1] = 1;
-    start[0] = mpi_rank*block[0];
+    start[0] = (hsize_t)mpi_rank_g*block[0];
     start[1] = 0;
 
     /* create a file dataspace independently */
     file_dataspace = H5Dget_space (dataset);
-    VRFY((file_dataspace >= 0), "H5Dget_space succeeded");
+    VRFY_G((file_dataspace >= 0), "H5Dget_space succeeded");
     ret = H5Sselect_hyperslab(file_dataspace, H5S_SELECT_SET, start, stride, count, block);
-    VRFY((ret >= 0), "H5Sset_hyperslab succeeded");
+    VRFY_G((ret >= 0), "H5Sset_hyperslab succeeded");
 
     /* create a memory dataspace independently */
     mem_dataspace = H5Screate_simple (RANK, block, NULL);
-    VRFY((mem_dataspace >= 0), "");
+    VRFY_G((mem_dataspace >= 0), "");
 
     /* fill the local slab with some trivial data */
     fill_datasets(start, block, wdata);
@@ -558,17 +554,17 @@ dataset_big_write(void)
 
     /* set up the collective transfer properties list */
     xfer_plist = H5Pcreate (H5P_DATASET_XFER);
-    VRFY((xfer_plist >= 0), "H5Pcreate xfer succeeded");
+    VRFY_G((xfer_plist >= 0), "H5Pcreate xfer succeeded");
     ret = H5Pset_dxpl_mpio(xfer_plist, H5FD_MPIO_COLLECTIVE);
-    VRFY((ret >= 0), "H5Pset_dxpl_mpio succeeded");
+    VRFY_G((ret >= 0), "H5Pset_dxpl_mpio succeeded");
     if(dxfer_coll_type == DXFER_INDEPENDENT_IO) {
         ret = H5Pset_dxpl_mpio_collective_opt(xfer_plist,H5FD_MPIO_INDIVIDUAL_IO);
-        VRFY((ret>= 0),"set independent IO collectively succeeded");
+        VRFY_G((ret>= 0),"set independent IO collectively succeeded");
     }
 
     ret = H5Dwrite(dataset, H5T_NATIVE_LLONG, mem_dataspace, file_dataspace,
                    xfer_plist, wdata);
-    VRFY((ret >= 0), "H5Dwrite dataset1 succeeded");
+    VRFY_G((ret >= 0), "H5Dwrite dataset1 succeeded");
 
     /* release all temporary handles. */
     H5Sclose(file_dataspace);
@@ -576,40 +572,40 @@ dataset_big_write(void)
     H5Pclose(xfer_plist);
 
     ret = H5Dclose(dataset);
-    VRFY((ret >= 0), "H5Dclose1 succeeded");
+    VRFY_G((ret >= 0), "H5Dclose1 succeeded");
 
 
     /* Each process takes a slabs of cols. */
-    if (mpi_rank == 0)
+    if (mpi_rank_g == 0)
         HDprintf("\nTesting Dataset2 write by COL\n");
     /* Create a large dataset */
     dims[0] = bigcount;
-    dims[1] = mpi_size;
+    dims[1] = (hsize_t)mpi_size_g;
 
     sid = H5Screate_simple (RANK, dims, NULL);
-    VRFY((sid >= 0), "H5Screate_simple succeeded");
+    VRFY_G((sid >= 0), "H5Screate_simple succeeded");
     dataset = H5Dcreate2(fid, DATASET2, H5T_NATIVE_LLONG, sid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
-    VRFY((dataset >= 0), "H5Dcreate2 succeeded");
+    VRFY_G((dataset >= 0), "H5Dcreate2 succeeded");
     H5Sclose(sid);
 
     block[0] = dims[0];
-    block[1] = dims[1]/mpi_size;
+    block[1] = dims[1]/(hsize_t)mpi_size_g;
     stride[0] = block[0];
     stride[1] = block[1];
     count[0] = 1;
     count[1] = 1;
     start[0] = 0;
-    start[1] = mpi_rank*block[1];
+    start[1] = (hsize_t)mpi_rank_g*block[1];
 
     /* create a file dataspace independently */
     file_dataspace = H5Dget_space (dataset);
-    VRFY((file_dataspace >= 0), "H5Dget_space succeeded");
+    VRFY_G((file_dataspace >= 0), "H5Dget_space succeeded");
     ret = H5Sselect_hyperslab(file_dataspace, H5S_SELECT_SET, start, stride, count, block);
-    VRFY((ret >= 0), "H5Sset_hyperslab succeeded");
+    VRFY_G((ret >= 0), "H5Sset_hyperslab succeeded");
 
     /* create a memory dataspace independently */
     mem_dataspace = H5Screate_simple (RANK, block, NULL);
-    VRFY((mem_dataspace >= 0), "");
+    VRFY_G((mem_dataspace >= 0), "");
 
     /* fill the local slab with some trivial data */
     fill_datasets(start, block, wdata);
@@ -621,17 +617,17 @@ dataset_big_write(void)
 
     /* set up the collective transfer properties list */
     xfer_plist = H5Pcreate (H5P_DATASET_XFER);
-    VRFY((xfer_plist >= 0), "H5Pcreate xfer succeeded");
+    VRFY_G((xfer_plist >= 0), "H5Pcreate xfer succeeded");
     ret = H5Pset_dxpl_mpio(xfer_plist, H5FD_MPIO_COLLECTIVE);
-    VRFY((ret >= 0), "H5Pset_dxpl_mpio succeeded");
+    VRFY_G((ret >= 0), "H5Pset_dxpl_mpio succeeded");
     if(dxfer_coll_type == DXFER_INDEPENDENT_IO) {
         ret = H5Pset_dxpl_mpio_collective_opt(xfer_plist,H5FD_MPIO_INDIVIDUAL_IO);
-        VRFY((ret>= 0),"set independent IO collectively succeeded");
+        VRFY_G((ret>= 0),"set independent IO collectively succeeded");
     }
 
     ret = H5Dwrite(dataset, H5T_NATIVE_LLONG, mem_dataspace, file_dataspace,
                    xfer_plist, wdata);
-    VRFY((ret >= 0), "H5Dwrite dataset1 succeeded");
+    VRFY_G((ret >= 0), "H5Dwrite dataset1 succeeded");
 
     /* release all temporary handles. */
     H5Sclose(file_dataspace);
@@ -639,51 +635,51 @@ dataset_big_write(void)
     H5Pclose(xfer_plist);
 
     ret = H5Dclose(dataset);
-    VRFY((ret >= 0), "H5Dclose1 succeeded");
+    VRFY_G((ret >= 0), "H5Dclose1 succeeded");
 
 
 
     /* ALL selection */
-    if (mpi_rank == 0)
+    if (mpi_rank_g == 0)
         HDprintf("\nTesting Dataset3 write select ALL proc 0, NONE others\n");
     /* Create a large dataset */
     dims[0] = bigcount;
     dims[1] = 1;
 
     sid = H5Screate_simple (RANK, dims, NULL);
-    VRFY((sid >= 0), "H5Screate_simple succeeded");
+    VRFY_G((sid >= 0), "H5Screate_simple succeeded");
     dataset = H5Dcreate2(fid, DATASET3, H5T_NATIVE_LLONG, sid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
-    VRFY((dataset >= 0), "H5Dcreate2 succeeded");
+    VRFY_G((dataset >= 0), "H5Dcreate2 succeeded");
     H5Sclose(sid);
 
     /* create a file dataspace independently */
     file_dataspace = H5Dget_space (dataset);
-    VRFY((file_dataspace >= 0), "H5Dget_space succeeded");
-    if(mpi_rank == 0) {
+    VRFY_G((file_dataspace >= 0), "H5Dget_space succeeded");
+    if(mpi_rank_g == 0) {
         ret = H5Sselect_all(file_dataspace);
-        VRFY((ret >= 0), "H5Sset_all succeeded");
+        VRFY_G((ret >= 0), "H5Sset_all succeeded");
     }
     else {
         ret = H5Sselect_none(file_dataspace);
-        VRFY((ret >= 0), "H5Sset_none succeeded");
+        VRFY_G((ret >= 0), "H5Sset_none succeeded");
     }
 
     /* create a memory dataspace independently */
     mem_dataspace = H5Screate_simple (RANK, dims, NULL);
-    VRFY((mem_dataspace >= 0), "");
-    if(mpi_rank != 0) {
+    VRFY_G((mem_dataspace >= 0), "");
+    if(mpi_rank_g != 0) {
         ret = H5Sselect_none(mem_dataspace);
-        VRFY((ret >= 0), "H5Sset_none succeeded");
+        VRFY_G((ret >= 0), "H5Sset_none succeeded");
     }
 
     /* set up the collective transfer properties list */
     xfer_plist = H5Pcreate (H5P_DATASET_XFER);
-    VRFY((xfer_plist >= 0), "H5Pcreate xfer succeeded");
+    VRFY_G((xfer_plist >= 0), "H5Pcreate xfer succeeded");
     ret = H5Pset_dxpl_mpio(xfer_plist, H5FD_MPIO_COLLECTIVE);
-    VRFY((ret >= 0), "H5Pset_dxpl_mpio succeeded");
+    VRFY_G((ret >= 0), "H5Pset_dxpl_mpio succeeded");
     if(dxfer_coll_type == DXFER_INDEPENDENT_IO) {
         ret = H5Pset_dxpl_mpio_collective_opt(xfer_plist,H5FD_MPIO_INDIVIDUAL_IO);
-        VRFY((ret>= 0),"set independent IO collectively succeeded");
+        VRFY_G((ret>= 0),"set independent IO collectively succeeded");
     }
 
     /* fill the local slab with some trivial data */
@@ -695,7 +691,7 @@ dataset_big_write(void)
 
     ret = H5Dwrite(dataset, H5T_NATIVE_LLONG, mem_dataspace, file_dataspace,
                    xfer_plist, wdata);
-    VRFY((ret >= 0), "H5Dwrite dataset1 succeeded");
+    VRFY_G((ret >= 0), "H5Dwrite dataset1 succeeded");
 
     /* release all temporary handles. */
     H5Sclose(file_dataspace);
@@ -703,19 +699,19 @@ dataset_big_write(void)
     H5Pclose(xfer_plist);
 
     ret = H5Dclose(dataset);
-    VRFY((ret >= 0), "H5Dclose1 succeeded");
+    VRFY_G((ret >= 0), "H5Dclose1 succeeded");
 
     /* Point selection */
-    if (mpi_rank == 0)
+    if (mpi_rank_g == 0)
         HDprintf("\nTesting Dataset4 write point selection\n");
     /* Create a large dataset */
     dims[0] = bigcount;
-    dims[1] = mpi_size * 4;
+    dims[1] = (hsize_t)(mpi_size_g * 4);
 
     sid = H5Screate_simple (RANK, dims, NULL);
-    VRFY((sid >= 0), "H5Screate_simple succeeded");
+    VRFY_G((sid >= 0), "H5Screate_simple succeeded");
     dataset = H5Dcreate2(fid, DATASET4, H5T_NATIVE_LLONG, sid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
-    VRFY((dataset >= 0), "H5Dcreate2 succeeded");
+    VRFY_G((dataset >= 0), "H5Dcreate2 succeeded");
     H5Sclose(sid);
 
     block[0] = dims[0]/2;
@@ -725,19 +721,19 @@ dataset_big_write(void)
     count[0] = 1;
     count[1] = 1;
     start[0] = 0;
-    start[1] = dims[1]/mpi_size * mpi_rank;
+    start[1] = dims[1]/(hsize_t)mpi_size_g * (hsize_t)mpi_rank_g;
 
     num_points = bigcount;
 
     coords = (hsize_t *)HDmalloc(num_points * RANK * sizeof(hsize_t));
-    VRFY((coords != NULL), "coords malloc succeeded");
+    VRFY_G((coords != NULL), "coords malloc succeeded");
 
     set_coords (start, count, stride, block, num_points, coords, IN_ORDER);
     /* create a file dataspace */
     file_dataspace = H5Dget_space (dataset);
-    VRFY((file_dataspace >= 0), "H5Dget_space succeeded");
+    VRFY_G((file_dataspace >= 0), "H5Dget_space succeeded");
     ret = H5Sselect_elements(file_dataspace, H5S_SELECT_SET, num_points, coords);
-    VRFY((ret >= 0), "H5Sselect_elements succeeded");
+    VRFY_G((ret >= 0), "H5Sselect_elements succeeded");
 
     if(coords) free(coords);
 
@@ -754,21 +750,21 @@ dataset_big_write(void)
      * appears to cause problems with 32 bit compilers.
      */
     mem_dataspace = H5Screate_simple (1, dims, NULL);
-    VRFY((mem_dataspace >= 0), "");
+    VRFY_G((mem_dataspace >= 0), "");
 
     /* set up the collective transfer properties list */
     xfer_plist = H5Pcreate (H5P_DATASET_XFER);
-    VRFY((xfer_plist >= 0), "H5Pcreate xfer succeeded");
+    VRFY_G((xfer_plist >= 0), "H5Pcreate xfer succeeded");
     ret = H5Pset_dxpl_mpio(xfer_plist, H5FD_MPIO_COLLECTIVE);
-    VRFY((ret >= 0), "H5Pset_dxpl_mpio succeeded");
+    VRFY_G((ret >= 0), "H5Pset_dxpl_mpio succeeded");
     if(dxfer_coll_type == DXFER_INDEPENDENT_IO) {
         ret = H5Pset_dxpl_mpio_collective_opt(xfer_plist,H5FD_MPIO_INDIVIDUAL_IO);
-        VRFY((ret>= 0),"set independent IO collectively succeeded");
+        VRFY_G((ret>= 0),"set independent IO collectively succeeded");
     }
 
     ret = H5Dwrite(dataset, H5T_NATIVE_LLONG, mem_dataspace, file_dataspace,
                    xfer_plist, wdata);
-    VRFY((ret >= 0), "H5Dwrite dataset1 succeeded");
+    VRFY_G((ret >= 0), "H5Dwrite dataset1 succeeded");
 
     /* release all temporary handles. */
     H5Sclose(file_dataspace);
@@ -776,7 +772,7 @@ dataset_big_write(void)
     H5Pclose(xfer_plist);
 
     ret = H5Dclose(dataset);
-    VRFY((ret >= 0), "H5Dclose1 succeeded");
+    VRFY_G((ret >= 0), "H5Dclose1 succeeded");
 
     HDfree(wdata);
     H5Fclose(fid);
@@ -806,60 +802,58 @@ dataset_big_read(void)
     hsize_t start[RANK];            /* for hyperslab setting */
     hsize_t count[RANK], stride[RANK];        /* for hyperslab setting */
     hsize_t block[RANK];            /* for hyperslab setting */
-    int i,j,k;
-    hsize_t h;
     size_t num_points;
     hsize_t *coords = NULL;
     herr_t ret;             /* Generic return value */
 
     /* allocate memory for data buffer */
     rdata = (B_DATATYPE *)HDmalloc(bigcount*sizeof(B_DATATYPE));
-    VRFY((rdata != NULL), "rdata malloc succeeded");
+    VRFY_G((rdata != NULL), "rdata malloc succeeded");
     wdata = (B_DATATYPE *)HDmalloc(bigcount*sizeof(B_DATATYPE));
-    VRFY((wdata != NULL), "wdata malloc succeeded");
+    VRFY_G((wdata != NULL), "wdata malloc succeeded");
 
     HDmemset(rdata, 0, bigcount*sizeof(B_DATATYPE));
 
     /* setup file access template */
     acc_tpl = H5Pcreate (H5P_FILE_ACCESS);
-    VRFY((acc_tpl >= 0), "H5P_FILE_ACCESS");
+    VRFY_G((acc_tpl >= 0), "H5P_FILE_ACCESS");
     H5Pset_fapl_mpio(acc_tpl, MPI_COMM_WORLD, MPI_INFO_NULL);
 
     /* open the file collectively */
     fid=H5Fopen(FILENAME[0],H5F_ACC_RDONLY,acc_tpl);
-    VRFY((fid >= 0), "H5Fopen succeeded");
+    VRFY_G((fid >= 0), "H5Fopen succeeded");
 
     /* Release file-access template */
     ret = H5Pclose(acc_tpl);
-    VRFY((ret >= 0), "");
+    VRFY_G((ret >= 0), "");
 
-    if (mpi_rank == 0)
+    if (mpi_rank_g == 0)
         HDprintf("\nRead Testing Dataset1 by COL\n");
 
     dataset = H5Dopen2(fid, DATASET1, H5P_DEFAULT);
-    VRFY((dataset >= 0), "H5Dopen2 succeeded");
+    VRFY_G((dataset >= 0), "H5Dopen2 succeeded");
 
     dims[0] = bigcount;
-    dims[1] = mpi_size;
+    dims[1] = (hsize_t)mpi_size_g;
     /* Each process takes a slabs of cols. */
     block[0] = dims[0];
-    block[1] = dims[1]/mpi_size;
+    block[1] = dims[1]/(hsize_t)mpi_size_g;
     stride[0] = block[0];
     stride[1] = block[1];
     count[0] = 1;
     count[1] = 1;
     start[0] = 0;
-    start[1] = mpi_rank*block[1];
+    start[1] = (hsize_t)mpi_rank_g*block[1];
 
     /* create a file dataspace independently */
     file_dataspace = H5Dget_space (dataset);
-    VRFY((file_dataspace >= 0), "H5Dget_space succeeded");
+    VRFY_G((file_dataspace >= 0), "H5Dget_space succeeded");
     ret = H5Sselect_hyperslab(file_dataspace, H5S_SELECT_SET, start, stride, count, block);
-    VRFY((ret >= 0), "H5Sset_hyperslab succeeded");
+    VRFY_G((ret >= 0), "H5Sset_hyperslab succeeded");
 
     /* create a memory dataspace independently */
     mem_dataspace = H5Screate_simple (RANK, block, NULL);
-    VRFY((mem_dataspace >= 0), "");
+    VRFY_G((mem_dataspace >= 0), "");
 
     /* fill dataset with test data */
     fill_datasets(start, block, wdata);
@@ -870,18 +864,18 @@ dataset_big_read(void)
 
     /* set up the collective transfer properties list */
     xfer_plist = H5Pcreate (H5P_DATASET_XFER);
-    VRFY((xfer_plist >= 0), "");
+    VRFY_G((xfer_plist >= 0), "");
     ret = H5Pset_dxpl_mpio(xfer_plist, H5FD_MPIO_COLLECTIVE);
-    VRFY((ret >= 0), "H5Pcreate xfer succeeded");
+    VRFY_G((ret >= 0), "H5Pcreate xfer succeeded");
     if(dxfer_coll_type == DXFER_INDEPENDENT_IO) {
         ret = H5Pset_dxpl_mpio_collective_opt(xfer_plist,H5FD_MPIO_INDIVIDUAL_IO);
-        VRFY((ret>= 0),"set independent IO collectively succeeded");
+        VRFY_G((ret>= 0),"set independent IO collectively succeeded");
     }
 
     /* read data collectively */
     ret = H5Dread(dataset, H5T_NATIVE_LLONG, mem_dataspace, file_dataspace,
                   xfer_plist, rdata);
-    VRFY((ret >= 0), "H5Dread dataset1 succeeded");
+    VRFY_G((ret >= 0), "H5Dread dataset1 succeeded");
 
     /* verify the read data with original expected data */
     ret = verify_data(start, count, stride, block, rdata, wdata);
@@ -892,36 +886,36 @@ dataset_big_read(void)
     H5Sclose(mem_dataspace);
     H5Pclose(xfer_plist);
     ret = H5Dclose(dataset);
-    VRFY((ret >= 0), "H5Dclose1 succeeded");
+    VRFY_G((ret >= 0), "H5Dclose1 succeeded");
 
 
-    if (mpi_rank == 0)
+    if (mpi_rank_g == 0)
         HDprintf("\nRead Testing Dataset2 by ROW\n");
     HDmemset(rdata, 0, bigcount*sizeof(B_DATATYPE));
     dataset = H5Dopen2(fid, DATASET2, H5P_DEFAULT);
-    VRFY((dataset >= 0), "H5Dopen2 succeeded");
+    VRFY_G((dataset >= 0), "H5Dopen2 succeeded");
 
     dims[0] = bigcount;
-    dims[1] = mpi_size;
+    dims[1] = (hsize_t)mpi_size_g;
     /* Each process takes a slabs of rows. */
-    block[0] = dims[0]/mpi_size;
+    block[0] = dims[0]/(hsize_t)mpi_size_g;
     block[1] = dims[1];
     stride[0] = block[0];
     stride[1] = block[1];
     count[0] = 1;
     count[1] = 1;
-    start[0] = mpi_rank*block[0];
+    start[0] = (hsize_t)mpi_rank_g*block[0];
     start[1] = 0;
 
     /* create a file dataspace independently */
     file_dataspace = H5Dget_space (dataset);
-    VRFY((file_dataspace >= 0), "H5Dget_space succeeded");
+    VRFY_G((file_dataspace >= 0), "H5Dget_space succeeded");
     ret = H5Sselect_hyperslab(file_dataspace, H5S_SELECT_SET, start, stride, count, block);
-    VRFY((ret >= 0), "H5Sset_hyperslab succeeded");
+    VRFY_G((ret >= 0), "H5Sset_hyperslab succeeded");
 
     /* create a memory dataspace independently */
     mem_dataspace = H5Screate_simple (RANK, block, NULL);
-    VRFY((mem_dataspace >= 0), "");
+    VRFY_G((mem_dataspace >= 0), "");
 
     /* fill dataset with test data */
     fill_datasets(start, block, wdata);
@@ -932,18 +926,18 @@ dataset_big_read(void)
 
     /* set up the collective transfer properties list */
     xfer_plist = H5Pcreate (H5P_DATASET_XFER);
-    VRFY((xfer_plist >= 0), "");
+    VRFY_G((xfer_plist >= 0), "");
     ret = H5Pset_dxpl_mpio(xfer_plist, H5FD_MPIO_COLLECTIVE);
-    VRFY((ret >= 0), "H5Pcreate xfer succeeded");
+    VRFY_G((ret >= 0), "H5Pcreate xfer succeeded");
     if(dxfer_coll_type == DXFER_INDEPENDENT_IO) {
         ret = H5Pset_dxpl_mpio_collective_opt(xfer_plist,H5FD_MPIO_INDIVIDUAL_IO);
-        VRFY((ret>= 0),"set independent IO collectively succeeded");
+        VRFY_G((ret>= 0),"set independent IO collectively succeeded");
     }
 
     /* read data collectively */
     ret = H5Dread(dataset, H5T_NATIVE_LLONG, mem_dataspace, file_dataspace,
                   xfer_plist, rdata);
-    VRFY((ret >= 0), "H5Dread dataset2 succeeded");
+    VRFY_G((ret >= 0), "H5Dread dataset2 succeeded");
 
     /* verify the read data with original expected data */
     ret = verify_data(start, count, stride, block, rdata, wdata);
@@ -954,35 +948,35 @@ dataset_big_read(void)
     H5Sclose(mem_dataspace);
     H5Pclose(xfer_plist);
     ret = H5Dclose(dataset);
-    VRFY((ret >= 0), "H5Dclose1 succeeded");
+    VRFY_G((ret >= 0), "H5Dclose1 succeeded");
 
-    if (mpi_rank == 0)
+    if (mpi_rank_g == 0)
         HDprintf("\nRead Testing Dataset3 read select ALL proc 0, NONE others\n");
     HDmemset(rdata, 0, bigcount*sizeof(B_DATATYPE));
     dataset = H5Dopen2(fid, DATASET3, H5P_DEFAULT);
-    VRFY((dataset >= 0), "H5Dopen2 succeeded");
+    VRFY_G((dataset >= 0), "H5Dopen2 succeeded");
 
     dims[0] = bigcount;
     dims[1] = 1;
 
     /* create a file dataspace independently */
     file_dataspace = H5Dget_space (dataset);
-    VRFY((file_dataspace >= 0), "H5Dget_space succeeded");
-    if(mpi_rank == 0) {
+    VRFY_G((file_dataspace >= 0), "H5Dget_space succeeded");
+    if(mpi_rank_g == 0) {
         ret = H5Sselect_all(file_dataspace);
-        VRFY((ret >= 0), "H5Sset_all succeeded");
+        VRFY_G((ret >= 0), "H5Sset_all succeeded");
     }
     else {
         ret = H5Sselect_none(file_dataspace);
-        VRFY((ret >= 0), "H5Sset_none succeeded");
+        VRFY_G((ret >= 0), "H5Sset_none succeeded");
     }
 
     /* create a memory dataspace independently */
     mem_dataspace = H5Screate_simple (RANK, dims, NULL);
-    VRFY((mem_dataspace >= 0), "");
-    if(mpi_rank != 0) {
+    VRFY_G((mem_dataspace >= 0), "");
+    if(mpi_rank_g != 0) {
         ret = H5Sselect_none(mem_dataspace);
-        VRFY((ret >= 0), "H5Sset_none succeeded");
+        VRFY_G((ret >= 0), "H5Sset_none succeeded");
     }
 
     /* fill dataset with test data */
@@ -994,20 +988,20 @@ dataset_big_read(void)
 
     /* set up the collective transfer properties list */
     xfer_plist = H5Pcreate (H5P_DATASET_XFER);
-    VRFY((xfer_plist >= 0), "");
+    VRFY_G((xfer_plist >= 0), "");
     ret = H5Pset_dxpl_mpio(xfer_plist, H5FD_MPIO_COLLECTIVE);
-    VRFY((ret >= 0), "H5Pcreate xfer succeeded");
+    VRFY_G((ret >= 0), "H5Pcreate xfer succeeded");
     if(dxfer_coll_type == DXFER_INDEPENDENT_IO) {
         ret = H5Pset_dxpl_mpio_collective_opt(xfer_plist,H5FD_MPIO_INDIVIDUAL_IO);
-        VRFY((ret>= 0),"set independent IO collectively succeeded");
+        VRFY_G((ret>= 0),"set independent IO collectively succeeded");
     }
 
     /* read data collectively */
     ret = H5Dread(dataset, H5T_NATIVE_LLONG, mem_dataspace, file_dataspace,
                   xfer_plist, rdata);
-    VRFY((ret >= 0), "H5Dread dataset3 succeeded");
+    VRFY_G((ret >= 0), "H5Dread dataset3 succeeded");
 
-    if(mpi_rank == 0) {
+    if(mpi_rank_g == 0) {
         /* verify the read data with original expected data */
         ret = verify_data(start, count, stride, block, rdata, wdata);
         if(ret) {HDfprintf(stderr, "verify failed\n"); exit(1);}
@@ -1018,15 +1012,15 @@ dataset_big_read(void)
     H5Sclose(mem_dataspace);
     H5Pclose(xfer_plist);
     ret = H5Dclose(dataset);
-    VRFY((ret >= 0), "H5Dclose1 succeeded");
+    VRFY_G((ret >= 0), "H5Dclose1 succeeded");
 
-    if (mpi_rank == 0)
+    if (mpi_rank_g == 0)
         HDprintf("\nRead Testing Dataset4 with Point selection\n");
     dataset = H5Dopen2(fid, DATASET4, H5P_DEFAULT);
-    VRFY((dataset >= 0), "H5Dopen2 succeeded");
+    VRFY_G((dataset >= 0), "H5Dopen2 succeeded");
 
     dims[0] = bigcount;
-    dims[1] = mpi_size * 4;
+    dims[1] = (hsize_t)(mpi_size_g * 4);
 
     block[0] = dims[0]/2;
     block[1] = 2;
@@ -1035,7 +1029,7 @@ dataset_big_read(void)
     count[0] = 1;
     count[1] = 1;
     start[0] = 0;
-    start[1] = dims[1]/mpi_size * mpi_rank;
+    start[1] = dims[1]/(hsize_t)mpi_size_g * (hsize_t)mpi_rank_g;
 
     fill_datasets(start, block, wdata);
     MESG("data_array initialized");
@@ -1047,14 +1041,14 @@ dataset_big_read(void)
     num_points = bigcount;
 
     coords = (hsize_t *)HDmalloc(num_points * RANK * sizeof(hsize_t));
-    VRFY((coords != NULL), "coords malloc succeeded");
+    VRFY_G((coords != NULL), "coords malloc succeeded");
 
     set_coords (start, count, stride, block, num_points, coords, IN_ORDER);
     /* create a file dataspace */
     file_dataspace = H5Dget_space (dataset);
-    VRFY((file_dataspace >= 0), "H5Dget_space succeeded");
+    VRFY_G((file_dataspace >= 0), "H5Dget_space succeeded");
     ret = H5Sselect_elements(file_dataspace, H5S_SELECT_SET, num_points, coords);
-    VRFY((ret >= 0), "H5Sselect_elements succeeded");
+    VRFY_G((ret >= 0), "H5Sselect_elements succeeded");
 
     if(coords) HDfree(coords);
 
@@ -1064,22 +1058,22 @@ dataset_big_read(void)
      * appears to cause problems with 32 bit compilers.
      */
     mem_dataspace = H5Screate_simple (1, dims, NULL);
-    VRFY((mem_dataspace >= 0), "");
+    VRFY_G((mem_dataspace >= 0), "");
 
     /* set up the collective transfer properties list */
     xfer_plist = H5Pcreate (H5P_DATASET_XFER);
-    VRFY((xfer_plist >= 0), "");
+    VRFY_G((xfer_plist >= 0), "");
     ret = H5Pset_dxpl_mpio(xfer_plist, H5FD_MPIO_COLLECTIVE);
-    VRFY((ret >= 0), "H5Pcreate xfer succeeded");
+    VRFY_G((ret >= 0), "H5Pcreate xfer succeeded");
     if(dxfer_coll_type == DXFER_INDEPENDENT_IO) {
         ret = H5Pset_dxpl_mpio_collective_opt(xfer_plist,H5FD_MPIO_INDIVIDUAL_IO);
-        VRFY((ret>= 0),"set independent IO collectively succeeded");
+        VRFY_G((ret>= 0),"set independent IO collectively succeeded");
     }
 
     /* read data collectively */
     ret = H5Dread(dataset, H5T_NATIVE_LLONG, mem_dataspace, file_dataspace,
                   xfer_plist, rdata);
-    VRFY((ret >= 0), "H5Dread dataset1 succeeded");
+    VRFY_G((ret >= 0), "H5Dread dataset1 succeeded");
 
     ret = verify_data(start, count, stride, block, rdata, wdata);
     if(ret) {HDfprintf(stderr, "verify failed\n"); exit(1);}
@@ -1089,7 +1083,7 @@ dataset_big_read(void)
     H5Sclose(mem_dataspace);
     H5Pclose(xfer_plist);
     ret = H5Dclose(dataset);
-    VRFY((ret >= 0), "H5Dclose1 succeeded");
+    VRFY_G((ret >= 0), "H5Dclose1 succeeded");
 
     HDfree(wdata);
     HDfree(rdata);
@@ -1110,7 +1104,7 @@ dataset_big_read(void)
     if (xfer_plist != -1) H5Pclose(xfer_plist);
     if (dataset != -1) {
         ret = H5Dclose(dataset);
-        VRFY((ret >= 0), "H5Dclose1 succeeded");
+        VRFY_G((ret >= 0), "H5Dclose1 succeeded");
     }
     H5Fclose(fid);
 
@@ -1135,7 +1129,7 @@ create_faccess_plist(MPI_Comm comm, MPI_Info info, int l_facc_type)
     MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
 
     ret_pl = H5Pcreate (H5P_FILE_ACCESS);
-    VRFY((ret_pl >= 0), "H5P_FILE_ACCESS");
+    VRFY_G((ret_pl >= 0), "H5P_FILE_ACCESS");
 
     if (l_facc_type == FACC_DEFAULT)
     return (ret_pl);
@@ -1143,11 +1137,11 @@ create_faccess_plist(MPI_Comm comm, MPI_Info info, int l_facc_type)
     if (l_facc_type == FACC_MPIO){
     /* set Parallel access with communicator */
     ret = H5Pset_fapl_mpio(ret_pl, comm, info);
-    VRFY((ret >= 0), "");
+    VRFY_G((ret >= 0), "");
         ret = H5Pset_all_coll_metadata_ops(ret_pl, TRUE);
-    VRFY((ret >= 0), "");
+    VRFY_G((ret >= 0), "");
         ret = H5Pset_coll_metadata_write(ret_pl, TRUE);
-    VRFY((ret >= 0), "");
+    VRFY_G((ret >= 0), "");
     return(ret_pl);
     }
 
@@ -1155,17 +1149,17 @@ create_faccess_plist(MPI_Comm comm, MPI_Info info, int l_facc_type)
     hid_t mpio_pl;
 
     mpio_pl = H5Pcreate (H5P_FILE_ACCESS);
-    VRFY((mpio_pl >= 0), "");
+    VRFY_G((mpio_pl >= 0), "");
     /* set Parallel access with communicator */
     ret = H5Pset_fapl_mpio(mpio_pl, comm, info);
-    VRFY((ret >= 0), "");
+    VRFY_G((ret >= 0), "");
 
     /* setup file access template */
     ret_pl = H5Pcreate (H5P_FILE_ACCESS);
-    VRFY((ret_pl >= 0), "");
+    VRFY_G((ret_pl >= 0), "");
     /* set Parallel access with communicator */
     ret = H5Pset_fapl_split(ret_pl, ".meta", mpio_pl, ".raw", mpio_pl);
-    VRFY((ret >= 0), "H5Pset_fapl_split succeeded");
+    VRFY_G((ret >= 0), "H5Pset_fapl_split succeeded");
     H5Pclose(mpio_pl);
     return(ret_pl);
     }
@@ -1214,7 +1208,7 @@ void
 coll_chunk1(void)
 {
     const char *filename = FILENAME[0];
-    if (mpi_rank == 0)
+    if (mpi_rank_g == 0)
         HDprintf("coll_chunk1\n");
 
     coll_chunktest(filename, 1, BYROW_CONT, API_NONE, HYPER, HYPER, OUT_OF_ORDER);
@@ -1268,7 +1262,7 @@ void
 coll_chunk2(void)
 {
     const char *filename = FILENAME[0];
-    if (mpi_rank == 0)
+    if (mpi_rank_g == 0)
         HDprintf("coll_chunk2\n");
 
     coll_chunktest(filename, 1, BYROW_DISCONT, API_NONE, HYPER, HYPER, OUT_OF_ORDER);
@@ -1323,18 +1317,18 @@ void
 coll_chunk3(void)
 {
     const char *filename = FILENAME[0];
-    if (mpi_rank == 0)
+    if (mpi_rank_g == 0)
         HDprintf("coll_chunk3\n");
 
-    coll_chunktest(filename, mpi_size, BYROW_CONT, API_NONE, HYPER, HYPER, OUT_OF_ORDER);
-    coll_chunktest(filename, mpi_size, BYROW_CONT, API_NONE, HYPER, POINT, OUT_OF_ORDER);
-    coll_chunktest(filename, mpi_size, BYROW_CONT, API_NONE, POINT, ALL, OUT_OF_ORDER);
-    coll_chunktest(filename, mpi_size, BYROW_CONT, API_NONE, POINT, POINT, OUT_OF_ORDER);
-    coll_chunktest(filename, mpi_size, BYROW_CONT, API_NONE, POINT, HYPER, OUT_OF_ORDER);
+    coll_chunktest(filename, mpi_size_g, BYROW_CONT, API_NONE, HYPER, HYPER, OUT_OF_ORDER);
+    coll_chunktest(filename, mpi_size_g, BYROW_CONT, API_NONE, HYPER, POINT, OUT_OF_ORDER);
+    coll_chunktest(filename, mpi_size_g, BYROW_CONT, API_NONE, POINT, ALL, OUT_OF_ORDER);
+    coll_chunktest(filename, mpi_size_g, BYROW_CONT, API_NONE, POINT, POINT, OUT_OF_ORDER);
+    coll_chunktest(filename, mpi_size_g, BYROW_CONT, API_NONE, POINT, HYPER, OUT_OF_ORDER);
 
-    coll_chunktest(filename, mpi_size, BYROW_CONT, API_NONE, POINT, ALL, IN_ORDER);
-    coll_chunktest(filename, mpi_size, BYROW_CONT, API_NONE, POINT, POINT, IN_ORDER);
-    coll_chunktest(filename, mpi_size, BYROW_CONT, API_NONE, POINT, HYPER, IN_ORDER);
+    coll_chunktest(filename, mpi_size_g, BYROW_CONT, API_NONE, POINT, ALL, IN_ORDER);
+    coll_chunktest(filename, mpi_size_g, BYROW_CONT, API_NONE, POINT, POINT, IN_ORDER);
+    coll_chunktest(filename, mpi_size_g, BYROW_CONT, API_NONE, POINT, HYPER, IN_ORDER);
 }
 
 
@@ -1395,34 +1389,33 @@ coll_chunktest(const char* filename,
 
   size_t  num_points;           /* for point selection */
   hsize_t *coords = NULL;       /* for point selection */
-  int i;
 
   /* Create the data space */
 
   acc_plist = create_faccess_plist(comm,info,facc_type);
-  VRFY((acc_plist >= 0),"");
+  VRFY_G((acc_plist >= 0),"");
 
   file = H5Fcreate(filename,H5F_ACC_TRUNC,H5P_DEFAULT,acc_plist);
-  VRFY((file >= 0),"H5Fcreate succeeded");
+  VRFY_G((file >= 0),"H5Fcreate succeeded");
 
   status = H5Pclose(acc_plist);
-  VRFY((status >= 0),"");
+  VRFY_G((status >= 0),"");
 
   /* setup dimensionality object */
-  dims[0] = space_dim1*mpi_size;
+  dims[0] = space_dim1*(hsize_t)mpi_size_g;
   dims[1] = space_dim2;
 
   /* allocate memory for data buffer */
   data_array1 = (int *)HDmalloc(dims[0] * dims[1] * sizeof(int));
-  VRFY((data_array1 != NULL), "data_array1 malloc succeeded");
+  VRFY_G((data_array1 != NULL), "data_array1 malloc succeeded");
 
   /* set up dimensions of the slab this process accesses */
-  ccslab_set(mpi_rank, mpi_size, start, count, stride, block, select_factor);
+  ccslab_set(mpi_rank_g, mpi_size_g, start, count, stride, block, select_factor);
 
   /* set up the coords array selection */
   num_points = block[0] * block[1] * count[0] * count[1];
   coords = (hsize_t *)HDmalloc(num_points * RANK * sizeof(hsize_t));
-  VRFY((coords != NULL), "coords malloc succeeded");
+  VRFY_G((coords != NULL), "coords malloc succeeded");
   point_set(start, count, stride, block, num_points, coords, mode);
 
   /* Warning: H5Screate_simple requires an array of hsize_t elements
@@ -1430,36 +1423,36 @@ coll_chunktest(const char* filename,
    * appears to cause problems with 32 bit compilers.
    */
   file_dataspace = H5Screate_simple(2, dims, NULL);
-  VRFY((file_dataspace >= 0), "file dataspace created succeeded");
+  VRFY_G((file_dataspace >= 0), "file dataspace created succeeded");
 
   if(ALL != mem_selection) {
       mem_dataspace = H5Screate_simple(2, dims, NULL);
-      VRFY((mem_dataspace >= 0), "mem dataspace created succeeded");
+      VRFY_G((mem_dataspace >= 0), "mem dataspace created succeeded");
   }
   else {
       /* Putting the warning about H5Screate_simple (above) into practice... */
       hsize_t dsdims[1] = {num_points};
       mem_dataspace = H5Screate_simple (1, dsdims, NULL);
-      VRFY((mem_dataspace >= 0), "mem_dataspace create succeeded");
+      VRFY_G((mem_dataspace >= 0), "mem_dataspace create succeeded");
   }
 
   crp_plist = H5Pcreate(H5P_DATASET_CREATE);
-  VRFY((crp_plist >= 0),"");
+  VRFY_G((crp_plist >= 0),"");
 
   /* Set up chunk information.  */
-  chunk_dims[0] = dims[0]/chunk_factor;
+  chunk_dims[0] = dims[0]/(hsize_t)chunk_factor;
 
   /* to decrease the testing time, maintain bigger chunk size */
   (chunk_factor == 1) ? (chunk_dims[1] = space_dim2) : (chunk_dims[1] = space_dim2/2);
   status = H5Pset_chunk(crp_plist, 2, chunk_dims);
-  VRFY((status >= 0),"chunk creation property list succeeded");
+  VRFY_G((status >= 0),"chunk creation property list succeeded");
 
   dataset = H5Dcreate2(file, DSET_COLLECTIVE_CHUNK_NAME, H5T_NATIVE_INT,
                        file_dataspace, H5P_DEFAULT, crp_plist, H5P_DEFAULT);
-  VRFY((dataset >= 0),"dataset created succeeded");
+  VRFY_G((dataset >= 0),"dataset created succeeded");
 
   status = H5Pclose(crp_plist);
-  VRFY((status >= 0), "");
+  VRFY_G((status >= 0), "");
 
   /*put some trivial data in the data array */
   ccdataset_fill(start, stride, count,block, data_array1, mem_selection);
@@ -1469,93 +1462,93 @@ coll_chunktest(const char* filename,
   switch (file_selection) {
       case HYPER:
           status = H5Sselect_hyperslab(file_dataspace, H5S_SELECT_SET, start, stride, count, block);
-          VRFY((status >= 0),"hyperslab selection succeeded");
+          VRFY_G((status >= 0),"hyperslab selection succeeded");
           break;
 
       case POINT:
           if (num_points) {
               status = H5Sselect_elements(file_dataspace, H5S_SELECT_SET, num_points, coords);
-              VRFY((status >= 0),"Element selection succeeded");
+              VRFY_G((status >= 0),"Element selection succeeded");
           }
           else {
               status = H5Sselect_none(file_dataspace);
-              VRFY((status >= 0),"none selection succeeded");
+              VRFY_G((status >= 0),"none selection succeeded");
           }
           break;
 
       case ALL:
           status = H5Sselect_all(file_dataspace);
-          VRFY((status >= 0), "H5Sselect_all succeeded");
+          VRFY_G((status >= 0), "H5Sselect_all succeeded");
           break;
   }
 
   switch (mem_selection) {
       case HYPER:
           status = H5Sselect_hyperslab(mem_dataspace, H5S_SELECT_SET, start, stride, count, block);
-          VRFY((status >= 0),"hyperslab selection succeeded");
+          VRFY_G((status >= 0),"hyperslab selection succeeded");
           break;
 
       case POINT:
           if (num_points) {
               status = H5Sselect_elements(mem_dataspace, H5S_SELECT_SET, num_points, coords);
-              VRFY((status >= 0),"Element selection succeeded");
+              VRFY_G((status >= 0),"Element selection succeeded");
           }
           else {
               status = H5Sselect_none(mem_dataspace);
-              VRFY((status >= 0),"none selection succeeded");
+              VRFY_G((status >= 0),"none selection succeeded");
           }
           break;
 
       case ALL:
           status = H5Sselect_all(mem_dataspace);
-          VRFY((status >= 0), "H5Sselect_all succeeded");
+          VRFY_G((status >= 0), "H5Sselect_all succeeded");
           break;
   }
 
   /* set up the collective transfer property list */
   xfer_plist = H5Pcreate(H5P_DATASET_XFER);
-  VRFY((xfer_plist >= 0), "");
+  VRFY_G((xfer_plist >= 0), "");
 
   status = H5Pset_dxpl_mpio(xfer_plist, H5FD_MPIO_COLLECTIVE);
-  VRFY((status>= 0),"MPIO collective transfer property succeeded");
+  VRFY_G((status>= 0),"MPIO collective transfer property succeeded");
   if(dxfer_coll_type == DXFER_INDEPENDENT_IO) {
      status = H5Pset_dxpl_mpio_collective_opt(xfer_plist, H5FD_MPIO_INDIVIDUAL_IO);
-     VRFY((status>= 0),"set independent IO collectively succeeded");
+     VRFY_G((status>= 0),"set independent IO collectively succeeded");
   }
 
   switch(api_option){
     case API_LINK_HARD:
     status = H5Pset_dxpl_mpio_chunk_opt(xfer_plist,H5FD_MPIO_CHUNK_ONE_IO);
-           VRFY((status>= 0),"collective chunk optimization succeeded");
+           VRFY_G((status>= 0),"collective chunk optimization succeeded");
            break;
 
     case API_MULTI_HARD:
     status = H5Pset_dxpl_mpio_chunk_opt(xfer_plist,H5FD_MPIO_CHUNK_MULTI_IO);
-    VRFY((status>= 0),"collective chunk optimization succeeded ");
+    VRFY_G((status>= 0),"collective chunk optimization succeeded ");
            break;
 
     case API_LINK_TRUE:
            status = H5Pset_dxpl_mpio_chunk_opt_num(xfer_plist,2);
-    VRFY((status>= 0),"collective chunk optimization set chunk number succeeded");
+    VRFY_G((status>= 0),"collective chunk optimization set chunk number succeeded");
            break;
 
     case API_LINK_FALSE:
            status = H5Pset_dxpl_mpio_chunk_opt_num(xfer_plist,6);
-           VRFY((status>= 0),"collective chunk optimization set chunk number succeeded");
+           VRFY_G((status>= 0),"collective chunk optimization set chunk number succeeded");
            break;
 
     case API_MULTI_COLL:
            status = H5Pset_dxpl_mpio_chunk_opt_num(xfer_plist,8);/* make sure it is using multi-chunk IO */
-           VRFY((status>= 0),"collective chunk optimization set chunk number succeeded");
+           VRFY_G((status>= 0),"collective chunk optimization set chunk number succeeded");
     status = H5Pset_dxpl_mpio_chunk_opt_ratio(xfer_plist,50);
-           VRFY((status>= 0),"collective chunk optimization set chunk ratio succeeded");
+           VRFY_G((status>= 0),"collective chunk optimization set chunk ratio succeeded");
            break;
 
     case API_MULTI_IND:
            status = H5Pset_dxpl_mpio_chunk_opt_num(xfer_plist,8);/* make sure it is using multi-chunk IO */
-           VRFY((status>= 0),"collective chunk optimization set chunk number succeeded");
+           VRFY_G((status>= 0),"collective chunk optimization set chunk number succeeded");
     status = H5Pset_dxpl_mpio_chunk_opt_ratio(xfer_plist,100);
-           VRFY((status>= 0),"collective chunk optimization set chunk ratio succeeded");
+           VRFY_G((status>= 0),"collective chunk optimization set chunk ratio succeeded");
            break;
 
     default:
@@ -1569,42 +1562,42 @@ coll_chunktest(const char* filename,
                prop_value = H5D_XFER_COLL_CHUNK_DEF;
                status = H5Pinsert2(xfer_plist, H5D_XFER_COLL_CHUNK_LINK_HARD_NAME, H5D_XFER_COLL_CHUNK_SIZE, &prop_value,
                            NULL, NULL, NULL, NULL, NULL, NULL);
-               VRFY((status >= 0),"testing property list inserted succeeded");
+               VRFY_G((status >= 0),"testing property list inserted succeeded");
                break;
 
             case API_MULTI_HARD:
                prop_value = H5D_XFER_COLL_CHUNK_DEF;
                status = H5Pinsert2(xfer_plist, H5D_XFER_COLL_CHUNK_MULTI_HARD_NAME, H5D_XFER_COLL_CHUNK_SIZE, &prop_value,
                            NULL, NULL, NULL, NULL, NULL, NULL);
-               VRFY((status >= 0),"testing property list inserted succeeded");
+               VRFY_G((status >= 0),"testing property list inserted succeeded");
                break;
 
             case API_LINK_TRUE:
                prop_value = H5D_XFER_COLL_CHUNK_DEF;
                status = H5Pinsert2(xfer_plist, H5D_XFER_COLL_CHUNK_LINK_NUM_TRUE_NAME, H5D_XFER_COLL_CHUNK_SIZE, &prop_value,
                            NULL, NULL, NULL, NULL, NULL, NULL);
-               VRFY((status >= 0),"testing property list inserted succeeded");
+               VRFY_G((status >= 0),"testing property list inserted succeeded");
                break;
 
             case API_LINK_FALSE:
                prop_value = H5D_XFER_COLL_CHUNK_DEF;
                status = H5Pinsert2(xfer_plist, H5D_XFER_COLL_CHUNK_LINK_NUM_FALSE_NAME, H5D_XFER_COLL_CHUNK_SIZE, &prop_value,
                            NULL, NULL, NULL, NULL, NULL, NULL);
-               VRFY((status >= 0),"testing property list inserted succeeded");
+               VRFY_G((status >= 0),"testing property list inserted succeeded");
                break;
 
             case API_MULTI_COLL:
                prop_value = H5D_XFER_COLL_CHUNK_DEF;
                status = H5Pinsert2(xfer_plist, H5D_XFER_COLL_CHUNK_MULTI_RATIO_COLL_NAME, H5D_XFER_COLL_CHUNK_SIZE, &prop_value,
                            NULL, NULL, NULL, NULL, NULL, NULL);
-               VRFY((status >= 0),"testing property list inserted succeeded");
+               VRFY_G((status >= 0),"testing property list inserted succeeded");
                break;
 
             case API_MULTI_IND:
                prop_value = H5D_XFER_COLL_CHUNK_DEF;
                status = H5Pinsert2(xfer_plist, H5D_XFER_COLL_CHUNK_MULTI_RATIO_IND_NAME, H5D_XFER_COLL_CHUNK_SIZE, &prop_value,
                            NULL, NULL, NULL, NULL, NULL, NULL);
-               VRFY((status >= 0),"testing property list inserted succeeded");
+               VRFY_G((status >= 0),"testing property list inserted succeeded");
                break;
 
             default:
@@ -1616,45 +1609,45 @@ coll_chunktest(const char* filename,
   /* write data collectively */
   status = H5Dwrite(dataset, H5T_NATIVE_INT, mem_dataspace, file_dataspace,
             xfer_plist, data_array1);
-  VRFY((status >= 0),"dataset write succeeded");
+  VRFY_G((status >= 0),"dataset write succeeded");
 
 #ifdef H5_HAVE_INSTRUMENTED_LIBRARY
   if(facc_type == FACC_MPIO) {
       switch(api_option){
             case API_LINK_HARD:
                status = H5Pget(xfer_plist,H5D_XFER_COLL_CHUNK_LINK_HARD_NAME,&prop_value);
-               VRFY((status >= 0),"testing property list get succeeded");
-               VRFY((prop_value == 0),"API to set LINK COLLECTIVE IO directly succeeded");
+               VRFY_G((status >= 0),"testing property list get succeeded");
+               VRFY_G((prop_value == 0),"API to set LINK COLLECTIVE IO directly succeeded");
                break;
 
             case API_MULTI_HARD:
                status = H5Pget(xfer_plist,H5D_XFER_COLL_CHUNK_MULTI_HARD_NAME,&prop_value);
-               VRFY((status >= 0),"testing property list get succeeded");
-               VRFY((prop_value == 0),"API to set MULTI-CHUNK COLLECTIVE IO optimization succeeded");
+               VRFY_G((status >= 0),"testing property list get succeeded");
+               VRFY_G((prop_value == 0),"API to set MULTI-CHUNK COLLECTIVE IO optimization succeeded");
                break;
 
             case API_LINK_TRUE:
                status = H5Pget(xfer_plist,H5D_XFER_COLL_CHUNK_LINK_NUM_TRUE_NAME,&prop_value);
-               VRFY((status >= 0),"testing property list get succeeded");
-               VRFY((prop_value == 0),"API to set LINK COLLECTIVE IO succeeded");
+               VRFY_G((status >= 0),"testing property list get succeeded");
+               VRFY_G((prop_value == 0),"API to set LINK COLLECTIVE IO succeeded");
                break;
 
             case API_LINK_FALSE:
                status = H5Pget(xfer_plist,H5D_XFER_COLL_CHUNK_LINK_NUM_FALSE_NAME,&prop_value);
-               VRFY((status >= 0),"testing property list get succeeded");
-               VRFY((prop_value == 0),"API to set LINK IO transferring to multi-chunk IO succeeded");
+               VRFY_G((status >= 0),"testing property list get succeeded");
+               VRFY_G((prop_value == 0),"API to set LINK IO transferring to multi-chunk IO succeeded");
                break;
 
             case API_MULTI_COLL:
                status = H5Pget(xfer_plist,H5D_XFER_COLL_CHUNK_MULTI_RATIO_COLL_NAME,&prop_value);
-               VRFY((status >= 0),"testing property list get succeeded");
-               VRFY((prop_value == 0),"API to set MULTI-CHUNK COLLECTIVE IO with optimization succeeded");
+               VRFY_G((status >= 0),"testing property list get succeeded");
+               VRFY_G((prop_value == 0),"API to set MULTI-CHUNK COLLECTIVE IO with optimization succeeded");
                break;
 
             case API_MULTI_IND:
                status = H5Pget(xfer_plist,H5D_XFER_COLL_CHUNK_MULTI_RATIO_IND_NAME,&prop_value);
-               VRFY((status >= 0),"testing property list get succeeded");
-               VRFY((prop_value == 0),"API to set MULTI-CHUNK IO transferring to independent IO  succeeded");
+               VRFY_G((status >= 0),"testing property list get succeeded");
+               VRFY_G((prop_value == 0),"API to set MULTI-CHUNK IO transferring to independent IO  succeeded");
                break;
 
             default:
@@ -1664,20 +1657,20 @@ coll_chunktest(const char* filename,
 #endif
 
   status = H5Dclose(dataset);
-  VRFY((status >= 0),"");
+  VRFY_G((status >= 0),"");
 
   status = H5Pclose(xfer_plist);
-  VRFY((status >= 0),"property list closed");
+  VRFY_G((status >= 0),"property list closed");
 
   status = H5Sclose(file_dataspace);
-  VRFY((status >= 0),"");
+  VRFY_G((status >= 0),"");
 
   status = H5Sclose(mem_dataspace);
-  VRFY((status >= 0),"");
+  VRFY_G((status >= 0),"");
 
 
   status = H5Fclose(file);
-  VRFY((status >= 0),"");
+  VRFY_G((status >= 0),"");
 
   if (data_array1) HDfree(data_array1);
 
@@ -1685,35 +1678,35 @@ coll_chunktest(const char* filename,
 
   /* allocate memory for data buffer */
   data_array1 = (int *)HDmalloc(dims[0]*dims[1]*sizeof(int));
-  VRFY((data_array1 != NULL), "data_array1 malloc succeeded");
+  VRFY_G((data_array1 != NULL), "data_array1 malloc succeeded");
 
   /* allocate memory for data buffer */
   data_origin1 = (int *)HDmalloc(dims[0]*dims[1]*sizeof(int));
-  VRFY((data_origin1 != NULL), "data_origin1 malloc succeeded");
+  VRFY_G((data_origin1 != NULL), "data_origin1 malloc succeeded");
 
   acc_plist = create_faccess_plist(comm, info, facc_type);
-  VRFY((acc_plist >= 0),"MPIO creation property list succeeded");
+  VRFY_G((acc_plist >= 0),"MPIO creation property list succeeded");
 
   file = H5Fopen(FILENAME[0],H5F_ACC_RDONLY,acc_plist);
-  VRFY((file >= 0),"H5Fcreate succeeded");
+  VRFY_G((file >= 0),"H5Fcreate succeeded");
 
   status = H5Pclose(acc_plist);
-  VRFY((status >= 0),"");
+  VRFY_G((status >= 0),"");
 
   /* open the collective dataset*/
   dataset = H5Dopen2(file, DSET_COLLECTIVE_CHUNK_NAME, H5P_DEFAULT);
-  VRFY((dataset >= 0), "");
+  VRFY_G((dataset >= 0), "");
 
   /* set up dimensions of the slab this process accesses */
-  ccslab_set(mpi_rank, mpi_size, start, count, stride, block, select_factor);
+  ccslab_set(mpi_rank_g, mpi_size_g, start, count, stride, block, select_factor);
 
   /* obtain the file and mem dataspace*/
   file_dataspace = H5Dget_space (dataset);
-  VRFY((file_dataspace >= 0), "");
+  VRFY_G((file_dataspace >= 0), "");
 
   if (ALL != mem_selection) {
       mem_dataspace = H5Dget_space (dataset);
-      VRFY((mem_dataspace >= 0), "");
+      VRFY_G((mem_dataspace >= 0), "");
   }
   else {
       /* Warning: H5Screate_simple requires an array of hsize_t elements
@@ -1722,92 +1715,92 @@ coll_chunktest(const char* filename,
        */
       hsize_t dsdims[1] = {num_points};
       mem_dataspace = H5Screate_simple (1, dsdims, NULL);
-      VRFY((mem_dataspace >= 0), "mem_dataspace create succeeded");
+      VRFY_G((mem_dataspace >= 0), "mem_dataspace create succeeded");
   }
 
   switch (file_selection) {
       case HYPER:
           status = H5Sselect_hyperslab(file_dataspace, H5S_SELECT_SET, start, stride, count, block);
-          VRFY((status >= 0),"hyperslab selection succeeded");
+          VRFY_G((status >= 0),"hyperslab selection succeeded");
           break;
 
       case POINT:
           if (num_points) {
               status = H5Sselect_elements(file_dataspace, H5S_SELECT_SET, num_points, coords);
-              VRFY((status >= 0),"Element selection succeeded");
+              VRFY_G((status >= 0),"Element selection succeeded");
           }
           else {
               status = H5Sselect_none(file_dataspace);
-              VRFY((status >= 0),"none selection succeeded");
+              VRFY_G((status >= 0),"none selection succeeded");
           }
           break;
 
       case ALL:
           status = H5Sselect_all(file_dataspace);
-          VRFY((status >= 0), "H5Sselect_all succeeded");
+          VRFY_G((status >= 0), "H5Sselect_all succeeded");
           break;
   }
 
   switch (mem_selection) {
       case HYPER:
           status = H5Sselect_hyperslab(mem_dataspace, H5S_SELECT_SET, start, stride, count, block);
-          VRFY((status >= 0),"hyperslab selection succeeded");
+          VRFY_G((status >= 0),"hyperslab selection succeeded");
           break;
 
       case POINT:
           if (num_points) {
               status = H5Sselect_elements(mem_dataspace, H5S_SELECT_SET, num_points, coords);
-              VRFY((status >= 0),"Element selection succeeded");
+              VRFY_G((status >= 0),"Element selection succeeded");
           }
           else {
               status = H5Sselect_none(mem_dataspace);
-              VRFY((status >= 0),"none selection succeeded");
+              VRFY_G((status >= 0),"none selection succeeded");
           }
           break;
 
       case ALL:
           status = H5Sselect_all(mem_dataspace);
-          VRFY((status >= 0), "H5Sselect_all succeeded");
+          VRFY_G((status >= 0), "H5Sselect_all succeeded");
           break;
   }
 
   /* fill dataset with test data */
   ccdataset_fill(start, stride,count,block, data_origin1, mem_selection);
   xfer_plist = H5Pcreate (H5P_DATASET_XFER);
-  VRFY((xfer_plist >= 0),"");
+  VRFY_G((xfer_plist >= 0),"");
 
   status = H5Pset_dxpl_mpio(xfer_plist, H5FD_MPIO_COLLECTIVE);
-  VRFY((status>= 0),"MPIO collective transfer property succeeded");
+  VRFY_G((status>= 0),"MPIO collective transfer property succeeded");
   if(dxfer_coll_type == DXFER_INDEPENDENT_IO) {
      status = H5Pset_dxpl_mpio_collective_opt(xfer_plist,H5FD_MPIO_INDIVIDUAL_IO);
-     VRFY((status>= 0),"set independent IO collectively succeeded");
+     VRFY_G((status>= 0),"set independent IO collectively succeeded");
   }
 
   status = H5Dread(dataset, H5T_NATIVE_INT, mem_dataspace, file_dataspace,
                    xfer_plist, data_array1);
-  VRFY((status >=0),"dataset read succeeded");
+  VRFY_G((status >=0),"dataset read succeeded");
 
   /* verify the read data with original expected data */
   status = ccdataset_vrfy(start, count, stride, block, data_array1, data_origin1, mem_selection);
   if (status) nerrors++;
 
   status = H5Pclose(xfer_plist);
-  VRFY((status >= 0),"property list closed");
+  VRFY_G((status >= 0),"property list closed");
 
   /* close dataset collectively */
   status=H5Dclose(dataset);
-  VRFY((status >= 0), "H5Dclose");
+  VRFY_G((status >= 0), "H5Dclose");
 
   /* release all IDs created */
   status = H5Sclose(file_dataspace);
-  VRFY((status >= 0),"H5Sclose");
+  VRFY_G((status >= 0),"H5Sclose");
 
   status = H5Sclose(mem_dataspace);
-  VRFY((status >= 0),"H5Sclose");
+  VRFY_G((status >= 0),"H5Sclose");
 
   /* close the file collectively */
   status = H5Fclose(file);
-  VRFY((status >= 0),"H5Fclose");
+  VRFY_G((status >= 0),"H5Fclose");
 
   /* release data buffers */
   if(coords) HDfree(coords);
@@ -1885,8 +1878,8 @@ int main(int argc, char **argv)
     }
 
     MPI_Init(&argc, &argv);
-    MPI_Comm_size(MPI_COMM_WORLD,&mpi_size);
-    MPI_Comm_rank(MPI_COMM_WORLD,&mpi_rank);
+    MPI_Comm_size(MPI_COMM_WORLD,&mpi_size_g);
+    MPI_Comm_rank(MPI_COMM_WORLD,&mpi_rank_g);
 
     /* Attempt to turn off atexit post processing so that in case errors
      * happen during the test and the process is aborted, it will not get
@@ -1900,7 +1893,7 @@ int main(int argc, char **argv)
     /* set alarm. */
     ALARM_ON;
 
-    ExpressMode = do_express_test(mpi_rank);
+    ExpressMode = do_express_test(mpi_rank_g);
 
     dataset_big_write();
     MPI_Barrier(MPI_COMM_WORLD);
@@ -1909,7 +1902,7 @@ int main(int argc, char **argv)
     MPI_Barrier(MPI_COMM_WORLD);
 
     if (ExpressMode > 0) {
-      if (mpi_rank == 0)
+      if (mpi_rank_g == 0)
           HDprintf("***Express test mode on.  Several tests are skipped\n");
     }
     else {
@@ -1923,7 +1916,7 @@ int main(int argc, char **argv)
     /* turn off alarm */
     ALARM_OFF;
 
-    if (mpi_rank == 0)
+    if (mpi_rank_g == 0)
         HDremove(FILENAME[0]);
 
     /* close HDF5 library */
diff --git a/testpar/t_cache.c b/testpar/t_cache.c
index ff89ee4..4f0f554 100644
--- a/testpar/t_cache.c
+++ b/testpar/t_cache.c
@@ -24,6 +24,7 @@
 
 #include "H5ACpkg.h"
 #include "H5Cpkg.h"
+#include "H5CXprivate.h"
 #include "H5Fpkg.h"
 #include "H5Iprivate.h"
 #include "H5MFprivate.h"
@@ -1619,7 +1620,7 @@ serve_read_request(struct mssg_t * mssg_ptr)
             reply.base_addr = data[target_index].base_addr;
             reply.len       = data[target_index].len;
             reply.ver       = data[target_index].ver;
-        reply.count     = 0;
+            reply.count     = 0;
             reply.magic     = MSSG_MAGIC;
 
         /* and update the counters */
@@ -1760,7 +1761,7 @@ serve_write_request(struct mssg_t * mssg_ptr)
     hbool_t report_mssg = FALSE;
     hbool_t success = TRUE;
     int target_index;
-    int new_ver_num;
+    int new_ver_num = 0;
     haddr_t target_addr;
 #if DO_WRITE_REQ_ACK
     struct mssg_t reply;
@@ -1925,7 +1926,7 @@ serve_total_writes_request(struct mssg_t * mssg_ptr)
         reply.base_addr = 0;
         reply.len       = 0;
         reply.ver       = 0;
-        reply.count     = total_writes;
+        reply.count     = (unsigned)total_writes;
         reply.magic     = MSSG_MAGIC;
     }
 
@@ -2004,7 +2005,7 @@ serve_total_reads_request(struct mssg_t * mssg_ptr)
         reply.base_addr = 0;
         reply.len       = 0;
         reply.ver       = 0;
-        reply.count     = total_reads;
+        reply.count     = (unsigned)total_reads;
         reply.magic     = MSSG_MAGIC;
     }
 
@@ -2098,7 +2099,7 @@ serve_entry_writes_request(struct mssg_t * mssg_ptr)
             reply.base_addr = target_addr;
             reply.len       = 0;
             reply.ver       = 0;
-        reply.count     = data[target_index].writes;
+            reply.count     = (unsigned)data[target_index].writes;
             reply.magic     = MSSG_MAGIC;
         }
     }
@@ -2195,7 +2196,7 @@ serve_entry_reads_request(struct mssg_t * mssg_ptr)
             reply.base_addr = target_addr;
             reply.len       = 0;
             reply.ver       = 0;
-        reply.count     = (long)(data[target_index].reads);
+            reply.count     = (unsigned)(data[target_index].reads);
             reply.magic     = MSSG_MAGIC;
         }
     }
@@ -4611,7 +4612,7 @@ verify_entry_reads(haddr_t addr,
                    int expected_entry_reads)
 {
     hbool_t success = TRUE;
-    int reported_entry_reads;
+    int reported_entry_reads = 0;
     struct mssg_t mssg;
 
     if ( success ) {
@@ -4718,7 +4719,7 @@ verify_entry_writes(haddr_t addr,
                     int expected_entry_writes)
 {
     hbool_t success = TRUE;
-    int reported_entry_writes;
+    int reported_entry_writes = 0;
     struct mssg_t mssg;
 
     if ( success ) {
@@ -7288,7 +7289,7 @@ smoke_check_6(int metadata_write_strategy)
             }
 
             /* Make sure coll entries do not cross the 80% threshold */
-            HDassert(cache_ptr->max_cache_size*0.8 > cache_ptr->coll_list_size);
+            HDassert((double)cache_ptr->max_cache_size*0.8 > cache_ptr->coll_list_size);
         }
 
         /* flush the file */
@@ -7318,7 +7319,7 @@ smoke_check_6(int metadata_write_strategy)
             }
 
             /* Make sure coll entries do not cross the 80% threshold */
-            HDassert(cache_ptr->max_cache_size*0.8 > cache_ptr->coll_list_size);
+            HDassert((double)cache_ptr->max_cache_size*0.8 > cache_ptr->coll_list_size);
         }
 
         /* protect the other half independently */
@@ -7339,7 +7340,7 @@ smoke_check_6(int metadata_write_strategy)
             }
 
             /* Make sure coll entries do not cross the 80% threshold */
-            HDassert(cache_ptr->max_cache_size*0.8 > cache_ptr->coll_list_size);
+            HDassert((double)cache_ptr->max_cache_size*0.8 > cache_ptr->coll_list_size);
         }
 
         for ( i = 0; i < (virt_num_data_entries); i++ )
diff --git a/testpar/testpar.h b/testpar/testpar.h
index 86677d1..2c1bce2 100644
--- a/testpar/testpar.h
+++ b/testpar/testpar.h
@@ -44,12 +44,12 @@
  * This will allow program to continue and can be used for debugging.
  * (The "do {...} while(0)" is to group all the statements as one unit.)
  */
-#define VRFY(val, mesg) do {                                            \
+#define VRFY_IMPL(val, mesg, rankvar) do {                              \
     if (val) {                                                          \
         MESG(mesg);                                                     \
     }                                                                   \
     else {                                                              \
-        HDprintf("Proc %d: ", mpi_rank);                                \
+        HDprintf("Proc %d: ", rankvar);                                 \
         HDprintf("*** Parallel ERROR ***\n");                           \
         HDprintf("    VRFY (%s) failed at line %4d in %s\n",            \
                mesg, (int)__LINE__, __FILE__);                          \
@@ -62,6 +62,9 @@
     }                                                                   \
 } while(0)
 
+#define VRFY_G(val, mesg) VRFY_IMPL(val, mesg, mpi_rank_g)
+#define VRFY(val, mesg) VRFY_IMPL(val, mesg, mpi_rank)
+
 /*
  * Checking for information purpose.
  * If val is false, print mesg; else nothing.