Merge HDF5 1.10.7 release files into 1.10/masterhdf5-1_10_7

1 files changed, 159 insertions, 160 deletions

diff --git a/src/H5PB.c b/src/H5PB.c
index 8d29951..907fe82 100644
--- a/src/H5PB.c
+++ b/src/H5PB.c
@@ -24,20 +24,21 @@
 /* Module Setup */
 /****************/
 
-#define H5F_FRIEND        /*suppress error about including H5Fpkg      */
+#define H5F_FRIEND              /* Suppress error about including H5Fpkg            */
 #include "H5PBmodule.h"         /* This source code file is part of the H5PB module */
 
 
 /***********/
 /* Headers */
 /***********/
-#include "H5private.h"        /* Generic Functions            */
-#include "H5Eprivate.h"        /* Error handling              */
-#include "H5Fpkg.h"        /* Files                */
-#include "H5FDprivate.h"    /* File drivers                */
-#include "H5Iprivate.h"        /* IDs                      */
-#include "H5PBpkg.h"            /* File access                */
-#include "H5SLprivate.h"    /* Skip List                */
+#include "H5private.h"          /* Generic Functions                */
+#include "H5Eprivate.h"         /* Error handling                   */
+#include "H5Fpkg.h"             /* Files                            */
+#include "H5FDprivate.h"        /* File drivers                     */
+#include "H5Iprivate.h"         /* IDs                              */
+#include "H5MMprivate.h"        /* Memory management                */
+#include "H5PBpkg.h"            /* File access                      */
+#include "H5SLprivate.h"        /* Skip List                        */
 
 
 /****************/
@@ -123,8 +124,8 @@ typedef struct {
 /* Local Prototypes */
 /********************/
 static herr_t H5PB__insert_entry(H5PB_t *page_buf, H5PB_entry_t *page_entry);
-static htri_t H5PB__make_space(H5F_t *f, H5PB_t *page_buf, H5FD_mem_t inserted_type);
-static herr_t H5PB__write_entry(H5F_t *f, H5PB_entry_t *page_entry);
+static htri_t H5PB__make_space(H5F_shared_t *f_sh, H5PB_t *page_buf, H5FD_mem_t inserted_type);
+static herr_t H5PB__write_entry(H5F_shared_t *f_sh, H5PB_entry_t *page_entry);
 
 
 /*********************/
@@ -150,7 +151,7 @@ H5FL_DEFINE_STATIC(H5PB_t);
 H5FL_DEFINE_STATIC(H5PB_entry_t);
 
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5PB_reset_stats
  *
@@ -161,7 +162,7 @@ H5FL_DEFINE_STATIC(H5PB_entry_t);
  *
  * Return:      Non-negative on success/Negative on failure
  *
- * Programmer:    Mohamad Chaarawi
+ * Programmer:  Mohamad Chaarawi
  *
  *-------------------------------------------------------------------------
  */
@@ -187,7 +188,7 @@ H5PB_reset_stats(H5PB_t *page_buf)
     FUNC_LEAVE_NOAPI(SUCCEED)
 }  /* H5PB_reset_stats() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5PB_get_stats
  *
@@ -201,9 +202,9 @@ H5PB_reset_stats(H5PB_t *page_buf)
  *              --evictions: the number of metadata and raw data evictions from the page buffer layer
  *              --bypasses: the number of metadata and raw data accesses that bypass the page buffer layer
  *
- * Return:        Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
- * Programmer:    Mohamad Chaarawi
+ * Programmer:  Mohamad Chaarawi
  *
  *-------------------------------------------------------------------------
  */
@@ -230,7 +231,7 @@ H5PB_get_stats(const H5PB_t *page_buf, unsigned accesses[2], unsigned hits[2],
     FUNC_LEAVE_NOAPI(SUCCEED)
 }  /* H5PB_get_stats */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5PB_print_stats()
  *
@@ -239,9 +240,9 @@ H5PB_get_stats(const H5PB_t *page_buf, unsigned accesses[2], unsigned hits[2],
  *
  *              Print out statistics collected for the page buffer layer.
  *
- * Return:        Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
- * Programmer:    Mohamad Chaarawi
+ * Programmer:  Mohamad Chaarawi
  *
  *-------------------------------------------------------------------------
  */
@@ -275,20 +276,20 @@ H5PB_print_stats(const H5PB_t *page_buf)
     FUNC_LEAVE_NOAPI(SUCCEED)
 } /* H5PB_print_stats */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5PB_create
  *
- * Purpose:    Create and setup the PB on the file.
+ * Purpose:     Create and setup the PB on the file.
  *
- * Return:    Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
- * Programmer:    Mohamad Chaarawi
+ * Programmer:  Mohamad Chaarawi
  *
  *-------------------------------------------------------------------------
  */
 herr_t
-H5PB_create(H5F_t *f, size_t size, unsigned page_buf_min_meta_perc, unsigned page_buf_min_raw_perc)
+H5PB_create(H5F_shared_t *f_sh, size_t size, unsigned page_buf_min_meta_perc, unsigned page_buf_min_raw_perc)
 {
     H5PB_t *page_buf = NULL;
     herr_t ret_value = SUCCEED;    /* Return value */
@@ -296,36 +297,35 @@ H5PB_create(H5F_t *f, size_t size, unsigned page_buf_min_meta_perc, unsigned pag
     FUNC_ENTER_NOAPI(FAIL)
 
     /* Sanity checks */
-    HDassert(f);
-    HDassert(f->shared);
+    HDassert(f_sh);
 
     /* Check args */
-    if(f->shared->fs_strategy != H5F_FSPACE_STRATEGY_PAGE)
+    if(f_sh->fs_strategy != H5F_FSPACE_STRATEGY_PAGE)
         HGOTO_ERROR(H5E_FILE, H5E_CANTINIT, FAIL, "Enabling Page Buffering requires PAGE file space strategy")
     /* round down the size if it is larger than the page size */
-    else if(size > f->shared->fs_page_size) {
+    else if(size > f_sh->fs_page_size) {
         hsize_t temp_size;
 
-        temp_size = (size / f->shared->fs_page_size) * f->shared->fs_page_size;
+        temp_size = (size / f_sh->fs_page_size) * f_sh->fs_page_size;
         H5_CHECKED_ASSIGN(size, size_t, temp_size, hsize_t);
     } /* end if */
-    else if(0 != size % f->shared->fs_page_size)
+    else if(0 != size % f_sh->fs_page_size)
         HGOTO_ERROR(H5E_PAGEBUF, H5E_CANTINIT, FAIL, "Page Buffer size must be >= to the page size")
 
     /* Allocate the new page buffering structure */
     if(NULL == (page_buf = H5FL_CALLOC(H5PB_t)))
-    HGOTO_ERROR(H5E_PAGEBUF, H5E_NOSPACE, FAIL, "memory allocation failed")
+        HGOTO_ERROR(H5E_PAGEBUF, H5E_NOSPACE, FAIL, "memory allocation failed")
 
     page_buf->max_size = size;
-    H5_CHECKED_ASSIGN(page_buf->page_size, size_t, f->shared->fs_page_size, hsize_t);
+    H5_CHECKED_ASSIGN(page_buf->page_size, size_t, f_sh->fs_page_size, hsize_t);
     page_buf->min_meta_perc = page_buf_min_meta_perc;
     page_buf->min_raw_perc = page_buf_min_raw_perc;
 
     /* Calculate the minimum page count for metadata and raw data
      * based on the fractions provided
      */
-    page_buf->min_meta_count = (unsigned)((size * page_buf_min_meta_perc) / (f->shared->fs_page_size * 100));
-    page_buf->min_raw_count = (unsigned)((size * page_buf_min_raw_perc) / (f->shared->fs_page_size * 100));
+    page_buf->min_meta_count = (unsigned)((size * page_buf_min_meta_perc) / (f_sh->fs_page_size * 100));
+    page_buf->min_raw_count = (unsigned)((size * page_buf_min_raw_perc) / (f_sh->fs_page_size * 100));
 
     if(NULL == (page_buf->slist_ptr = H5SL_create(H5SL_TYPE_HADDR, NULL)))
         HGOTO_ERROR(H5E_PAGEBUF, H5E_CANTCREATE, FAIL, "can't create skip list")
@@ -335,7 +335,7 @@ H5PB_create(H5F_t *f, size_t size, unsigned page_buf_min_meta_perc, unsigned pag
     if(NULL == (page_buf->page_fac = H5FL_fac_init(page_buf->page_size)))
         HGOTO_ERROR(H5E_PAGEBUF, H5E_CANTINIT, FAIL, "can't create page factory")
 
-    f->shared->page_buf = page_buf;
+    f_sh->page_buf = page_buf;
 
 done:
     if(ret_value < 0) {
@@ -353,15 +353,15 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* H5PB_create */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5PB__flush_cb
  *
- * Purpose:    Callback to flush PB skiplist entries.
+ * Purpose:     Callback to flush PB skiplist entries.
  *
- * Return:    Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
- * Programmer:    Mohamad Chaarawi
+ * Programmer:  Mohamad Chaarawi
  *
  *-------------------------------------------------------------------------
  */
@@ -369,52 +369,52 @@ static herr_t
 H5PB__flush_cb(void *item, void H5_ATTR_UNUSED *key, void *_op_data)
 {
     H5PB_entry_t *page_entry = (H5PB_entry_t *)item;    /* Pointer to page entry node */
-    H5F_t *f = (H5F_t *)_op_data;
+    H5F_shared_t *f_sh = (H5F_shared_t *)_op_data;
     herr_t  ret_value = SUCCEED;    /* Return value */
 
     FUNC_ENTER_STATIC
 
     /* Sanity checks */
     HDassert(page_entry);
-    HDassert(f);
+    HDassert(f_sh);
 
     /* Flush the page if it's dirty */
     if(page_entry->is_dirty)
-        if(H5PB__write_entry(f, page_entry) < 0)
+        if(H5PB__write_entry(f_sh, page_entry) < 0)
             HGOTO_ERROR(H5E_PAGEBUF, H5E_WRITEERROR, FAIL, "file write failed")
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* H5PB__flush_cb() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5PB_flush
  *
- * Purpose:    Flush/Free all the PB entries to the file.
+ * Purpose:     Flush/Free all the PB entries to the file.
  *
- * Return:    Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
- * Programmer:    Mohamad Chaarawi
+ * Programmer:  Mohamad Chaarawi
  *
  *-------------------------------------------------------------------------
  */
 herr_t
-H5PB_flush(H5F_t *f)
+H5PB_flush(H5F_shared_t *f_sh)
 {
     herr_t  ret_value = SUCCEED;    /* Return value */
 
     FUNC_ENTER_NOAPI(FAIL)
 
     /* Sanity check */
-    HDassert(f);
+    HDassert(f_sh);
 
     /* Flush all the entries in the PB skiplist, if we have write access on the file */
-    if(f->shared->page_buf && (H5F_ACC_RDWR & H5F_INTENT(f))) {
-        H5PB_t *page_buf = f->shared->page_buf;
+    if(f_sh->page_buf && (H5F_ACC_RDWR & H5F_SHARED_INTENT(f_sh))) {
+        H5PB_t *page_buf = f_sh->page_buf;
 
         /* Iterate over all entries in page buffer skip list */
-        if(H5SL_iterate(page_buf->slist_ptr, H5PB__flush_cb, (void *)f))
+        if(H5SL_iterate(page_buf->slist_ptr, H5PB__flush_cb, f_sh))
             HGOTO_ERROR(H5E_PAGEBUF, H5E_BADITER, FAIL, "can't flush page buffer skip list")
     } /* end if */
 
@@ -422,15 +422,15 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* H5PB_flush */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5PB__dest_cb
  *
- * Purpose:    Callback to free PB skiplist entries.
+ * Purpose:     Callback to free PB skiplist entries.
  *
- * Return:    Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
- * Programmer:    Mohamad Chaarawi
+ * Programmer:  Mohamad Chaarawi
  *
  *-------------------------------------------------------------------------
  */
@@ -459,34 +459,34 @@ H5PB__dest_cb(void *item, void H5_ATTR_UNUSED *key, void *_op_data)
     FUNC_LEAVE_NOAPI(SUCCEED)
 } /* H5PB__dest_cb() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5PB_dest
  *
- * Purpose:    Flush and destroy the PB on the file if it exists.
+ * Purpose:     Flush and destroy the PB on the file if it exists.
  *
- * Return:    Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
- * Programmer:    Mohamad Chaarawi
+ * Programmer:  Mohamad Chaarawi
  *
  *-------------------------------------------------------------------------
  */
 herr_t
-H5PB_dest(H5F_t *f)
+H5PB_dest(H5F_shared_t *f_sh)
 {
     herr_t  ret_value = SUCCEED;        /* Return value */
 
     FUNC_ENTER_NOAPI(FAIL)
 
     /* Sanity checks */
-    HDassert(f);
+    HDassert(f_sh);
 
     /* flush and destroy the page buffer, if it exists */
-    if(f->shared->page_buf) {
-        H5PB_t *page_buf = f->shared->page_buf;
+    if(f_sh->page_buf) {
+        H5PB_t *page_buf = f_sh->page_buf;
         H5PB_ud1_t op_data;                 /* Iteration context */
 
-        if(H5PB_flush(f) < 0)
+        if(H5PB_flush(f_sh) < 0)
             HGOTO_ERROR(H5E_PAGEBUF, H5E_CANTFLUSH, FAIL, "can't flush page buffer")
 
         /* Set up context info */
@@ -506,38 +506,40 @@ H5PB_dest(H5F_t *f)
         if(H5FL_fac_term(page_buf->page_fac) < 0)
             HGOTO_ERROR(H5E_PAGEBUF, H5E_CANTRELEASE, FAIL, "can't destroy page buffer page factory")
 
-        f->shared->page_buf = H5FL_FREE(H5PB_t, page_buf);
+        f_sh->page_buf = H5FL_FREE(H5PB_t, page_buf);
     } /* end if */
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* H5PB_dest */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5PB_add_new_page
  *
- * Purpose:    Add a new page to the new page skip list. This is called
+ * Purpose:     Add a new page to the new page skip list. This is called
  *              from the MF layer when a new page is allocated to
  *              indicate to the page buffer layer that a read of the page
  *              from the file is not necessary since it's an empty page.
  *
- * Return:    Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
- * Programmer:    Mohamad Chaarawi
+ * Programmer:  Mohamad Chaarawi
  *
  *-------------------------------------------------------------------------
  */
 herr_t
-H5PB_add_new_page(H5F_t *f, H5FD_mem_t type, haddr_t page_addr)
+H5PB_add_new_page(H5F_shared_t *f_sh, H5FD_mem_t type, haddr_t page_addr)
 {
-    H5PB_t *page_buf = f->shared->page_buf;
-    H5PB_entry_t *page_entry = NULL;    /* pointer to the corresponding page entry */
-    herr_t ret_value = SUCCEED;    /* Return value */
+    H5PB_t *page_buf;                   /* Page buffer to operate on */
+    H5PB_entry_t *page_entry = NULL;    /* Pointer to the corresponding page entry */
+    herr_t ret_value = SUCCEED;         /* Return value */
 
     FUNC_ENTER_NOAPI(FAIL)
 
     /* Sanity checks */
+    HDassert(f_sh);
+    page_buf = f_sh->page_buf;
     HDassert(page_buf);
 
     /* If there is an existing page, this means that at some point the
@@ -571,18 +573,18 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* H5PB_add_new_page */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5PB_update_entry
  *
- * Purpose:    In PHDF5, entries that are written by other processes and just
+ * Purpose:     In PHDF5, entries that are written by other processes and just
  *              marked clean by this process have to have their corresponding
  *              pages updated if they exist in the page buffer.
  *              This routine checks and update the pages.
  *
- * Return:    Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
- * Programmer:    Mohamad Chaarawi
+ * Programmer:  Mohamad Chaarawi
  *
  *-------------------------------------------------------------------------
  */
@@ -609,7 +611,7 @@ H5PB_update_entry(H5PB_t *page_buf, haddr_t addr, size_t size, const void *buf)
 
         HDassert(addr + size <= page_addr + page_buf->page_size);
         offset = addr - page_addr;
-        HDmemcpy((uint8_t *)page_entry->page_buf_ptr + offset, buf, size);
+        H5MM_memcpy((uint8_t *)page_entry->page_buf_ptr + offset, buf, size);
 
         /* move to top of LRU list */
         H5PB__MOVE_TO_TOP_LRU(page_buf, page_entry)
@@ -618,7 +620,7 @@ H5PB_update_entry(H5PB_t *page_buf, haddr_t addr, size_t size, const void *buf)
     FUNC_LEAVE_NOAPI(SUCCEED)
 } /* H5PB_update_entry */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5PB_remove_entry
  *
@@ -635,15 +637,17 @@ H5PB_update_entry(H5PB_t *page_buf, haddr_t addr, size_t size, const void *buf)
  *-------------------------------------------------------------------------
  */
 herr_t
-H5PB_remove_entry(const H5F_t *f, haddr_t addr)
+H5PB_remove_entry(const H5F_shared_t *f_sh, haddr_t addr)
 {
-    H5PB_t *page_buf = f->shared->page_buf;
-    H5PB_entry_t *page_entry = NULL;        /* pointer to the page entry being searched */
-    herr_t ret_value = SUCCEED;             /* Return value */
+    H5PB_t *page_buf;                   /* Page buffer to operate on */
+    H5PB_entry_t *page_entry = NULL;    /* Pointer to the page entry being searched */
+    herr_t ret_value = SUCCEED;         /* Return value */
 
     FUNC_ENTER_NOAPI(FAIL)
 
     /* Sanity checks */
+    HDassert(f_sh);
+    page_buf = f_sh->page_buf;
     HDassert(page_buf);
 
     /* Search for address in the skip list */
@@ -669,21 +673,21 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* H5PB_remove_entry */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5PB_read
  *
- * Purpose:    Reads in the data from the page containing it if it exists
+ * Purpose:     Reads in the data from the page containing it if it exists
  *              in the PB cache; otherwise reads in the page through the VFD.
  *
- * Return:    Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
- * Programmer:    Mohamad Chaarawi
+ * Programmer:  Mohamad Chaarawi
  *
  *-------------------------------------------------------------------------
  */
 herr_t
-H5PB_read(H5F_t *f, H5FD_mem_t type, haddr_t addr, size_t size, void *buf/*out*/)
+H5PB_read(H5F_shared_t *f_sh, H5FD_mem_t type, haddr_t addr, size_t size, void *buf/*out*/)
 {
     H5PB_t *page_buf;                   /* Page buffering info for this file */
     H5PB_entry_t *page_entry;           /* Pointer to the corresponding page entry */
@@ -700,21 +704,21 @@ H5PB_read(H5F_t *f, H5FD_mem_t type, haddr_t addr, size_t size, void *buf/*out*/
     FUNC_ENTER_NOAPI(FAIL)
 
     /* Sanity checks */
-    HDassert(f);
+    HDassert(f_sh);
     HDassert(type != H5FD_MEM_GHEAP);
 
     /* Get pointer to page buffer info for this file */
-    page_buf = f->shared->page_buf;
+    page_buf = f_sh->page_buf;
 
 #ifdef H5_HAVE_PARALLEL
-    if(H5F_HAS_FEATURE(f, H5FD_FEAT_HAS_MPI)) {
+    if(H5F_SHARED_HAS_FEATURE(f_sh, H5FD_FEAT_HAS_MPI)) {
 #if 1
         bypass_pb = TRUE;
 #else
         /* MSC - why this stopped working ? */
         int mpi_size;
 
-        if((mpi_size = H5F_mpi_get_size(f)) < 0)
+        if((mpi_size = H5F_shared_mpi_get_size(f_sh)) < 0)
             HGOTO_ERROR(H5E_PAGEBUF, H5E_CANTGET, FAIL, "can't retrieve MPI communicator size")
         if(1 != mpi_size)
             bypass_pb = TRUE;
@@ -728,7 +732,7 @@ H5PB_read(H5F_t *f, H5FD_mem_t type, haddr_t addr, size_t size, void *buf/*out*/
      */
     if(NULL == page_buf || size >= page_buf->page_size ||
            (bypass_pb && H5FD_MEM_DRAW == type)) {
-        if(H5F__accum_read(f, type, addr, size, buf) < 0)
+        if(H5F__accum_read(f_sh, type, addr, size, buf) < 0)
             HGOTO_ERROR(H5E_PAGEBUF, H5E_READERROR, FAIL, "read through metadata accumulator failed")
 
         /* Update statistics */
@@ -779,7 +783,7 @@ H5PB_read(H5F_t *f, H5FD_mem_t type, haddr_t addr, size_t size, void *buf/*out*/
     } /* end else */
 
     /* Translate to file driver I/O info object */
-    file = f->shared->lf;
+    file = f_sh->lf;
 
     /* Copy raw data from dirty pages into the read buffer if the read
        request spans pages in the page buffer*/
@@ -818,7 +822,7 @@ H5PB_read(H5F_t *f, H5FD_mem_t type, haddr_t addr, size_t size, void *buf/*out*/
                         offset = addr - first_page_addr;
                         HDassert(page_buf->page_size > offset);
 
-                        HDmemcpy(buf, (uint8_t *)page_entry->page_buf_ptr + offset,
+                        H5MM_memcpy(buf, (uint8_t *)page_entry->page_buf_ptr + offset,
                                  page_buf->page_size - (size_t)offset);
 
                         /* move to top of LRU list */
@@ -829,7 +833,7 @@ H5PB_read(H5F_t *f, H5FD_mem_t type, haddr_t addr, size_t size, void *buf/*out*/
                         offset = (num_touched_pages-2)*page_buf->page_size +
                             (page_buf->page_size - (addr - first_page_addr));
 
-                        HDmemcpy((uint8_t *)buf + offset, page_entry->page_buf_ptr,
+                        H5MM_memcpy((uint8_t *)buf + offset, page_entry->page_buf_ptr,
                                  (size_t)((addr + size) - last_page_addr));
 
                         /* move to top of LRU list */
@@ -839,7 +843,7 @@ H5PB_read(H5F_t *f, H5FD_mem_t type, haddr_t addr, size_t size, void *buf/*out*/
                     else {
                         offset = i*page_buf->page_size;
 
-                        HDmemcpy((uint8_t *)buf+(i*page_buf->page_size) , page_entry->page_buf_ptr,
+                        H5MM_memcpy((uint8_t *)buf+(i*page_buf->page_size) , page_entry->page_buf_ptr,
                              page_buf->page_size);
                     } /* end else */
                 } /* end if */
@@ -872,7 +876,7 @@ H5PB_read(H5F_t *f, H5FD_mem_t type, haddr_t addr, size_t size, void *buf/*out*/
                 buf_offset = (0 == i ? 0 : size - access_size);
 
                 /* copy the requested data from the page into the input buffer */
-                HDmemcpy((uint8_t *)buf + buf_offset, (uint8_t *)page_entry->page_buf_ptr + offset, access_size);
+                H5MM_memcpy((uint8_t *)buf + buf_offset, (uint8_t *)page_entry->page_buf_ptr + offset, access_size);
 
                 /* Update LRU */
                 H5PB__MOVE_TO_TOP_LRU(page_buf, page_entry)
@@ -894,7 +898,7 @@ H5PB_read(H5F_t *f, H5FD_mem_t type, haddr_t addr, size_t size, void *buf/*out*/
                     htri_t can_make_space;
 
                     /* check if we can make space in page buffer */
-                    if((can_make_space = H5PB__make_space(f, page_buf, type)) < 0)
+                    if((can_make_space = H5PB__make_space(f_sh, page_buf, type)) < 0)
                         HGOTO_ERROR(H5E_PAGEBUF, H5E_NOSPACE, FAIL, "make space in Page buffer Failed")
 
                     /* if make_space returns 0, then we can't use the page
@@ -919,7 +923,7 @@ H5PB_read(H5F_t *f, H5FD_mem_t type, haddr_t addr, size_t size, void *buf/*out*/
                 /* Read page through the VFD layer, but make sure we don't read past the EOA. */
 
                 /* Retrieve the 'eoa' for the file */
-                if(HADDR_UNDEF == (eoa = H5F_get_eoa(f, type)))
+                if(HADDR_UNDEF == (eoa = H5F_shared_get_eoa(f_sh, type)))
                     HGOTO_ERROR(H5E_PAGEBUF, H5E_CANTGET, FAIL, "driver get_eoa request failed")
 
                 /* If the entire page falls outside the EOA, then fail */
@@ -937,7 +941,7 @@ H5PB_read(H5F_t *f, H5FD_mem_t type, haddr_t addr, size_t size, void *buf/*out*/
                 /* Copy the requested data from the page into the input buffer */
                 offset = (0 == i ? addr - search_addr : 0);
                 buf_offset = (0 == i ? 0 : size - access_size);
-                HDmemcpy((uint8_t *)buf + buf_offset, (uint8_t *)new_page_buf + offset, access_size);
+                H5MM_memcpy((uint8_t *)buf + buf_offset, (uint8_t *)new_page_buf + offset, access_size);
 
                 /* Create the new PB entry */
                 if(NULL == (page_entry = H5FL_CALLOC(H5PB_entry_t)))
@@ -965,22 +969,22 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5PB_read() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5PB_write
  *
- * Purpose: Write data into the Page Buffer. If the page exists in the
- *          cache, update it; otherwise read it from disk, update it, and
- *          insert into cache.
+ * Purpose:     Write data into the Page Buffer. If the page exists in the
+ *              cache, update it; otherwise read it from disk, update it, and
+ *              insert into cache.
  *
- * Return:    Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
- * Programmer:    Mohamad Chaarawi
+ * Programmer:  Mohamad Chaarawi
  *
  *-------------------------------------------------------------------------
  */
 herr_t
-H5PB_write(H5F_t *f, H5FD_mem_t type, haddr_t addr,
+H5PB_write(H5F_shared_t *f_sh, H5FD_mem_t type, haddr_t addr,
     size_t size, const void *buf)
 {
     H5PB_t *page_buf;                   /* Page buffering info for this file */
@@ -998,20 +1002,20 @@ H5PB_write(H5F_t *f, H5FD_mem_t type, haddr_t addr,
     FUNC_ENTER_NOAPI(FAIL)
 
     /* Sanity checks */
-    HDassert(f);
+    HDassert(f_sh);
 
     /* Get pointer to page buffer info for this file */
-    page_buf = f->shared->page_buf;
+    page_buf = f_sh->page_buf;
 
 #ifdef H5_HAVE_PARALLEL
-    if(H5F_HAS_FEATURE(f, H5FD_FEAT_HAS_MPI)) {
+    if(H5F_SHARED_HAS_FEATURE(f_sh, H5FD_FEAT_HAS_MPI)) {
 #if 1
         bypass_pb = TRUE;
 #else
         /* MSC - why this stopped working ? */
         int mpi_size;
 
-        if((mpi_size = H5F_mpi_get_size(f)) < 0)
+        if((mpi_size = H5F_shared_mpi_get_size(f_sh)) < 0)
             HGOTO_ERROR(H5E_PAGEBUF, H5E_CANTGET, FAIL, "can't retrieve MPI communicator size")
         if(1 != mpi_size)
             bypass_pb = TRUE;
@@ -1024,7 +1028,7 @@ H5PB_write(H5F_t *f, H5FD_mem_t type, haddr_t addr,
      * buffering.
      */
     if(NULL == page_buf || size >= page_buf->page_size || bypass_pb) {
-        if(H5F__accum_write(f, type, addr, size, buf) < 0)
+        if(H5F__accum_write(f_sh, type, addr, size, buf) < 0)
             HGOTO_ERROR(H5E_PAGEBUF, H5E_WRITEERROR, FAIL, "write through metadata accumulator failed")
 
         /* Update statistics */
@@ -1083,7 +1087,7 @@ H5PB_write(H5F_t *f, H5FD_mem_t type, haddr_t addr,
     } /* end else */
 
     /* Translate to file driver I/O info object */
-    file = f->shared->lf;
+    file = f_sh->lf;
 
     /* Check if existing pages for raw data need to be updated since raw data access is not atomic */
     if(H5FD_MEM_DRAW == type && size >= page_buf->page_size) {
@@ -1102,7 +1106,7 @@ H5PB_write(H5F_t *f, H5FD_mem_t type, haddr_t addr,
                     HDassert(page_buf->page_size > offset);
 
                     /* Update page's data */
-                    HDmemcpy((uint8_t *)page_entry->page_buf_ptr + offset, buf, page_buf->page_size - (size_t)offset);
+                    H5MM_memcpy((uint8_t *)page_entry->page_buf_ptr + offset, buf, page_buf->page_size - (size_t)offset);
 
                     /* Mark page dirty and push to top of LRU */
                     page_entry->is_dirty = TRUE;
@@ -1121,7 +1125,7 @@ H5PB_write(H5F_t *f, H5FD_mem_t type, haddr_t addr,
                         (page_buf->page_size - (addr - first_page_addr));
 
                     /* Update page's data */
-                    HDmemcpy(page_entry->page_buf_ptr, (const uint8_t *)buf + offset,
+                    H5MM_memcpy(page_entry->page_buf_ptr, (const uint8_t *)buf + offset,
                              (size_t)((addr + size) - last_page_addr));
 
                     /* Mark page dirty and push to top of LRU */
@@ -1173,7 +1177,7 @@ H5PB_write(H5F_t *f, H5FD_mem_t type, haddr_t addr,
                 buf_offset = (0 == i ? 0 : size - access_size);
 
                 /* Copy the requested data from the input buffer into the page */
-                HDmemcpy((uint8_t *)page_entry->page_buf_ptr + offset, (const uint8_t *)buf + buf_offset, access_size);
+                H5MM_memcpy((uint8_t *)page_entry->page_buf_ptr + offset, (const uint8_t *)buf + buf_offset, access_size);
 
                 /* Mark page dirty and push to top of LRU */
                 page_entry->is_dirty = TRUE;
@@ -1195,7 +1199,7 @@ H5PB_write(H5F_t *f, H5FD_mem_t type, haddr_t addr,
                     htri_t can_make_space;
 
                     /* Check if we can make space in page buffer */
-                    if((can_make_space = H5PB__make_space(f, page_buf, type)) < 0)
+                    if((can_make_space = H5PB__make_space(f_sh, page_buf, type)) < 0)
                         HGOTO_ERROR(H5E_PAGEBUF, H5E_NOSPACE, FAIL, "make space in Page buffer Failed")
 
                     /* If make_space returns 0, then we can't use the page
@@ -1214,7 +1218,7 @@ H5PB_write(H5F_t *f, H5FD_mem_t type, haddr_t addr,
                 } /* end if */
 
                 /* Don't bother searching if there is no write access */
-                if(H5F_ACC_RDWR & H5F_INTENT(f))
+                if(H5F_ACC_RDWR & H5F_SHARED_INTENT(f_sh))
                     /* Lookup & remove the page from the new skip list page if
                      * it exists to see if this is a new page from the MF layer
                      */
@@ -1257,7 +1261,7 @@ H5PB_write(H5F_t *f, H5FD_mem_t type, haddr_t addr,
                     page_entry->type = (H5F_mem_page_t)type;
 
                     /* Retrieve the 'eoa' for the file */
-                    if(HADDR_UNDEF == (eoa = H5F_get_eoa(f, type)))
+                    if(HADDR_UNDEF == (eoa = H5F_shared_get_eoa(f_sh, type)))
                         HGOTO_ERROR(H5E_PAGEBUF, H5E_CANTGET, FAIL, "driver get_eoa request failed")
 
                     /* If the entire page falls outside the EOA, then fail */
@@ -1268,8 +1272,8 @@ H5PB_write(H5F_t *f, H5FD_mem_t type, haddr_t addr,
                      * returned will most likely be HADDR_UNDEF, so skip
                      * that check.
                      */
-                    if(!H5F_HAS_FEATURE(f, H5FD_FEAT_HAS_MPI))
-                        if(HADDR_UNDEF == (eof = H5FD_get_eof(f->shared->lf, H5FD_MEM_DEFAULT)))
+                    if(!H5F_SHARED_HAS_FEATURE(f_sh, H5FD_FEAT_HAS_MPI))
+                        if(HADDR_UNDEF == (eof = H5FD_get_eof(f_sh->lf, H5FD_MEM_DEFAULT)))
                             HGOTO_ERROR(H5E_PAGEBUF, H5E_CANTGET, FAIL, "driver get_eof request failed")
 
                     /* Adjust the read size to not go beyond the EOA */
@@ -1289,7 +1293,7 @@ H5PB_write(H5F_t *f, H5FD_mem_t type, haddr_t addr,
                 } /* end else */
 
                 /* Copy the requested data from the page into the input buffer */
-                HDmemcpy((uint8_t *)new_page_buf + offset, (const uint8_t *)buf+buf_offset, access_size);
+                H5MM_memcpy((uint8_t *)new_page_buf + offset, (const uint8_t *)buf+buf_offset, access_size);
 
                 /* Page is dirty now */
                 page_entry->is_dirty = TRUE;
@@ -1305,28 +1309,26 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5PB_write() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5PB__insert_entry()
  *
- * Purpose: ???
- *
- *          This function was created without documentation.
- *          What follows is my best understanding of Mohamad's intent.
+ * Purpose:     This function was created without documentation.
+ *              What follows is my best understanding of Mohamad's intent.
  *
- *        Insert the supplied page into the page buffer, both the
- *          skip list and the LRU.
+ *              Insert the supplied page into the page buffer, both the
+ *              skip list and the LRU.
  *
- *          As best I can tell, this function imposes no limit on the
- *          number of entries in the page buffer beyond an assertion
- *          failure it the page count exceeds the limit.
+ *              As best I can tell, this function imposes no limit on the
+ *              number of entries in the page buffer beyond an assertion
+ *              failure it the page count exceeds the limit.
  *
  *                                               JRM -- 12/22/16
  *
  *
- * Return:    Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
- * Programmer:    Mohamad Chaarawi
+ * Programmer:  Mohamad Chaarawi
  *
  *-------------------------------------------------------------------------
  */
@@ -1355,30 +1357,28 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5PB__insert_entry() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5PB__make_space()
  *
- * Purpose: ???
- *
- *          This function was created without documentation.
- *          What follows is my best understanding of Mohamad's intent.
+ * Purpose:     This function was created without documentation.
+ *              What follows is my best understanding of Mohamad's intent.
  *
- *          If necessary and if possible, evict a page from the page
- *          buffer to make space for the supplied page.  Depending on
- *        the page buffer configuration and contents, and the page
- *          supplied this may or may not be possible.
+ *              If necessary and if possible, evict a page from the page
+ *              buffer to make space for the supplied page.  Depending on
+ *              the page buffer configuration and contents, and the page
+ *              supplied this may or may not be possible.
  *
  *                                             JRM -- 12/22/16
  *
- * Return:    Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
- * Programmer:    Mohamad Chaarawi
+ * Programmer:  Mohamad Chaarawi
  *
  *-------------------------------------------------------------------------
  */
 static htri_t
-H5PB__make_space(H5F_t *f, H5PB_t *page_buf, H5FD_mem_t inserted_type)
+H5PB__make_space(H5F_shared_t *f_sh, H5PB_t *page_buf, H5FD_mem_t inserted_type)
 {
     H5PB_entry_t *page_entry;   /* Pointer to page eviction candidate */
     htri_t ret_value = TRUE;    /* Return value */
@@ -1386,7 +1386,7 @@ H5PB__make_space(H5F_t *f, H5PB_t *page_buf, H5FD_mem_t inserted_type)
     FUNC_ENTER_STATIC
 
     /* Sanity check */
-    HDassert(f);
+    HDassert(f_sh);
     HDassert(page_buf);
 
     /* Get oldest entry */
@@ -1443,7 +1443,7 @@ H5PB__make_space(H5F_t *f, H5PB_t *page_buf, H5FD_mem_t inserted_type)
 
     /* Flush page if dirty */
     if(page_entry->is_dirty)
-        if(H5PB__write_entry(f, page_entry) < 0)
+        if(H5PB__write_entry(f_sh, page_entry) < 0)
             HGOTO_ERROR(H5E_PAGEBUF, H5E_WRITEERROR, FAIL, "file write failed")
 
     /* Update statistics */
@@ -1460,24 +1460,23 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5PB__make_space() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5PB__write_entry()
  *
- * Purpose: ???
- *
- *          This function was created without documentation.
- *          What follows is my best understanding of Mohamad's intent.
+ * Purpose:     ???
  *
+ *              This function was created without documentation.
+ *              What follows is my best understanding of Mohamad's intent.
  *
- * Return:    Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
- * Programmer:    Mohamad Chaarawi
+ * Programmer:  Mohamad Chaarawi
  *
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5PB__write_entry(H5F_t *f, H5PB_entry_t *page_entry)
+H5PB__write_entry(H5F_shared_t *f_sh, H5PB_entry_t *page_entry)
 {
     haddr_t eoa;                    /* Current EOA for the file */
     herr_t ret_value = SUCCEED;    /* Return value */
@@ -1485,11 +1484,11 @@ H5PB__write_entry(H5F_t *f, H5PB_entry_t *page_entry)
     FUNC_ENTER_STATIC
 
     /* Sanity check */
-    HDassert(f);
+    HDassert(f_sh);
     HDassert(page_entry);
 
     /* Retrieve the 'eoa' for the file */
-    if(HADDR_UNDEF == (eoa = H5F_get_eoa(f, (H5FD_mem_t)page_entry->type)))
+    if(HADDR_UNDEF == (eoa = H5F_shared_get_eoa(f_sh, (H5FD_mem_t)page_entry->type)))
         HGOTO_ERROR(H5E_PAGEBUF, H5E_CANTGET, FAIL, "driver get_eoa request failed")
 
     /* If the starting address of the page is larger than
@@ -1497,14 +1496,14 @@ H5PB__write_entry(H5F_t *f, H5PB_entry_t *page_entry)
      */
     if(page_entry->addr <= eoa) {
         H5FD_t *file;                   /* File driver I/O info */
-        size_t page_size = f->shared->page_buf->page_size;
+        size_t page_size = f_sh->page_buf->page_size;
 
         /* Adjust the page length if it exceeds the EOA */
         if((page_entry->addr + page_size) > eoa)
             page_size = (size_t)(eoa - page_entry->addr);
 
         /* Translate to file driver I/O info object */
-        file = f->shared->lf;
+        file = f_sh->lf;
 
         if(H5FD_write(file, (H5FD_mem_t)page_entry->type, page_entry->addr, page_size, page_entry->page_buf_ptr) < 0)
             HGOTO_ERROR(H5E_PAGEBUF, H5E_WRITEERROR, FAIL, "file write failed")