diff --git a/configure.ac b/configure.ac
index e7561bcd2..ac0e3e87e 100644
--- a/configure.ac
+++ b/configure.ac
@@ -1339,7 +1339,11 @@ AC_CHECK_FUNCS([MPI_Type_create_subarray_c \
                 MPI_Bcast_c \
                 MPI_Get_count_c \
                 MPI_Pack_c \
-                MPI_Unpack_c], [], [have_mpi_large_count_apis=no])
+                MPI_Unpack_c \
+                MPI_File_read_at_c \
+                MPI_File_read_at_all_c \
+                MPI_File_write_at_c \
+                MPI_File_write_at_all_c], [], [have_mpi_large_count_apis=no])
 # If one of the above APIs is not available, have_mpi_large_count_apis will be
 # set to no
 UD_MSG_DEBUG([have_mpi_large_count_apis=$have_mpi_large_count_apis])
diff --git a/src/drivers/ncmpio/ncmpio_close.c b/src/drivers/ncmpio/ncmpio_close.c
index c3cf33977..ec79088e8 100644
--- a/src/drivers/ncmpio/ncmpio_close.c
+++ b/src/drivers/ncmpio/ncmpio_close.c
@@ -60,29 +60,30 @@ ncmpio_free_NC(NC *ncp)
 /*----< ncmpio_close_files() >-----------------------------------------------*/
 int
 ncmpio_close_files(NC *ncp, int doUnlink) {
+    char *mpi_name;
     int mpireturn;
 
     assert(ncp != NULL); /* this should never occur */
 
     if (ncp->independent_fh != MPI_FILE_NULL) {
-        TRACE_IO(MPI_File_close)(&ncp->independent_fh);
+        TRACE_IO(MPI_File_close, (&ncp->independent_fh));
         if (mpireturn != MPI_SUCCESS)
-            return ncmpii_error_mpi2nc(mpireturn, "MPI_File_close");
+            return ncmpii_error_mpi2nc(mpireturn, mpi_name);
     }
 
     if (ncp->nprocs > 1 && ncp->collective_fh != MPI_FILE_NULL) {
-        TRACE_IO(MPI_File_close)(&ncp->collective_fh);
+        TRACE_IO(MPI_File_close, (&ncp->collective_fh));
         if (mpireturn != MPI_SUCCESS)
-            return ncmpii_error_mpi2nc(mpireturn, "MPI_File_close");
+            return ncmpii_error_mpi2nc(mpireturn, mpi_name);
     }
 
     if (doUnlink) {
         /* called from ncmpi_abort, if the file is being created and is still
          * in define mode, the file is deleted */
         if (ncp->rank == 0) {
-            TRACE_IO(MPI_File_delete)((char *)ncp->path, ncp->mpiinfo);
+            TRACE_IO(MPI_File_delete, ((char *)ncp->path, ncp->mpiinfo));
             if (mpireturn != MPI_SUCCESS)
-                return ncmpii_error_mpi2nc(mpireturn, "MPI_File_delete");
+                return ncmpii_error_mpi2nc(mpireturn, mpi_name);
         }
         if (ncp->nprocs > 1)
             MPI_Barrier(ncp->comm);
@@ -186,31 +187,31 @@ ncmpio_close(void *ncdp)
 #else
             MPI_File fh;
             int mpireturn;
-            mpireturn = MPI_File_open(MPI_COMM_SELF, ncp->path, MPI_MODE_RDWR, MPI_INFO_NULL, &fh);
+            TRACE_IO(MPI_File_open, (MPI_COMM_SELF, ncp->path, MPI_MODE_RDWR, MPI_INFO_NULL, &fh));
             if (mpireturn == MPI_SUCCESS) {
                 /* obtain file size */
                 MPI_Offset *file_size;
-                mpireturn = MPI_File_get_size(fh, &file_size);
+                TRACE_IO(MPI_File_get_size, (fh, &file_size));
                 if (mpireturn != MPI_SUCCESS) {
-                    err = ncmpii_error_mpi2nc(mpireturn,"MPI_File_get_size");
+                    err = ncmpii_error_mpi2nc(mpireturn, mpi_name);
                     if (status == NC_NOERR) status = err;
                 }
                 /* truncate file size to header size, if larger than header */
                 if (file_size > ncp->xsz) {
-                    mpireturn = MPI_File_set_size(fh, ncp->xsz);
+                    TRACE_IO(MPI_File_set_size, (fh, ncp->xsz));
                     if (mpireturn != MPI_SUCCESS) {
-                        err = ncmpii_error_mpi2nc(mpireturn,"MPI_File_set_size");
+                        err = ncmpii_error_mpi2nc(mpireturn, mpi_name);
                         if (status == NC_NOERR) status = err;
                     }
                 }
-                mpireturn = MPI_File_close(&fh);
+                TRACE_IO(MPI_File_close, (&fh));
                 if (mpireturn != MPI_SUCCESS) {
-                    err = ncmpii_error_mpi2nc(mpireturn,"MPI_File_close");
+                    err = ncmpii_error_mpi2nc(mpireturn, mpi_name);
                     if (status == NC_NOERR) status = err;
                 }
             }
             else {
-                err = ncmpii_error_mpi2nc(mpireturn,"MPI_File_open");
+                err = ncmpii_error_mpi2nc(mpireturn, mpi_name);
                 if (status == NC_NOERR) status = err;
             }
 #endif
diff --git a/src/drivers/ncmpio/ncmpio_create.c b/src/drivers/ncmpio/ncmpio_create.c
index a705ed642..e5cee83d3 100644
--- a/src/drivers/ncmpio/ncmpio_create.c
+++ b/src/drivers/ncmpio/ncmpio_create.c
@@ -42,7 +42,7 @@ ncmpio_create(MPI_Comm     comm,
               MPI_Info     user_info, /* user's and env info combined */
               void       **ncpp)
 {
-    char *env_str, *filename;
+    char *env_str, *filename, *mpi_name;
     int rank, nprocs, mpiomode, err, mpireturn, default_format, file_exist=1;
     int use_trunc=1;
     MPI_File fh;
@@ -138,25 +138,28 @@ ncmpio_create(MPI_Comm     comm,
                  * expensive
                  */
                 err = unlink(filename);
-                if (err < 0 && errno != ENOENT) /* ignore ENOENT: file not exist */
+                if (err < 0 && errno != ENOENT)
+                    /* ignore ENOENT: file not exist */
                     DEBUG_ASSIGN_ERROR(err, NC_EFILE) /* other error */
                 else
                     err = NC_NOERR;
 #else
                 err = NC_NOERR;
-                TRACE_IO(MPI_File_delete)((char *)path, MPI_INFO_NULL);
+                TRACE_IO(MPI_File_delete, ((char *)path, MPI_INFO_NULL));
                 if (mpireturn != MPI_SUCCESS) {
                     int errorclass;
                     MPI_Error_class(mpireturn, &errorclass);
-                    if (errorclass != MPI_ERR_NO_SUCH_FILE) /* ignore file not exist */
-                        err = ncmpii_error_mpi2nc(mpireturn, "MPI_File_delete");
+                    if (errorclass != MPI_ERR_NO_SUCH_FILE)
+                        /* ignore file not exist */
+                        err = ncmpii_error_mpi2nc(mpireturn, mpi_name);
                 }
 #endif
             }
             else { /* file is not a regular file, truncate it to zero size */
 #ifdef HAVE_TRUNCATE
                 err = truncate(filename, 0); /* can be expensive */
-                if (err < 0 && errno != ENOENT) /* ignore ENOENT: file not exist */
+                if (err < 0 && errno != ENOENT)
+                    /* ignore ENOENT: file not exist */
                     DEBUG_ASSIGN_ERROR(err, NC_EFILE) /* other error */
                 else
                     err = NC_NOERR;
@@ -174,26 +177,25 @@ ncmpio_create(MPI_Comm     comm,
                  * be expensive.
                  */
                 err = NC_NOERR;
-                TRACE_IO(MPI_File_open)(MPI_COMM_SELF, (char *)path, MPI_MODE_RDWR,
-                                        MPI_INFO_NULL, &fh);
+                TRACE_IO(MPI_File_open, (MPI_COMM_SELF, (char *)path, MPI_MODE_RDWR, MPI_INFO_NULL, &fh));
                 if (mpireturn != MPI_SUCCESS) {
                     int errorclass;
                     MPI_Error_class(mpireturn, &errorclass);
-                    err = ncmpii_error_mpi2nc(mpireturn, "MPI_File_open");
+                    err = ncmpii_error_mpi2nc(mpireturn, mpi_name);
                 }
                 else {
-                    TRACE_IO(MPI_File_set_size)(fh, 0); /* can be expensive */
+                    TRACE_IO(MPI_File_set_size, (fh, 0)); /* can be expensive */
                     if (mpireturn != MPI_SUCCESS) {
                         int errorclass;
                         MPI_Error_class(mpireturn, &errorclass);
-                        err = ncmpii_error_mpi2nc(mpireturn, "MPI_File_set_size");
+                        err = ncmpii_error_mpi2nc(mpireturn, mpi_name);
                     }
                     else {
-                        TRACE_IO(MPI_File_close)(&fh);
+                        TRACE_IO(MPI_File_close, (&fh));
                         if (mpireturn != MPI_SUCCESS) {
                             int errorclass;
                             MPI_Error_class(mpireturn, &errorclass);
-                            err = ncmpii_error_mpi2nc(mpireturn, "MPI_File_close");
+                            err = ncmpii_error_mpi2nc(mpireturn, mpi_name);
                         }
                     }
                 }
@@ -208,7 +210,7 @@ ncmpio_create(MPI_Comm     comm,
     }
 
     /* create file collectively -------------------------------------------- */
-    TRACE_IO(MPI_File_open)(comm, (char *)path, mpiomode, user_info, &fh);
+    TRACE_IO(MPI_File_open, (comm, (char *)path, mpiomode, user_info, &fh));
     if (mpireturn != MPI_SUCCESS) {
 #ifndef HAVE_ACCESS
         if (fIsSet(cmode, NC_NOCLOBBER)) {
@@ -226,7 +228,7 @@ ncmpio_create(MPI_Comm     comm,
             if (errno == EEXIST) DEBUG_RETURN_ERROR(NC_EEXIST)
         }
 #endif
-        return ncmpii_error_mpi2nc(mpireturn, "MPI_File_open");
+        return ncmpii_error_mpi2nc(mpireturn, mpi_name);
         /* for NC_NOCLOBBER, MPI_MODE_EXCL was added to mpiomode. If the file
          * already exists, MPI-IO should return error class MPI_ERR_FILE_EXISTS
          * which PnetCDF will return error code NC_EEXIST. This is checked
@@ -238,9 +240,9 @@ ncmpio_create(MPI_Comm     comm,
         errno = 0;
 
     /* get the I/O hints used/modified by MPI-IO */
-    mpireturn = MPI_File_get_info(fh, &info_used);
+    TRACE_IO(MPI_File_get_info, (fh, &info_used));
     if (mpireturn != MPI_SUCCESS)
-        return ncmpii_error_mpi2nc(mpireturn, "MPI_File_get_info");
+        return ncmpii_error_mpi2nc(mpireturn, mpi_name);
 
     /* Now the file has been successfully created, allocate/set NC object */
 
diff --git a/src/drivers/ncmpio/ncmpio_enddef.c b/src/drivers/ncmpio/ncmpio_enddef.c
index 890d3690c..9b700ba57 100644
--- a/src/drivers/ncmpio/ncmpio_enddef.c
+++ b/src/drivers/ncmpio/ncmpio_enddef.c
@@ -167,6 +167,7 @@ move_file_block(NC         *ncp,
                 MPI_Offset  from,   /* source      starting file offset */
                 MPI_Offset  nbytes) /* amount to be moved */
 {
+    char *mpi_name;
     int rank, nprocs, mpireturn, err, status=NC_NOERR, do_coll;
     void *buf;
     size_t num_moves, mv_amnt, p_units;
@@ -239,14 +240,16 @@ move_file_block(NC         *ncp,
         mpireturn = MPI_SUCCESS;
 
         /* read from file at off_from for amount of chunk_size */
-        if (do_coll)
-            TRACE_IO(MPI_File_read_at_all)(fh, off_from, buf, chunk_size,
-                                           MPI_BYTE, &mpistatus);
-        else if (chunk_size > 0)
-            TRACE_IO(MPI_File_read_at)(fh, off_from, buf, chunk_size,
-                                           MPI_BYTE, &mpistatus);
+        if (do_coll) {
+            TRACE_IO(MPI_File_read_at_all, (fh, off_from, buf, chunk_size,
+                                            MPI_BYTE, &mpistatus));
+        }
+        else if (chunk_size > 0) {
+            TRACE_IO(MPI_File_read_at, (fh, off_from, buf, chunk_size,
+                                        MPI_BYTE, &mpistatus));
+        }
         if (mpireturn != MPI_SUCCESS) {
-            err = ncmpii_error_mpi2nc(mpireturn, "MPI_File_read_at_all");
+            err = ncmpii_error_mpi2nc(mpireturn, mpi_name);
             if (status == NC_NOERR && err == NC_EFILE)
                 DEBUG_ASSIGN_ERROR(status, NC_EREAD)
             get_size = chunk_size;
@@ -282,16 +285,18 @@ move_file_block(NC         *ncp,
          * call to MPI_Get_count() above returns the actual amount of data read
          * from the file, i.e. get_size.
          */
-        if (do_coll)
-            TRACE_IO(MPI_File_write_at_all)(fh, off_to, buf,
-                                            get_size /* NOT chunk_size */,
-                                            MPI_BYTE, &mpistatus);
-        else if (get_size > 0)
-            TRACE_IO(MPI_File_write_at)(fh, off_to, buf,
-                                            get_size /* NOT chunk_size */,
-                                            MPI_BYTE, &mpistatus);
+        if (do_coll) {
+            TRACE_IO(MPI_File_write_at_all, (fh, off_to, buf,
+                                             get_size /* NOT chunk_size */,
+                                             MPI_BYTE, &mpistatus));
+        }
+        else if (get_size > 0) {
+            TRACE_IO(MPI_File_write_at, (fh, off_to, buf,
+                                         get_size /* NOT chunk_size */,
+                                         MPI_BYTE, &mpistatus));
+        }
         if (mpireturn != MPI_SUCCESS) {
-            err = ncmpii_error_mpi2nc(mpireturn, "MPI_File_write_at_all");
+            err = ncmpii_error_mpi2nc(mpireturn, mpi_name);
             if (status == NC_NOERR && err == NC_EFILE)
                 DEBUG_ASSIGN_ERROR(status, NC_EWRITE)
         }
@@ -597,6 +602,7 @@ NC_begins(NC *ncp)
 static int
 write_NC(NC *ncp)
 {
+    char *mpi_name;
     int status=NC_NOERR, mpireturn, err, is_coll;
     MPI_Offset i, header_wlen, ntimes;
     MPI_File fh;
@@ -680,14 +686,16 @@ write_NC(NC *ncp)
         buf_ptr = buf;
         for (i=0; i<ntimes; i++) {
             int bufCount = (int) MIN(remain, NC_MAX_INT);
-            if (is_coll)
-                TRACE_IO(MPI_File_write_at_all)(fh, offset, buf_ptr, bufCount,
-                                                MPI_BYTE, &mpistatus);
-            else
-                TRACE_IO(MPI_File_write_at)(fh, offset, buf_ptr, bufCount,
-                                            MPI_BYTE, &mpistatus);
+            if (is_coll) {
+                TRACE_IO(MPI_File_write_at_all, (fh, offset, buf_ptr, bufCount,
+                                                 MPI_BYTE, &mpistatus));
+            }
+            else {
+                TRACE_IO(MPI_File_write_at, (fh, offset, buf_ptr, bufCount,
+                                             MPI_BYTE, &mpistatus));
+            }
             if (mpireturn != MPI_SUCCESS) {
-                err = ncmpii_error_mpi2nc(mpireturn, "MPI_File_write_at");
+                err = ncmpii_error_mpi2nc(mpireturn, mpi_name);
                 /* write has failed, which is more serious than inconsistency */
                 if (err == NC_EFILE) DEBUG_ASSIGN_ERROR(status, NC_EWRITE)
             }
@@ -711,9 +719,9 @@ write_NC(NC *ncp)
     }
     else if (fIsSet(ncp->flags, NC_HCOLL)) {
         /* other processes participate the collective call */
-        for (i=0; i<ntimes; i++)
-            TRACE_IO(MPI_File_write_at_all)(fh, 0, NULL, 0, MPI_BYTE,
-                                            &mpistatus);
+        for (i=0; i<ntimes; i++) {
+            TRACE_IO(MPI_File_write_at_all, (fh, 0, NULL, 0, MPI_BYTE, &mpistatus));
+        }
     }
 
 fn_exit:
diff --git a/src/drivers/ncmpio/ncmpio_file_io.c b/src/drivers/ncmpio/ncmpio_file_io.c
index c1b732378..3787a9ab5 100644
--- a/src/drivers/ncmpio/ncmpio_file_io.c
+++ b/src/drivers/ncmpio/ncmpio_file_io.c
@@ -28,6 +28,7 @@ ncmpio_read_write(NC           *ncp,
                   void         *buf,
                   int           buftype_is_contig)
 {
+    char *mpi_name;
     int status=NC_NOERR, err=NC_NOERR, mpireturn;
     MPI_Status mpistatus;
     MPI_File fh;
@@ -37,16 +38,19 @@ ncmpio_read_write(NC           *ncp,
     MPI_Count btype_size;
     /* MPI_Type_size_c is introduced in MPI 4.0 */
     mpireturn = MPI_Type_size_c(buf_type, &btype_size);
+    mpi_name = "MPI_Type_size_c";
 #elif defined(HAVE_MPI_TYPE_SIZE_X)
     MPI_Count btype_size;
     /* MPI_Type_size_x is introduced in MPI 3.0 */
     mpireturn = MPI_Type_size_x(buf_type, &btype_size);
+    mpi_name = "MPI_Type_size_x";
 #else
     int btype_size;
     mpireturn = MPI_Type_size(buf_type, &btype_size);
+    mpi_name = "MPI_Type_size";
 #endif
     if (mpireturn != MPI_SUCCESS) {
-        err = ncmpii_error_mpi2nc(mpireturn, "MPI_Type_size");
+        err = ncmpii_error_mpi2nc(mpireturn, mpi_name);
         /* return the first encountered error if there is any */
         err = (err == NC_EFILE) ? NC_EREAD : err;
     }
@@ -85,22 +89,14 @@ ncmpio_read_write(NC           *ncp,
 
     if (rw_flag == NC_REQ_RD) {
         void         *xbuf=buf;
-        int           xlen=(int)buf_count;
         MPI_Datatype  xbuf_type=buf_type;
 
-        if (buf_count > NC_MAX_INT) {
 #ifdef HAVE_MPI_LARGE_COUNT
-            mpireturn = MPI_Type_contiguous_c((MPI_Count)buf_count, buf_type, &xbuf_type);
-            if (mpireturn != MPI_SUCCESS) {
-                err = ncmpii_error_mpi2nc(mpireturn, "MPI_Type_contiguous_c");
-                if (coll_indep == NC_REQ_COLL)
-                    DEBUG_ASSIGN_ERROR(status, err)
-                else
-                    DEBUG_RETURN_ERROR(err)
-            }
-            MPI_Type_commit(&xbuf_type);
-            xlen = 1;
+        MPI_Count xlen = (MPI_Count)buf_count;
 #else
+        int xlen = (int)buf_count;
+
+        if (buf_count > NC_MAX_INT) {
             if (coll_indep == NC_REQ_COLL) {
 #ifdef PNETCDF_DEBUG
                 fprintf(stderr,"%d: %s line %d:  NC_EINTOVERFLOW buf_count=%lld\n",
@@ -112,17 +108,21 @@ ncmpio_read_write(NC           *ncp,
             }
             else
                 DEBUG_RETURN_ERROR(NC_EINTOVERFLOW)
-#endif
         }
-        else if (buf_count > 0 && !buftype_is_contig &&
-                 req_size <= ncp->ibuf_size) {
+#endif
+
+        if (xlen > 0 && !buftype_is_contig && req_size <= ncp->ibuf_size) {
             /* if read buffer is noncontiguous and size is < ncp->ibuf_size,
              * allocate a temporary buffer and use it to read, as some MPI,
              * e.g. Cray on KNL, can be significantly slow when read buffer is
              * noncontiguous.
              */
+#ifdef HAVE_MPI_LARGE_COUNT
+            xbuf_type = MPI_BYTE;
+            xlen = (MPI_Count)req_size;
+#else
             if (req_size > NC_MAX_INT) {
-                mpireturn = MPI_Type_contiguous((int)buf_count, buf_type, &xbuf_type);
+                mpireturn = MPI_Type_contiguous(xlen, buf_type, &xbuf_type);
                 if (mpireturn != MPI_SUCCESS) {
                     err = ncmpii_error_mpi2nc(mpireturn, "MPI_Type_contiguous");
                     if (coll_indep == NC_REQ_COLL)
@@ -137,33 +137,32 @@ ncmpio_read_write(NC           *ncp,
                 xbuf_type = MPI_BYTE;
                 xlen = (int)req_size;
             }
+#endif
             xbuf = NCI_Malloc((size_t)req_size);
         }
 
         if (ncp->nprocs > 1 && coll_indep == NC_REQ_COLL) {
-            TRACE_IO(MPI_File_read_at_all)(fh, offset, xbuf, xlen, xbuf_type,
-                                           &mpistatus);
-            if (mpireturn != MPI_SUCCESS) {
-                err = ncmpii_error_mpi2nc(mpireturn, "MPI_File_read_at_all");
-                /* return the first encountered error if there is any */
-                if (status == NC_NOERR) {
-                    err = (err == NC_EFILE) ? NC_EREAD : err;
-                    DEBUG_ASSIGN_ERROR(status, err)
-                }
-            }
+#ifdef HAVE_MPI_LARGE_COUNT
+            TRACE_IO(MPI_File_read_at_all_c, (fh, offset, xbuf, xlen, xbuf_type, &mpistatus));
+#else
+            TRACE_IO(MPI_File_read_at_all, (fh, offset, xbuf, xlen, xbuf_type, &mpistatus));
+#endif
         } else {
-            TRACE_IO(MPI_File_read_at)(fh, offset, xbuf, xlen, xbuf_type,
-                                       &mpistatus);
-            if (mpireturn != MPI_SUCCESS) {
-                err = ncmpii_error_mpi2nc(mpireturn, "MPI_File_read_at");
-                /* return the first encountered error if there is any */
-                if (status == NC_NOERR) {
-                    err = (err == NC_EFILE) ? NC_EREAD : err;
-                    DEBUG_RETURN_ERROR(err)
-                }
+#ifdef HAVE_MPI_LARGE_COUNT
+            TRACE_IO(MPI_File_read_at_c, (fh, offset, xbuf, xlen, xbuf_type, &mpistatus));
+#else
+            TRACE_IO(MPI_File_read_at, (fh, offset, xbuf, xlen, xbuf_type, &mpistatus));
+#endif
+        }
+        if (mpireturn != MPI_SUCCESS) {
+            err = ncmpii_error_mpi2nc(mpireturn, mpi_name);
+            /* return the first encountered error if there is any */
+            if (status == NC_NOERR) {
+                err = (err == NC_EFILE) ? NC_EREAD : err;
+                DEBUG_ASSIGN_ERROR(status, err)
             }
         }
-        if (mpireturn == MPI_SUCCESS) {
+        else {
             /* update the number of bytes read since file open */
 #ifdef HAVE_MPI_GET_COUNT_C
             MPI_Count get_size;
@@ -193,13 +192,15 @@ ncmpio_read_write(NC           *ncp,
             MPI_Count pos=0;
             mpireturn = MPI_Unpack_c(xbuf, xlen, &pos, buf, (MPI_Count)buf_count,
                                      buf_type, MPI_COMM_SELF);
+            mpi_name = "MPI_Unpack_c";
 #else
             int pos=0;
             mpireturn = MPI_Unpack(xbuf, xlen, &pos, buf, (int)buf_count,
                                    buf_type, MPI_COMM_SELF);
+            mpi_name = "MPI_Unpack";
 #endif
             if (mpireturn != MPI_SUCCESS) {
-                err = ncmpii_error_mpi2nc(mpireturn, "MPI_Unpack");
+                err = ncmpii_error_mpi2nc(mpireturn, mpi_name);
                 if (coll_indep == NC_REQ_COLL)
                     DEBUG_ASSIGN_ERROR(status, err)
                 else
@@ -211,22 +212,13 @@ ncmpio_read_write(NC           *ncp,
             MPI_Type_free(&xbuf_type);
     } else { /* NC_REQ_WR */
         void         *xbuf=buf;
-        int           xlen=(int)buf_count;
         MPI_Datatype  xbuf_type=buf_type;
 
-        if (buf_count > NC_MAX_INT) {
 #ifdef HAVE_MPI_LARGE_COUNT
-            mpireturn = MPI_Type_contiguous_c((MPI_Count)buf_count, buf_type, &xbuf_type);
-            if (mpireturn != MPI_SUCCESS) {
-                err = ncmpii_error_mpi2nc(mpireturn, "MPI_Type_contiguous_c");
-                if (coll_indep == NC_REQ_COLL)
-                    DEBUG_ASSIGN_ERROR(status, err)
-                else
-                    DEBUG_RETURN_ERROR(err)
-            }
-            MPI_Type_commit(&xbuf_type);
-            xlen = 1;
+        MPI_Count xlen = (MPI_Count)buf_count;
 #else
+        int xlen = (int)buf_count;
+        if (buf_count > NC_MAX_INT) {
             if (coll_indep == NC_REQ_COLL) {
 #ifdef PNETCDF_DEBUG
                 fprintf(stderr,"%d: %s line %d:  NC_EINTOVERFLOW buf_count=%lld\n",
@@ -238,87 +230,71 @@ ncmpio_read_write(NC           *ncp,
             }
             else
                 DEBUG_RETURN_ERROR(NC_EINTOVERFLOW)
-#endif
         }
-        else if (buf_count > 0 && !buftype_is_contig &&
-                 req_size <= ncp->ibuf_size) {
+#endif
+
+        if (xlen > 0 && !buftype_is_contig && req_size <= ncp->ibuf_size) {
             /* if write buffer is noncontiguous and size is < ncp->ibuf_size,
              * allocate a temporary buffer and use it to write, as some MPI,
              * e.g. Cray on KNL, can be significantly slow when write buffer is
              * noncontiguous.
              */
-            if (req_size > NC_MAX_INT) {
 #ifdef HAVE_MPI_LARGE_COUNT
-                MPI_Count pos=0;
-                xbuf = NCI_Malloc(req_size);
-                mpireturn = MPI_Pack_c(buf, (MPI_Count)buf_count, buf_type, xbuf,
-                                       (MPI_Count)req_size, &pos, MPI_COMM_SELF);
-                if (mpireturn != MPI_SUCCESS) {
-                    err = ncmpii_error_mpi2nc(mpireturn, "MPI_Pack_c");
-                    if (coll_indep == NC_REQ_COLL)
-                        DEBUG_ASSIGN_ERROR(status, err)
-                    else
-                        DEBUG_RETURN_ERROR(err)
-                }
-                mpireturn = MPI_Type_contiguous_c((MPI_Count)req_size, MPI_BYTE, &xbuf_type);
-                if (mpireturn != MPI_SUCCESS) {
-                    err = ncmpii_error_mpi2nc(mpireturn, "MPI_Type_contiguous_c");
-                    if (coll_indep == NC_REQ_COLL) {
-                        DEBUG_ASSIGN_ERROR(status, err)
-                        xlen = 0;
-                    }
-                    else
-                        DEBUG_RETURN_ERROR(err)
-                }
-                MPI_Type_commit(&xbuf_type);
-                xlen = 1;
+            MPI_Count pos=0;
+            xbuf_type = MPI_BYTE;
+            xlen = (MPI_Count)req_size;
+            xbuf = NCI_Malloc(req_size);
+            mpireturn = MPI_Pack_c(buf, (MPI_Count)buf_count, buf_type, xbuf,
+                                   (MPI_Count)req_size, &pos, MPI_COMM_SELF);
+            mpi_name = "MPI_Pack_c";
 #else
+            if (req_size > NC_MAX_INT) {
                 /* skip packing write data into a temp buffer */
                 xlen = (int)buf_count;
                 xbuf_type = buf_type;
-#endif
+                mpireturn = MPI_SUCCESS;
             }
             else {
                 int pos=0;
+                xbuf_type = MPI_BYTE;
                 xlen = (int)req_size;
                 xbuf = NCI_Malloc(xlen);
                 mpireturn = MPI_Pack(buf, (int)buf_count, buf_type, xbuf,
                                      xlen, &pos, MPI_COMM_SELF);
-                if (mpireturn != MPI_SUCCESS) {
-                    err = ncmpii_error_mpi2nc(mpireturn, "MPI_Pack");
-                    if (coll_indep == NC_REQ_COLL)
-                        DEBUG_ASSIGN_ERROR(status, err)
-                    else
-                        DEBUG_RETURN_ERROR(err)
-                }
-                xbuf_type = MPI_BYTE;
+                mpi_name = "MPI_Pack";
             }
-        }
-
-        if (ncp->nprocs > 1 && coll_indep == NC_REQ_COLL) {
-            TRACE_IO(MPI_File_write_at_all)(fh, offset, xbuf, xlen, xbuf_type,
-                                            &mpistatus);
+#endif
             if (mpireturn != MPI_SUCCESS) {
-                err = ncmpii_error_mpi2nc(mpireturn, "MPI_File_write_at_all");
-                /* return the first encountered error if there is any */
-                if (status == NC_NOERR) {
-                    err = (err == NC_EFILE) ? NC_EWRITE : err;
+                err = ncmpii_error_mpi2nc(mpireturn, mpi_name);
+                if (coll_indep == NC_REQ_COLL)
                     DEBUG_ASSIGN_ERROR(status, err)
-                }
+                else
+                    DEBUG_RETURN_ERROR(err)
             }
+        }
+
+        if (ncp->nprocs > 1 && coll_indep == NC_REQ_COLL) {
+#ifdef HAVE_MPI_LARGE_COUNT
+            TRACE_IO(MPI_File_write_at_all_c, (fh, offset, xbuf, xlen, xbuf_type, &mpistatus));
+#else
+            TRACE_IO(MPI_File_write_at_all, (fh, offset, xbuf, xlen, xbuf_type, &mpistatus));
+#endif
         } else {
-            TRACE_IO(MPI_File_write_at)(fh, offset, xbuf, xlen, xbuf_type,
-                                        &mpistatus);
-            if (mpireturn != MPI_SUCCESS) {
-                err = ncmpii_error_mpi2nc(mpireturn, "MPI_File_write_at");
-                /* return the first encountered error if there is any */
-                if (status == NC_NOERR) {
-                    err = (err == NC_EFILE) ? NC_EWRITE : err;
-                    DEBUG_RETURN_ERROR(err)
-                }
+#ifdef HAVE_MPI_LARGE_COUNT
+            TRACE_IO(MPI_File_write_at_c, (fh, offset, xbuf, xlen, xbuf_type, &mpistatus));
+#else
+            TRACE_IO(MPI_File_write_at, (fh, offset, xbuf, xlen, xbuf_type, &mpistatus));
+#endif
+        }
+        if (mpireturn != MPI_SUCCESS) {
+            err = ncmpii_error_mpi2nc(mpireturn, mpi_name);
+            /* return the first encountered error if there is any */
+            if (status == NC_NOERR) {
+                err = (err == NC_EFILE) ? NC_EWRITE : err;
+                DEBUG_ASSIGN_ERROR(status, err)
             }
         }
-        if (mpireturn == MPI_SUCCESS) {
+        else {
             /* update the number of bytes written since file open */
 #ifdef HAVE_MPI_GET_COUNT_C
             MPI_Count put_size;
diff --git a/src/drivers/ncmpio/ncmpio_file_misc.c b/src/drivers/ncmpio/ncmpio_file_misc.c
index 2049559d8..f24185de2 100644
--- a/src/drivers/ncmpio/ncmpio_file_misc.c
+++ b/src/drivers/ncmpio/ncmpio_file_misc.c
@@ -81,6 +81,7 @@ dup_NC(const NC *ref)
 int
 ncmpio_redef(void *ncdp)
 {
+    char *mpi_name;
     int err, status=NC_NOERR, mpireturn;
     NC *ncp = (NC*)ncdp;
 
@@ -107,18 +108,18 @@ ncmpio_redef(void *ncdp)
     fSet(ncp->flags, NC_MODE_DEF);
 
     /* must reset fileview as header extent may later change in enddef() */
-    TRACE_IO(MPI_File_set_view)(ncp->collective_fh, 0, MPI_BYTE,
-                                MPI_BYTE, "native", MPI_INFO_NULL);
+    TRACE_IO(MPI_File_set_view, (ncp->collective_fh, 0, MPI_BYTE,
+                                 MPI_BYTE, "native", MPI_INFO_NULL));
     if (mpireturn != MPI_SUCCESS) {
-        err = ncmpii_error_mpi2nc(mpireturn, "MPI_File_set_view");
+        err = ncmpii_error_mpi2nc(mpireturn, mpi_name);
         DEBUG_ASSIGN_ERROR(status, err)
     }
 
     if (ncp->independent_fh != MPI_FILE_NULL) {
-        TRACE_IO(MPI_File_set_view)(ncp->independent_fh, 0, MPI_BYTE,
-                                    MPI_BYTE, "native", MPI_INFO_NULL);
+        TRACE_IO(MPI_File_set_view, (ncp->independent_fh, 0, MPI_BYTE,
+                                     MPI_BYTE, "native", MPI_INFO_NULL));
         if (mpireturn != MPI_SUCCESS) {
-            err = ncmpii_error_mpi2nc(mpireturn, "MPI_File_set_view");
+            err = ncmpii_error_mpi2nc(mpireturn, mpi_name);
             DEBUG_ASSIGN_ERROR(status, err)
         }
     }
@@ -131,6 +132,7 @@ ncmpio_redef(void *ncdp)
 int
 ncmpio_begin_indep_data(void *ncdp)
 {
+    char *mpi_name;
     NC *ncp = (NC*)ncdp;
 
     if (NC_indef(ncp))  /* must not be in define mode */
@@ -158,11 +160,11 @@ ncmpio_begin_indep_data(void *ncdp)
      */
     if (ncp->independent_fh == MPI_FILE_NULL) {
         int mpireturn;
-        TRACE_IO(MPI_File_open)(MPI_COMM_SELF, ncp->path,
-                                ncp->mpiomode, ncp->mpiinfo,
-                                &ncp->independent_fh);
+        TRACE_IO(MPI_File_open, (MPI_COMM_SELF, ncp->path,
+                                 ncp->mpiomode, ncp->mpiinfo,
+                                 &ncp->independent_fh));
         if (mpireturn != MPI_SUCCESS)
-            return ncmpii_error_mpi2nc(mpireturn, "MPI_File_open");
+            return ncmpii_error_mpi2nc(mpireturn, mpi_name);
     }
     return NC_NOERR;
 }
@@ -442,11 +444,12 @@ int
 ncmpi_delete(const char *filename,
              MPI_Info    info)
 {
+    char *mpi_name;
     int err=NC_NOERR, mpireturn;
 
-    TRACE_IO(MPI_File_delete)((char*)filename, info);
+    TRACE_IO(MPI_File_delete, ((char*)filename, info));
     if (mpireturn != MPI_SUCCESS)
-        err = ncmpii_error_mpi2nc(mpireturn, "MPI_File_delete");
+        err = ncmpii_error_mpi2nc(mpireturn, mpi_name);
     return err;
 }
 
diff --git a/src/drivers/ncmpio/ncmpio_filetype.c b/src/drivers/ncmpio/ncmpio_filetype.c
index 8a7e46d8b..828ab4132 100644
--- a/src/drivers/ncmpio/ncmpio_filetype.c
+++ b/src/drivers/ncmpio/ncmpio_filetype.c
@@ -620,12 +620,13 @@ ncmpio_file_set_view(const NC     *ncp,
                      MPI_Offset   *offset,  /* IN/OUT */
                      MPI_Datatype  filetype)
 {
+    char *mpi_name;
     int err, mpireturn, status=NC_NOERR;
 
     if (filetype == MPI_BYTE) {
         /* filetype is a contiguous space, make the whole file visible */
-        TRACE_IO(MPI_File_set_view)(fh, 0, MPI_BYTE, MPI_BYTE,
-                                    "native", MPI_INFO_NULL);
+        TRACE_IO(MPI_File_set_view, (fh, 0, MPI_BYTE, MPI_BYTE,
+                                     "native", MPI_INFO_NULL));
         return NC_NOERR;
     }
 
@@ -685,8 +686,8 @@ ncmpio_file_set_view(const NC     *ncp,
 #ifndef HAVE_MPI_LARGE_COUNT
 err_out:
 #endif
-        TRACE_IO(MPI_File_set_view)(fh, 0, MPI_BYTE, root_filetype, "native",
-                                    MPI_INFO_NULL);
+        TRACE_IO(MPI_File_set_view, (fh, 0, MPI_BYTE, root_filetype, "native",
+                                     MPI_INFO_NULL));
         if (root_filetype != MPI_BYTE)
             MPI_Type_free(&root_filetype);
 
@@ -694,13 +695,13 @@ ncmpio_file_set_view(const NC     *ncp,
         *offset = ncp->begin_var;
     }
     else {
-        TRACE_IO(MPI_File_set_view)(fh, *offset, MPI_BYTE, filetype, "native",
-                                    MPI_INFO_NULL);
+        TRACE_IO(MPI_File_set_view, (fh, *offset, MPI_BYTE, filetype, "native",
+                                     MPI_INFO_NULL));
         /* the explicit offset is already set in fileview */
         *offset = 0;
     }
     if (mpireturn != MPI_SUCCESS) {
-        err = ncmpii_error_mpi2nc(mpireturn, "MPI_File_set_view");
+        err = ncmpii_error_mpi2nc(mpireturn, mpi_name);
         if (status == NC_NOERR) status = err;
     }
 
diff --git a/src/drivers/ncmpio/ncmpio_fill.c b/src/drivers/ncmpio/ncmpio_fill.c
index 712c3fd66..e392a366d 100644
--- a/src/drivers/ncmpio/ncmpio_fill.c
+++ b/src/drivers/ncmpio/ncmpio_fill.c
@@ -144,6 +144,7 @@ fill_var_rec(NC         *ncp,
              NC_var     *varp,
              MPI_Offset  recno) /* record number */
 {
+    char *mpi_name;
     int err, status=NC_NOERR, mpireturn;
     void *buf;
     MPI_Offset var_len, start, count, offset;
@@ -192,43 +193,48 @@ fill_var_rec(NC         *ncp,
     fh = ncp->collective_fh;
 
     /* make the entire file visible */
-    TRACE_IO(MPI_File_set_view)(fh, 0, MPI_BYTE, MPI_BYTE, "native",
-                                MPI_INFO_NULL);
+    TRACE_IO(MPI_File_set_view, (fh, 0, MPI_BYTE, MPI_BYTE, "native",
+                                 MPI_INFO_NULL));
+    if (mpireturn != MPI_SUCCESS) {
+        err = ncmpii_error_mpi2nc(mpireturn, mpi_name);
+        if (status == NC_NOERR) status = err;
+    }
 
     count *= varp->xsz;
 
     bufType = MPI_BYTE;
+
+#ifndef HAVE_MPI_LARGE_COUNT
     if (count > NC_MAX_INT) {
-#ifdef HAVE_MPI_LARGE_COUNT
-        mpireturn = MPI_Type_contiguous_c((MPI_Count)count, MPI_BYTE, &bufType);
-        if (mpireturn != MPI_SUCCESS) {
-            err = ncmpii_error_mpi2nc(mpireturn, "MPI_Type_contiguous_c");
-            if (status == NC_NOERR) status = err;
-            /* still participate collective write with 0-length request */
-            count = 0;
-        }
-        else {
-            MPI_Type_commit(&bufType);
-            count = 1;
-        }
-#else
         DEBUG_ASSIGN_ERROR(err, NC_EINTOVERFLOW)
         if (status == NC_NOERR) status = err;
         count = 0; /* participate collective write with 0-length request */
-#endif
     }
+#endif
 
     /* write to variable collectively */
-    if (ncp->nprocs > 1)
-        TRACE_IO(MPI_File_write_at_all)(fh, offset, buf, (int)count, bufType,
-                                        &mpistatus);
-    else
-        TRACE_IO(MPI_File_write_at)(fh, offset, buf, (int)count, bufType,
-                                    &mpistatus);
+    if (ncp->nprocs > 1) {
+#ifdef HAVE_MPI_LARGE_COUNT
+        TRACE_IO(MPI_File_write_at_all_c, (fh, offset, buf, (MPI_Count)count,
+                                           bufType, &mpistatus));
+#else
+        TRACE_IO(MPI_File_write_at_all, (fh, offset, buf, (int)count,
+                                         bufType, &mpistatus));
+#endif
+    }
+    else {
+#ifdef HAVE_MPI_LARGE_COUNT
+        TRACE_IO(MPI_File_write_at_c, (fh, offset, buf, (MPI_Count)count,
+                                       bufType, &mpistatus));
+#else
+        TRACE_IO(MPI_File_write_at, (fh, offset, buf, (int)count,
+                                     bufType, &mpistatus));
+#endif
+    }
     NCI_Free(buf);
     if (bufType != MPI_BYTE) MPI_Type_free(&bufType);
     if (mpireturn != MPI_SUCCESS) {
-        err = ncmpii_error_mpi2nc(mpireturn, "MPI_File_write_at_all");
+        err = ncmpii_error_mpi2nc(mpireturn, mpi_name);
         if (status == NC_NOERR) status = err;
     }
 
@@ -359,7 +365,7 @@ fillerup_aggregate(NC *ncp, NC *old_ncp)
 {
     int i, j, k, mpireturn, err, status=NC_NOERR;
     int start_vid, recno, nVarsFill;
-    char *buf_ptr, *noFill;
+    char *buf_ptr, *noFill, *mpi_name;
     void *buf;
     size_t nsegs;
     MPI_Offset buf_len, var_len, nrecs, start, *count;
@@ -620,8 +626,8 @@ fillerup_aggregate(NC *ncp, NC *old_ncp)
     /* when nprocs == 1, we keep I/O mode in independent mode at all time */
     fh = ncp->collective_fh;
 
-    TRACE_IO(MPI_File_set_view)(fh, 0, MPI_BYTE, filetype, "native",
-                                MPI_INFO_NULL);
+    TRACE_IO(MPI_File_set_view, (fh, 0, MPI_BYTE, filetype, "native",
+                                 MPI_INFO_NULL));
     if (k > 0) MPI_Type_free(&filetype);
 
     bufType = MPI_BYTE;
@@ -648,20 +654,38 @@ fillerup_aggregate(NC *ncp, NC *old_ncp)
     }
 
     /* write to variable collectively */
-    if (ncp->nprocs > 1)
-        TRACE_IO(MPI_File_write_at_all)(fh, 0, buf, (int)buf_len, bufType, &mpistatus);
-    else
-        TRACE_IO(MPI_File_write_at)(fh, 0, buf, (int)buf_len, bufType, &mpistatus);
+    if (ncp->nprocs > 1) {
+#ifdef HAVE_MPI_LARGE_COUNT
+        TRACE_IO(MPI_File_write_at_all_c, (fh, 0, buf, (MPI_Count)buf_len,
+                                           bufType, &mpistatus));
+#else
+        TRACE_IO(MPI_File_write_at_all, (fh, 0, buf, (int)buf_len,
+                                         bufType, &mpistatus));
+#endif
+    }
+    else {
+#ifdef HAVE_MPI_LARGE_COUNT
+        TRACE_IO(MPI_File_write_at_c, (fh, 0, buf, (MPI_Count)buf_len,
+                                       bufType, &mpistatus));
+#else
+        TRACE_IO(MPI_File_write_at, (fh, 0, buf, (int)buf_len,
+                                     bufType, &mpistatus));
+#endif
+    }
 
     NCI_Free(buf);
     if (bufType != MPI_BYTE) MPI_Type_free(&bufType);
+    if (mpireturn != MPI_SUCCESS) {
+        err = ncmpii_error_mpi2nc(mpireturn, mpi_name);
+        if (status == NC_NOERR) status = err;
+    }
 
-    TRACE_IO(MPI_File_set_view)(fh, 0, MPI_BYTE, MPI_BYTE, "native",
-                                MPI_INFO_NULL);
-    if (mpireturn != MPI_SUCCESS)
-        if (status == NC_NOERR)
-            status = ncmpii_error_mpi2nc(mpireturn, "MPI_File_set_view");
-
+    TRACE_IO(MPI_File_set_view, (fh, 0, MPI_BYTE, MPI_BYTE, "native",
+                                 MPI_INFO_NULL));
+    if (mpireturn != MPI_SUCCESS) {
+        err = ncmpii_error_mpi2nc(mpireturn, mpi_name);
+        if (status == NC_NOERR) status = err;
+    }
     return status;
 }
 
diff --git a/src/drivers/ncmpio/ncmpio_header_get.c b/src/drivers/ncmpio/ncmpio_header_get.c
index f4a7f91a9..6ddd89bc1 100644
--- a/src/drivers/ncmpio/ncmpio_header_get.c
+++ b/src/drivers/ncmpio/ncmpio_header_get.c
@@ -321,6 +321,7 @@ hdr_len_NC_vararray(const NC_vararray *ncap,
  */
 static int
 hdr_fetch(bufferinfo *gbp) {
+    char *mpi_name;
     int rank, nprocs, err=NC_NOERR, mpireturn;
     MPI_Status mpistatus;
 
@@ -359,14 +360,16 @@ hdr_fetch(bufferinfo *gbp) {
 
         /* fileview is already entire file visible and MPI_File_read_at does
            not change the file pointer */
-        if (gbp->coll_mode == 1) /* collective read */
-            TRACE_IO(MPI_File_read_at_all)(gbp->collective_fh, gbp->offset, readBuf,
-                                           readLen, MPI_BYTE, &mpistatus);
-        else
-            TRACE_IO(MPI_File_read_at)(gbp->collective_fh, gbp->offset, readBuf,
-                                       readLen, MPI_BYTE, &mpistatus);
+        if (gbp->coll_mode == 1) { /* collective read */
+            TRACE_IO(MPI_File_read_at_all, (gbp->collective_fh, gbp->offset, readBuf,
+                                            readLen, MPI_BYTE, &mpistatus));
+        }
+        else {
+            TRACE_IO(MPI_File_read_at, (gbp->collective_fh, gbp->offset, readBuf,
+                                        readLen, MPI_BYTE, &mpistatus));
+        }
         if (mpireturn != MPI_SUCCESS) {
-            err = ncmpii_error_mpi2nc(mpireturn, "MPI_File_read_at");
+            err = ncmpii_error_mpi2nc(mpireturn, mpi_name);
             if (err == NC_EFILE) DEBUG_ASSIGN_ERROR(err, NC_EREAD)
         }
         else {
@@ -394,8 +397,12 @@ hdr_fetch(bufferinfo *gbp) {
     }
     else if (gbp->coll_mode == 1) { /* collective read */
         /* other processes participate the collective call */
-        TRACE_IO(MPI_File_read_at_all)(gbp->collective_fh, 0, NULL,
-                                       0, MPI_BYTE, &mpistatus);
+        TRACE_IO(MPI_File_read_at_all, (gbp->collective_fh, 0, NULL,
+                                        0, MPI_BYTE, &mpistatus));
+        if (mpireturn != MPI_SUCCESS) {
+            err = ncmpii_error_mpi2nc(mpireturn, mpi_name);
+            if (err == NC_EFILE) DEBUG_ASSIGN_ERROR(err, NC_EREAD)
+        }
     }
 
     if (gbp->safe_mode == 1 && nprocs > 1) {
diff --git a/src/drivers/ncmpio/ncmpio_header_put.c b/src/drivers/ncmpio/ncmpio_header_put.c
index 8c9c22a55..8daf88c67 100644
--- a/src/drivers/ncmpio/ncmpio_header_put.c
+++ b/src/drivers/ncmpio/ncmpio_header_put.c
@@ -514,6 +514,7 @@ ncmpio_hdr_put_NC(NC *ncp, void *buf)
  */
 int ncmpio_write_header(NC *ncp)
 {
+    char *mpi_name;
     int status=NC_NOERR, mpireturn, err;
     size_t i, ntimes;
     MPI_File fh;
@@ -562,15 +563,16 @@ int ncmpio_write_header(NC *ncp)
              */
             memset(&mpistatus, 0, sizeof(MPI_Status));
 
-            if (fIsSet(ncp->flags, NC_HCOLL)) /* header collective write */
-                TRACE_IO(MPI_File_write_at_all)(fh, offset, buf_ptr, writeLen,
-                                                MPI_BYTE, &mpistatus);
-            else /* header independent write */
-                TRACE_IO(MPI_File_write_at)(fh, offset, buf_ptr, writeLen,
-                                            MPI_BYTE, &mpistatus);
-
+            if (fIsSet(ncp->flags, NC_HCOLL)) { /* header collective write */
+                TRACE_IO(MPI_File_write_at_all, (fh, offset, buf_ptr, writeLen,
+                                                 MPI_BYTE, &mpistatus));
+            }
+            else { /* header independent write */
+                TRACE_IO(MPI_File_write_at, (fh, offset, buf_ptr, writeLen,
+                                             MPI_BYTE, &mpistatus));
+            }
             if (mpireturn != MPI_SUCCESS) {
-                err = ncmpii_error_mpi2nc(mpireturn, "MPI_File_write_at");
+                err = ncmpii_error_mpi2nc(mpireturn, mpi_name);
                 if (status == NC_NOERR) {
                     err = (err == NC_EFILE) ? NC_EWRITE : err;
                     DEBUG_ASSIGN_ERROR(status, err)
@@ -597,8 +599,9 @@ int ncmpio_write_header(NC *ncp)
     }
     else if (fIsSet(ncp->flags, NC_HCOLL)) { /* header collective write */
         /* collective write: other processes participate the collective call */
-        for (i=0; i<ntimes; i++)
-            TRACE_IO(MPI_File_write_at_all)(fh, 0, NULL, 0, MPI_BYTE, &mpistatus);
+        for (i=0; i<ntimes; i++) {
+            TRACE_IO(MPI_File_write_at_all, (fh, 0, NULL, 0, MPI_BYTE, &mpistatus));
+        }
     }
 
     if (ncp->safe_mode == 1) {
diff --git a/src/drivers/ncmpio/ncmpio_open.c b/src/drivers/ncmpio/ncmpio_open.c
index cdbfbbdc6..a24726ee9 100644
--- a/src/drivers/ncmpio/ncmpio_open.c
+++ b/src/drivers/ncmpio/ncmpio_open.c
@@ -39,7 +39,7 @@ ncmpio_open(MPI_Comm     comm,
             MPI_Info     user_info, /* user's and env info combined */
             void       **ncpp)
 {
-    char *env_str;
+    char *env_str, *mpi_name;
     int i, mpiomode, err, status=NC_NOERR, mpireturn;
     MPI_File fh;
     MPI_Info info_used;
@@ -74,14 +74,14 @@ ncmpio_open(MPI_Comm     comm,
     /* open file collectively ---------------------------------------------- */
     mpiomode = fIsSet(omode, NC_WRITE) ? MPI_MODE_RDWR : MPI_MODE_RDONLY;
 
-    TRACE_IO(MPI_File_open)(comm, (char *)path, mpiomode, user_info, &fh);
+    TRACE_IO(MPI_File_open, (comm, (char *)path, mpiomode, user_info, &fh));
     if (mpireturn != MPI_SUCCESS)
-        return ncmpii_error_mpi2nc(mpireturn, "MPI_File_open");
+        return ncmpii_error_mpi2nc(mpireturn, mpi_name);
 
     /* get the file info used/modified by MPI-IO */
-    mpireturn = MPI_File_get_info(fh, &info_used);
+    TRACE_IO(MPI_File_get_info, (fh, &info_used));
     if (mpireturn != MPI_SUCCESS)
-        return ncmpii_error_mpi2nc(mpireturn, "MPI_File_get_info");
+        return ncmpii_error_mpi2nc(mpireturn, mpi_name);
 
     /* Now the file has been successfully opened, allocate/set NC object */
 
diff --git a/src/drivers/ncmpio/ncmpio_sync.c b/src/drivers/ncmpio/ncmpio_sync.c
index 096d9fe9b..06490db43 100644
--- a/src/drivers/ncmpio/ncmpio_sync.c
+++ b/src/drivers/ncmpio/ncmpio_sync.c
@@ -33,21 +33,22 @@
  */
 int
 ncmpio_file_sync(NC *ncp) {
+    char *mpi_name;
     int mpireturn;
 
     if (ncp->independent_fh != MPI_FILE_NULL) {
-        TRACE_IO(MPI_File_sync)(ncp->independent_fh);
+        TRACE_IO(MPI_File_sync, (ncp->independent_fh));
         if (mpireturn != MPI_SUCCESS)
-            return ncmpii_error_mpi2nc(mpireturn, "MPI_File_sync");
+            return ncmpii_error_mpi2nc(mpireturn, mpi_name);
     }
     /* when nprocs == 1, ncp->collective_fh == ncp->independent_fh */
     if (ncp->nprocs == 1) return NC_NOERR;
 
     /* ncp->collective_fh is never MPI_FILE_NULL as collective mode is
      * default in PnetCDF */
-    TRACE_IO(MPI_File_sync)(ncp->collective_fh);
+    TRACE_IO(MPI_File_sync, (ncp->collective_fh));
     if (mpireturn != MPI_SUCCESS)
-        return ncmpii_error_mpi2nc(mpireturn, "MPI_File_sync");
+        return ncmpii_error_mpi2nc(mpireturn, mpi_name);
 
     /* Barrier is not necessary ...
     TRACE_COMM(MPI_Barrier)(ncp->comm);
@@ -68,6 +69,7 @@ int
 ncmpio_write_numrecs(NC         *ncp,
                      MPI_Offset  new_numrecs)
 {
+    char *mpi_name;
     int mpireturn, err;
     MPI_File fh;
     MPI_Status mpistatus;
@@ -85,8 +87,9 @@ ncmpio_write_numrecs(NC         *ncp,
 
     if (ncp->rank > 0 && fIsSet(ncp->flags, NC_HCOLL)) {
         /* other processes participate the collective call */
-        TRACE_IO(MPI_File_write_at_all)(fh, 0, NULL, 0, MPI_BYTE, &mpistatus);
-        return NC_NOERR;
+        TRACE_IO(MPI_File_write_at_all, (fh, 0, NULL, 0, MPI_BYTE, &mpistatus));
+        return (mpireturn == MPI_SUCCESS) ? NC_NOERR :
+               ncmpii_error_mpi2nc(mpireturn, mpi_name);
     }
 
     if (new_numrecs > ncp->numrecs || NC_ndirty(ncp)) {
@@ -118,14 +121,16 @@ ncmpio_write_numrecs(NC         *ncp,
         memset(&mpistatus, 0, sizeof(MPI_Status));
 
         /* root's file view always includes the entire file header */
-        if (fIsSet(ncp->flags, NC_HCOLL) && ncp->nprocs > 1)
-            TRACE_IO(MPI_File_write_at_all)(fh, NC_NUMRECS_OFFSET, (void*)pos,
-                                            len, MPI_BYTE, &mpistatus);
-        else
-            TRACE_IO(MPI_File_write_at)(fh, NC_NUMRECS_OFFSET, (void*)pos,
-                                        len, MPI_BYTE, &mpistatus);
+        if (fIsSet(ncp->flags, NC_HCOLL) && ncp->nprocs > 1) {
+            TRACE_IO(MPI_File_write_at_all, (fh, NC_NUMRECS_OFFSET, (void*)pos,
+                                             len, MPI_BYTE, &mpistatus));
+        }
+        else {
+            TRACE_IO(MPI_File_write_at, (fh, NC_NUMRECS_OFFSET, (void*)pos,
+                                         len, MPI_BYTE, &mpistatus));
+        }
         if (mpireturn != MPI_SUCCESS) {
-            err = ncmpii_error_mpi2nc(mpireturn, "MPI_File_write_at");
+            err = ncmpii_error_mpi2nc(mpireturn, mpi_name);
             if (err == NC_EFILE) DEBUG_RETURN_ERROR(NC_EWRITE)
         }
         else {
diff --git a/src/drivers/ncmpio/ncmpio_wait.c b/src/drivers/ncmpio/ncmpio_wait.c
index a4b2b7f3e..fc635acfa 100644
--- a/src/drivers/ncmpio/ncmpio_wait.c
+++ b/src/drivers/ncmpio/ncmpio_wait.c
@@ -52,6 +52,7 @@ static int mgetput(NC *ncp, int num_reqs, NC_req *reqs, int rw_flag,
 int
 ncmpio_getput_zero_req(NC *ncp, int reqMode)
 {
+    char *mpi_name;
     int err, mpireturn, status=NC_NOERR;
     MPI_Status mpistatus;
     MPI_File fh;
@@ -61,26 +62,29 @@ ncmpio_getput_zero_req(NC *ncp, int reqMode)
 
     fh = ncp->collective_fh;
 
-    TRACE_IO(MPI_File_set_view)(fh, 0, MPI_BYTE, MPI_BYTE, "native",
-                                MPI_INFO_NULL);
+    TRACE_IO(MPI_File_set_view, (fh, 0, MPI_BYTE, MPI_BYTE, "native", MPI_INFO_NULL));
 
     if (fIsSet(reqMode, NC_REQ_RD)) {
-        if (ncp->nprocs > 1)
-            TRACE_IO(MPI_File_read_at_all)(fh, 0, NULL, 0, MPI_BYTE, &mpistatus);
-        else
-            TRACE_IO(MPI_File_read_at)(fh, 0, NULL, 0, MPI_BYTE, &mpistatus);
+        if (ncp->nprocs > 1) {
+            TRACE_IO(MPI_File_read_at_all, (fh, 0, NULL, 0, MPI_BYTE, &mpistatus));
+        }
+        else {
+            TRACE_IO(MPI_File_read_at, (fh, 0, NULL, 0, MPI_BYTE, &mpistatus));
+        }
         if (mpireturn != MPI_SUCCESS) {
-            err = ncmpii_error_mpi2nc(mpireturn, "MPI_File_read_at_all");
+            err = ncmpii_error_mpi2nc(mpireturn, mpi_name);
             err = (err == NC_EFILE) ? NC_EREAD : err;
             DEBUG_ASSIGN_ERROR(status, err)
         }
     } else { /* write request */
-        if (ncp->nprocs > 1)
-            TRACE_IO(MPI_File_write_at_all)(fh, 0, NULL, 0, MPI_BYTE, &mpistatus);
-        else
-            TRACE_IO(MPI_File_write_at)(fh, 0, NULL, 0, MPI_BYTE, &mpistatus);
+        if (ncp->nprocs > 1) {
+            TRACE_IO(MPI_File_write_at_all, (fh, 0, NULL, 0, MPI_BYTE, &mpistatus));
+        }
+        else {
+            TRACE_IO(MPI_File_write_at, (fh, 0, NULL, 0, MPI_BYTE, &mpistatus));
+        }
         if (mpireturn != MPI_SUCCESS) {
-            err = ncmpii_error_mpi2nc(mpireturn, "MPI_File_write_at_all");
+            err = ncmpii_error_mpi2nc(mpireturn, mpi_name);
             err = (err == NC_EFILE) ? NC_EWRITE : err;
             DEBUG_ASSIGN_ERROR(status, err)
         }
@@ -88,8 +92,8 @@ ncmpio_getput_zero_req(NC *ncp, int reqMode)
 
     /* No longer need to reset the file view, as the root's fileview includes
      * the whole file header.
-     TRACE_IO(MPI_File_set_view)(fh, 0, MPI_BYTE, MPI_BYTE, "native",
-                                 MPI_INFO_NULL);
+     TRACE_IO(MPI_File_set_view, (fh, 0, MPI_BYTE, MPI_BYTE, "native",
+                                  MPI_INFO_NULL));
      */
 
     return status;
@@ -2083,8 +2087,8 @@ req_aggregation(NC     *ncp,
 
     /* No longer need to reset the file view, as the root's fileview includes
      * the whole file header.
-     TRACE_IO(MPI_File_set_view)(fh, 0, MPI_BYTE, MPI_BYTE, "native",
-                                 MPI_INFO_NULL);
+     TRACE_IO(MPI_File_set_view, (fh, 0, MPI_BYTE, MPI_BYTE, "native",
+                                  MPI_INFO_NULL));
      */
 
     return status;
@@ -2507,8 +2511,8 @@ mgetput(NC     *ncp,
 
     /* No longer need to reset the file view, as the root's fileview includes
      * the whole file header.
-     TRACE_IO(MPI_File_set_view)(fh, 0, MPI_BYTE, MPI_BYTE, "native",
-                                 MPI_INFO_NULL);
+     TRACE_IO(MPI_File_set_view, (fh, 0, MPI_BYTE, MPI_BYTE, "native",
+                                  MPI_INFO_NULL));
      */
 
     return status;
diff --git a/src/include/pnc_debug.h b/src/include/pnc_debug.h
index 7b9134111..976244896 100644
--- a/src/include/pnc_debug.h
+++ b/src/include/pnc_debug.h
@@ -22,9 +22,14 @@
 #endif
 
 #ifdef PNETCDF_TRACE_MPI_IO
-#define TRACE_IO(x) printf("TRACE-MPI-IO:   FILE %s FUNC %s() LINE %d calling %s()\n",__FILE__,__func__,__LINE__,#x),mpireturn=x
+#define TRACE_IO(x, y) { \
+    mpi_name = #x; \
+    printf("TRACE-MPI-IO:   FILE %s FUNC %s() LINE %d calling %s()\n", \
+           __FILE__,__func__,__LINE__,#x); \
+    mpireturn = x y ; \
+}
 #else
-#define TRACE_IO(x) mpireturn=x
+#define TRACE_IO(x, y) { mpi_name = #x; mpireturn = x y ; }
 #endif
 
 #define CHECK_MPI_ERROR(mpi_errorcode, err_msg, nc_err) {                     \