Brings monotonic timer changes from develop

21 files changed, 1901 insertions, 1013 deletions

diff --git a/MANIFEST b/MANIFEST
index 60bb838..cd4e209 100644
--- a/MANIFEST
+++ b/MANIFEST
@@ -190,6 +190,7 @@
 ./examples/h5_chunk_read.c
 ./examples/h5_compound.c
 ./examples/h5_crtgrpd.c
+./examples/h5_debug_trace.c
 ./examples/h5_subset.c
 ./examples/h5_cmprss.c
 ./examples/h5_rdwt.c
@@ -1183,6 +1184,7 @@
 ./test/theap.c
 ./test/thread_id.c
 ./test/tid.c
+./test/timer.c
 ./test/titerate.c
 ./test/tlayouto.h5
 ./test/tmeta.c
diff --git a/config/cmake/H5pubconf.h.in b/config/cmake/H5pubconf.h.in
index 7d4b28e..5ccf460 100644
--- a/config/cmake/H5pubconf.h.in
+++ b/config/cmake/H5pubconf.h.in
@@ -267,9 +267,6 @@
 /* Define to 1 if you have the `lstat' function. */
 #cmakedefine H5_HAVE_LSTAT @H5_HAVE_LSTAT@
 
-/* Define to 1 if you have the <mach/mach_time.h> header file. */
-#cmakedefine H5_HAVE_MACH_MACH_TIME_H @H5_HAVE_MACH_MACH_TIME_H@
-
 /* Define to 1 if you have the <memory.h> header file. */
 #cmakedefine H5_HAVE_MEMORY_H @H5_HAVE_MEMORY_H@
 
@@ -421,9 +418,6 @@
 /* Define to 1 if you have the <sys/stat.h> header file. */
 #cmakedefine H5_HAVE_SYS_STAT_H @H5_HAVE_SYS_STAT_H@
 
-/* Define to 1 if you have the <sys/timeb.h> header file. */
-#cmakedefine H5_HAVE_SYS_TIMEB_H @H5_HAVE_SYS_TIMEB_H@
-
 /* Define to 1 if you have the <sys/time.h> header file. */
 #cmakedefine H5_HAVE_SYS_TIME_H @H5_HAVE_SYS_TIME_H@
 
diff --git a/config/cmake_ext_mod/ConfigureChecks.cmake b/config/cmake_ext_mod/ConfigureChecks.cmake
index 93b977e..0ddb6d0 100644
--- a/config/cmake_ext_mod/ConfigureChecks.cmake
+++ b/config/cmake_ext_mod/ConfigureChecks.cmake
@@ -137,15 +137,11 @@ CHECK_INCLUDE_FILE_CONCAT ("stddef.h"        ${HDF_PREFIX}_HAVE_STDDEF_H)
 CHECK_INCLUDE_FILE_CONCAT ("stdint.h"        ${HDF_PREFIX}_HAVE_STDINT_H)
 CHECK_INCLUDE_FILE_CONCAT ("unistd.h"        ${HDF_PREFIX}_HAVE_UNISTD_H)
 
-# Darwin
-CHECK_INCLUDE_FILE_CONCAT ("mach/mach_time.h" ${HDF_PREFIX}_HAVE_MACH_MACH_TIME_H)
-
 # Windows
 CHECK_INCLUDE_FILE_CONCAT ("io.h"            ${HDF_PREFIX}_HAVE_IO_H)
 if (NOT CYGWIN)
   CHECK_INCLUDE_FILE_CONCAT ("winsock2.h"      ${HDF_PREFIX}_HAVE_WINSOCK2_H)
 endif ()
-CHECK_INCLUDE_FILE_CONCAT ("sys/timeb.h"     ${HDF_PREFIX}_HAVE_SYS_TIMEB_H)
 
 if (CMAKE_SYSTEM_NAME MATCHES "OSF")
   CHECK_INCLUDE_FILE_CONCAT ("sys/sysinfo.h" ${HDF_PREFIX}_HAVE_SYS_SYSINFO_H)
@@ -166,6 +162,8 @@ CHECK_INCLUDE_FILE_CONCAT ("memory.h"        ${HDF_PREFIX}_HAVE_MEMORY_H)
 CHECK_INCLUDE_FILE_CONCAT ("dlfcn.h"         ${HDF_PREFIX}_HAVE_DLFCN_H)
 CHECK_INCLUDE_FILE_CONCAT ("inttypes.h"      ${HDF_PREFIX}_HAVE_INTTYPES_H)
 CHECK_INCLUDE_FILE_CONCAT ("netinet/in.h"    ${HDF_PREFIX}_HAVE_NETINET_IN_H)
+CHECK_INCLUDE_FILE_CONCAT ("netdb.h"         ${HDF_PREFIX}_HAVE_NETDB_H)
+CHECK_INCLUDE_FILE_CONCAT ("arpa/inet.h"     ${HDF_PREFIX}_HAVE_ARPA_INET_H)
 # _Bool type support
 CHECK_INCLUDE_FILE_CONCAT (stdbool.h    ${HDF_PREFIX}_HAVE_STDBOOL_H)
 
diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
index 8383ba2..bc9a445 100644
--- a/examples/CMakeLists.txt
+++ b/examples/CMakeLists.txt
@@ -29,6 +29,7 @@ set (examples
     h5_extlink
     h5_elink_unix2win
     h5_shared_mesg
+    h5_debug_trace
     h5_vds
     h5_vds-exc
     h5_vds-exclim
diff --git a/examples/Makefile.am b/examples/Makefile.am
index 12ec52a..adc86ed 100644
--- a/examples/Makefile.am
+++ b/examples/Makefile.am
@@ -35,22 +35,23 @@ EXAMPLE_PROG = h5_write h5_read h5_extend_write h5_chunk_read h5_compound \
             h5_crtgrpd h5_subset h5_cmprss h5_rdwt h5_crtgrpar h5_extend \
             h5_crtatt h5_crtgrp h5_crtdat \
             h5_group h5_select h5_attribute h5_mount h5_reference h5_drivers \
-            h5_ref2reg h5_extlink h5_elink_unix2win h5_shared_mesg h5_vds h5_vds-exc \
-            h5_vds-exclim h5_vds-eiger h5_vds-simpleIO h5_vds-percival \
+            h5_ref2reg h5_extlink h5_elink_unix2win h5_shared_mesg h5_debug_trace \
+            h5_vds h5_vds-exc h5_vds-exclim h5_vds-eiger h5_vds-simpleIO h5_vds-percival \
             h5_vds-percival-unlim h5_vds-percival-unlim-maxmin
 TEST_SCRIPT=testh5cc.sh
 TEST_EXAMPLES_SCRIPT=$(INSTALL_SCRIPT_FILES)
 
 # Install files
 # List all file that should be installed in examples directory
-INSTALL_FILES = h5_write.c h5_read.c h5_extend_write.c h5_chunk_read.c   \
-            h5_crtgrpd.c h5_subset.c h5_cmprss.c h5_rdwt.c h5_crtgrpar.c \
-            h5_extend.c h5_crtatt.c h5_crtgrp.c h5_crtdat.c \
-            h5_compound.c h5_group.c h5_select.c h5_attribute.c h5_mount.c \
-            h5_reference.c h5_drivers.c h5_extlink.c h5_elink_unix2win.c   \
-            h5_ref2reg.c h5_shared_mesg.c ph5example.c h5_vds.c h5_vds-exc.c \
-            h5_vds-exclim.c h5_vds-eiger.c h5_vds-simpleIO.c h5_vds-percival.c \
-            h5_vds-percival-unlim.c h5_vds-percival-unlim-maxmin.c
+INSTALL_FILES = h5_write.c h5_read.c h5_extend_write.c h5_chunk_read.c h5_compound.c \
+            h5_crtgrpd.c h5_subset.c h5_cmprss.c h5_rdwt.c h5_crtgrpar.c h5_extend.c \
+            h5_crtatt.c h5_crtgrp.c h5_crtdat.c \
+            h5_group.c h5_select.c h5_attribute.c h5_mount.c h5_drivers.c \
+            h5_reference.c  h5_ref2reg.c \
+            h5_extlink.c h5_elink_unix2win.c h5_shared_mesg.c h5_debug_trace.c \
+            ph5example.c \
+            h5_vds.c h5_vds-exc.c h5_vds-exclim.c h5_vds-eiger.c h5_vds-simpleIO.c \
+            h5_vds-percival.c h5_vds-percival-unlim.c h5_vds-percival-unlim-maxmin.c
 
 
 
diff --git a/examples/h5_debug_trace.c b/examples/h5_debug_trace.c
new file mode 100644
index 0000000..5da55ed
--- /dev/null
+++ b/examples/h5_debug_trace.c
@@ -0,0 +1,144 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright by The HDF Group.                                               *
+ * Copyright by the Board of Trustees of the University of Illinois.         *
+ * All rights reserved.                                                      *
+ *                                                                           *
+ * This file is part of HDF5.  The full HDF5 copyright notice, including     *
+ * terms governing use, modification, and redistribution, is contained in    *
+ * the files COPYING and Copyright.html.  COPYING can be found at the root   *
+ * of the source code distribution tree; Copyright.html can be found at the  *
+ * root level of an installed copy of the electronic HDF5 document set and   *
+ * is linked from the top-level documents page.  It can also be found at     *
+ * http://hdfgroup.org/HDF5/doc/Copyright.html.  If you do not have          *
+ * access to either file, you may request a copy from help@hdfgroup.org.     *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+ 
+/* This example demonstrates debug trace output.
+ *
+ * Debug/trace/performance output is not tested as a regular part of our
+ * testing so this program gives a quick check that it's all working.
+ *
+ * Preconditions:
+ *
+ * You need to set an environment variable named HDF5_DEBUG to have a value
+ * of "+all trace ttimes".  In the bash shell, you'd use:
+ *
+ *      export HDF5_DEBUG="+all trace ttimes"
+ *
+ * When you are done with this test program, you can set the variable back
+ * to "-all" to suppress trace output.
+ *
+ * Usage:
+ *
+ * Compile and run the test program, then inspect the output.  You should see
+ * trace information for each HDF5 function call that increase over time.
+ * Each time stamp is in seconds and designated with an '@' sign.  The
+ * elapsed time for the function call is given in seconds in the [dt= ]
+ * part.
+ *
+ * You will also get summary output for the shuffle filter performance and
+ * data type conversion performance.  These will include the elapsed time
+ * (always) and the system and user times (if available on your system).  On
+ * fast machines, these numbers may be 0.0.  Adjust the loop variables in
+ * the program as needed to generate reasonable output.
+ */
+ 
+#include <stdio.h>
+#include <stdlib.h>
+ 
+#include "hdf5.h"
+ 
+#define BUF_SIZE   1048576
+#define N_LOOPS    64
+ 
+#define TESTFILE "h5_debug_trace_out.h5"
+ 
+int
+main(int argc, char **argv)
+{
+    int i, j;
+    int *data;
+    
+    hid_t   fid;
+    hid_t   pid;
+    hid_t   did;
+    hid_t   sid;
+    
+    hsize_t dims[1] = { BUF_SIZE };
+    hsize_t chunk_sizes[1] = { 1024 };
+    
+    herr_t err;
+    
+    /*************************************************************************/
+
+    /* Warn the user about trace deluge to come */
+
+    printf("Testing debug/trace/performance data generation\n");
+    printf("\n");
+    printf("This test should generate a large amount of trace data\n");
+    printf("\n");
+    printf("*** BEGIN TRACE OUTPUT ***\n");
+    printf("\n");
+    fflush(stdout);
+
+    /* This will emit H5Tconvert() performance information */
+    
+    for(i = 0; i < N_LOOPS; i++) {
+        
+        /* The buffer has to be large enough to hold the conversion output */
+        data = (int *)malloc(BUF_SIZE * sizeof(double));
+        
+        for(j = 0; j < BUF_SIZE; j++) {
+            data[j] = j;
+        }
+        
+        err = H5Tconvert(H5T_NATIVE_INT, H5T_NATIVE_DOUBLE, BUF_SIZE, data,
+            NULL, H5P_DEFAULT);
+        
+        if(err < 0) {
+            fprintf(stderr, "ERROR: Conversion failed\n");
+            free(data);
+            return err;
+        }
+        
+        free(data);
+        
+    }
+    
+    
+    /* This will emit H5Z performance information */
+    
+    data = (int *)malloc(BUF_SIZE * sizeof(int));
+    
+    for(i = 0; i < BUF_SIZE; i++) {
+        data[i] = i;
+    }
+    
+    fid = H5Fcreate(TESTFILE, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+    
+    pid = H5Pcreate(H5P_DATASET_CREATE);
+    err = H5Pset_chunk(pid, 1, chunk_sizes);
+    err = H5Pset_shuffle(pid);
+    
+    sid = H5Screate_simple(1, dims, dims);
+    did = H5Dcreate2(fid, "somedata", H5T_NATIVE_INT, sid, H5P_DEFAULT, pid, H5P_DEFAULT);
+    err = H5Dwrite(did, H5T_NATIVE_INT, sid, sid, H5P_DEFAULT, data);
+    
+    H5Sclose(sid);
+    H5Dclose(did);
+    H5Pclose(pid);
+    H5Fclose(fid);
+    
+    free(data);
+    
+    /* Finished */
+    fflush(stdout);
+    printf("\n");
+    printf("*** END TRACE OUTPUT ***\n");
+    printf("\n");
+
+    remove(TESTFILE);
+    
+    return 0;
+}
+
diff --git a/examples/run-c-ex.sh.in b/examples/run-c-ex.sh.in
index b5ec561..1990ad9 100644
--- a/examples/run-c-ex.sh.in
+++ b/examples/run-c-ex.sh.in
@@ -145,6 +145,11 @@ then
         rm h5_extlink &&\
         RunTest h5_elink_unix2win &&\
         rm h5_elink_unix2win &&\
+        OLD_DEBUG_STRING=$HDF5_DEBUG &&\
+        export HDF5_DEBUG="+all +trace +ttimes" &&\
+        RunTest h5_debug_trace &&\
+        HDF5_DEBUG=$OLD_DEBUG_STRING &&\
+        rm h5_debug_trace &&\
         RunTest h5_shared_mesg &&\
         rm h5_shared_mesg &&\
         RunTest h5_vds-eiger &&\
diff --git a/src/H5FDlog.c b/src/H5FDlog.c
index d34a273..5d1b536 100644
--- a/src/H5FDlog.c
+++ b/src/H5FDlog.c
@@ -12,7 +12,7 @@
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
 /*
- * Programmer:  Quincey Koziol <koziol@hdfgroup.org>
+ * Programmer:  Quincey Koziol
  *              Monday, April 17, 2000
  *
  * Purpose:     The POSIX unbuffered file driver using only the HDF5 public
@@ -155,71 +155,71 @@ typedef struct H5FD_log_t {
  *                  which can be addressed entirely by the second
  *                  argument of the file seek function.
  */
-#define MAXADDR                 (((haddr_t)1<<(8*sizeof(HDoff_t)-1))-1)
-#define ADDR_OVERFLOW(A)        (HADDR_UNDEF==(A) || ((A) & ~(haddr_t)MAXADDR))
+#define MAXADDR                 (((haddr_t)1 << (8 * sizeof(HDoff_t) - 1)) - 1)
+#define ADDR_OVERFLOW(A)        (HADDR_UNDEF == (A) || ((A) & ~(haddr_t)MAXADDR))
 #define SIZE_OVERFLOW(Z)        ((Z) & ~(hsize_t)MAXADDR)
 #define REGION_OVERFLOW(A,Z)    (ADDR_OVERFLOW(A) || SIZE_OVERFLOW(Z) ||    \
-                                 HADDR_UNDEF==(A)+(Z) ||                    \
-                                (HDoff_t)((A)+(Z))<(HDoff_t)(A))
+                                    HADDR_UNDEF == (A) + (Z) ||             \
+                                    (HDoff_t)((A) + (Z)) < (HDoff_t)(A))
 
 /* Prototypes */
-static herr_t H5FD_log_term(void);
-static void *H5FD_log_fapl_get(H5FD_t *file);
-static void *H5FD_log_fapl_copy(const void *_old_fa);
-static herr_t H5FD_log_fapl_free(void *_fa);
-static H5FD_t *H5FD_log_open(const char *name, unsigned flags, hid_t fapl_id,
+static herr_t H5FD__log_term(void);
+static void *H5FD__log_fapl_get(H5FD_t *file);
+static void *H5FD__log_fapl_copy(const void *_old_fa);
+static herr_t H5FD__log_fapl_free(void *_fa);
+static H5FD_t *H5FD__log_open(const char *name, unsigned flags, hid_t fapl_id,
             haddr_t maxaddr);
-static herr_t H5FD_log_close(H5FD_t *_file);
-static int H5FD_log_cmp(const H5FD_t *_f1, const H5FD_t *_f2);
-static herr_t H5FD_log_query(const H5FD_t *_f1, unsigned long *flags);
-static haddr_t H5FD_log_alloc(H5FD_t *_file, H5FD_mem_t type, hid_t dxpl_id, hsize_t size);
+static herr_t H5FD__log_close(H5FD_t *_file);
+static int H5FD__log_cmp(const H5FD_t *_f1, const H5FD_t *_f2);
+static herr_t H5FD__log_query(const H5FD_t *_f1, unsigned long *flags);
+static haddr_t H5FD__log_alloc(H5FD_t *_file, H5FD_mem_t type, hid_t dxpl_id, hsize_t size);
 static herr_t H5FD__log_free(H5FD_t *_file, H5FD_mem_t type, hid_t dxpl_id, haddr_t addr,
             hsize_t size);
-static haddr_t H5FD_log_get_eoa(const H5FD_t *_file, H5FD_mem_t type);
-static herr_t H5FD_log_set_eoa(H5FD_t *_file, H5FD_mem_t type, haddr_t addr);
-static haddr_t H5FD_log_get_eof(const H5FD_t *_file, H5FD_mem_t type);
-static herr_t  H5FD_log_get_handle(H5FD_t *_file, hid_t fapl, void** file_handle);
-static herr_t H5FD_log_read(H5FD_t *_file, H5FD_mem_t type, hid_t fapl_id, haddr_t addr,
+static haddr_t H5FD__log_get_eoa(const H5FD_t *_file, H5FD_mem_t type);
+static herr_t H5FD__log_set_eoa(H5FD_t *_file, H5FD_mem_t type, haddr_t addr);
+static haddr_t H5FD__log_get_eof(const H5FD_t *_file, H5FD_mem_t type);
+static herr_t  H5FD__log_get_handle(H5FD_t *_file, hid_t fapl, void** file_handle);
+static herr_t H5FD__log_read(H5FD_t *_file, H5FD_mem_t type, hid_t fapl_id, haddr_t addr,
             size_t size, void *buf);
-static herr_t H5FD_log_write(H5FD_t *_file, H5FD_mem_t type, hid_t fapl_id, haddr_t addr,
+static herr_t H5FD__log_write(H5FD_t *_file, H5FD_mem_t type, hid_t fapl_id, haddr_t addr,
             size_t size, const void *buf);
-static herr_t H5FD_log_truncate(H5FD_t *_file, hid_t dxpl_id, hbool_t closing);
-static herr_t H5FD_log_lock(H5FD_t *_file, hbool_t rw);
-static herr_t H5FD_log_unlock(H5FD_t *_file);
+static herr_t H5FD__log_truncate(H5FD_t *_file, hid_t dxpl_id, hbool_t closing);
+static herr_t H5FD__log_lock(H5FD_t *_file, hbool_t rw);
+static herr_t H5FD__log_unlock(H5FD_t *_file);
 
 static const H5FD_class_t H5FD_log_g = {
-    "log",					/*name			*/
-    MAXADDR,					/*maxaddr		*/
-    H5F_CLOSE_WEAK,				/* fc_degree		*/
-    H5FD_log_term,                              /*terminate             */
-    NULL,					/*sb_size		*/
-    NULL,					/*sb_encode		*/
-    NULL,					/*sb_decode		*/
-    sizeof(H5FD_log_fapl_t),                    /*fapl_size		*/
-    H5FD_log_fapl_get,		                /*fapl_get		*/
-    H5FD_log_fapl_copy,		                /*fapl_copy		*/
-    H5FD_log_fapl_free,		                /*fapl_free		*/
-    0,						/*dxpl_size		*/
-    NULL,					/*dxpl_copy		*/
-    NULL,					/*dxpl_free		*/
-    H5FD_log_open,				/*open			*/
-    H5FD_log_close,				/*close			*/
-    H5FD_log_cmp,				/*cmp			*/
-    H5FD_log_query,				/*query			*/
-    NULL,					/*get_type_map		*/
-    H5FD_log_alloc,				/*alloc			*/
-    H5FD__log_free,				/*free			*/
-    H5FD_log_get_eoa,				/*get_eoa		*/
-    H5FD_log_set_eoa, 				/*set_eoa		*/
-    H5FD_log_get_eof,				/*get_eof		*/
-    H5FD_log_get_handle,                        /*get_handle            */
-    H5FD_log_read,				/*read			*/
-    H5FD_log_write,				/*write			*/
-    NULL,					/*flush			*/
-    H5FD_log_truncate,				/*truncate		*/
-    H5FD_log_lock,                              /*lock                  */
-    H5FD_log_unlock,                            /*unlock                */
-    H5FD_FLMAP_DICHOTOMY			/*fl_map		*/
+    "log",					/* name			*/
+    MAXADDR,					/* maxaddr		*/
+    H5F_CLOSE_WEAK,				/*  fc_degree		*/
+    H5FD__log_term,                             /* terminate            */
+    NULL,					/* sb_size		*/
+    NULL,					/* sb_encode		*/
+    NULL,					/* sb_decode		*/
+    sizeof(H5FD_log_fapl_t),                    /* fapl_size		*/
+    H5FD__log_fapl_get,		                /* fapl_get		*/
+    H5FD__log_fapl_copy,		        /* fapl_copy		*/
+    H5FD__log_fapl_free,		        /* fapl_free		*/
+    0,						/* dxpl_size		*/
+    NULL,					/* dxpl_copy		*/
+    NULL,					/* dxpl_free		*/
+    H5FD__log_open,				/* open			*/
+    H5FD__log_close,				/* close		*/
+    H5FD__log_cmp,				/* cmp			*/
+    H5FD__log_query,				/* query		*/
+    NULL,					/* get_type_map		*/
+    H5FD__log_alloc,				/* alloc		*/
+    H5FD__log_free,				/* free			*/
+    H5FD__log_get_eoa,				/* get_eoa		*/
+    H5FD__log_set_eoa, 				/* set_eoa		*/
+    H5FD__log_get_eof,				/* get_eof		*/
+    H5FD__log_get_handle,                       /* get_handle           */
+    H5FD__log_read,				/* read			*/
+    H5FD__log_write,				/* write		*/
+    NULL,					/* flush		*/
+    H5FD__log_truncate,				/* truncate		*/
+    H5FD__log_lock,                             /* lock                 */
+    H5FD__log_unlock,                           /* unlock               */
+    H5FD_FLMAP_DICHOTOMY			/* fl_map		*/
 };
 
 /* Declare a free list to manage the H5FD_log_t struct */
@@ -293,7 +293,7 @@ done:
 
 
 /*---------------------------------------------------------------------------
- * Function:    H5FD_log_term
+ * Function:    H5FD__log_term
  *
  * Purpose:     Shut down the VFD
  *
@@ -305,15 +305,15 @@ done:
  *---------------------------------------------------------------------------
  */
 static herr_t
-H5FD_log_term(void)
+H5FD__log_term(void)
 {
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    FUNC_ENTER_STATIC_NOERR
 
     /* Reset VFL ID */
     H5FD_LOG_g = 0;
 
     FUNC_LEAVE_NOAPI(SUCCEED)
-} /* end H5FD_log_term() */
+} /* end H5FD__log_term() */
 
 
 /*-------------------------------------------------------------------------
@@ -366,7 +366,7 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5FD_log_fapl_get
+ * Function:    H5FD__log_fapl_get
  *
  * Purpose:     Returns a file access property list which indicates how the
  *              specified file is being accessed. The return list could be
@@ -382,22 +382,22 @@ done:
  *-------------------------------------------------------------------------
  */
 static void *
-H5FD_log_fapl_get(H5FD_t *_file)
+H5FD__log_fapl_get(H5FD_t *_file)
 {
     H5FD_log_t  *file = (H5FD_log_t *)_file;
     void        *ret_value = NULL;              /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    FUNC_ENTER_STATIC_NOERR
 
     /* Set return value */
-    ret_value = H5FD_log_fapl_copy(&(file->fa));
+    ret_value = H5FD__log_fapl_copy(&(file->fa));
 
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5FD_log_fapl_get() */
+} /* end H5FD__log_fapl_get() */
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5FD_log_fapl_copy
+ * Function:    H5FD__log_fapl_copy
  *
  * Purpose:     Copies the log-specific file access properties.
  *
@@ -410,13 +410,13 @@ H5FD_log_fapl_get(H5FD_t *_file)
  *-------------------------------------------------------------------------
  */
 static void *
-H5FD_log_fapl_copy(const void *_old_fa)
+H5FD__log_fapl_copy(const void *_old_fa)
 {
     const H5FD_log_fapl_t   *old_fa = (const H5FD_log_fapl_t*)_old_fa;
     H5FD_log_fapl_t         *new_fa = NULL;     /* New FAPL info */
     void                    *ret_value = NULL;  /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
     HDassert(old_fa);
 
@@ -444,11 +444,11 @@ done:
         } /* end if */
 
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5FD_log_fapl_copy() */
+} /* end H5FD__log_fapl_copy() */
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5FD_log_fapl_free
+ * Function:    H5FD__log_fapl_free
  *
  * Purpose:     Frees the log-specific file access properties.
  *
@@ -460,11 +460,11 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5FD_log_fapl_free(void *_fa)
+H5FD__log_fapl_free(void *_fa)
 {
     H5FD_log_fapl_t	*fa = (H5FD_log_fapl_t*)_fa;
 
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    FUNC_ENTER_STATIC_NOERR
 
     /* Free the fapl information */
     if(fa->logfile)
@@ -472,11 +472,11 @@ H5FD_log_fapl_free(void *_fa)
     H5MM_xfree(fa);
 
     FUNC_LEAVE_NOAPI(SUCCEED)
-} /* end H5FD_log_fapl_free() */
+} /* end H5FD__log_fapl_free() */
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5FD_log_open
+ * Function:    H5FD__log_open
  *
  * Purpose:     Create and/or opens a file as an HDF5 file.
  *
@@ -491,7 +491,7 @@ H5FD_log_fapl_free(void *_fa)
  *-------------------------------------------------------------------------
  */
 static H5FD_t *
-H5FD_log_open(const char *name, unsigned flags, hid_t fapl_id, haddr_t maxaddr)
+H5FD__log_open(const char *name, unsigned flags, hid_t fapl_id, haddr_t maxaddr)
 {
     H5FD_log_t      *file = NULL;
     H5P_genplist_t  *plist;         /* Property list */
@@ -501,15 +501,12 @@ H5FD_log_open(const char *name, unsigned flags, hid_t fapl_id, haddr_t maxaddr)
 #ifdef H5_HAVE_WIN32_API
     struct _BY_HANDLE_FILE_INFORMATION fileinfo;
 #endif
-#ifdef H5_HAVE_GETTIMEOFDAY
-    struct timeval timeval_start;
-    struct timeval open_timeval_diff;
-    struct timeval stat_timeval_diff;
-#endif /* H5_HAVE_GETTIMEOFDAY */
+    H5_timer_t      open_timer;         /* Timer for open() call */
+    H5_timer_t      stat_timer;         /* Timer for stat() call */
     h5_stat_t       sb;
     H5FD_t          *ret_value = NULL;  /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
     /* Sanity check on file offsets */
     HDcompile_assert(sizeof(HDoff_t) >= sizeof(size_t));
@@ -537,54 +534,36 @@ H5FD_log_open(const char *name, unsigned flags, hid_t fapl_id, haddr_t maxaddr)
     if(NULL == (fa = (const H5FD_log_fapl_t *)H5P_peek_driver_info(plist)))
         HGOTO_ERROR(H5E_PLIST, H5E_BADVALUE, NULL, "bad VFL driver info")
 
-#ifdef H5_HAVE_GETTIMEOFDAY
-    if(fa->flags & H5FD_LOG_TIME_OPEN)
-        HDgettimeofday(&timeval_start, NULL);
-#endif /* H5_HAVE_GETTIMEOFDAY */
+    /* Start timer for open() call */
+    if(fa->flags & H5FD_LOG_TIME_OPEN) {
+        H5_timer_init(&open_timer);
+        H5_timer_start(&open_timer);
+    } /* end if */
+
     /* Open the file */
     if((fd = HDopen(name, o_flags, H5_POSIX_CREATE_MODE_RW)) < 0) {
         int myerrno = errno;
 
         HGOTO_ERROR(H5E_FILE, H5E_CANTOPENFILE, NULL, "unable to open file: name = '%s', errno = %d, error message = '%s', flags = %x, o_flags = %x", name, myerrno, HDstrerror(myerrno), flags, (unsigned)o_flags);
     } /* end if */
-#ifdef H5_HAVE_GETTIMEOFDAY
-    if(fa->flags & H5FD_LOG_TIME_OPEN) {
-        struct timeval timeval_stop;
 
-        HDgettimeofday(&timeval_stop, NULL);
+    /* Stop timer for open() call */
+    if(fa->flags & H5FD_LOG_TIME_OPEN)
+        H5_timer_stop(&open_timer);
 
-         /* Calculate the elapsed gettimeofday time */
-         open_timeval_diff.tv_usec = timeval_stop.tv_usec - timeval_start.tv_usec;
-         open_timeval_diff.tv_sec = timeval_stop.tv_sec - timeval_start.tv_sec;
-         if(open_timeval_diff.tv_usec < 0) {
-             open_timeval_diff.tv_usec += 1000000;
-             open_timeval_diff.tv_sec--;
-         } /* end if */
+    /* Start timer for stat() call */
+    if(fa->flags & H5FD_LOG_TIME_STAT) {
+        H5_timer_init(&stat_timer);
+        H5_timer_start(&stat_timer);
     } /* end if */
-#endif /* H5_HAVE_GETTIMEOFDAY */
 
-#ifdef H5_HAVE_GETTIMEOFDAY
-    if(fa->flags & H5FD_LOG_TIME_STAT)
-        HDgettimeofday(&timeval_start, NULL);
-#endif /* H5_HAVE_GETTIMEOFDAY */
     /* Get the file stats */
     if(HDfstat(fd, &sb) < 0)
         HSYS_GOTO_ERROR(H5E_FILE, H5E_BADFILE, NULL, "unable to fstat file")
-#ifdef H5_HAVE_GETTIMEOFDAY
-    if(fa->flags & H5FD_LOG_TIME_STAT) {
-        struct timeval timeval_stop;
 
-        HDgettimeofday(&timeval_stop, NULL);
-
-         /* Calculate the elapsed gettimeofday time */
-         stat_timeval_diff.tv_usec = timeval_stop.tv_usec - timeval_start.tv_usec;
-         stat_timeval_diff.tv_sec = timeval_stop.tv_sec - timeval_start.tv_sec;
-         if(stat_timeval_diff.tv_usec < 0) {
-             stat_timeval_diff.tv_usec += 1000000;
-             stat_timeval_diff.tv_sec--;
-         } /* end if */
-    } /* end if */
-#endif /* H5_HAVE_GETTIMEOFDAY */
+    /* Stop timer for stat() call */
+    if(fa->flags & H5FD_LOG_TIME_STAT)
+        H5_timer_stop(&stat_timer);
 
     /* Create the new file struct */
     if(NULL == (file = H5FL_CALLOC(H5FD_log_t)))
@@ -645,13 +624,19 @@ H5FD_log_open(const char *name, unsigned flags, hid_t fapl_id, haddr_t maxaddr)
         else
             file->logfp = stderr;
 
-#ifdef H5_HAVE_GETTIMEOFDAY
-        if(file->fa.flags & H5FD_LOG_TIME_OPEN)
-            HDfprintf(file->logfp, "Open took: (%f s)\n", (double)open_timeval_diff.tv_sec + ((double)open_timeval_diff.tv_usec / (double)1000000.0f));
-        if(file->fa.flags & H5FD_LOG_TIME_STAT)
-            HDfprintf(file->logfp, "Stat took: (%f s)\n", (double)stat_timeval_diff.tv_sec + ((double)stat_timeval_diff.tv_usec / (double)1000000.0f));
-#endif /* H5_HAVE_GETTIMEOFDAY */
+        /* Log the timer values */
+        if(file->fa.flags & H5FD_LOG_TIME_OPEN) {
+            H5_timevals_t   open_times;         /* Elapsed time for open() call */
 
+            H5_timer_get_times(open_timer, &open_times);
+            HDfprintf(file->logfp, "Open took: (%f s)\n", open_times.elapsed);
+        } /* end if */
+        if(file->fa.flags & H5FD_LOG_TIME_STAT) {
+            H5_timevals_t   stat_times;         /* Elapsed time for stat() call */
+
+            H5_timer_get_times(stat_timer, &stat_times);
+            HDfprintf(file->logfp, "Stat took: (%f s)\n", stat_times.elapsed);
+        } /* end if */
     } /* end if */
 
     /* Check the file locking flags in the fapl */
@@ -688,11 +673,11 @@ done:
     } /* end if */
 
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5FD_log_open() */
+} /* end H5FD__log_open() */
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5FD_log_close
+ * Function:    H5FD__log_close
  *
  * Purpose:     Closes an HDF5 file.
  *
@@ -705,30 +690,30 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5FD_log_close(H5FD_t *_file)
+H5FD__log_close(H5FD_t *_file)
 {
     H5FD_log_t	*file = (H5FD_log_t *)_file;
-#ifdef H5_HAVE_GETTIMEOFDAY
-    struct timeval timeval_start, timeval_stop;
-#endif /* H5_HAVE_GETTIMEOFDAY */
-    herr_t ret_value = SUCCEED;                 /* Return value */
+    H5_timer_t      close_timer;        /* Timer for close() call */
+    herr_t ret_value = SUCCEED;         /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
     /* Sanity check */
     HDassert(file);
 
-#ifdef H5_HAVE_GETTIMEOFDAY
-    if(file->fa.flags&H5FD_LOG_TIME_CLOSE)
-        HDgettimeofday(&timeval_start, NULL);
-#endif /* H5_HAVE_GETTIMEOFDAY */
+    /* Start timer for close() call */
+    if(file->fa.flags & H5FD_LOG_TIME_CLOSE) {
+        H5_timer_init(&close_timer);
+        H5_timer_start(&close_timer);
+    } /* end if */
+
     /* Close the underlying file */
     if(HDclose(file->fd) < 0)
         HSYS_GOTO_ERROR(H5E_IO, H5E_CANTCLOSEFILE, FAIL, "unable to close file")
-#ifdef H5_HAVE_GETTIMEOFDAY
+
+    /* Stop timer for close() call */
     if(file->fa.flags&H5FD_LOG_TIME_CLOSE)
-        HDgettimeofday(&timeval_stop, NULL);
-#endif /* H5_HAVE_GETTIMEOFDAY */
+        H5_timer_stop(&close_timer);
 
     /* Dump I/O information */
     if(file->fa.flags != 0) {
@@ -736,20 +721,12 @@ H5FD_log_close(H5FD_t *_file)
         haddr_t last_addr;
         unsigned char last_val;
 
-#ifdef H5_HAVE_GETTIMEOFDAY
         if(file->fa.flags & H5FD_LOG_TIME_CLOSE) {
-            struct timeval timeval_diff;
-
-             /* Calculate the elapsed gettimeofday time */
-             timeval_diff.tv_usec = timeval_stop.tv_usec - timeval_start.tv_usec;
-             timeval_diff.tv_sec = timeval_stop.tv_sec - timeval_start.tv_sec;
-             if(timeval_diff.tv_usec < 0) {
-                 timeval_diff.tv_usec += 1000000;
-                 timeval_diff.tv_sec--;
-             } /* end if */
-            HDfprintf(file->logfp, "Close took: (%f s)\n", (double)timeval_diff.tv_sec + ((double)timeval_diff.tv_usec / (double)1000000.0f));
+            H5_timevals_t   close_times;        /* Elapsed time for close() call */
+
+            H5_timer_get_times(close_timer, &close_times);
+            HDfprintf(file->logfp, "Close took: (%f s)\n", close_times.elapsed);
         } /* end if */
-#endif /* H5_HAVE_GETTIMEOFDAY */
 
         /* Dump the total number of seek/read/write operations */
         if(file->fa.flags & H5FD_LOG_NUM_READ)
@@ -841,11 +818,11 @@ H5FD_log_close(H5FD_t *_file)
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5FD_log_close() */
+} /* end H5FD__log_close() */
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5FD_log_cmp
+ * Function:    H5FD__log_cmp
  *
  * Purpose:     Compares two files belonging to this driver using an
  *              arbitrary (but consistent) ordering.
@@ -860,13 +837,13 @@ done:
  *-------------------------------------------------------------------------
  */
 static int
-H5FD_log_cmp(const H5FD_t *_f1, const H5FD_t *_f2)
+H5FD__log_cmp(const H5FD_t *_f1, const H5FD_t *_f2)
 {
     const H5FD_log_t    *f1 = (const H5FD_log_t *)_f1;
     const H5FD_log_t    *f2 = (const H5FD_log_t *)_f2;
     int ret_value = 0;
 
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    FUNC_ENTER_STATIC_NOERR
 
 #ifdef H5_HAVE_WIN32_API
     if(f1->dwVolumeSerialNumber < f2->dwVolumeSerialNumber) HGOTO_DONE(-1)
@@ -897,11 +874,11 @@ H5FD_log_cmp(const H5FD_t *_f1, const H5FD_t *_f2)
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5FD_log_cmp() */
+} /* end H5FD__log_cmp() */
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5FD_log_query
+ * Function:    H5FD__log_query
  *
  * Purpose:     Set the flags that this VFL driver is capable of supporting.
  *              (listed in H5FDpublic.h)
@@ -914,11 +891,11 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5FD_log_query(const H5FD_t *_file, unsigned long *flags /* out */)
+H5FD__log_query(const H5FD_t *_file, unsigned long *flags /* out */)
 {
     const H5FD_log_t    *file = (const H5FD_log_t *)_file;
 
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    FUNC_ENTER_STATIC_NOERR
 
     /* Set the VFL feature flags that this driver supports */
     if(flags) {
@@ -937,11 +914,11 @@ H5FD_log_query(const H5FD_t *_file, unsigned long *flags /* out */)
     } /* end if */
 
     FUNC_LEAVE_NOAPI(SUCCEED)
-} /* end H5FD_log_query() */
+} /* end H5FD__log_query() */
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5FD_log_alloc
+ * Function:    H5FD__log_alloc
  *
  * Purpose:     Allocate file memory.
  *
@@ -954,13 +931,13 @@ H5FD_log_query(const H5FD_t *_file, unsigned long *flags /* out */)
  *-------------------------------------------------------------------------
  */
 static haddr_t
-H5FD_log_alloc(H5FD_t *_file, H5FD_mem_t type, hid_t H5_ATTR_UNUSED dxpl_id, hsize_t size)
+H5FD__log_alloc(H5FD_t *_file, H5FD_mem_t type, hid_t H5_ATTR_UNUSED dxpl_id, hsize_t size)
 {
     H5FD_log_t	*file = (H5FD_log_t *)_file;
     haddr_t addr;
     haddr_t ret_value = HADDR_UNDEF;    /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    FUNC_ENTER_STATIC_NOERR
 
     /* Compute the address for the block to allocate */
     addr = file->eoa;
@@ -984,7 +961,7 @@ H5FD_log_alloc(H5FD_t *_file, H5FD_mem_t type, hid_t H5_ATTR_UNUSED dxpl_id, hsi
     ret_value = addr;
 
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5FD_log_alloc() */
+} /* end H5FD__log_alloc() */
 
 
 /*-------------------------------------------------------------------------
@@ -1025,7 +1002,7 @@ H5FD__log_free(H5FD_t *_file, H5FD_mem_t type, hid_t H5_ATTR_UNUSED dxpl_id,
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5FD_log_get_eoa
+ * Function:    H5FD__log_get_eoa
  *
  * Purpose:     Gets the end-of-address marker for the file. The EOA marker
  *              is the first address past the last byte allocated in the
@@ -1040,18 +1017,18 @@ H5FD__log_free(H5FD_t *_file, H5FD_mem_t type, hid_t H5_ATTR_UNUSED dxpl_id,
  *-------------------------------------------------------------------------
  */
 static haddr_t
-H5FD_log_get_eoa(const H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type)
+H5FD__log_get_eoa(const H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type)
 {
     const H5FD_log_t    *file = (const H5FD_log_t *)_file;
 
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    FUNC_ENTER_STATIC_NOERR
 
     FUNC_LEAVE_NOAPI(file->eoa)
-} /* end H5FD_log_get_eoa() */
+} /* end H5FD__log_get_eoa() */
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5FD_log_set_eoa
+ * Function:    H5FD__log_set_eoa
  *
  * Purpose:     Set the end-of-address marker for the file. This function is
  *              called shortly after an existing HDF5 file is opened in order
@@ -1065,11 +1042,11 @@ H5FD_log_get_eoa(const H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type)
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5FD_log_set_eoa(H5FD_t *_file, H5FD_mem_t type, haddr_t addr)
+H5FD__log_set_eoa(H5FD_t *_file, H5FD_mem_t type, haddr_t addr)
 {
     H5FD_log_t  *file = (H5FD_log_t *)_file;
 
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    FUNC_ENTER_STATIC_NOERR
 
     if(file->fa.flags != 0) {
         /* Check for increasing file size */
@@ -1108,11 +1085,11 @@ H5FD_log_set_eoa(H5FD_t *_file, H5FD_mem_t type, haddr_t addr)
     file->eoa = addr;
 
     FUNC_LEAVE_NOAPI(SUCCEED)
-} /* end H5FD_log_set_eoa() */
+} /* end H5FD__log_set_eoa() */
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5FD_log_get_eof
+ * Function:    H5FD__log_get_eof
  *
  * Purpose:     Returns the end-of-file marker, which is the greater of
  *              either the filesystem end-of-file or the HDF5 end-of-address
@@ -1129,18 +1106,18 @@ H5FD_log_set_eoa(H5FD_t *_file, H5FD_mem_t type, haddr_t addr)
  *-------------------------------------------------------------------------
  */
 static haddr_t
-H5FD_log_get_eof(const H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type)
+H5FD__log_get_eof(const H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type)
 {
     const H5FD_log_t	*file = (const H5FD_log_t *)_file;
 
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    FUNC_ENTER_STATIC_NOERR
 
     FUNC_LEAVE_NOAPI(file->eof)
-} /* end H5FD_log_get_eof() */
+} /* end H5FD__log_get_eof() */
 
 
 /*-------------------------------------------------------------------------
- * Function:       H5FD_log_get_handle
+ * Function:       H5FD__log_get_handle
  *
  * Purpose:        Returns the file handle of LOG file driver.
  *
@@ -1152,12 +1129,12 @@ H5FD_log_get_eof(const H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type)
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5FD_log_get_handle(H5FD_t *_file, hid_t H5_ATTR_UNUSED fapl, void **file_handle)
+H5FD__log_get_handle(H5FD_t *_file, hid_t H5_ATTR_UNUSED fapl, void **file_handle)
 {
     H5FD_log_t          *file = (H5FD_log_t *)_file;
     herr_t              ret_value = SUCCEED;
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
     if(!file_handle)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "file handle not valid")
@@ -1166,11 +1143,11 @@ H5FD_log_get_handle(H5FD_t *_file, hid_t H5_ATTR_UNUSED fapl, void **file_handle
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5FD_log_get_handle() */
+} /* end H5FD__log_get_handle() */
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5FD_log_read
+ * Function:    H5FD__log_read
  *
  * Purpose:     Reads SIZE bytes of data from FILE beginning at address ADDR
  *              into buffer BUF according to data transfer properties in
@@ -1186,19 +1163,22 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5FD_log_read(H5FD_t *_file, H5FD_mem_t type, hid_t H5_ATTR_UNUSED dxpl_id, haddr_t addr,
+H5FD__log_read(H5FD_t *_file, H5FD_mem_t type, hid_t H5_ATTR_UNUSED dxpl_id, haddr_t addr,
             size_t size, void *buf/*out*/)
 {
     H5FD_log_t          *file = (H5FD_log_t *)_file;
     size_t              orig_size = size; /* Save the original size for later */
     haddr_t             orig_addr = addr;
-#ifdef H5_HAVE_GETTIMEOFDAY
-    struct timeval      timeval_start, timeval_stop;
-#endif /* H5_HAVE_GETTIMEOFDAY */
+    H5_timer_t          read_timer;             /* Timer for read operation */
+    H5_timevals_t       read_times;             /* Elapsed time for read operation */
+#ifndef H5_HAVE_PREADWRITE
+    H5_timer_t          seek_timer;             /* Timer for seek operation */
+    H5_timevals_t       seek_times;             /* Elapsed time for seek operation */
+#endif /* H5_HAVE_PREADWRITE */
     HDoff_t             offset = (HDoff_t)addr;
-    herr_t              ret_value = SUCCEED;       /* Return value */
+    herr_t              ret_value = SUCCEED;    /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
     HDassert(file && file->pub.cls);
     HDassert(buf);
@@ -1225,59 +1205,56 @@ H5FD_log_read(H5FD_t *_file, H5FD_mem_t type, hid_t H5_ATTR_UNUSED dxpl_id, hadd
 #ifndef H5_HAVE_PREADWRITE
     /* Seek to the correct location (if we don't have pread) */
     if(addr != file->pos || OP_READ != file->op) {
-#ifdef H5_HAVE_GETTIMEOFDAY
-        if(file->fa.flags & H5FD_LOG_TIME_SEEK)
-            HDgettimeofday(&timeval_start, NULL);
-#endif /* H5_HAVE_GETTIMEOFDAY */
+        /* Start timer for seek() call */
+        if(file->fa.flags & H5FD_LOG_TIME_SEEK) {
+            H5_timer_init(&seek_timer);
+            H5_timer_start(&seek_timer);
+        } /* end if */
+
         if(HDlseek(file->fd, (HDoff_t)addr, SEEK_SET) < 0)
             HSYS_GOTO_ERROR(H5E_IO, H5E_SEEKERROR, FAIL, "unable to seek to proper position")
-#ifdef H5_HAVE_GETTIMEOFDAY
+
+        /* Stop timer for seek() call */
         if(file->fa.flags & H5FD_LOG_TIME_SEEK)
-            HDgettimeofday(&timeval_stop, NULL);
-#endif /* H5_HAVE_GETTIMEOFDAY */
+            H5_timer_stop(&seek_timer);
 
-        /* Log information about the seek */
+        /* Add to the number of seeks, when tracking that */
         if(file->fa.flags & H5FD_LOG_NUM_SEEK)
             file->total_seek_ops++;
+
+        /* Add to the total seek time, when tracking that */
+        if(file->fa.flags & H5FD_LOG_TIME_SEEK) {
+            H5_timer_get_times(seek_timer, &seek_times);
+            file->total_seek_time += seek_times.elapsed;
+        } /* end if */
+
+        /* Emit log string if we're tracking individual seek events. */
         if(file->fa.flags & H5FD_LOG_LOC_SEEK) {
             HDfprintf(file->logfp, "Seek: From %10a To %10a", file->pos, addr);
-#ifdef H5_HAVE_GETTIMEOFDAY
-            if(file->fa.flags & H5FD_LOG_TIME_SEEK) {
-                struct timeval timeval_diff;
-                double time_diff;
-
-                /* Calculate the elapsed gettimeofday time */
-                timeval_diff.tv_usec = timeval_stop.tv_usec - timeval_start.tv_usec;
-                timeval_diff.tv_sec = timeval_stop.tv_sec - timeval_start.tv_sec;
-                if(timeval_diff.tv_usec < 0) {
-                    timeval_diff.tv_usec += 1000000;
-                    timeval_diff.tv_sec--;
-                } /* end if */
-                time_diff = (double)timeval_diff.tv_sec + ((double)timeval_diff.tv_usec / (double)1000000.0f);
-                HDfprintf(file->logfp, " (%fs @ %.6lu.%.6llu)\n", time_diff, (unsigned long long)timeval_start.tv_sec, (unsigned long long)timeval_start.tv_usec);
 
-                /* Add to total seek time */
-                file->total_seek_time += time_diff;
-            } /* end if */
-            else
-                HDfprintf(file->logfp, "\n");
-#else /* H5_HAVE_GETTIMEOFDAY */
-            HDfprintf(file->logfp, "\n");
-#endif /* H5_HAVE_GETTIMEOFDAY */
+            /* Add the seek time, if we're tracking that.
+             * Note that the seek time is NOT emitted for when just H5FD_LOG_TIME_SEEK
+             * is set.
+             */
+            if(file->fa.flags & H5FD_LOG_TIME_SEEK)
+                HDfprintf(file->logfp, " (%fs @ %f)\n", seek_times.elapsed, seek_timer.initial.elapsed);
+             else
+                 HDfprintf(file->logfp, "\n");
         } /* end if */
     } /* end if */
 #endif /* H5_HAVE_PREADWRITE */
 
+    /* Start timer for read operation */
+    if(file->fa.flags & H5FD_LOG_TIME_READ) {
+        H5_timer_init(&read_timer);
+        H5_timer_start(&read_timer);
+    } /* end if */
+
     /*
      * Read data, being careful of interrupted system calls, partial results,
      * and the end of the file.
      */
-#ifdef H5_HAVE_GETTIMEOFDAY
-    if(file->fa.flags & H5FD_LOG_TIME_READ)
-        HDgettimeofday(&timeval_start, NULL);
-#endif /* H5_HAVE_GETTIMEOFDAY */
     while(size > 0) {
-
         h5_posix_io_t       bytes_in        = 0;    /* # of bytes to read       */
         h5_posix_io_ret_t   bytes_read      = -1;   /* # of bytes actually read */
 
@@ -1325,14 +1302,22 @@ H5FD_log_read(H5FD_t *_file, H5FD_mem_t type, hid_t H5_ATTR_UNUSED dxpl_id, hadd
         buf = (char *)buf + bytes_read;
 
     } /* end while */
-#ifdef H5_HAVE_GETTIMEOFDAY
+
+    /* Stop timer for read operation */
     if(file->fa.flags & H5FD_LOG_TIME_READ)
-        HDgettimeofday(&timeval_stop, NULL);
-#endif /* H5_HAVE_GETTIMEOFDAY */
+        H5_timer_stop(&read_timer);
 
-    /* Log information about the read */
+    /* Add to the number of reads, when tracking that */
     if(file->fa.flags & H5FD_LOG_NUM_READ)
         file->total_read_ops++;
+
+    /* Add to the total read time, when tracking that */
+    if(file->fa.flags & H5FD_LOG_TIME_READ) {
+        H5_timer_get_times(read_timer, &read_times);
+        file->total_read_time += read_times.elapsed;
+    } /* end if */
+
+    /* Log information about the read */
     if(file->fa.flags & H5FD_LOG_LOC_READ) {
         HDfprintf(file->logfp, "%10a-%10a (%10Zu bytes) (%s) Read", orig_addr, (orig_addr + orig_size) - 1, orig_size, flavors[type]);
 
@@ -1342,30 +1327,14 @@ H5FD_log_read(H5FD_t *_file, H5FD_mem_t type, hid_t H5_ATTR_UNUSED dxpl_id, hadd
             HDassert(type == H5FD_MEM_DEFAULT || type == (H5FD_mem_t)file->flavor[(orig_addr + orig_size) - 1] || (H5FD_mem_t)file->flavor[(orig_addr + orig_size) - 1] == H5FD_MEM_DEFAULT);
         } /* end if */
 
-
-#ifdef H5_HAVE_GETTIMEOFDAY
-        if(file->fa.flags & H5FD_LOG_TIME_READ) {
-            struct timeval timeval_diff;
-            double time_diff;
-
-            /* Calculate the elapsed gettimeofday time */
-            timeval_diff.tv_usec = timeval_stop.tv_usec - timeval_start.tv_usec;
-            timeval_diff.tv_sec = timeval_stop.tv_sec - timeval_start.tv_sec;
-            if(timeval_diff.tv_usec < 0) {
-                timeval_diff.tv_usec += 1000000;
-                timeval_diff.tv_sec--;
-            } /* end if */
-            time_diff = (double)timeval_diff.tv_sec + ((double)timeval_diff.tv_usec / (double)1000000.0f);
-            HDfprintf(file->logfp, " (%fs @ %.6lu.%.6llu)\n", time_diff, (unsigned long long)timeval_start.tv_sec, (unsigned long long)timeval_start.tv_usec);
-
-            /* Add to total read time */
-            file->total_read_time += time_diff;
-        } /* end if */
+        /* Add the read time, if we're tracking that.
+         * Note that the read time is NOT emitted for when just H5FD_LOG_TIME_READ
+         * is set.
+         */
+        if(file->fa.flags & H5FD_LOG_TIME_READ)
+            HDfprintf(file->logfp, " (%fs @ %f)\n", read_times.elapsed, read_timer.initial.elapsed);
         else
             HDfprintf(file->logfp, "\n");
-#else /* H5_HAVE_GETTIMEOFDAY */
-        HDfprintf(file->logfp, "\n");
-#endif /* H5_HAVE_GETTIMEOFDAY */
     } /* end if */
 
     /* Update current position */
@@ -1380,11 +1349,11 @@ done:
     } /* end if */
 
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5FD_log_read() */
+} /* end H5FD__log_read() */
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5FD_log_write
+ * Function:    H5FD__log_write
  *
  * Purpose:     Writes SIZE bytes of data to FILE beginning at address ADDR
  *              from buffer BUF according to data transfer properties in
@@ -1398,19 +1367,22 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5FD_log_write(H5FD_t *_file, H5FD_mem_t type, hid_t H5_ATTR_UNUSED dxpl_id, haddr_t addr,
+H5FD__log_write(H5FD_t *_file, H5FD_mem_t type, hid_t H5_ATTR_UNUSED dxpl_id, haddr_t addr,
             size_t size, const void *buf)
 {
     H5FD_log_t          *file = (H5FD_log_t *)_file;
     size_t              orig_size = size; /* Save the original size for later */
     haddr_t             orig_addr = addr;
-#ifdef H5_HAVE_GETTIMEOFDAY
-    struct timeval      timeval_start, timeval_stop;
-#endif /* H5_HAVE_GETTIMEOFDAY */
+    H5_timer_t          write_timer;            /* Timer for write operation */
+    H5_timevals_t       write_times;            /* Elapsed time for write operation */
+#ifndef H5_HAVE_PREADWRITE
+    H5_timer_t          seek_timer;             /* Timer for seek operation */
+    H5_timevals_t       seek_times;             /* Elapsed time for seek operation */
+#endif /* H5_HAVE_PREADWRITE */
     HDoff_t             offset = (HDoff_t)addr;
-    herr_t              ret_value = SUCCEED;       /* Return value */
+    herr_t              ret_value = SUCCEED;    /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
     HDassert(file && file->pub.cls);
     HDassert(size > 0);
@@ -1442,59 +1414,56 @@ H5FD_log_write(H5FD_t *_file, H5FD_mem_t type, hid_t H5_ATTR_UNUSED dxpl_id, had
 #ifndef H5_HAVE_PREADWRITE
     /* Seek to the correct location (if we don't have pwrite) */
     if(addr != file->pos || OP_WRITE != file->op) {
-#ifdef H5_HAVE_GETTIMEOFDAY
-        if(file->fa.flags & H5FD_LOG_TIME_SEEK)
-            HDgettimeofday(&timeval_start, NULL);
-#endif /* H5_HAVE_GETTIMEOFDAY */
+        /* Start timer for seek() call */
+        if(file->fa.flags & H5FD_LOG_TIME_SEEK) {
+            H5_timer_init(&seek_timer);
+            H5_timer_start(&seek_timer);
+        } /* end if */
+
         if(HDlseek(file->fd, (HDoff_t)addr, SEEK_SET) < 0)
             HSYS_GOTO_ERROR(H5E_IO, H5E_SEEKERROR, FAIL, "unable to seek to proper position")
-#ifdef H5_HAVE_GETTIMEOFDAY
+
+        /* Stop timer for seek() call */
         if(file->fa.flags & H5FD_LOG_TIME_SEEK)
-            HDgettimeofday(&timeval_stop, NULL);
-#endif /* H5_HAVE_GETTIMEOFDAY */
+            H5_timer_stop(&seek_timer);
 
-        /* Log information about the seek */
+        /* Add to the number of seeks, when tracking that */
         if(file->fa.flags & H5FD_LOG_NUM_SEEK)
             file->total_seek_ops++;
+
+        /* Add to the total seek time, when tracking that */
+        if(file->fa.flags & H5FD_LOG_TIME_SEEK) {
+            H5_timer_get_times(seek_timer, &seek_times);
+            file->total_seek_time += seek_times.elapsed;
+        } /* end if */
+
+        /* Emit log string if we're tracking individual seek events. */
         if(file->fa.flags & H5FD_LOG_LOC_SEEK) {
             HDfprintf(file->logfp, "Seek: From %10a To %10a", file->pos, addr);
-#ifdef H5_HAVE_GETTIMEOFDAY
-            if(file->fa.flags & H5FD_LOG_TIME_SEEK) {
-                struct timeval timeval_diff;
-                double time_diff;
-
-                /* Calculate the elapsed gettimeofday time */
-                timeval_diff.tv_usec = timeval_stop.tv_usec - timeval_start.tv_usec;
-                timeval_diff.tv_sec = timeval_stop.tv_sec - timeval_start.tv_sec;
-                if(timeval_diff.tv_usec < 0) {
-                    timeval_diff.tv_usec += 1000000;
-                    timeval_diff.tv_sec--;
-                } /* end if */
-                time_diff = (double)timeval_diff.tv_sec + ((double)timeval_diff.tv_usec / (double)1000000.0f);
-                HDfprintf(file->logfp, " (%fs @ %.6lu.%.6llu)\n", time_diff, (unsigned long long)timeval_start.tv_sec, (unsigned long long)timeval_start.tv_usec);
 
-                /* Add to total seek time */
-                file->total_seek_time += time_diff;
-            } /* end if */
-            else
-                HDfprintf(file->logfp, "\n");
-#else /* H5_HAVE_GETTIMEOFDAY */
-            HDfprintf(file->logfp, "\n");
-#endif /* H5_HAVE_GETTIMEOFDAY */
+            /* Add the seek time, if we're tracking that.
+             * Note that the seek time is NOT emitted for when just H5FD_LOG_TIME_SEEK
+             * is set.
+             */
+            if(file->fa.flags & H5FD_LOG_TIME_SEEK)
+                HDfprintf(file->logfp, " (%fs @ %f)\n", seek_times.elapsed, seek_timer.initial.elapsed);
+             else
+                 HDfprintf(file->logfp, "\n");
         } /* end if */
     } /* end if */
 #endif /* H5_HAVE_PREADWRITE */
 
+    /* Start timer for write operation */
+    if(file->fa.flags&H5FD_LOG_TIME_WRITE) {
+        H5_timer_init(&write_timer);
+        H5_timer_start(&write_timer);
+    } /* end if */
+
     /*
      * Write the data, being careful of interrupted system calls and partial
      * results
      */
-#ifdef H5_HAVE_GETTIMEOFDAY
-    if(file->fa.flags&H5FD_LOG_TIME_WRITE)
-        HDgettimeofday(&timeval_start, NULL);
-#endif /* H5_HAVE_GETTIMEOFDAY */
     while(size > 0) {
-
         h5_posix_io_t       bytes_in        = 0;    /* # of bytes to write  */
         h5_posix_io_ret_t   bytes_wrote     = -1;   /* # of bytes written   */
 
@@ -1535,14 +1504,22 @@ H5FD_log_write(H5FD_t *_file, H5FD_mem_t type, hid_t H5_ATTR_UNUSED dxpl_id, had
         addr += (haddr_t)bytes_wrote;
         buf = (const char *)buf + bytes_wrote;
     } /* end while */
-#ifdef H5_HAVE_GETTIMEOFDAY
+
+    /* Stop timer for write operation */
     if(file->fa.flags & H5FD_LOG_TIME_WRITE)
-        HDgettimeofday(&timeval_stop, NULL);
-#endif /* H5_HAVE_GETTIMEOFDAY */
+        H5_timer_stop(&write_timer);
 
-    /* Log information about the write */
+    /* Add to the number of writes, when tracking that */
     if(file->fa.flags & H5FD_LOG_NUM_WRITE)
         file->total_write_ops++;
+
+    /* Add to the total write time, when tracking that */
+    if(file->fa.flags & H5FD_LOG_TIME_WRITE) {
+        H5_timer_get_times(write_timer, &write_times);
+        file->total_write_time += write_times.elapsed;
+    } /* end if */
+
+    /* Log information about the write */
     if(file->fa.flags & H5FD_LOG_LOC_WRITE) {
         HDfprintf(file->logfp, "%10a-%10a (%10Zu bytes) (%s) Written", orig_addr, (orig_addr + orig_size) - 1, orig_size, flavors[type]);
 
@@ -1554,29 +1531,14 @@ H5FD_log_write(H5FD_t *_file, H5FD_mem_t type, hid_t H5_ATTR_UNUSED dxpl_id, had
             } /* end if */
         } /* end if */
 
-#ifdef H5_HAVE_GETTIMEOFDAY
-        if(file->fa.flags & H5FD_LOG_TIME_WRITE) {
-            struct timeval timeval_diff;
-            double time_diff;
-
-            /* Calculate the elapsed gettimeofday time */
-            timeval_diff.tv_usec = timeval_stop.tv_usec - timeval_start.tv_usec;
-            timeval_diff.tv_sec = timeval_stop.tv_sec - timeval_start.tv_sec;
-            if(timeval_diff.tv_usec < 0) {
-                timeval_diff.tv_usec += 1000000;
-                timeval_diff.tv_sec--;
-            } /* end if */
-            time_diff = (double)timeval_diff.tv_sec + ((double)timeval_diff.tv_usec / (double)1000000.0f);
-            HDfprintf(file->logfp, " (%fs @ %.6lu.%.6llu)\n", time_diff, (unsigned long long)timeval_start.tv_sec, (unsigned long long)timeval_start.tv_usec);
-
-            /* Add to total write time */
-            file->total_write_time += time_diff;
-        } /* end if */
-        else
-            HDfprintf(file->logfp, "\n");
-#else /* H5_HAVE_GETTIMEOFDAY */
-        HDfprintf(file->logfp, "\n");
-#endif /* H5_HAVE_GETTIMEOFDAY */
+        /* Add the write time, if we're tracking that.
+         * Note that the write time is NOT emitted for when just H5FD_LOG_TIME_WRITE
+         * is set.
+         */
+        if(file->fa.flags & H5FD_LOG_TIME_WRITE)
+            HDfprintf(file->logfp, " (%fs @ %f)\n", write_times.elapsed, write_timer.initial.elapsed);
+         else
+             HDfprintf(file->logfp, "\n");
     } /* end if */
 
     /* Update current position and eof */
@@ -1593,11 +1555,11 @@ done:
     } /* end if */
 
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5FD_log_write() */
+} /* end H5FD__log_write() */
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5FD_log_truncate
+ * Function:    H5FD__log_truncate
  *
  * Purpose:     Makes sure that the true file size is the same (or larger)
  *              than the end-of-address.
@@ -1610,34 +1572,33 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5FD_log_truncate(H5FD_t *_file, hid_t H5_ATTR_UNUSED dxpl_id, hbool_t H5_ATTR_UNUSED closing)
+H5FD__log_truncate(H5FD_t *_file, hid_t H5_ATTR_UNUSED dxpl_id, hbool_t H5_ATTR_UNUSED closing)
 {
     H5FD_log_t  *file = (H5FD_log_t *)_file;
     herr_t      ret_value = SUCCEED;                /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
     HDassert(file);
 
     /* Extend the file to make sure it's large enough */
     if(!H5F_addr_eq(file->eoa, file->eof)) {
-#ifdef H5_HAVE_GETTIMEOFDAY
-        struct timeval timeval_start, timeval_stop;
-#endif /* H5_HAVE_GETTIMEOFDAY */
+        H5_timer_t      trunc_timer;        /* Timer for truncate operation */
+        H5_timevals_t   trunc_times;        /* Elapsed time for truncate operation */
+
+        /* Start timer for truncate operation */
+        if(file->fa.flags & H5FD_LOG_TIME_TRUNCATE) {
+            H5_timer_init(&trunc_timer);
+            H5_timer_start(&trunc_timer);
+        } /* end if */
+
 #ifdef H5_HAVE_WIN32_API
+{
         LARGE_INTEGER   li;         /* 64-bit (union) integer for SetFilePointer() call */
         DWORD           dwPtrLow;   /* Low-order pointer bits from SetFilePointer()
                                      * Only used as an error code here.
                                      */
-        DWORD           dwError;    /* DWORD error code from GetLastError() */
-        BOOL            bError;     /* Boolean error flag */
-#endif /* H5_HAVE_WIN32_API */
 
-#ifdef H5_HAVE_GETTIMEOFDAY
-        if(file->fa.flags & H5FD_LOG_TIME_TRUNCATE)
-            HDgettimeofday(&timeval_start, NULL);
-#endif /* H5_HAVE_GETTIMEOFDAY */
-#ifdef H5_HAVE_WIN32_API
         /* Windows uses this odd QuadPart union for 32/64-bit portability */
         li.QuadPart = (__int64)file->eoa;
 
@@ -1648,51 +1609,48 @@ H5FD_log_truncate(H5FD_t *_file, hid_t H5_ATTR_UNUSED dxpl_id, hbool_t H5_ATTR_U
          */
         dwPtrLow = SetFilePointer(file->hFile, li.LowPart, &li.HighPart, FILE_BEGIN);
         if(INVALID_SET_FILE_POINTER == dwPtrLow) {
+            DWORD           dwError;    /* DWORD error code from GetLastError() */
+
             dwError = GetLastError();
             if(dwError != NO_ERROR )
                 HGOTO_ERROR(H5E_FILE, H5E_FILEOPEN, FAIL, "unable to set file pointer")
-        }
+        } /* end if */
 
-        bError = SetEndOfFile(file->hFile);
-        if(0 == bError)
+        if(0 == SetEndOfFile(file->hFile))
             HGOTO_ERROR(H5E_IO, H5E_SEEKERROR, FAIL, "unable to extend file properly")
+}
 #else /* H5_HAVE_WIN32_API */
+        /* Truncate/extend the file */
         if(-1 == HDftruncate(file->fd, (HDoff_t)file->eoa))
             HSYS_GOTO_ERROR(H5E_IO, H5E_SEEKERROR, FAIL, "unable to extend file properly")
 #endif /* H5_HAVE_WIN32_API */
-#ifdef H5_HAVE_GETTIMEOFDAY
+
+        /* Stop timer for truncate operation */
         if(file->fa.flags & H5FD_LOG_TIME_TRUNCATE)
-            HDgettimeofday(&timeval_stop, NULL);
-#endif /* H5_HAVE_GETTIMEOFDAY */
+            H5_timer_stop(&trunc_timer);
 
-        /* Log information about the truncate */
+        /* Add to the number of truncates, when tracking that */
         if(file->fa.flags & H5FD_LOG_NUM_TRUNCATE)
             file->total_truncate_ops++;
+
+        /* Add to the total truncate time, when tracking that */
+        if(file->fa.flags & H5FD_LOG_TIME_TRUNCATE) {
+            H5_timer_get_times(trunc_timer, &trunc_times);
+            file->total_truncate_time += trunc_times.elapsed;
+        } /* end if */
+
+        /* Emit log string if we're tracking individual truncate events. */
         if(file->fa.flags & H5FD_LOG_TRUNCATE) {
             HDfprintf(file->logfp, "Truncate: To %10a", file->eoa);
-#ifdef H5_HAVE_GETTIMEOFDAY
-            if(file->fa.flags & H5FD_LOG_TIME_TRUNCATE) {
-                struct timeval timeval_diff;
-                double time_diff;
-
-                /* Calculate the elapsed gettimeofday time */
-                timeval_diff.tv_usec = timeval_stop.tv_usec - timeval_start.tv_usec;
-                timeval_diff.tv_sec = timeval_stop.tv_sec - timeval_start.tv_sec;
-                if(timeval_diff.tv_usec < 0) {
-                    timeval_diff.tv_usec += 1000000;
-                    timeval_diff.tv_sec--;
-                } /* end if */
-                time_diff = (double)timeval_diff.tv_sec + ((double)timeval_diff.tv_usec / (double)1000000.0f);
-                HDfprintf(file->logfp, " (%fs @ %.6lu.%.6llu)\n", time_diff, (unsigned long long)timeval_start.tv_sec, (unsigned long long)timeval_start.tv_usec);
 
-                /* Add to total truncate time */
-                file->total_truncate_time += time_diff;
-            } /* end if */
-            else
-                HDfprintf(file->logfp, "\n");
-#else /* H5_HAVE_GETTIMEOFDAY */
-            HDfprintf(file->logfp, "\n");
-#endif /* H5_HAVE_GETTIMEOFDAY */
+            /* Add the truncate time, if we're tracking that.
+             * Note that the truncate time is NOT emitted for when just H5FD_LOG_TIME_TRUNCATE
+             * is set.
+             */
+            if(file->fa.flags & H5FD_LOG_TIME_TRUNCATE)
+                HDfprintf(file->logfp, " (%fs @ %f)\n", trunc_times.elapsed, trunc_timer.initial.elapsed);
+             else
+                 HDfprintf(file->logfp, "\n");
         } /* end if */
 
         /* Update the eof value */
@@ -1705,11 +1663,11 @@ H5FD_log_truncate(H5FD_t *_file, hid_t H5_ATTR_UNUSED dxpl_id, hbool_t H5_ATTR_U
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5FD_log_truncate() */
+} /* end H5FD__log_truncate() */
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5FD_log_lock
+ * Function:    H5FD__log_lock
  *
  * Purpose:     Place a lock on the file
  *
@@ -1721,13 +1679,13 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5FD_log_lock(H5FD_t *_file, hbool_t rw)
+H5FD__log_lock(H5FD_t *_file, hbool_t rw)
 {
     H5FD_log_t	*file = (H5FD_log_t *)_file;    /* VFD file struct          */
     int lock_flags;                             /* file locking flags       */
     herr_t ret_value = SUCCEED;                 /* Return value             */
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
     /* Sanity check */
     HDassert(file);
@@ -1749,11 +1707,11 @@ H5FD_log_lock(H5FD_t *_file, hbool_t rw)
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5FD_log_lock() */
+} /* end H5FD__log_lock() */
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5FD_log_unlock
+ * Function:    H5FD__log_unlock
  *
  * Purpose:     Remove the existing lock on the file
  *
@@ -1764,12 +1722,12 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5FD_log_unlock(H5FD_t *_file)
+H5FD__log_unlock(H5FD_t *_file)
 {
     H5FD_log_t  *file = (H5FD_log_t *)_file;    /* VFD file struct          */
     herr_t ret_value = SUCCEED;                 /* Return value             */
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
     HDassert(file);
 
@@ -1786,5 +1744,5 @@ H5FD_log_unlock(H5FD_t *_file)
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5FD_log_unlock() */
+} /* end H5FD__log_unlock() */
 
diff --git a/src/H5FDlog.h b/src/H5FDlog.h
index a69bb18..db51f3d 100644
--- a/src/H5FDlog.h
+++ b/src/H5FDlog.h
@@ -12,7 +12,7 @@
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
 /*
- * Programmer:  Quincey Koziol <koziol@ncsa.uiuc.edu>
+ * Programmer:  Quincey Koziol
  *              Monday, April 17, 2000
  *
  * Purpose:	The public header file for the log driver.
diff --git a/src/H5T.c b/src/H5T.c
index 2ecc474..910021e 100644
--- a/src/H5T.c
+++ b/src/H5T.c
@@ -1815,12 +1815,6 @@ done:
  * Programmer:    Robb Matzke
  *        Friday, January     9, 1998
  *
- * Modifications:
- *
- *     Robb Matzke, 1 Jun 1998
- *    It is illegal to lock a named datatype since we must allow named
- *    types to be closed (to release file resources) but locking a type
- *    prevents that.
  *-------------------------------------------------------------------------
  */
 herr_t
@@ -1893,9 +1887,6 @@ done:
  * Programmer:    Robb Matzke
  *        Monday, December  8, 1997
  *
- * Modifications:
- *      Broke out from H5Tget_class - QAK - 6/4/99
- *
  *-------------------------------------------------------------------------
  */
 H5T_class_t
@@ -2882,10 +2873,6 @@ done:
  * Programmer:    Raymond Lu
  *              July 14, 2004
  *
- * Modification:Raymond Lu
- *              17 February 2011
- *              I changed the value for the APP_REF parameter of H5I_register
- *              from FALSE to TRUE.
  *-------------------------------------------------------------------------
  */
 hid_t
@@ -3046,10 +3033,6 @@ done:
  * Programmer:    Robb Matzke
  *        Friday, December  5, 1997
  *
- * Modifications:
- *              Raymond Lu
- *              19 May 2011
- *              We support fixed size or variable-length string now.
  *-------------------------------------------------------------------------
  */
 H5T_t *
@@ -5055,11 +5038,6 @@ H5T_path_noop(const H5T_path_t *p)
  * Programmer:    Raymond Lu
  *        8 June 2007
  *
- * Modifications:  Neil Fortner
- *      19 September 2008
- *      Changed return value to H5T_subset_info_t
- *      (to allow it to return copy_size)
- *
  *-------------------------------------------------------------------------
  */
 H5T_subset_info_t *
@@ -5154,15 +5132,18 @@ H5T_convert(H5T_path_t *tpath, hid_t src_id, hid_t dst_id, size_t nelmts,
     size_t buf_stride, size_t bkg_stride, void *buf, void *bkg)
 {
 #ifdef H5T_DEBUG
-    H5_timer_t        timer;
+    H5_timer_t  timer;                  /* Timer for conversion */
 #endif
     herr_t ret_value = SUCCEED;         /* Return value */
 
     FUNC_ENTER_NOAPI(FAIL)
 
 #ifdef H5T_DEBUG
-    if(H5DEBUG(T))
-        H5_timer_begin(&timer);
+    if(H5DEBUG(T)) {
+        /* Initialize and start timer */
+        H5_timer_init(&timer);
+        H5_timer_start(&timer);
+    } /* end if */
 #endif
 
     /* Call the appropriate conversion callback */
@@ -5176,10 +5157,16 @@ H5T_convert(H5T_path_t *tpath, hid_t src_id, hid_t dst_id, size_t nelmts,
             HGOTO_ERROR(H5E_DATATYPE, H5E_CANTCONVERT, FAIL, "datatype conversion failed")
 #ifdef H5T_DEBUG
     if(H5DEBUG(T)) {
-        H5_timer_end(&(tpath->stats.timer), &timer);
+        /* Stop timer */
+        H5_timer_stop(&timer);
+
+        /* Record elapsed timer info */
+        H5_timer_get_times(timer, &tpath->stats.times);
+
+        /* Increment # of calls and # of elements converted */
         tpath->stats.ncalls++;
         tpath->stats.nelmts += nelmts;
-    }
+    } /* end if */
 #endif
 
 done:
diff --git a/src/H5Tdbg.c b/src/H5Tdbg.c
index eb648f3..6188138 100644
--- a/src/H5Tdbg.c
+++ b/src/H5Tdbg.c
@@ -13,11 +13,11 @@
 
 /*-------------------------------------------------------------------------
  *
- * Created:		H5Tdbg.c
- *			Jul 19 2007
- *			Quincey Koziol <koziol@hdfgroup.org>
+ * Created:         H5Tdbg.c
+ *                  Jul 19 2007
+ *                  Quincey Koziol
  *
- * Purpose:		Dump debugging information about a datatype
+ * Purpose:         Dump debugging information about a datatype
  *
  *-------------------------------------------------------------------------
  */
@@ -95,25 +95,24 @@
 herr_t
 H5T__print_stats(H5T_path_t H5_ATTR_UNUSED * path, int H5_ATTR_UNUSED * nprint/*in,out*/)
 {
-#ifdef H5T_DEBUG
-    hsize_t	nbytes;
-    char	bandwidth[32];
-#endif
-
     FUNC_ENTER_PACKAGE_NOERR
 
 #ifdef H5T_DEBUG
-    if (H5DEBUG(T) && path->stats.ncalls > 0) {
-        if (nprint && 0 == (*nprint)++) {
-            HDfprintf(H5DEBUG(T), "H5T: type conversion statistics:\n");
-            HDfprintf(H5DEBUG(T), "   %-16s %10s %10s %8s %8s %8s %10s\n",
-                "Conversion", "Elmts", "Calls", "User",
-                "System", "Elapsed", "Bandwidth");
-            HDfprintf(H5DEBUG(T), "   %-16s %10s %10s %8s %8s %8s %10s\n",
-                "----------", "-----", "-----", "----",
-                "------", "-------", "---------");
-        }
-        if (path->src && path->dst)
+    if(H5DEBUG(T) && path->stats.ncalls > 0) {
+        hsize_t    nbytes;
+        char    bandwidth[32];
+
+    if(nprint && 0 == (*nprint)++) {
+        HDfprintf(H5DEBUG(T), "H5T: type conversion statistics:\n");
+        HDfprintf(H5DEBUG(T), "   %-16s %10s %10s %8s %8s %8s %10s\n",
+            "Conversion", "Elmts", "Calls", "User",
+            "System", "Elapsed", "Bandwidth");
+        HDfprintf(H5DEBUG(T), "   %-16s %10s %10s %8s %8s %8s %10s\n",
+            "----------", "-----", "-----", "----",
+            "------", "-------", "---------");
+    } /* end if */
+
+        if(path->src && path->dst)
             nbytes = MAX(H5T_get_size(path->src), H5T_get_size(path->dst));
         else if (path->src)
             nbytes = H5T_get_size(path->src);
@@ -121,18 +120,20 @@ H5T__print_stats(H5T_path_t H5_ATTR_UNUSED * path, int H5_ATTR_UNUSED * nprint/*
             nbytes = H5T_get_size(path->dst);
         else
             nbytes = 0;
-        nbytes *= path->stats.nelmts;
-        H5_bandwidth(bandwidth, (double)nbytes, path->stats.timer.etime);
-        HDfprintf(H5DEBUG(T), "   %-16s %10Hd %10d %8.2f %8.2f %8.2f %10s\n",
-            path->name,
-            path->stats.nelmts,
-            path->stats.ncalls,
-            path->stats.timer.utime,
-            path->stats.timer.stime,
-            path->stats.timer.etime,
-            bandwidth);
-    }
+
+    nbytes *= path->stats.nelmts;
+        H5_bandwidth(bandwidth, (double)nbytes, path->stats.times.elapsed);
+        HDfprintf(H5DEBUG(T), "   %-16s %10Hd %10d %8T %8T %8T %10s\n",
+        path->name,
+        path->stats.nelmts,
+        path->stats.ncalls,
+                   path->stats.times.user,
+                   path->stats.times.system,
+                   path->stats.times.elapsed,
+        bandwidth);
+    } /* end if */
 #endif
+
     FUNC_LEAVE_NOAPI(SUCCEED)
 } /* end H5T__print_stats() */
 
@@ -405,18 +406,18 @@ H5T_debug(const H5T_t *dt, FILE *stream)
         } /* end else */
     }
     else if (H5T_ENUM == dt->shared->type) {
-        size_t	base_size;
+        size_t    base_size;
 
         /* Enumeration data type */
         HDfprintf(stream, " ");
         H5T_debug(dt->shared->parent, stream);
         base_size = dt->shared->parent->shared->size;
         for (i = 0; i < dt->shared->u.enumer.nmembs; i++) {
-            size_t	k;
+            size_t    k;
 
             HDfprintf(stream, "\n\"%s\" = 0x", dt->shared->u.enumer.name[i]);
             for (k = 0; k < base_size; k++)
-                HDfprintf(stream, "%02lx", (unsigned long)(dt->shared->u.enumer.value + (i * base_size) + k));
+                HDfprintf(stream, "%02p", ((uint8_t *)dt->shared->u.enumer.value + (i * base_size) + k));
         } /* end for */
         HDfprintf(stream, "\n");
     }
diff --git a/src/H5Tpkg.h b/src/H5Tpkg.h
index 05879ff..b8d2435 100644
--- a/src/H5Tpkg.h
+++ b/src/H5Tpkg.h
@@ -12,7 +12,7 @@
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
 /*
- * Programmer:	Robb Matzke <matzke@llnl.gov>
+ * Programmer:	Robb Matzke
  *		Monday, December  8, 1997
  *
  * Purpose:	This file contains declarations which are visible only within
@@ -146,7 +146,7 @@
 struct H5T_stats_t {
     unsigned	ncalls;			/*num calls to conversion function   */
     hsize_t	nelmts;			/*total data points converted	     */
-    H5_timer_t	timer;			/*total time for conversion	     */
+    H5_timevals_t times;		/*total time for conversion	     */
 };
 
 /* Library internal datatype conversion functions are... */
diff --git a/src/H5Z.c b/src/H5Z.c
index 93d7df9..d8bb7c4 100644
--- a/src/H5Z.c
+++ b/src/H5Z.c
@@ -35,10 +35,10 @@
 #ifdef H5Z_DEBUG
 typedef struct H5Z_stats_t {
     struct {
-        hsize_t    total;    /* total number of bytes processed */
-        hsize_t    errors;   /* bytes of total attributable to errors */
-        H5_timer_t timer;    /* execution time including errors */
-    } stats[2];              /* 0=output, 1=input */
+        hsize_t     total;      /* total number of bytes processed */
+        hsize_t     errors;     /* bytes of total attributable to errors */
+        H5_timevals_t times;    /* execution time including errors */
+    } stats[2];                 /* 0 = output, 1 = input */
 } H5Z_stats_t;
 #endif /* H5Z_DEBUG */
 
@@ -68,7 +68,7 @@ static H5Z_stats_t          *H5Z_stat_table_g = NULL;
 #endif /* H5Z_DEBUG */
 
 /* Local functions */
-static int H5Z_find_idx(H5Z_filter_t id);
+static int H5Z__find_idx(H5Z_filter_t id);
 static int H5Z__check_unregister_dset_cb(void *obj_ptr, hid_t obj_id, void *key);
 static int H5Z__check_unregister_group_cb(void *obj_ptr, hid_t obj_id, void *key);
 static int H5Z__flush_file_cb(void *obj_ptr, hid_t obj_id, void *key);
@@ -132,9 +132,9 @@ H5Z_term_package(void)
 
     if(H5_PKG_INIT_VAR) {
 #ifdef H5Z_DEBUG
-        char comment[16], bandwidth[32];
-        int dir, nprint = 0;
-        size_t i;
+        char    comment[16], bandwidth[32];
+        int     dir, nprint = 0;
+        size_t  i;
 
         if(H5DEBUG(Z)) {
             for(i = 0; i < H5Z_table_used_g; i++) {
@@ -167,25 +167,26 @@ H5Z_term_package(void)
                     */
                     H5_bandwidth(bandwidth,
                             (double)(H5Z_stat_table_g[i].stats[dir].total),
-                            H5Z_stat_table_g[i].stats[dir].timer.etime);
+                            H5Z_stat_table_g[i].stats[dir].times.elapsed);
 
                     /* Print the statistics */
-                    HDfprintf(H5DEBUG(Z),
-                            "   %s%-15s %10Hd %10Hd %8.2f %8.2f %8.2f "
-                            "%10s\n", dir?"<":">", comment,
+                    HDfprintf(H5DEBUG(Z), "   %s%-15s %10Hd %10Hd %8T %8T %8T %10s\n",
+                            (dir ? "<" : ">"), comment,
                             H5Z_stat_table_g[i].stats[dir].total,
                             H5Z_stat_table_g[i].stats[dir].errors,
-                            H5Z_stat_table_g[i].stats[dir].timer.utime,
-                            H5Z_stat_table_g[i].stats[dir].timer.stime,
-                            H5Z_stat_table_g[i].stats[dir].timer.etime,
+                            H5Z_stat_table_g[i].stats[dir].times.user,
+                            H5Z_stat_table_g[i].stats[dir].times.system,
+                            H5Z_stat_table_g[i].stats[dir].times.elapsed,
                             bandwidth);
                 } /* end for */
             } /* end for */
         } /* end if */
 #endif /* H5Z_DEBUG */
+
         /* Free the table of filters */
-        if (H5Z_table_g) {
+        if(H5Z_table_g) {
             H5Z_table_g = (H5Z_class2_t *)H5MM_xfree(H5Z_table_g);
+
 #ifdef H5Z_DEBUG
             H5Z_stat_table_g = (H5Z_stats_t *)H5MM_xfree(H5Z_stat_table_g);
 #endif /* H5Z_DEBUG */
@@ -378,8 +379,8 @@ done:
  * Purpose:     Same as the public version except this one allows filters
  *               to be unset for predefined method numbers <H5Z_FILTER_RESERVED
  *
- * Return:      Non-negative on success
- *              Negative on failure
+ * Return:      SUCCEED/FAIL
+ *
  *-------------------------------------------------------------------------
  */
 herr_t
@@ -700,8 +701,8 @@ H5Z_filter_avail(H5Z_filter_t id)
             HGOTO_DONE(TRUE)
 
     key.id = (int)id;
-    if (NULL != (filter_info = (const H5Z_class2_t *)H5PL_load(H5PL_TYPE_FILTER, key))) {
-        if (H5Z_register(filter_info) < 0)
+    if(NULL != (filter_info = (const H5Z_class2_t *)H5PL_load(H5PL_TYPE_FILTER, key))) {
+        if(H5Z_register(filter_info) < 0)
             HGOTO_ERROR(H5E_PLINE, H5E_CANTINIT, FAIL, "unable to register loaded filter")
         HGOTO_DONE(TRUE)
     } /* end if */
@@ -712,7 +713,7 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function: H5Z_prelude_callback
+ * Function: H5Z__prelude_callback
  *
  * Purpose:  Makes a dataset creation "prelude" callback for the "can_apply"
  *           or "set_local" routines.
@@ -725,14 +726,14 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5Z_prelude_callback(const H5O_pline_t *pline, hid_t dcpl_id, hid_t type_id,
+H5Z__prelude_callback(const H5O_pline_t *pline, hid_t dcpl_id, hid_t type_id,
     hid_t space_id, H5Z_prelude_type_t prelude_type)
 {
     H5Z_class2_t    *fclass;                /* Individual filter information */
     size_t          u;                      /* Local index variable */
     htri_t          ret_value = TRUE;       /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
     HDassert(pline->nused > 0);
 
@@ -790,11 +791,11 @@ H5Z_prelude_callback(const H5O_pline_t *pline, hid_t dcpl_id, hid_t type_id,
 done:
 
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5Z_prelude_callback() */
+} /* end H5Z__prelude_callback() */
 
 
 /*-------------------------------------------------------------------------
- * Function: H5Z_prepare_prelude_callback_dcpl
+ * Function: H5Z__prepare_prelude_callback_dcpl
  *
  * Purpose:  Prepares to make a dataset creation "prelude" callback
  *           for the "can_apply" or "set_local" routines.
@@ -807,13 +808,13 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5Z_prepare_prelude_callback_dcpl(hid_t dcpl_id, hid_t type_id, H5Z_prelude_type_t prelude_type)
+H5Z__prepare_prelude_callback_dcpl(hid_t dcpl_id, hid_t type_id, H5Z_prelude_type_t prelude_type)
 {
     hid_t   space_id = -1;            /* ID for dataspace describing chunk */
     H5O_layout_t *dcpl_layout = NULL; /* Dataset's layout information */
     herr_t  ret_value = SUCCEED;      /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
     HDassert(H5I_GENPROP_LST == H5I_get_type(dcpl_id));
     HDassert(H5I_DATATYPE == H5I_get_type(type_id));
@@ -861,7 +862,7 @@ H5Z_prepare_prelude_callback_dcpl(hid_t dcpl_id, hid_t type_id, H5Z_prelude_type
                 }
 
                 /* Make the callbacks */
-                if (H5Z_prelude_callback(&dcpl_pline, dcpl_id, type_id, space_id, prelude_type) < 0)
+                if (H5Z__prelude_callback(&dcpl_pline, dcpl_id, type_id, space_id, prelude_type) < 0)
                     HGOTO_ERROR(H5E_PLINE, H5E_CANAPPLY, FAIL, "unable to apply filter")
             }
         }
@@ -875,7 +876,7 @@ done:
         dcpl_layout = (H5O_layout_t *)H5MM_xfree(dcpl_layout);
 
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5Z_prepare_prelude_callback_dcpl() */
+} /* end H5Z__prepare_prelude_callback_dcpl() */
 
 
 /*-------------------------------------------------------------------------
@@ -901,7 +902,7 @@ H5Z_can_apply(hid_t dcpl_id, hid_t type_id)
     FUNC_ENTER_NOAPI(FAIL)
 
     /* Make "can apply" callbacks for filters in pipeline */
-    if (H5Z_prepare_prelude_callback_dcpl(dcpl_id, type_id, H5Z_PRELUDE_CAN_APPLY) < 0)
+    if (H5Z__prepare_prelude_callback_dcpl(dcpl_id, type_id, H5Z_PRELUDE_CAN_APPLY) < 0)
         HGOTO_ERROR(H5E_PLINE, H5E_CANAPPLY, FAIL, "unable to apply filter")
 
 done:
@@ -932,7 +933,7 @@ H5Z_set_local(hid_t dcpl_id, hid_t type_id)
     FUNC_ENTER_NOAPI(FAIL)
 
     /* Make "set local" callbacks for filters in pipeline */
-    if (H5Z_prepare_prelude_callback_dcpl(dcpl_id, type_id, H5Z_PRELUDE_SET_LOCAL) < 0)
+    if (H5Z__prepare_prelude_callback_dcpl(dcpl_id, type_id, H5Z_PRELUDE_SET_LOCAL) < 0)
         HGOTO_ERROR(H5E_PLINE, H5E_SETLOCAL, FAIL, "local filter parameters not set")
 
 done:
@@ -961,7 +962,7 @@ H5Z_can_apply_direct(const H5O_pline_t *pline)
     HDassert(pline->nused > 0);
 
     /* Make "can apply" callbacks for filters in pipeline */
-    if (H5Z_prelude_callback(pline, (hid_t)-1, (hid_t)-1, (hid_t)-1, H5Z_PRELUDE_CAN_APPLY) < 0)
+    if (H5Z__prelude_callback(pline, (hid_t)-1, (hid_t)-1, (hid_t)-1, H5Z_PRELUDE_CAN_APPLY) < 0)
         HGOTO_ERROR(H5E_PLINE, H5E_CANAPPLY, FAIL, "unable to apply filter")
 
 done:
@@ -994,7 +995,7 @@ H5Z_set_local_direct(const H5O_pline_t *pline)
     HDassert(pline->nused > 0);
 
     /* Make "set local" callbacks for filters in pipeline */
-    if (H5Z_prelude_callback(pline, (hid_t)-1, (hid_t)-1, (hid_t)-1, H5Z_PRELUDE_SET_LOCAL) < 0)
+    if (H5Z__prelude_callback(pline, (hid_t)-1, (hid_t)-1, (hid_t)-1, H5Z_PRELUDE_SET_LOCAL) < 0)
         HGOTO_ERROR(H5E_PLINE, H5E_SETLOCAL, FAIL, "local filter parameters not set")
 
 done:
@@ -1167,7 +1168,7 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function: H5Z_find_idx
+ * Function: H5Z__find_idx
  *
  * Purpose:  Given a filter ID return the offset in the global array
  *           that holds all the registered filters.
@@ -1177,20 +1178,20 @@ done:
  *-------------------------------------------------------------------------
  */
 static int
-H5Z_find_idx(H5Z_filter_t id)
+H5Z__find_idx(H5Z_filter_t id)
 {
     size_t i;                   /* Local index variable */
     int    ret_value = FAIL;    /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    FUNC_ENTER_STATIC_NOERR
 
-    for (i = 0; i < H5Z_table_used_g; i++)
-        if (H5Z_table_g[i].id == id)
+    for(i = 0; i < H5Z_table_used_g; i++)
+        if(H5Z_table_g[i].id == id)
             HGOTO_DONE((int)i)
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5Z_find_idx() */
+} /* end H5Z__find_idx() */
 
 
 /*-------------------------------------------------------------------------
@@ -1212,7 +1213,7 @@ H5Z_find(H5Z_filter_t id)
     FUNC_ENTER_NOAPI(NULL)
 
     /* Get the index in the global table */
-    if ((idx = H5Z_find_idx(id)) < 0)
+    if ((idx = H5Z__find_idx(id)) < 0)
         HGOTO_ERROR(H5E_PLINE, H5E_NOTFOUND, NULL, "required filter %d is not registered", id)
 
     /* Set return value */
@@ -1248,20 +1249,22 @@ done:
  */
 herr_t
 H5Z_pipeline(const H5O_pline_t *pline, unsigned flags,
-        unsigned *filter_mask/*in,out*/, H5Z_EDC_t edc_read,
-        H5Z_cb_t cb_struct, size_t *nbytes/*in,out*/,
-        size_t *buf_size/*in,out*/, void **buf/*in,out*/)
+    unsigned *filter_mask/*in,out*/, H5Z_EDC_t edc_read, H5Z_cb_t cb_struct,
+    size_t *nbytes/*in,out*/, size_t *buf_size/*in,out*/, void **buf/*in,out*/)
 {
-    size_t    i, idx, new_nbytes;
-    int       fclass_idx;        /* Index of filter class in global table */
-    H5Z_class2_t *fclass=NULL;   /* Filter class pointer */
+    size_t          idx;
+    size_t          new_nbytes;
+    int             fclass_idx;     /* Index of filter class in global table */
+    H5Z_class2_t   *fclass = NULL;  /* Filter class pointer */
 #ifdef H5Z_DEBUG
-    H5Z_stats_t  *fstats=NULL;   /* Filter stats pointer */
-    H5_timer_t    timer;
+    H5Z_stats_t   *fstats = NULL;   /* Filter stats pointer */
+    H5_timer_t      timer;           /* Timer for filter operations */
+    H5_timevals_t   times;           /* Elapsed time for each operation */
 #endif
-    unsigned    failed = 0;
-    unsigned    tmp_flags;
-    herr_t      ret_value = SUCCEED;       /* Return value */
+    unsigned        failed = 0;
+    unsigned        tmp_flags;
+    size_t          i;
+    herr_t          ret_value = SUCCEED;    /* Return value */
 
     FUNC_ENTER_NOAPI(FAIL)
 
@@ -1272,11 +1275,13 @@ H5Z_pipeline(const H5O_pline_t *pline, unsigned flags,
     HDassert(buf && *buf);
     HDassert(!pline || pline->nused < H5Z_MAX_NFILTERS);
 
-    if (pline && (flags & H5Z_FLAG_REVERSE)) { /* Read */
-        for (i = pline->nused; i > 0; --i) {
-            idx = i-1;
-
-            if (*filter_mask & ((unsigned)1 << idx)) {
+#ifdef H5Z_DEBUG
+    H5_timer_init(&timer);
+#endif
+    if(pline && (flags & H5Z_FLAG_REVERSE)) { /* Read */
+        for(i = pline->nused; i > 0; --i) {
+            idx = i - 1;
+            if(*filter_mask & ((unsigned)1 << idx)) {
                 failed |= (unsigned)1 << idx;
                 continue;   /* filter excluded */
             }
@@ -1285,10 +1290,10 @@ H5Z_pipeline(const H5O_pline_t *pline, unsigned flags,
              * indicate no plugin through HDF5_PRELOAD_PLUG (using the symbol "::"),
              * try to load it dynamically and register it.  Otherwise, return failure
              */
-            if ((fclass_idx = H5Z_find_idx(pline->filter[idx].id)) < 0) {
-                hbool_t issue_error = FALSE;
+            if ((fclass_idx = H5Z__find_idx(pline->filter[idx].id)) < 0) {
                 H5PL_key_t key;
                 const H5Z_class2_t    *filter_info;
+                hbool_t issue_error = FALSE;
 
                 /* Try loading the filter */
                 key.id = (int)(pline->filter[idx].id);
@@ -1298,7 +1303,7 @@ H5Z_pipeline(const H5O_pline_t *pline, unsigned flags,
                         HGOTO_ERROR(H5E_PLINE, H5E_CANTINIT, FAIL, "unable to register filter")
 
                     /* Search in the table of registered filters again to find the dynamic filter just loaded and registered */
-                    if ((fclass_idx = H5Z_find_idx(pline->filter[idx].id)) < 0)
+                    if((fclass_idx = H5Z__find_idx(pline->filter[idx].id)) < 0)
                         issue_error = TRUE;
                 }
                 else
@@ -1316,76 +1321,96 @@ H5Z_pipeline(const H5O_pline_t *pline, unsigned flags,
             } /* end if */
 
             fclass = &H5Z_table_g[fclass_idx];
+
 #ifdef H5Z_DEBUG
             fstats = &H5Z_stat_table_g[fclass_idx];
-            H5_timer_begin (&timer);
+            H5_timer_start(&timer);
 #endif
+
             tmp_flags = flags | (pline->filter[idx].flags);
-            tmp_flags |= (edc_read== H5Z_DISABLE_EDC) ? H5Z_FLAG_SKIP_EDC : 0;
-            new_nbytes = (fclass->filter)(tmp_flags, pline->filter[idx].cd_nelmts,
-                                        pline->filter[idx].cd_values, *nbytes, buf_size, buf);
+            tmp_flags |= (edc_read == H5Z_DISABLE_EDC) ? H5Z_FLAG_SKIP_EDC : 0;
+            new_nbytes = (fclass->filter)(tmp_flags,
+                    pline->filter[idx].cd_nelmts, pline->filter[idx].cd_values,
+                    *nbytes, buf_size, buf);
 
 #ifdef H5Z_DEBUG
-            H5_timer_end (&(fstats->stats[1].timer), &timer);
+            H5_timer_stop(&timer);
+            H5_timer_get_times(timer, &times);
+            fstats->stats[1].times.elapsed += times.elapsed;
+            fstats->stats[1].times.system  += times.system;
+            fstats->stats[1].times.user    += times.user;
+
             fstats->stats[1].total += MAX(*nbytes, new_nbytes);
-            if (0 == new_nbytes)
+            if(0 == new_nbytes)
                 fstats->stats[1].errors += *nbytes;
 #endif
 
-            if (0 == new_nbytes) {
-                if ((cb_struct.func && (H5Z_CB_FAIL == cb_struct.func(pline->filter[idx].id, *buf, *buf_size, cb_struct.op_data))) || !cb_struct.func)
+            if(0 == new_nbytes) {
+                if((cb_struct.func
+                        && (H5Z_CB_FAIL == cb_struct.func(pline->filter[idx].id, *buf, *buf_size, cb_struct.op_data)))
+                        || !cb_struct.func)
                     HGOTO_ERROR(H5E_PLINE, H5E_READERROR, FAIL, "filter returned failure during read")
 
                 *nbytes = *buf_size;
                 failed |= (unsigned)1 << idx;
-                H5E_clear_stack (NULL);
+                H5E_clear_stack(NULL);
             }
             else
                 *nbytes = new_nbytes;
         }
     }
-    else if (pline) { /* Write */
-        for (idx = 0; idx < pline->nused; idx++) {
-            if (*filter_mask & ((unsigned)1 << idx)) {
+    else if(pline) { /* Write */
+        for(idx = 0; idx < pline->nused; idx++) {
+            if(*filter_mask & ((unsigned)1 << idx)) {
                 failed |= (unsigned)1 << idx;
-                continue; /*filter excluded*/
+                continue;       /* filter excluded */
             }
-            if ((fclass_idx = H5Z_find_idx(pline->filter[idx].id)) < 0) {
+            if((fclass_idx = H5Z__find_idx(pline->filter[idx].id)) < 0) {
                 /* Check if filter is optional -- If it isn't, then error */
-                if ((pline->filter[idx].flags & H5Z_FLAG_OPTIONAL) == 0)
+                if((pline->filter[idx].flags & H5Z_FLAG_OPTIONAL) == 0)
                     HGOTO_ERROR(H5E_PLINE, H5E_WRITEERROR, FAIL, "required filter is not registered")
-
                 failed |= (unsigned)1 << idx;
-                H5E_clear_stack (NULL);
-                continue; /*filter excluded*/
-            }
+                H5E_clear_stack(NULL);
+                continue;       /* filter excluded */
+            } /* end if */
+
             fclass = &H5Z_table_g[fclass_idx];
+
 #ifdef H5Z_DEBUG
             fstats = &H5Z_stat_table_g[fclass_idx];
-            H5_timer_begin (&timer);
+            H5_timer_start(&timer);
 #endif
-            new_nbytes = (fclass->filter)(flags | (pline->filter[idx].flags), pline->filter[idx].cd_nelmts,
-                    pline->filter[idx].cd_values, *nbytes, buf_size, buf);
+
+            new_nbytes = (fclass->filter)(flags | (pline->filter[idx].flags),
+                    pline->filter[idx].cd_nelmts, pline->filter[idx].cd_values,
+                    *nbytes, buf_size, buf);
+
 #ifdef H5Z_DEBUG
-            H5_timer_end (&(fstats->stats[0].timer), &timer);
+            H5_timer_stop(&timer);
+            H5_timer_get_times(timer, &times);
+            fstats->stats[0].times.elapsed += times.elapsed;
+            fstats->stats[0].times.system  += times.system;
+            fstats->stats[0].times.user    += times.user;
+
             fstats->stats[0].total += MAX(*nbytes, new_nbytes);
-            if (0 == new_nbytes)
+            if(0 == new_nbytes)
                 fstats->stats[0].errors += *nbytes;
 #endif
-            if (0 == new_nbytes) {
-                if (0 == (pline->filter[idx].flags & H5Z_FLAG_OPTIONAL)) {
-                    if ((cb_struct.func && (H5Z_CB_FAIL == cb_struct.func (pline->filter[idx].id, *buf, *nbytes, cb_struct.op_data))) || !cb_struct.func)
+
+            if(0 == new_nbytes) {
+                if(0 == (pline->filter[idx].flags & H5Z_FLAG_OPTIONAL)) {
+                    if((cb_struct.func && (H5Z_CB_FAIL == cb_struct.func(pline->filter[idx].id, *buf, *nbytes, cb_struct.op_data)))
+                            || !cb_struct.func)
                         HGOTO_ERROR(H5E_PLINE, H5E_WRITEERROR, FAIL, "filter returned failure")
 
                     *nbytes = *buf_size;
                 }
-
                 failed |= (unsigned)1 << idx;
-                H5E_clear_stack (NULL);
+                H5E_clear_stack(NULL);
             }
             else
                 *nbytes = new_nbytes;
-        }
+        } /* end for */
     }
 
     *filter_mask = failed;
diff --git a/src/H5private.h b/src/H5private.h
index 6c481c9..08f69c0 100644
--- a/src/H5private.h
+++ b/src/H5private.h
@@ -633,21 +633,37 @@
 #define LOCK_UN     0x08
 #endif /* H5_HAVE_FLOCK */
 
-/*
- * Data types and functions for timing certain parts of the library.
+/* Typedefs and functions for timing certain parts of the library. */
+
+/* A set of elapsed/user/system times emitted as a time point by the
+ * platform-independent timers.
  */
 typedef struct {
-    double  utime;    /*user time      */
-    double  stime;    /*system time      */
-    double  etime;    /*elapsed wall-clock time  */
+    double user;      /* User time in seconds */
+    double system;    /* System time in seconds */
+    double elapsed;   /* Elapsed (wall clock) time in seconds */
+} H5_timevals_t;
+
+/* Timer structure for platform-independent timers */
+typedef struct {
+    H5_timevals_t   initial;            /* Current interval start time */
+    H5_timevals_t   final_interval;     /* Last interval elapsed time */
+    H5_timevals_t   total;              /* Total elapsed time for all intervals */
+    hbool_t         is_running;         /* Whether timer is running */
 } H5_timer_t;
 
-H5_DLL void H5_timer_reset (H5_timer_t *timer);
-H5_DLL void H5_timer_begin (H5_timer_t *timer);
-H5_DLL void H5_timer_end (H5_timer_t *sum/*in,out*/,
-         H5_timer_t *timer/*in,out*/);
+/* Returns library bandwidth as a pretty string */
 H5_DLL void H5_bandwidth(char *buf/*out*/, double nbytes, double nseconds);
+
+/* Timer functionality */
 H5_DLL time_t H5_now(void);
+H5_DLL uint64_t H5_now_usec(void);
+H5_DLL herr_t H5_timer_init(H5_timer_t *timer /*in,out*/);
+H5_DLL herr_t H5_timer_start(H5_timer_t *timer /*in,out*/);
+H5_DLL herr_t H5_timer_stop(H5_timer_t *timer /*in,out*/);
+H5_DLL herr_t H5_timer_get_times(H5_timer_t timer, H5_timevals_t *times /*in,out*/);
+H5_DLL herr_t H5_timer_get_total_times(H5_timer_t timer, H5_timevals_t *times /*in,out*/);
+H5_DLL char *H5_timer_get_time_string(double seconds);
 
 /* Depth of object copy */
 typedef enum {
@@ -769,6 +785,9 @@ typedef struct {
 #ifndef HDclock
     #define HDclock()    clock()
 #endif /* HDclock */
+#ifndef HDclock_gettime
+    #define HDclock_gettime(CID, TS)    clock_gettime(CID, TS)
+#endif /* HDclock_gettime */
 #ifndef HDclose
     #define HDclose(F)    close(F)
 #endif /* HDclose */
diff --git a/src/H5system.c b/src/H5system.c
index dfb8d21..e2747f4 100644
--- a/src/H5system.c
+++ b/src/H5system.c
@@ -13,11 +13,11 @@
 
 /*-------------------------------------------------------------------------
  *
- * Created:    H5system.c
- *      Aug 21 2006
- *      Quincey Koziol <koziol@hdfgroup.org>
+ * Created:     H5system.c
+ *              Aug 21 2006
+ *              Quincey Koziol
  *
- * Purpose:    System call wrapper implementations.
+ * Purpose:     System call wrapper implementations.
  *
  *-------------------------------------------------------------------------
  */
@@ -30,10 +30,10 @@
 /***********/
 /* Headers */
 /***********/
-#include "H5private.h"        /* Generic Functions            */
-#include "H5Eprivate.h"        /* Error handling              */
-#include "H5Fprivate.h"        /* File access                */
-#include "H5MMprivate.h"    /* Memory management            */
+#include "H5private.h"      /* Generic Functions        */
+#include "H5Eprivate.h"     /* Error handling           */
+#include "H5Fprivate.h"     /* File access              */
+#include "H5MMprivate.h"    /* Memory management        */
 
 
 /****************/
@@ -377,7 +377,7 @@ HDfprintf(FILE *stream, const char *fmt, ...)
                             if(fwidth)
                                 len += HDsnprintf(format_templ + len, (sizeof(format_templ) - (size_t)(len + 1)),  "%d", fwidth);
                             HDstrncat(format_templ, "s", (sizeof(format_templ) - (size_t)(len + 1)));
-                            fprintf(stream, format_templ, "UNDEF");
+                            n = fprintf(stream, format_templ, "UNDEF");
                         }
                     }
                     break;
@@ -407,11 +407,25 @@ HDfprintf(FILE *stream, const char *fmt, ...)
                         htri_t tri_var = HDva_arg(ap, htri_t);
 
                         if(tri_var > 0)
-                            fprintf(stream, "TRUE");
+                            n = fprintf(stream, "TRUE");
                         else if(!tri_var)
-                            fprintf(stream, "FALSE");
+                            n = fprintf(stream, "FALSE");
                         else
-                            fprintf(stream, "FAIL(%d)", (int)tri_var);
+                            n = fprintf(stream, "FAIL(%d)", (int)tri_var);
+                    }
+                    break;
+
+                case 'T':       /* Elapsed time, in seconds */
+                    {
+                        double seconds = HDva_arg(ap, double);
+                        char *time_string = H5_timer_get_time_string(seconds);
+
+                        if(time_string) {
+                            n = fprintf(stream, format_templ, time_string);
+                            HDfree(time_string);
+                        } /* end if */
+                        else
+                            n = fprintf(stream, format_templ, "(error)");
                     }
                     break;
 
@@ -474,8 +488,6 @@ H5_GCC_DIAG_ON(format-nonliteral)
  * Programmer:  Robb Matzke
  *              Thursday, April  9, 1998
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 #ifndef HDstrtoll
@@ -833,11 +845,88 @@ Wsetenv(const char *name, const char *value, int overwrite)
 #pragma comment(lib, "advapi32.lib")
 #endif
 
+
+/*-------------------------------------------------------------------------
+ * Function:    H5_get_win32_times
+ *
+ * Purpose:     Gets the elapsed, system and user times on Windows platforms.
+ *              All time values are in seconds.
+ *
+ * Return:      Success:  0
+ *              Failure:  -1
+ *
+ * Programmer:  Dana Robinson
+ *              May 2011
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifdef H5_HAVE_WIN32_API
+int
+H5_get_win32_times(H5_timevals_t *tvs /*in,out*/)
+{
+    static HANDLE process_handle;
+    ULARGE_INTEGER kernel_start;
+    ULARGE_INTEGER user_start;
+    FILETIME KernelTime;
+    FILETIME UserTime;
+    FILETIME CreationTime;
+    FILETIME ExitTime;
+    LARGE_INTEGER counts_start;
+    static LARGE_INTEGER counts_freq;
+    static hbool_t is_initialized = FALSE;
+    BOOL err;
+
+    HDassert(tvs);
+
+    if(!is_initialized) {
+        /* NOTE: This is just a pseudo handle and does not need to be closed. */
+        process_handle = GetCurrentProcess();
+        err = QueryPerformanceFrequency(&counts_freq);
+        if(0 == err)
+            return -1;
+        is_initialized = TRUE;
+    } /* end if */
+
+    /*************************
+     * System and user times *
+     *************************/
+
+    err = GetProcessTimes(process_handle, &CreationTime, &ExitTime, &KernelTime,
+            &UserTime);
+    if(0 == err)
+        return -1;
+
+    /* The 1.0E7 factor seems strange but it's due to the clock
+     * ticking in 100 ns increments.
+     */
+    kernel_start.HighPart = KernelTime.dwHighDateTime;
+    kernel_start.LowPart = KernelTime.dwLowDateTime;
+    tvs->system = (double)(kernel_start.QuadPart / 1.0E7F);
+
+    user_start.HighPart = UserTime.dwHighDateTime;
+    user_start.LowPart = UserTime.dwLowDateTime;
+    tvs->user = (double)(user_start.QuadPart / 1.0E7F);
+
+    /****************
+     * Elapsed time *
+     ****************/
+
+    err = QueryPerformanceCounter(&counts_start);
+    if(0 == err)
+        return -1;
+
+    tvs->elapsed = (double)(counts_start.QuadPart) / (double)counts_freq.QuadPart;
+
+    return 0;
+} /* end H5_get_win32_times() */
+#endif
+
 #define WloginBuffer_count 256
 static char Wlogin_buffer[WloginBuffer_count];
 
+
 char*
-Wgetlogin()
+Wgetlogin(void)
 {
 
 #ifdef H5_HAVE_WINSOCK2_H
@@ -1342,38 +1431,6 @@ H5_nanosleep(uint64_t nanosec)
     FUNC_LEAVE_NOAPI_VOID
 } /* end H5_nanosleep() */
 
-
-/*--------------------------------------------------------------------------
- * Function:    H5_get_time
- *
- * Purpose:     Get the current time, as the time of seconds after the UNIX epoch
- *
- * Return:      SUCCEED/FAIL
- *
- * Programmer:  Quincey Koziol
- *              October 05, 2016
- *--------------------------------------------------------------------------
- */
-double
-H5_get_time(void)
-{
-#ifdef H5_HAVE_GETTIMEOFDAY
-    struct timeval curr_time;
-#endif /* H5_HAVE_GETTIMEOFDAY */
-    double ret_value = (double)0.0f;
-
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
-
-#ifdef H5_HAVE_GETTIMEOFDAY
-    HDgettimeofday(&curr_time, NULL);
-
-    ret_value = (double)curr_time.tv_sec + ((double)curr_time.tv_usec / (double)1000000.0f);
-#endif /* H5_HAVE_GETTIMEOFDAY */
-
-    FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5_get_time() */
-
-
 #ifdef H5_HAVE_WIN32_API
 
 #define H5_WIN32_ENV_VAR_BUFFER_SIZE    32767
diff --git a/src/H5timer.c b/src/H5timer.c
index 4b1ec06..61d6f0f 100644
--- a/src/H5timer.c
+++ b/src/H5timer.c
@@ -12,12 +12,11 @@
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
 /*-------------------------------------------------------------------------
- *
  * Created:		H5timer.c
  *			Aug 21 2006
- *			Quincey Koziol <koziol@hdfgroup.org>
+ *			Quincey Koziol
  *
- * Purpose:		Internal 'timer' routines & support routines.
+ * Purpose:             Internal, platform-independent 'timer' support routines.
  *
  *-------------------------------------------------------------------------
  */
@@ -32,20 +31,22 @@
 /***********/
 #include "H5private.h"		/* Generic Functions			*/
 
-/* We need this for the struct rusage declaration */
-#if defined(H5_HAVE_GETRUSAGE) && defined(H5_HAVE_SYS_RESOURCE_H)
-#   include <sys/resource.h>
-#endif
-
-#if defined(H5_HAVE_GETTIMEOFDAY) && defined(H5_HAVE_SYS_TIME_H)
-#include <sys/time.h>
-#endif
-
 
 /****************/
 /* Local Macros */
 /****************/
 
+/* Size of a generated time string.
+ * Most time strings should be < 20 or so characters (max!) so this should be a
+ * safe size.  Dynamically allocating the correct size would be painful.
+ */
+#define H5TIMER_TIME_STRING_LEN 1536
+
+/* Conversion factors */
+#define H5_SEC_PER_DAY  (double)(24.0F * 60.0F * 60.0F)
+#define H5_SEC_PER_HOUR (double)(60.0F * 60.0F)
+#define H5_SEC_PER_MIN  (double)(60.0F)
+
 
 /******************/
 /* Local Typedefs */
@@ -76,104 +77,6 @@
 /* Local Variables */
 /*******************/
 
-
-/*-------------------------------------------------------------------------
- * Function:	H5_timer_reset
- *
- * Purpose:	Resets the timer struct to zero.  Use this to reset a timer
- *		that's being used as an accumulator for summing times.
- *
- * Return:	void
- *
- * Programmer:	Robb Matzke
- *              Thursday, April 16, 1998
- *
- *-------------------------------------------------------------------------
- */
-void
-H5_timer_reset (H5_timer_t *timer)
-{
-    HDassert(timer);
-    HDmemset(timer, 0, sizeof *timer);
-} /* end H5_timer_reset() */
-
-
-/*-------------------------------------------------------------------------
- * Function:	H5_timer_begin
- *
- * Purpose:	Initialize a timer to time something.
- *
- * Return:	void
- *
- * Programmer:	Robb Matzke
- *              Thursday, April 16, 1998
- *
- *-------------------------------------------------------------------------
- */
-void
-H5_timer_begin (H5_timer_t *timer)
-{
-#ifdef H5_HAVE_GETRUSAGE
-    struct rusage	rusage;
-#endif
-#ifdef H5_HAVE_GETTIMEOFDAY
-    struct timeval	etime;
-#endif
-
-    HDassert(timer);
-
-#ifdef H5_HAVE_GETRUSAGE
-    HDgetrusage (RUSAGE_SELF, &rusage);
-    timer->utime = (double)rusage.ru_utime.tv_sec +
-                   ((double)rusage.ru_utime.tv_usec / (double)1e6F);
-    timer->stime = (double)rusage.ru_stime.tv_sec +
-                   ((double)rusage.ru_stime.tv_usec / (double)1e6F);
-#else
-    timer->utime = 0.0F;
-    timer->stime = 0.0F;
-#endif
-#ifdef H5_HAVE_GETTIMEOFDAY
-    HDgettimeofday (&etime, NULL);
-    timer->etime = (double)etime.tv_sec + ((double)etime.tv_usec / (double)1e6F);
-#else
-    timer->etime = 0.0F;
-#endif
-} /* end H5_timer_begin() */
-
-
-/*-------------------------------------------------------------------------
- * Function:	H5_timer_end
- *
- * Purpose:	This function should be called at the end of a timed region.
- *		The SUM is an optional pointer which will accumulate times.
- *		TMS is the same struct that was passed to H5_timer_start().
- *		On return, TMS will contain total times for the timed region.
- *
- * Return:	void
- *
- * Programmer:	Robb Matzke
- *              Thursday, April 16, 1998
- *
- *-------------------------------------------------------------------------
- */
-void
-H5_timer_end (H5_timer_t *sum/*in,out*/, H5_timer_t *timer/*in,out*/)
-{
-    H5_timer_t		now;
-
-    HDassert(timer);
-    H5_timer_begin(&now);
-
-    timer->utime = MAX((double)0.0F, now.utime - timer->utime);
-    timer->stime = MAX((double)0.0F, now.stime - timer->stime);
-    timer->etime = MAX((double)0.0F, now.etime - timer->etime);
-
-    if (sum) {
-        sum->utime += timer->utime;
-        sum->stime += timer->stime;
-        sum->etime += timer->etime;
-    }
-} /* end H5_timer_end() */
 
 
 /*-------------------------------------------------------------------------
@@ -209,32 +112,35 @@ H5_bandwidth(char *buf/*out*/, double nbytes, double nseconds)
     if(nseconds <= (double)0.0F)
         HDstrcpy(buf, "       NaN");
     else {
-        bw = nbytes/nseconds;
+        bw = nbytes / nseconds;
         if(H5_DBL_ABS_EQUAL(bw, (double)0.0F))
             HDstrcpy(buf, "0.000  B/s");
         else if(bw < (double)1.0F)
             HDsprintf(buf, "%10.4e", bw);
         else if(bw < (double)H5_KB) {
             HDsprintf(buf, "%05.4f", bw);
-            HDstrcpy(buf+5, "  B/s");
+            HDstrcpy(buf + 5, "  B/s");
         } else if(bw < (double)H5_MB) {
             HDsprintf(buf, "%05.4f", bw / (double)H5_KB);
-            HDstrcpy(buf+5, " kB/s");
+            HDstrcpy(buf + 5, " kB/s");
         } else if(bw < (double)H5_GB) {
             HDsprintf(buf, "%05.4f", bw / (double)H5_MB);
-            HDstrcpy(buf+5, " MB/s");
+            HDstrcpy(buf + 5, " MB/s");
         } else if(bw < (double)H5_TB) {
             HDsprintf(buf, "%05.4f", bw / (double)H5_GB);
-            HDstrcpy(buf+5, " GB/s");
+            HDstrcpy(buf + 5, " GB/s");
         } else if(bw < (double)H5_PB) {
             HDsprintf(buf, "%05.4f", bw / (double)H5_TB);
-            HDstrcpy(buf+5, " TB/s");
+            HDstrcpy(buf + 5, " TB/s");
+        } else if(bw < (double)H5_EB) {
+            HDsprintf(buf, "%05.4f", bw / (double)H5_PB);
+            HDstrcpy(buf + 5, " PB/s");
         } else {
             HDsprintf(buf, "%10.4e", bw);
             if(HDstrlen(buf) > 10)
                 HDsprintf(buf, "%10.3e", bw);
-        }
-    }
+        } /* end else-if */
+    } /* end else */
 } /* end H5_bandwidth() */
 
 
@@ -269,3 +175,488 @@ H5_now(void)
     return(now);
 } /* end H5_now() */
 
+
+/*-------------------------------------------------------------------------
+ * Function:	H5_now_usec
+ *
+ * Purpose:	Retrieves the current time, as microseconds after the UNIX epoch.
+ *
+ * Return:	# of microseconds from the epoch (can't fail)
+ *
+ * Programmer:	Quincey Koziol
+ *              Tuesday, November 28, 2006
+ *
+ *-------------------------------------------------------------------------
+ */
+uint64_t
+H5_now_usec(void)
+{
+    uint64_t	now;                    /* Current time, in microseconds */
+
+#if defined(H5_HAVE_CLOCK_GETTIME)
+    {
+        struct timespec ts;
+
+        HDclock_gettime(CLOCK_MONOTONIC, &ts);
+        now = (uint64_t)(ts.tv_sec * (1000 * 1000)) + (uint64_t)(ts.tv_nsec / 1000);
+    }
+#elif defined(H5_HAVE_GETTIMEOFDAY)
+    {
+        struct timeval now_tv;
+
+        HDgettimeofday(&now_tv, NULL);
+        now = (uint64_t)(now_tv.tv_sec * (1000 * 1000)) + (uint64_t)now_tv.tv_usec;
+    }
+#else /* H5_HAVE_GETTIMEOFDAY */
+    now = (uint64_t)(HDtime(NULL) * (1000 * 1000));
+#endif /* H5_HAVE_GETTIMEOFDAY */
+
+    return(now);
+} /* end H5_now_usec() */
+
+
+/*--------------------------------------------------------------------------
+ * Function:    H5_get_time
+ *
+ * Purpose:     Get the current time, as the time of seconds after the UNIX epoch
+ *
+ * Return:      Success:    A non-negative time value
+ *              Failure:    -1.0 (in theory, can't currently fail)
+ *
+ * Programmer:  Quincey Koziol
+ *              October 05, 2016
+ *--------------------------------------------------------------------------
+ */
+double
+H5_get_time(void)
+{
+    double ret_value = (double)0.0f;
+
+    FUNC_ENTER_NOAPI_NOINIT_NOERR
+
+#if defined(H5_HAVE_CLOCK_GETTIME)
+    {
+        struct timespec ts;
+
+        HDclock_gettime(CLOCK_MONOTONIC, &ts);
+        ret_value = (double)ts.tv_sec + ((double)ts.tv_nsec / (double)1000000000.0f);
+    }
+#elif defined(H5_HAVE_GETTIMEOFDAY)
+    {
+        struct timeval now_tv;
+
+        HDgettimeofday(&now_tv, NULL);
+        ret_value = (double)now_tv.tv_sec + ((double)now_tv.tv_usec / (double)1000000.0f);
+    }
+#else
+    ret_value = (double)HDtime(NULL);
+#endif
+
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* end H5_get_time() */
+
+
+
+/*-------------------------------------------------------------------------
+ * Function:    H5__timer_get_timevals
+ *
+ * Purpose:     Internal platform-specific function to get time system,
+ *              user and elapsed time values.
+ *
+ * Return:      Success:    0
+ *              Failure:    -1
+ *
+ * Programmer:  Dana Robinson
+ *              May 2011
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5__timer_get_timevals(H5_timevals_t *times /*in,out*/)
+{
+    /* Sanity check */
+    HDassert(times);
+
+    /* Windows call handles both system/user and elapsed times */
+#ifdef H5_HAVE_WIN32_API
+    if(H5_get_win32_times(times) < 0) {
+        times->elapsed   = -1.0;
+        times->system    = -1.0;
+        times->user      = -1.0;
+
+        return -1;
+    } /* end if */
+#else /* H5_HAVE_WIN32_API */
+
+    /*************************
+     * System and user times *
+     *************************/
+#if defined(H5_HAVE_GETRUSAGE)
+{
+    struct rusage res;
+
+    if(HDgetrusage(RUSAGE_SELF, &res) < 0)
+        return -1;
+    times->system = (double)res.ru_stime.tv_sec + ((double)res.ru_stime.tv_usec / (double)1.0E6F);
+    times->user   = (double)res.ru_utime.tv_sec + ((double)res.ru_utime.tv_usec / (double)1.0E6F);
+}
+#else
+    /* No suitable way to get system/user times */
+    /* This is not an error condition, they just won't be available */
+    times->system = -1.0;
+    times->user   = -1.0;
+#endif
+
+    /****************
+     * Elapsed time *
+     ****************/
+
+    times->elapsed = H5_get_time();
+
+#endif /* H5_HAVE_WIN32_API */
+
+    return 0;
+} /* end H5__timer_get_timevals() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:    H5_timer_init
+ *
+ * Purpose:     Initialize a platform-independent timer.
+ *
+ *              Timer usage is as follows:
+ *
+ *              1) Call H5_timer_init(), passing in a timer struct, to set
+ *                 up the timer.
+ *
+ *              2) Wrap any code you'd like to time with calls to
+ *                 H5_timer_start/stop().  For accurate timing, place these
+ *                 calls as close to the code of interest as possible.  You
+ *                 can call start/stop multiple times on the same timer -
+ *                 when you do this, H5_timer_get_times() will return time
+ *                 values for the current/last session and
+ *                 H5_timer_get_total_times() will return the summed times
+ *                 of all sessions (see #3 and #4, below).
+ *
+ *              3) Use H5_timer_get_times() to get the current system, user
+ *                 and elapsed times from a running timer.  If called on a
+ *                 stopped timer, this will return the time recorded at the
+ *                 stop point.
+ *
+ *              4) Call H5_timer_get_total_times() to get the total system,
+ *                 user and elapsed times recorded across multiple start/stop
+ *                 sessions.  If called on a running timer, it will return the
+ *                 time recorded up to that point.  On a stopped timer, it
+ *                 will return the time recorded at the stop point.
+ *
+ *              NOTE: Obtaining a time point is not free!  Keep in mind that
+ *                    the time functions make system calls and can have
+ *                    non-trivial overhead.  If you call one of the get_time
+ *                    functions on a running timer, that overhead will be
+ *                    added to the reported times.
+ *
+ *              5) All times recorded will be in seconds.  These can be
+ *                 converted into human-readable strings with the
+ *                 H5_timer_get_time_string() function.
+ *
+ *              6) A timer can be reset using by calling H5_timer_init() on
+ *                 it.  This will set its state to 'stopped' and reset all
+ *                 accumulated times to zero.
+ *
+ *
+ * Return:      Success:    0
+ *              Failure:    -1
+ *
+ * Programmer:  Dana Robinson
+ *              May 2011
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5_timer_init(H5_timer_t *timer /*in,out*/)
+{
+    /* Sanity check */
+    HDassert(timer);
+
+    /* Initialize everything */
+    HDmemset(timer, 0, sizeof(H5_timer_t));
+
+    return 0;
+} /* end H5_timer_init() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:    H5_timer_start
+ *
+ * Purpose:     Start tracking time in a platform-independent timer.
+ *
+ * Return:      Success:    0
+ *              Failure:    -1
+ *
+ * Programmer:  Dana Robinson
+ *              May 2011
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5_timer_start(H5_timer_t *timer /*in,out*/)
+{
+    /* Sanity check */
+    HDassert(timer);
+
+    /* Start the timer
+     * This sets the "initial" times to the system-defined start times.
+     */
+    if(H5__timer_get_timevals(&(timer->initial)) < 0)
+        return -1;
+
+    timer->is_running = TRUE;
+
+    return 0;
+} /* end H5_timer_start() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:    H5_timer_stop
+ *
+ * Purpose:     Stop tracking time in a platform-independent timer.
+ *
+ * Return:      Success:    0
+ *              Failure:    -1
+ *
+ * Programmer:  Dana Robinson
+ *              May 2011
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5_timer_stop(H5_timer_t *timer /*in,out*/)
+{
+    /* Sanity check */
+    HDassert(timer);
+
+    /* Stop the timer */
+    if(H5__timer_get_timevals(&(timer->final_interval)) < 0)
+        return -1;
+
+    /* The "final" times are stored as intervals (final - initial)
+     * for more useful reporting to the user.
+     */
+    timer->final_interval.elapsed = timer->final_interval.elapsed - timer->initial.elapsed;
+    timer->final_interval.system  = timer->final_interval.system  - timer->initial.system;
+    timer->final_interval.user    = timer->final_interval.user    - timer->initial.user;
+
+    /* Add the intervals to the elapsed time */
+    timer->total.elapsed += timer->final_interval.elapsed;
+    timer->total.system  += timer->final_interval.system;
+    timer->total.user    += timer->final_interval.user;
+
+    timer->is_running = FALSE;
+
+    return 0;
+} /* end H5_timer_stop() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:    H5_timer_get_times
+ *
+ * Purpose:     Get the system, user and elapsed times from a timer.  These
+ *              are the times since the timer was last started and will be
+ *              0.0 in a timer that has not been started since it was
+ *              initialized.
+ *
+ *              This function can be called either before or after
+ *              H5_timer_stop() has been called.  If it is called before the
+ *              stop function, the timer will continue to run.
+ *
+ *              The system and user times will be -1.0 if those times cannot
+ *              be computed on a particular platform.  The elapsed time will
+ *              always be present.
+ *
+ * Return:      Success:    0
+ *              Failure:    -1
+ *
+ * Programmer:  Dana Robinson
+ *              May 2011
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5_timer_get_times(H5_timer_t timer, H5_timevals_t *times /*in,out*/)
+{
+    /* Sanity check */
+    HDassert(times);
+
+    if(timer.is_running) {
+        H5_timevals_t   now;
+
+        /* Get the current times and report the current intervals without
+         * stopping the timer.
+         */
+        if(H5__timer_get_timevals(&now) < 0)
+            return -1;
+
+        times->elapsed = now.elapsed - timer.initial.elapsed;
+        times->system  = now.system  - timer.initial.system;
+        times->user    = now.user    - timer.initial.user;
+    } /* end if */
+    else {
+        times->elapsed = timer.final_interval.elapsed;
+        times->system  = timer.final_interval.system;
+        times->user    = timer.final_interval.user;
+    } /* end else */
+
+    return 0;
+} /* end H5_timer_get_times() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:    H5_timer_get_total_times
+ *
+ * Purpose:     Get the TOTAL system, user and elapsed times recorded by
+ *              the timer since its initialization.  This is the sum of all
+ *              times recorded while the timer was running.
+ *
+ *              These will be 0.0 in a timer that has not been started
+ *              since it was initialized.  Calling H5_timer_init() on a
+ *              timer will reset these values to 0.0.
+ *
+ *              This function can be called either before or after
+ *              H5_timer_stop() has been called.  If it is called before the
+ *              stop function, the timer will continue to run.
+ *
+ *              The system and user times will be -1.0 if those times cannot
+ *              be computed on a particular platform.  The elapsed time will
+ *              always be present.
+ *
+ * Return:      Success:    0
+ *              Failure:    -1
+ *
+ * Programmer:  Dana Robinson
+ *              May 2011
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5_timer_get_total_times(H5_timer_t timer, H5_timevals_t *times /*in,out*/)
+{
+    /* Sanity check */
+    HDassert(times);
+
+    if(timer.is_running) {
+        H5_timevals_t   now;
+
+        /* Get the current times and report the current totals without
+         * stopping the timer.
+         */
+        if(H5__timer_get_timevals(&now) < 0)
+            return -1;
+
+        times->elapsed = timer.total.elapsed + (now.elapsed - timer.initial.elapsed);
+        times->system  = timer.total.system  + (now.system  - timer.initial.system);
+        times->user    = timer.total.user    + (now.user    - timer.initial.user);
+    } /* end if */
+    else {
+        times->elapsed = timer.total.elapsed;
+        times->system  = timer.total.system;
+        times->user    = timer.total.user;
+    } /* end else */
+
+    return 0;
+} /* end H5_timer_get_total_times() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:    H5_timer_get_time_string
+ *
+ * Purpose:     Converts a time (in seconds) into a human-readable string
+ *              suitable for log messages.
+ *
+ * Return:      Success:  The time string.
+ *
+ *                        The general format of the time string is:
+ *
+ *                        "N/A"                 time < 0 (invalid time)
+ *                        "%.f ns"              time < 1 microsecond
+ *                        "%.1f us"             time < 1 millisecond
+ *                        "%.1f ms"             time < 1 second
+ *                        "%.2f s"              time < 1 minute
+ *                        "%.f m %.f s"         time < 1 hour
+ *                        "%.f h %.f m %.f s"   longer times
+ *
+ *              Failure:  NULL
+ *
+ * Programmer:  Dana Robinson
+ *              May 2011
+ *
+ *-------------------------------------------------------------------------
+ */
+char *
+H5_timer_get_time_string(double seconds)
+{
+    char *s;                /* output string */
+
+    /* Used when the time is greater than 59 seconds */
+    double days;
+    double hours;
+    double minutes;
+    double remainder_sec;
+
+    /* Extract larger time units from count of seconds */
+    if(seconds > (double)60.0F) {
+        /* Set initial # of seconds */
+        remainder_sec = seconds;
+
+        /* Extract days */
+        days = HDfloor(remainder_sec / H5_SEC_PER_DAY);
+        remainder_sec -= (days * H5_SEC_PER_DAY);
+
+        /* Extract hours */
+        hours = HDfloor(remainder_sec / H5_SEC_PER_HOUR);
+        remainder_sec -= (hours * H5_SEC_PER_HOUR);
+
+        /* Extract minutes */
+        minutes = HDfloor(remainder_sec / H5_SEC_PER_MIN);
+        remainder_sec -= (minutes * H5_SEC_PER_MIN);
+
+        /* The # of seconds left is in remainder_sec */
+    } /* end if */
+
+    /* Allocate */
+    if(NULL == (s = (char *)HDcalloc(H5TIMER_TIME_STRING_LEN, sizeof(char))))
+        return NULL;
+
+    /* Do we need a format string? Some people might like a certain
+     * number of milliseconds or s before spilling to the next highest
+     * time unit.  Perhaps this could be passed as an integer.
+     * (name? round_up_size? ?)
+     */
+    if(seconds < (double)0.0F)
+        HDsprintf(s, "N/A");
+    else if(H5_DBL_ABS_EQUAL((double)0.0F, seconds))
+        HDsprintf(s, "0.0 s");
+    else if(seconds < (double)1.0E-6F)
+        /* t < 1 us, Print time in ns */
+        HDsprintf(s, "%.f ns", seconds * (double)1.0E9F);
+    else if(seconds < (double)1.0E-3F)
+        /* t < 1 ms, Print time in us */
+        HDsprintf(s, "%.1f us", seconds * (double)1.0E6F);
+    else if(seconds < (double)1.0F)
+        /* t < 1 s, Print time in ms */
+        HDsprintf(s, "%.1f ms", seconds * (double)1.0E3F);
+    else if(seconds < H5_SEC_PER_MIN)
+        /* t < 1 m, Print time in s */
+        HDsprintf(s, "%.2f s", seconds);
+    else if(seconds < H5_SEC_PER_HOUR)
+        /* t < 1 h, Print time in m and s */
+        HDsprintf(s, "%.f m %.f s", minutes, remainder_sec);
+    else if(seconds < H5_SEC_PER_DAY)
+        /* t < 1 d, Print time in h, m and s */
+        HDsprintf(s, "%.f h %.f m %.f s", hours, minutes, remainder_sec);
+    else
+        /* Print time in d, h, m and s */
+        HDsprintf(s, "%.f d %.f h %.f m %.f s", days, hours, minutes, remainder_sec);
+
+    return s;
+} /* end H5_timer_get_time_string() */
+
diff --git a/src/H5trace.c b/src/H5trace.c
index 93ff681..cf14565 100644
--- a/src/H5trace.c
+++ b/src/H5trace.c
@@ -15,7 +15,7 @@
  *
  * Created:     H5trace.c
  *              Aug 21 2006
- *              Quincey Koziol <koziol@hdfgroup.org>
+ *              Quincey Koziol
  *
  * Purpose:     Internal code for tracing API calls
  *
@@ -125,8 +125,11 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
     hssize_t            i;
     void                *vp = NULL;
     FILE                *out = H5_debug_g.trace;
-    H5_timer_t          event_time;
-    static H5_timer_t   first_time = {0.0F, 0.0F, 0.0F};
+    static hbool_t      is_first_invocation = TRUE;
+    H5_timer_t          function_timer;
+    H5_timevals_t       function_times;
+    static H5_timer_t   running_timer;
+    H5_timevals_t       running_times;
     static int          current_depth = 0;
     static int          last_call_depth = 0;
 
@@ -152,13 +155,18 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
         } /* end else */
     } /* end if */
 
-    /* Get time for event */
-    if(H5_DBL_ABS_EQUAL(first_time.etime, (double)0.0f))
-        H5_timer_begin(&first_time);
-    if(H5_debug_g.ttimes)
-        H5_timer_begin(&event_time);
-    else
-        HDmemset(&event_time, 0, sizeof event_time);
+    /* Get time for event if the trace times flag is set */
+    if(is_first_invocation && H5_debug_g.ttimes) {
+        /* start the library-wide timer */
+        is_first_invocation = FALSE;
+        H5_timer_init(&running_timer);
+        H5_timer_start(&running_timer);
+    } /* end if */
+    if(H5_debug_g.ttimes) {
+        /* start the timer for this function */
+        H5_timer_init(&function_timer);
+        H5_timer_start(&function_timer);
+    } /* end if */
 
     /* Print the first part of the line.  This is the indication of the
      * nesting depth followed by the function name and either start of
@@ -174,7 +182,9 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
             if(H5_debug_g.ttimes) {
                 char tmp[320];
 
-                HDsprintf(tmp, "%.6f", event_time.etime-first_time.etime);
+                H5_timer_get_times(function_timer, &function_times);
+                H5_timer_get_times(running_timer, &running_times);
+                HDsprintf(tmp, "%.6f", (function_times.elapsed - running_times.elapsed));
                 HDfprintf(out, " %*s ", (int)HDstrlen(tmp), "");
             } /* end if */
             for(i = 0; i < current_depth; i++)
@@ -189,8 +199,11 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
     else {
         if(current_depth>last_call_depth)
             HDfputs(" = <delayed>\n", out);
-        if(H5_debug_g.ttimes)
-            HDfprintf(out, "@%.6f ", event_time.etime - first_time.etime);
+        if(H5_debug_g.ttimes) {
+            H5_timer_get_times(function_timer, &function_times);
+            H5_timer_get_times(running_timer, &running_times);
+            HDfprintf(out, "@%.6f ", (function_times.elapsed - running_times.elapsed));
+        } /* end if */
         for(i = 0; i < current_depth; i++)
             HDfputc('+', out);
         HDfprintf(out, "%*s%s(", 2*current_depth, "", func);
@@ -296,7 +309,7 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
                     case 'a':
                         if(ptr) {
                             if(vp)
-                                HDfprintf (out, "0x%p", vp);
+                                HDfprintf(out, "0x%p", vp);
                             else
                                 HDfprintf(out, "NULL");
                         } /* end if */
@@ -749,7 +762,7 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
                         break;
 
                     default:
-                       HDfprintf (out, "BADTYPE(D%c)", type[1]);
+                       HDfprintf(out, "BADTYPE(D%c)", type[1]);
                         goto error;
                 } /* end switch */
                 break;
@@ -1095,7 +1108,7 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
                     case 's':
                         if(ptr) {
                             if(vp)
-                                HDfprintf (out, "0x%p", vp);
+                                HDfprintf(out, "0x%p", vp);
                             else
                                 HDfprintf(out, "NULL");
                         } /* end if */
@@ -1172,7 +1185,7 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
                         break;
 
                     default:
-                        HDfprintf (out, "BADTYPE(H%c)", type[1]);
+                        HDfprintf(out, "BADTYPE(H%c)", type[1]);
                         goto error;
                 } /* end switch */
                 break;
@@ -1356,7 +1369,7 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
                                 break;
 
                             case H5I_NTYPES:
-                                HDfprintf (out, "%ld (ntypes - error)", (long)obj);
+                                HDfprintf(out, "%ld (ntypes - error)", (long)obj);
                                 break;
 
                             default:
@@ -1460,7 +1473,7 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
                         else {
                             int is = HDva_arg(ap, int);
 
-                            HDfprintf (out, "%d", is);
+                            HDfprintf(out, "%d", is);
                             asize[argno] = is;
                         } /* end else */
                         break;
@@ -1576,7 +1589,7 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
                         break;
 
                     default:
-                        HDfprintf (out, "BADTYPE(I%c)", type[1]);
+                        HDfprintf(out, "BADTYPE(I%c)", type[1]);
                         goto error;
                 } /* end switch */
                 break;
@@ -1586,7 +1599,7 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
                     case 'l':
                         if(ptr) {
                             if(vp)
-                                HDfprintf (out, "0x%p", vp);
+                                HDfprintf(out, "0x%p", vp);
                             else
                                 HDfprintf(out, "NULL");
                         } /* end if */
@@ -1730,7 +1743,7 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
                 else {
                     off_t offset = HDva_arg(ap, off_t);
 
-                    HDfprintf (out, "%ld", (long)offset);
+                    HDfprintf(out, "%ld", (long)offset);
                 } /* end else */
                 break;
 
@@ -2394,7 +2407,7 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
                         break;
 
                     default:
-                        HDfprintf (out, "BADTYPE(T%c)", type[1]);
+                        HDfprintf(out, "BADTYPE(T%c)", type[1]);
                         goto error;
                 } /* end switch */
                 break;
@@ -2410,9 +2423,9 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
                     htri_t tri_var = HDva_arg (ap, htri_t);
 
                     if(tri_var>0)
-                        HDfprintf (out, "TRUE");
+                        HDfprintf(out, "TRUE");
                     else if(!tri_var)
-                        HDfprintf (out, "FALSE");
+                        HDfprintf(out, "FALSE");
                     else
                         HDfprintf(out, "FAIL(%d)", (int)tri_var);
                 } /* end else */
@@ -2469,7 +2482,7 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
                         break;
 
                     default:
-                        HDfprintf (out, "BADTYPE(U%c)", type[1]);
+                        HDfprintf(out, "BADTYPE(U%c)", type[1]);
                         goto error;
                 } /* end switch */
                 break;
@@ -2650,9 +2663,12 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
     } /* end for */
 
     /* Display event time for return */
-    if(returning && H5_debug_g.ttimes)
-        HDfprintf(out, " @%.6f [dt=%.6f]", (event_time.etime - first_time.etime),
-                (event_time.etime - *returning));
+    if(returning && H5_debug_g.ttimes) {
+        H5_timer_get_times(function_timer, &function_times);
+        H5_timer_get_times(running_timer, &running_times);
+        HDfprintf(out, " @%.6f [dt=%.6f]", (function_times.elapsed - running_times.elapsed),
+                (function_times.elapsed - *returning));
+    } /* end if */
 
 error:
     HDva_end(ap);
@@ -2660,10 +2676,13 @@ error:
         HDfprintf(out, ";\n");
     else {
         last_call_depth = current_depth++;
-        HDfprintf (out, ")");
+        HDfprintf(out, ")");
     } /* end else */
     HDfflush(out);
 
-    return event_time.etime;
+    if(H5_debug_g.ttimes)
+        return function_times.elapsed;
+    else
+        return 0.0F;
 } /* end H5_trace() */
 
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index d4c33b9..900ed0f 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -256,6 +256,7 @@ set (H5_TESTS
     cork
     swmr
     thread_id # special link
+    timer
 )
 
 macro (ADD_H5_EXE file)
diff --git a/test/Makefile.am b/test/Makefile.am
index 874e35d..7e1cd4b 100644
--- a/test/Makefile.am
+++ b/test/Makefile.am
@@ -65,7 +65,7 @@ TEST_PROG= testhdf5 \
            flush1 flush2 app_ref enum set_extent ttsafe enc_dec_plist \
            enc_dec_plist_cross_platform getname vfd ros3 s3comms hdfs ntypes \
            dangle dtransform reserved cross_read freespace mf vds file_image \
-           unregister cache_logging cork swmr thread_id
+           unregister cache_logging cork swmr thread_id timer
 
 # List programs to be built when testing here.
 # error_test and err_compat are built at the same time as the other tests, but executed by testerror.sh.
diff --git a/test/timer.c b/test/timer.c
new file mode 100644
index 0000000..1014e75
--- /dev/null
+++ b/test/timer.c
@@ -0,0 +1,414 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright by The HDF Group.                                               *
+ * Copyright by the Board of Trustees of the University of Illinois.         *
+ * All rights reserved.                                                      *
+ *                                                                           *
+ * This file is part of HDF5.  The full HDF5 copyright notice, including     *
+ * terms governing use, modification, and redistribution, is contained in    *
+ * the files COPYING and Copyright.html.  COPYING can be found at the root   *
+ * of the source code distribution tree; Copyright.html can be found at the  *
+ * root level of an installed copy of the electronic HDF5 document set and   *
+ * is linked from the top-level documents page.  It can also be found at     *
+ * http://hdfgroup.org/HDF5/doc/Copyright.html.  If you do not have          *
+ * access to either file, you may request a copy from help@hdfgroup.org.     *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+/*
+ * Programmer:  Dana Robinson
+ *              May, 2011
+ *
+ * Purpose:     Tests the operation of the platform-independent timers.
+ */
+
+#include "h5test.h"
+
+
+
+
+/*-------------------------------------------------------------------------
+ * Function:    test_time_formatting
+ *
+ * Purpose:     Tests time string creation.
+ *
+ * Return:      Success:        0
+ *              Failure:        -1
+ *
+ * Programmer:  Dana Robinson
+ *              May 2011
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+test_time_formatting(void)
+{
+    char *s = NULL;
+
+    TESTING("Time string formats");
+
+    /*      < 0,            N/A             */
+    s = H5_timer_get_time_string(-1.0F);
+    if(NULL == s || HDstrcmp(s, "N/A") != 0)
+        TEST_ERROR;
+    HDfree(s);
+
+    /*      0               0               */
+    s = H5_timer_get_time_string(0.0F);
+    if(NULL == s || HDstrcmp(s, "0.0 s") != 0)
+        TEST_ERROR;
+    HDfree(s);
+
+    /*      < 1 us          nanoseconds     */
+    s = H5_timer_get_time_string(123.0E-9F);
+    if(NULL == s || HDstrcmp(s, "123 ns") != 0)
+        TEST_ERROR;
+    HDfree(s);
+
+    /*      < 1 ms          microseconds    */
+    s = H5_timer_get_time_string(23.456E-6F);
+    if(NULL == s || HDstrcmp(s, "23.5 us") != 0)
+        TEST_ERROR;
+    HDfree(s);
+
+    /*      < 1 s           milliseconds    */
+    s = H5_timer_get_time_string(4.56789E-3F);
+    if(NULL == s || HDstrcmp(s, "4.6 ms") != 0)
+        TEST_ERROR;
+    HDfree(s);
+
+    /*      < 1 min         seconds         */
+    s = H5_timer_get_time_string(3.14F);
+    if(NULL == s || HDstrcmp(s, "3.14 s") != 0)
+        TEST_ERROR;
+    HDfree(s);
+
+    /*      < 1 hr          mins, secs      */
+    s = H5_timer_get_time_string(2521.0F);
+    if(NULL == s || HDstrcmp(s, "42 m 1 s") != 0)
+        TEST_ERROR;
+    HDfree(s);
+
+    /*      < 1 d           hrs, mins, secs */
+    s = H5_timer_get_time_string(9756.0F);
+    if(NULL == s || HDstrcmp(s, "2 h 42 m 36 s") != 0)
+        TEST_ERROR;
+    HDfree(s);
+
+    /*      > 1 d            days, hrs, mins, secs */
+    s = H5_timer_get_time_string(280802.0F);
+    if(NULL == s || HDstrcmp(s, "3 d 6 h 0 m 2 s") != 0)
+        TEST_ERROR;
+    HDfree(s);
+
+    PASSED();
+    return 0;
+
+error:
+    if(s)
+        HDfree(s);
+    return -1;
+
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function:    test_timer_system_user
+ *
+ * Purpose:     Tests the ability to get system and user times from the
+ *              timers.
+ *              Some platforms may require special code to get system and
+ *              user times.  If we do not support that particular platform
+ *              dependent functionality, this test is skipped.
+ *
+ * Return:      Success:        0
+ *              Failure:        -1
+ *
+ * Programmer:  Dana Robinson
+ *              May 2011
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+test_timer_system_user(void)
+{
+    int             i;
+    char            *buf = NULL;
+    H5_timer_t      timer;
+    H5_timevals_t   times;
+    herr_t          err;
+
+    TESTING("system/user times");
+
+    err = H5_timer_init(&timer);
+    if(err < 0)
+        TEST_ERROR;
+
+    err = H5_timer_start(&timer);
+    if(err < 0)
+        TEST_ERROR;
+
+    /* The system and user times may not be present on some systems.  They
+      * will be -1.0 if they are not.
+     */
+    if(timer.initial.system < (double)0.0f || timer.initial.user < (double)0.0f) {
+        SKIPPED();
+        printf("NOTE: No suitable way to get system/user times on this platform.\n");
+        return 0;
+    }
+
+    /* Do some fake work */
+    for(i=0; i < 1024; i++) {
+        buf = (char *)HDmalloc(1024 * (size_t)i);
+        HDfree(buf);
+    }
+
+    err = H5_timer_stop(&timer);
+    if(err < 0)
+        TEST_ERROR;
+
+    err = H5_timer_get_times(timer, &times);
+    if(err < 0)
+        TEST_ERROR;
+
+    /* System and user times should be non-negative. */
+    if(times.system < (double)0.0f || times.user < (double)0.0f)
+        TEST_ERROR;
+
+    PASSED();
+    return 0;
+
+error:
+    return -1;
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function:    test_timer_elapsed
+ *
+ * Purpose:     Tests the ability to get elapsed times from the timers.
+ *              We should always be able to get an elapsed time,
+ *              regardless of the time libraries or platform.
+ *
+ * Return:      Success:        0
+ *              Failure:        -1
+ *
+ * Programmer:  Dana Robinson
+ *              May 2011
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+test_timer_elapsed(void)
+{
+    int             i;
+    char            *buf = NULL;
+    H5_timer_t      timer;
+    H5_timevals_t   times;
+    herr_t          err;
+
+    TESTING("elapsed times");
+
+    err = H5_timer_init(&timer);
+    if(err < 0)
+        TEST_ERROR;
+
+    err = H5_timer_start(&timer);
+    if(err < 0)
+        TEST_ERROR;
+
+    /* Do some fake work */
+    for(i=0; i < 1024; i++) {
+        buf = (char *)HDmalloc(1024 * (size_t)i);
+        HDfree(buf);
+    }
+
+    err = H5_timer_stop(&timer);
+    if(err < 0)
+        TEST_ERROR;
+
+    err = H5_timer_get_times(timer, &times);
+    if(err < 0)
+        TEST_ERROR;
+
+    /* Elapsed time should be non-negative. */
+    if(times.elapsed < (double)0.0f)
+        TEST_ERROR;
+
+    PASSED();
+    return 0;
+
+error:
+    return -1;
+}
+
+
+
+static herr_t
+test_timer_functionality(void)
+{
+    int             i;
+    char            *buf = NULL;
+    H5_timer_t      timer;
+
+    H5_timevals_t   times;
+    double          prev_etime;
+    double          prev_total_etime;
+
+    herr_t          err;
+
+    TESTING("timer functionality");
+
+    /*****************
+     * CHECK STARTUP *
+     *****************/
+
+    /* Timer should be running after start */
+    err = H5_timer_init(&timer);
+    if(err < 0 || timer.is_running)
+        TEST_ERROR;
+
+    /* Times should be initialized to zero */
+    err = H5_timer_get_times(timer, &times);
+    if(err < 0 || !H5_DBL_ABS_EQUAL(times.elapsed, (double)0.0f))
+        TEST_ERROR;
+
+    err = H5_timer_get_total_times(timer, &times);
+    if(err < 0 || !H5_DBL_ABS_EQUAL(times.elapsed, (double)0.0f))
+        TEST_ERROR;
+
+
+    /********************
+     * CHECK START/STOP *
+     ********************/
+
+    /* Running state should change after start */
+    err = H5_timer_start(&timer);
+    if(err < 0 || !timer.is_running)
+        TEST_ERROR;
+
+    /* Do some fake work */
+    for(i=0; i < 1024; i++) {
+        buf = (char *)HDmalloc(1024 * (size_t)i);
+        HDfree(buf);
+    }
+
+    /* Running state should change after stop */
+    err = H5_timer_stop(&timer);
+    if(err < 0 || timer.is_running)
+        TEST_ERROR;
+
+    /* Times should be positive and non-negative */
+    err = H5_timer_get_times(timer, &times);
+    if(err < 0 || times.elapsed < (double)0.0f)
+        TEST_ERROR;
+
+    err = H5_timer_get_total_times(timer, &times);
+    if(err < 0 || times.elapsed < (double)0.0f)
+        TEST_ERROR;
+
+
+    /**********************
+     * CHECK INTERRUPTING *
+     **********************/
+
+    /* Timer should change stat and refresh to 0s */
+    err = H5_timer_init(&timer);
+    if(err < 0 || timer.is_running)
+        TEST_ERROR;
+
+    err = H5_timer_get_times(timer, &times);
+    if(err < 0 || !H5_DBL_ABS_EQUAL(times.elapsed, (double)0.0f))
+        TEST_ERROR;
+
+    err = H5_timer_get_total_times(timer, &times);
+    if(err < 0 || !H5_DBL_ABS_EQUAL(times.elapsed, (double)0.0f))
+        TEST_ERROR;
+
+    /* Timer state should flip */
+    err = H5_timer_start(&timer);
+    if(err < 0 || !timer.is_running)
+        TEST_ERROR;
+
+    /* Do some fake work */
+    for(i=0; i < 1024; i++) {
+        buf = (char *)HDmalloc(1024 * (size_t)i);
+        HDfree(buf);
+    }
+
+    /* Times should be non-negative */
+    err = H5_timer_get_times(timer, &times);
+    if(err < 0 || times.elapsed < (double)0.0f)
+        TEST_ERROR;
+    prev_etime = times.elapsed;
+
+    err = H5_timer_get_total_times(timer, &times);
+    if(err < 0 || times.elapsed < (double)0.0f)
+        TEST_ERROR;
+    prev_total_etime = times.elapsed;
+
+    /* Do some fake work */
+    for(i=0; i < 1024; i++) {
+        buf = (char *)HDmalloc(1024 * (size_t)i);
+        HDfree(buf);
+    }
+
+    /* State should flip on stop */
+    err = H5_timer_stop(&timer);
+    if(err < 0 || timer.is_running)
+        TEST_ERROR;
+
+    /* Times should be >= than the cached intermediate times */
+    err = H5_timer_get_times(timer, &times);
+    if(err < 0 || times.elapsed < prev_etime)
+        TEST_ERROR;
+
+    err = H5_timer_get_total_times(timer, &times);
+    if(err < 0 || times.elapsed < prev_total_etime)
+        TEST_ERROR;
+
+
+    PASSED();
+    return 0;
+
+error:
+    return -1;
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function:    main
+ *
+ * Purpose:     Tests the basic functionality of the platform-independent
+ *              timers
+ *
+ * Return:      Success:        0
+ *              Failure:        1
+ *
+ * Programmer:  Dana Robinson
+ *              May, 2011
+ *
+ *-------------------------------------------------------------------------
+ */
+int
+main(void)
+{
+    int             nerrors = 0;
+
+    h5_reset();
+
+    printf("Testing platform-independent timer functionality.\n");
+
+    nerrors += test_time_formatting()       < 0 ? 1 : 0;
+    nerrors += test_timer_system_user()     < 0 ? 1 : 0;
+    nerrors += test_timer_elapsed()         < 0 ? 1 : 0;
+    nerrors += test_timer_functionality()   < 0 ? 1 : 0;
+
+    if(nerrors) {
+        printf("***** %d platform-independent timer TEST%s FAILED! *****\n",
+        nerrors, nerrors > 1 ? "S" : "");
+        return 1;
+    } else {
+        printf("All platform-independent timer tests passed.\n");
+        return 0;
+    }
+}
+
diff --git a/tools/test/perform/iopipe.c b/tools/test/perform/iopipe.c
index bf4728d..bb74a1b 100644
--- a/tools/test/perform/iopipe.c
+++ b/tools/test/perform/iopipe.c
@@ -12,7 +12,7 @@
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
 /*
- * Programmer:  Robb Matzke <matzke@llnl.gov>
+ * Programmer:  Robb Matzke
  *              Thursday, March 12, 1998
  */
 
@@ -21,10 +21,6 @@
 
 #include "H5private.h"
 
-#ifdef H5_HAVE_SYS_TIMEB
-#include <sys/timeb.h>
-#endif
-
 
 #define RAW_FILE_NAME  "iopipe.raw"
 #define HDF5_FILE_NAME  "iopipe.h5"
@@ -56,25 +52,18 @@
  * Programmer:  Robb Matzke
  *              Thursday, March 12, 1998
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
-#ifdef H5_HAVE_GETRUSAGE
 static void
-print_stats (const char *prefix,
+print_stats(const char *prefix,
+#ifdef H5_HAVE_GETRUSAGE
        struct rusage *r_start, struct rusage *r_stop,
-       struct timeval *t_start, struct timeval *t_stop,
-       size_t nbytes)
-#else /* H5_HAVE_GETRUSAGE */
-static void
-print_stats (const char *prefix,
-       struct timeval *r_start, struct timeval *r_stop,
-       struct timeval *t_start, struct timeval *t_stop,
-       size_t nbytes)
 #endif /* H5_HAVE_GETRUSAGE */
+       double t_start, double t_stop,
+       size_t nbytes)
 {
-    double  e_time, bw;
+    double  e_time;
+    char bw[16];
 #ifdef H5_HAVE_GETRUSAGE
     double  u_time, s_time;
 
@@ -88,27 +77,16 @@ print_stats (const char *prefix,
        ((double)(r_start->ru_stime.tv_sec)+
         (double)(r_start->ru_stime.tv_usec)/(double)1000000.0F);
 #endif
-#ifndef H5_HAVE_SYS_TIMEB
-    e_time = ((double)(t_stop->tv_sec)+
-        (double)(t_stop->tv_usec)/(double)1000000.0F) -
-       ((double)(t_start->tv_sec)+
-        (double)(t_start->tv_usec)/(double)1000000.0F);
-#else
-    e_time = ((double)(t_stop->tv_sec)+
-        (double)(t_stop->tv_usec)/(double)1000.0F) -
-       ((double)(t_start->tv_sec)+
-        (double)(t_start->tv_usec)/(double)1000.0F);
-#endif
-    bw = (double)nbytes / e_time;
+    e_time = t_stop - t_start;
+    H5_bandwidth(bw, (double)nbytes, e_time);
 
 #ifdef H5_HAVE_GETRUSAGE
-    printf (HEADING "%1.2fuser %1.2fsystem %1.2felapsed %1.2fMB/s\n",
-      prefix, u_time, s_time, e_time, bw/(1024*1024));
+    HDprintf(HEADING "%1.2fuser %1.2fsystem %1.2felapsed %s\n",
+      prefix, u_time, s_time, e_time, bw);
 #else
-    printf (HEADING "%1.2felapsed %1.2fMB/s\n",
-      prefix, e_time, bw/(1024*1024));
+    HDprintf(HEADING "%1.2felapsed %s\n",
+      prefix, e_time, bw);
 #endif
-
 }
 
 
@@ -122,12 +100,10 @@ print_stats (const char *prefix,
  * Programmer:  Robb Matzke
  *              Thursday, March 12, 1998
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 static void
-synchronize (void)
+synchronize(void)
 {
 #ifdef H5_HAVE_SYSTEM
 #if defined(H5_HAVE_WIN32_API) && ! defined(__CYGWIN__)
@@ -157,24 +133,20 @@ synchronize (void)
  * Programmer:  Robb Matzke
  *              Thursday, March 12, 1998
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 int
-main (void)
+main(void)
 {
-    static hsize_t  size[2] = {REQUEST_SIZE_X, REQUEST_SIZE_Y};
-    static unsigned  nread = NREAD_REQUESTS, nwrite = NWRITE_REQUESTS;
+    hsize_t  size[2] = {REQUEST_SIZE_X, REQUEST_SIZE_Y};
+    unsigned  nread = NREAD_REQUESTS, nwrite = NWRITE_REQUESTS;
 
     unsigned char  *the_data = NULL;
     hid_t    file, dset, file_space = H5I_INVALID_HID;
 #ifdef H5_HAVE_GETRUSAGE
     struct rusage  r_start, r_stop;
-#else
-    struct timeval r_start, r_stop;
 #endif
-    struct timeval  t_start, t_stop;
+    double  t_start, t_stop;
     int      fd;
     unsigned    u;
     herr_t      H5_ATTR_NDEBUG_UNUSED status;
@@ -184,322 +156,221 @@ main (void)
     hsize_t    count[2];
 
 
-#ifdef H5_HAVE_SYS_TIMEB
-  struct _timeb *tbstart = malloc(sizeof(struct _timeb));
-  struct _timeb *tbstop = malloc(sizeof(struct _timeb));
-#endif
     /*
      * The extra cast in the following statement is a bug workaround for the
      * Win32 version 5.0 compiler.
      * 1998-11-06 ptl
      */
-    printf ("I/O request size is %1.1fMB\n",
-      (double)(hssize_t)(size[0]*size[1])/(double)1024.0F*(double)1024);
+    HDprintf("I/O request size is %1.1fMB\n",
+      (double)(hssize_t)(size[0] * size[1]) / (double)1024.0F * (double)1024);
 
     /* Open the files */
-    file = H5Fcreate (HDF5_FILE_NAME, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
-    HDassert (file>=0);
-    fd = HDopen (RAW_FILE_NAME, O_RDWR|O_CREAT|O_TRUNC, 0666);
-    HDassert (fd>=0);
+    file = H5Fcreate(HDF5_FILE_NAME, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+    HDassert(file >= 0);
+    fd = HDopen(RAW_FILE_NAME, O_RDWR|O_CREAT|O_TRUNC, 0666);
+    HDassert(fd >= 0);
 
     /* Create the dataset */
-    file_space = H5Screate_simple (2, size, size);
+    file_space = H5Screate_simple(2, size, size);
     HDassert(file_space >= 0);
     dset = H5Dcreate2(file, "dset", H5T_NATIVE_UCHAR, file_space, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
     HDassert(dset >= 0);
-    the_data = (unsigned char *)malloc((size_t)(size[0] * size[1]));
+    the_data = (unsigned char *)HDmalloc((size_t)(size[0] * size[1]));
 
     /* initial fill for lazy malloc */
     HDmemset(the_data, 0xAA, (size_t)(size[0] * size[1]));
 
+
     /* Fill raw */
-    synchronize ();
+    synchronize();
 #ifdef H5_HAVE_GETRUSAGE
     HDgetrusage(RUSAGE_SELF, &r_start);
 #endif
-#ifdef H5_HAVE_GETTIMEOFDAY
-    HDgettimeofday(&t_start, NULL);
-#else
-#ifdef H5_HAVE_SYS_TIMEB
-  _ftime(tbstart);
-#endif
-#endif
-    HDfprintf (stderr, HEADING, "fill raw");
+    t_start = H5_get_time();
+    HDfprintf(stderr, HEADING, "fill raw");
     for(u = 0; u < nwrite; u++) {
-  putc (PROGRESS, stderr);
-  HDfflush(stderr);
-  HDmemset(the_data, 0xAA, (size_t)(size[0]*size[1]));
+      HDputc(PROGRESS, stderr);
+      HDfflush(stderr);
+      HDmemset(the_data, 0xAA, (size_t)(size[0] * size[1]));
     }
 #ifdef H5_HAVE_GETRUSAGE
     HDgetrusage(RUSAGE_SELF, &r_stop);
 #endif
-#ifdef H5_HAVE_GETTIMEOFDAY
-    HDgettimeofday(&t_stop, NULL);
-#else
-#ifdef H5_HAVE_SYS_TIMEB
-  _ftime(tbstop);
-  t_start.tv_sec = tbstart->time;
-  t_start.tv_usec = tbstart->millitm;
-  t_stop.tv_sec = tbstop->time;
-  t_stop.tv_usec = tbstop->millitm;
-#endif
-#endif
-    putc ('\n', stderr);
-    print_stats ("fill raw",
-     &r_start, &r_stop, &t_start, &t_stop,
-     (size_t)(nread*size[0]*size[1]));
+    t_stop = H5_get_time();
+    HDputc('\n', stderr);
+    print_stats("fill raw",
+#ifdef H5_HAVE_GETRUSAGE
+            &r_start, &r_stop,
+#endif /* H5_HAVE_GETRUSAGE */
+            t_start, t_stop, (size_t)(nread * size[0] * size[1]));
 
 
     /* Fill hdf5 */
-    synchronize ();
+    synchronize();
 #ifdef H5_HAVE_GETRUSAGE
     HDgetrusage(RUSAGE_SELF, &r_start);
 #endif
-#ifdef H5_HAVE_GETTIMEOFDAY
-    HDgettimeofday(&t_start, NULL);
-#else
-#ifdef H5_HAVE_SYS_TIMEB
-  _ftime(tbstart);
-#endif
-#endif
-    HDfprintf (stderr, HEADING, "fill hdf5");
+    t_start = H5_get_time();
+    HDfprintf(stderr, HEADING, "fill hdf5");
     for(u = 0; u < nread; u++) {
-  putc (PROGRESS, stderr);
-  HDfflush(stderr);
-  status = H5Dread (dset, H5T_NATIVE_UCHAR, file_space, file_space,
-        H5P_DEFAULT, the_data);
-  HDassert (status>=0);
+      HDputc(PROGRESS, stderr);
+      HDfflush(stderr);
+      status = H5Dread(dset, H5T_NATIVE_UCHAR, file_space, file_space,
+            H5P_DEFAULT, the_data);
+      HDassert(status >= 0);
     }
 #ifdef H5_HAVE_GETRUSAGE
     HDgetrusage(RUSAGE_SELF, &r_stop);
 #endif
-#ifdef H5_HAVE_GETTIMEOFDAY
-    HDgettimeofday(&t_stop, NULL);
-#else
-#ifdef H5_HAVE_SYS_TIMEB
-  _ftime(tbstop);
-  t_start.tv_sec = tbstart->time;
-  t_start.tv_usec = tbstart->millitm;
-  t_stop.tv_sec = tbstop->time;
-  t_stop.tv_usec = tbstop->millitm;
-#endif
-#endif
-    putc ('\n', stderr);
-    print_stats ("fill hdf5",
-     &r_start, &r_stop, &t_start, &t_stop,
-     (size_t)(nread*size[0]*size[1]));
+    t_stop = H5_get_time();
+    HDputc('\n', stderr);
+    print_stats("fill hdf5",
+#ifdef H5_HAVE_GETRUSAGE
+            &r_start, &r_stop,
+#endif /* H5_HAVE_GETRUSAGE */
+            t_start, t_stop, (size_t)(nread * size[0] * size[1]));
 
     /* Write the raw dataset */
-    synchronize ();
+    synchronize();
 #ifdef H5_HAVE_GETRUSAGE
     HDgetrusage(RUSAGE_SELF, &r_start);
 #endif
-#ifdef H5_HAVE_GETTIMEOFDAY
-    HDgettimeofday(&t_start, NULL);
-#else
-#ifdef H5_HAVE_SYS_TIMEB
-  _ftime(tbstart);
-#endif
-#endif
-    HDfprintf (stderr, HEADING, "out raw");
+    t_start = H5_get_time();
+    HDfprintf(stderr, HEADING, "out raw");
     for(u = 0; u < nwrite; u++) {
-  putc (PROGRESS, stderr);
-  HDfflush(stderr);
-  offset = HDlseek (fd, (off_t)0, SEEK_SET);
-  HDassert (0==offset);
-  n = HDwrite (fd, the_data, (size_t)(size[0]*size[1]));
-  HDassert (n>=0 && (size_t)n==size[0]*size[1]);
+      HDputc(PROGRESS, stderr);
+      HDfflush(stderr);
+      offset = HDlseek(fd, (off_t)0, SEEK_SET);
+      HDassert(0 == offset);
+      n = HDwrite(fd, the_data, (size_t)(size[0] * size[1]));
+      HDassert(n >= 0 && (size_t)n == (size[0] * size[1]));
     }
 #ifdef H5_HAVE_GETRUSAGE
     HDgetrusage(RUSAGE_SELF, &r_stop);
 #endif
-#ifdef H5_HAVE_GETTIMEOFDAY
-    HDgettimeofday(&t_stop, NULL);
-#else
-#ifdef H5_HAVE_SYS_TIMEB
-  _ftime(tbstop);
-  t_start.tv_sec = tbstart->time;
-  t_start.tv_usec = tbstart->millitm;
-  t_stop.tv_sec = tbstop->time;
-  t_stop.tv_usec = tbstop->millitm;
-#endif
-#endif
-    putc ('\n', stderr);
-    print_stats ("out raw",
-     &r_start, &r_stop, &t_start, &t_stop,
-     (size_t)(nread*size[0]*size[1]));
+    t_stop = H5_get_time();
+    HDputc('\n', stderr);
+    print_stats("out raw",
+#ifdef H5_HAVE_GETRUSAGE
+            &r_start, &r_stop,
+#endif /* H5_HAVE_GETRUSAGE */
+            t_start, t_stop, (size_t)(nread * size[0] * size[1]));
 
     /* Write the hdf5 dataset */
-    synchronize ();
+    synchronize();
 #ifdef H5_HAVE_GETRUSAGE
     HDgetrusage(RUSAGE_SELF, &r_start);
 #endif
-#ifdef H5_HAVE_GETTIMEOFDAY
-    HDgettimeofday(&t_start, NULL);
-#else
-#ifdef H5_HAVE_SYS_TIMEB
-  _ftime(tbstart);
-#endif
-#endif
-    HDfprintf (stderr, HEADING, "out hdf5");
+    t_start = H5_get_time();
+    HDfprintf(stderr, HEADING, "out hdf5");
     for(u = 0; u < nwrite; u++) {
-  putc (PROGRESS, stderr);
-  HDfflush(stderr);
-  status = H5Dwrite (dset, H5T_NATIVE_UCHAR, H5S_ALL, H5S_ALL,
-         H5P_DEFAULT, the_data);
-  HDassert (status>=0);
+      HDputc(PROGRESS, stderr);
+      HDfflush(stderr);
+      status = H5Dwrite(dset, H5T_NATIVE_UCHAR, H5S_ALL, H5S_ALL,
+             H5P_DEFAULT, the_data);
+      HDassert(status >= 0);
     }
 #ifdef H5_HAVE_GETRUSAGE
     HDgetrusage(RUSAGE_SELF, &r_stop);
 #endif
-#ifdef H5_HAVE_GETTIMEOFDAY
-    HDgettimeofday(&t_stop, NULL);
-#else
-#ifdef H5_HAVE_SYS_TIMEB
-  _ftime(tbstop);
-  t_start.tv_sec = tbstart->time;
-  t_start.tv_usec = tbstart->millitm;
-  t_stop.tv_sec = tbstop->time;
-  t_stop.tv_usec = tbstop->millitm;
-#endif
-#endif
-    putc ('\n', stderr);
-    print_stats ("out hdf5",
-     &r_start, &r_stop, &t_start, &t_stop,
-     (size_t)(nread*size[0]*size[1]));
+    t_stop = H5_get_time();
+    HDputc('\n', stderr);
+    print_stats("out hdf5",
+#ifdef H5_HAVE_GETRUSAGE
+            &r_start, &r_stop,
+#endif /* H5_HAVE_GETRUSAGE */
+            t_start, t_stop, (size_t)(nread * size[0] * size[1]));
 
     /* Read the raw dataset */
-    synchronize ();
+    synchronize();
 #ifdef H5_HAVE_GETRUSAGE
     HDgetrusage(RUSAGE_SELF, &r_start);
 #endif
-#ifdef H5_HAVE_GETTIMEOFDAY
-    HDgettimeofday(&t_start, NULL);
-#else
-#ifdef H5_HAVE_SYS_TIMEB
-  _ftime(tbstart);
-#endif
-#endif
-    HDfprintf (stderr, HEADING, "in raw");
+    t_start = H5_get_time();
+    HDfprintf(stderr, HEADING, "in raw");
     for(u = 0; u < nread; u++) {
-  putc (PROGRESS, stderr);
-  HDfflush(stderr);
-  offset = HDlseek (fd, (off_t)0, SEEK_SET);
-  HDassert (0==offset);
-  n = HDread (fd, the_data, (size_t)(size[0]*size[1]));
-  HDassert (n>=0 && (size_t)n==size[0]*size[1]);
+      HDputc(PROGRESS, stderr);
+      HDfflush(stderr);
+      offset = HDlseek(fd, (off_t)0, SEEK_SET);
+      HDassert(0 == offset);
+      n = HDread(fd, the_data, (size_t)(size[0] * size[1]));
+      HDassert(n >= 0 && (size_t)n == (size[0] * size[1]));
     }
 #ifdef H5_HAVE_GETRUSAGE
     HDgetrusage(RUSAGE_SELF, &r_stop);
 #endif
-#ifdef H5_HAVE_GETTIMEOFDAY
-    HDgettimeofday(&t_stop, NULL);
-#else
-#ifdef H5_HAVE_SYS_TIMEB
-  _ftime(tbstop);
-  t_start.tv_sec = tbstart->time;
-  t_start.tv_usec = tbstart->millitm;
-  t_stop.tv_sec = tbstop->time;
-  t_stop.tv_usec = tbstop->millitm;
-#endif
-#endif
-    putc ('\n', stderr);
-    print_stats ("in raw",
-     &r_start, &r_stop, &t_start, &t_stop,
-     (size_t)(nread*size[0]*size[1]));
+    t_stop = H5_get_time();
+    HDputc('\n', stderr);
+    print_stats("in raw",
+#ifdef H5_HAVE_GETRUSAGE
+            &r_start, &r_stop,
+#endif /* H5_HAVE_GETRUSAGE */
+            t_start, t_stop, (size_t)(nread * size[0] * size[1]));
 
 
     /* Read the hdf5 dataset */
-    synchronize ();
+    synchronize();
 #ifdef H5_HAVE_GETRUSAGE
     HDgetrusage(RUSAGE_SELF, &r_start);
 #endif
-#ifdef H5_HAVE_GETTIMEOFDAY
-    HDgettimeofday(&t_start, NULL);
-#else
-#ifdef H5_HAVE_SYS_TIMEB
-  _ftime(tbstart);
-#endif
-#endif
-    HDfprintf (stderr, HEADING, "in hdf5");
+    t_start = H5_get_time();
+    HDfprintf(stderr, HEADING, "in hdf5");
     for(u = 0; u < nread; u++) {
-  putc (PROGRESS, stderr);
-  HDfflush(stderr);
-  status = H5Dread (dset, H5T_NATIVE_UCHAR, file_space, file_space,
-        H5P_DEFAULT, the_data);
-  HDassert (status>=0);
+      HDputc(PROGRESS, stderr);
+      HDfflush(stderr);
+      status = H5Dread(dset, H5T_NATIVE_UCHAR, file_space, file_space,
+            H5P_DEFAULT, the_data);
+      HDassert(status >= 0);
     }
 #ifdef H5_HAVE_GETRUSAGE
     HDgetrusage(RUSAGE_SELF, &r_stop);
 #endif
-#ifdef H5_HAVE_GETTIMEOFDAY
-    HDgettimeofday(&t_stop, NULL);
-#else
-#ifdef H5_HAVE_SYS_TIMEB
-  _ftime(tbstop);
-  t_start.tv_sec = tbstart->time;
-  t_start.tv_usec = tbstart->millitm;
-  t_stop.tv_sec = tbstop->time;
-  t_stop.tv_usec = tbstop->millitm;
-#endif
-#endif
-    putc ('\n', stderr);
-    print_stats ("in hdf5",
-     &r_start, &r_stop, &t_start, &t_stop,
-     (size_t)(nread*size[0]*size[1]));
+    t_stop = H5_get_time();
+    HDputc('\n', stderr);
+    print_stats("in hdf5",
+#ifdef H5_HAVE_GETRUSAGE
+            &r_start, &r_stop,
+#endif /* H5_HAVE_GETRUSAGE */
+            t_start, t_stop, (size_t)(nread * size[0] * size[1]));
 
     /* Read hyperslab */
-    HDassert (size[0]>20 && size[1]>20);
+    HDassert(size[0] > 20 && size[1] > 20);
     start[0] = start[1] = 10;
-    count[0] = count[1] = size[0]-20;
-    status = H5Sselect_hyperslab (file_space, H5S_SELECT_SET, start, NULL, count, NULL);
-    HDassert (status>=0);
-    synchronize ();
+    count[0] = count[1] = size[0] - 20;
+    status = H5Sselect_hyperslab(file_space, H5S_SELECT_SET, start, NULL, count, NULL);
+    HDassert(status >= 0);
+    synchronize();
 #ifdef H5_HAVE_GETRUSAGE
     HDgetrusage(RUSAGE_SELF, &r_start);
 #endif
-#ifdef H5_HAVE_GETTIMEOFDAY
-    HDgettimeofday(&t_start, NULL);
-#else
-#ifdef H5_HAVE_SYS_TIMEB
-  _ftime(tbstart);
-#endif
-#endif
-    HDfprintf (stderr, HEADING, "in hdf5 partial");
+    t_start = H5_get_time();
+    HDfprintf(stderr, HEADING, "in hdf5 partial");
     for(u = 0; u < nread; u++) {
-  putc (PROGRESS, stderr);
-  HDfflush(stderr);
-  status = H5Dread (dset, H5T_NATIVE_UCHAR, file_space, file_space,
-        H5P_DEFAULT, the_data);
-  HDassert (status>=0);
+      HDputc(PROGRESS, stderr);
+      HDfflush(stderr);
+      status = H5Dread(dset, H5T_NATIVE_UCHAR, file_space, file_space,
+            H5P_DEFAULT, the_data);
+      HDassert(status >= 0);
     }
 #ifdef H5_HAVE_GETRUSAGE
     HDgetrusage(RUSAGE_SELF, &r_stop);
 #endif
-#ifdef H5_HAVE_GETTIMEOFDAY
-    HDgettimeofday(&t_stop, NULL);
-#else
-#ifdef H5_HAVE_SYS_TIMEB
-  _ftime(tbstop);
-  t_start.tv_sec = tbstart->time;
-  t_start.tv_usec = tbstart->millitm;
-  t_stop.tv_sec = tbstop->time;
-  t_stop.tv_usec = tbstop->millitm;
-#endif
-#endif
-    putc('\n', stderr);
+    t_stop = H5_get_time();
+    HDputc('\n', stderr);
     print_stats("in hdf5 partial",
-     &r_start, &r_stop, &t_start, &t_stop,
-     (size_t)(nread*count[0]*count[1]));
-
-
+#ifdef H5_HAVE_GETRUSAGE
+            &r_start, &r_stop,
+#endif /* H5_HAVE_GETRUSAGE */
+            t_start, t_stop, (size_t)(nread * size[0] * size[1]));
 
     /* Close everything */
     HDclose(fd);
+
     H5Dclose(dset);
     H5Sclose(file_space);
     H5Fclose(file);
-    free(the_data);
+
+    HDfree(the_data);
 
     return 0;
 }