[svn-r24720] bring r24709 from trunk:

rename H5V to H5VM since H5V is needed in the fastforward project for
view objects.  The addition of view objects in the fastforward project
is expected to be brough into the trunk sometimes in the future, which
is why we need to make this change.

37 files changed, 371 insertions, 311 deletions

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 9f9f9e9..7aad6ad 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -516,7 +516,7 @@ SET (common_SRCS
     ${HDF5_SRC_DIR}/H5SL.c
     ${HDF5_SRC_DIR}/H5ST.c
     ${HDF5_SRC_DIR}/H5TS.c
-    ${HDF5_SRC_DIR}/H5V.c
+    ${HDF5_SRC_DIR}/H5VM.c
     ${HDF5_SRC_DIR}/H5WB.c
 )
 
@@ -600,7 +600,7 @@ SET (H5_PRIVATE_HEADERS
     ${HDF5_SRC_DIR}/H5STprivate.h
     ${HDF5_SRC_DIR}/H5Tprivate.h
     ${HDF5_SRC_DIR}/H5TSprivate.h
-    ${HDF5_SRC_DIR}/H5Vprivate.h
+    ${HDF5_SRC_DIR}/H5VMprivate.h
     ${HDF5_SRC_DIR}/H5WBprivate.h
     ${HDF5_SRC_DIR}/H5Zprivate.h
     ${HDF5_SRC_DIR}/H5win32defs.h
diff --git a/src/H5B2hdr.c b/src/H5B2hdr.c
index 2148f1e..443a2e5 100644
--- a/src/H5B2hdr.c
+++ b/src/H5B2hdr.c
@@ -37,7 +37,7 @@
 #include "H5B2pkg.h"		/* v2 B-trees				*/
 #include "H5Eprivate.h"		/* Error handling		  	*/
 #include "H5MFprivate.h"	/* File memory management		*/
-#include "H5Vprivate.h"		/* Vectors and arrays 			*/
+#include "H5VMprivate.h"		/* Vectors and arrays 			*/
 
 /****************/
 /* Local Macros */
@@ -181,7 +181,7 @@ HDmemset(hdr->page, 0, hdr->node_size);
 
     /* Compute size to store # of records in each node */
     /* (uses leaf # of records because its the largest) */
-    u_max_nrec_size = H5V_limit_enc_size((uint64_t)hdr->node_info[0].max_nrec);
+    u_max_nrec_size = H5VM_limit_enc_size((uint64_t)hdr->node_info[0].max_nrec);
     H5_ASSIGN_OVERFLOW(/* To: */ hdr->max_nrec_size, /* From: */ u_max_nrec_size, /* From: */ unsigned, /* To: */ uint8_t)
     HDassert(hdr->max_nrec_size <= H5B2_SIZEOF_RECORDS_PER_NODE);
 
@@ -197,7 +197,7 @@ HDmemset(hdr->page, 0, hdr->node_size);
 
             hdr->node_info[u].cum_max_nrec = ((hdr->node_info[u].max_nrec + 1) *
                 hdr->node_info[u - 1].cum_max_nrec) + hdr->node_info[u].max_nrec;
-            u_max_nrec_size = H5V_limit_enc_size((uint64_t)hdr->node_info[u].cum_max_nrec);
+            u_max_nrec_size = H5VM_limit_enc_size((uint64_t)hdr->node_info[u].cum_max_nrec);
             H5_ASSIGN_OVERFLOW(/* To: */ hdr->node_info[u].cum_max_nrec_size, /* From: */ u_max_nrec_size, /* From: */ unsigned, /* To: */ uint8_t)
 
             if(NULL == (hdr->node_info[u].nat_rec_fac = H5FL_fac_init(hdr->cls->nrec_size * hdr->node_info[u].max_nrec)))
diff --git a/src/H5B2int.c b/src/H5B2int.c
index 1d5b5ff..ea0d265 100644
--- a/src/H5B2int.c
+++ b/src/H5B2int.c
@@ -37,7 +37,7 @@
 #include "H5B2pkg.h"		/* v2 B-trees				*/
 #include "H5Eprivate.h"		/* Error handling		  	*/
 #include "H5MFprivate.h"	/* File memory management		*/
-#include "H5Vprivate.h"		/* Vectors and arrays 			*/
+#include "H5VMprivate.h"		/* Vectors and arrays 			*/
 
 /****************/
 /* Local Macros */
@@ -387,7 +387,7 @@ H5B2_split_root(H5B2_hdr_t *hdr, hid_t dxpl_id)
     hdr->node_info[hdr->depth].merge_nrec = (hdr->node_info[hdr->depth].max_nrec * hdr->merge_percent) / 100;
     hdr->node_info[hdr->depth].cum_max_nrec = ((hdr->node_info[hdr->depth].max_nrec + 1) *
         hdr->node_info[hdr->depth - 1].cum_max_nrec) + hdr->node_info[hdr->depth].max_nrec;
-    u_max_nrec_size = H5V_limit_enc_size((uint64_t)hdr->node_info[hdr->depth].cum_max_nrec);
+    u_max_nrec_size = H5VM_limit_enc_size((uint64_t)hdr->node_info[hdr->depth].cum_max_nrec);
     H5_ASSIGN_OVERFLOW(/* To: */ hdr->node_info[hdr->depth].cum_max_nrec_size, /* From: */ u_max_nrec_size, /* From: */ unsigned, /* To: */ uint8_t)
     if(NULL == (hdr->node_info[hdr->depth].nat_rec_fac = H5FL_fac_init(hdr->cls->nrec_size * hdr->node_info[hdr->depth].max_nrec)))
 	HGOTO_ERROR(H5E_RESOURCE, H5E_CANTINIT, FAIL, "can't create node native key block factory")
diff --git a/src/H5Dbtree.c b/src/H5Dbtree.c
index e204bb9..af91753 100644
--- a/src/H5Dbtree.c
+++ b/src/H5Dbtree.c
@@ -43,7 +43,7 @@
 #include "H5MFprivate.h"	/* File space management		*/
 #include "H5Oprivate.h"		/* Object headers		  	*/
 #include "H5Sprivate.h"         /* Dataspaces                           */
-#include "H5Vprivate.h"		/* Vector and array functions		*/
+#include "H5VMprivate.h"		/* Vector and array functions		*/
 
 /****************/
 /* Local Macros */
@@ -345,7 +345,7 @@ H5D__btree_cmp2(void *_lt_key, void *_udata, void *_rt_key)
     HDassert(udata->layout->ndims > 0 && udata->layout->ndims <= H5O_LAYOUT_NDIMS);
 
     /* Compare the offsets but ignore the other fields */
-    ret_value = H5V_vector_cmp_u(udata->layout->ndims, lt_key->offset, rt_key->offset);
+    ret_value = H5VM_vector_cmp_u(udata->layout->ndims, lt_key->offset, rt_key->offset);
 
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5D__btree_cmp2() */
@@ -409,9 +409,9 @@ H5D__btree_cmp3(void *_lt_key, void *_udata, void *_rt_key)
             ret_value = (-1);
     } /* end if */
     else {
-        if(H5V_vector_ge_u(udata->layout->ndims, udata->offset, rt_key->offset))
+        if(H5VM_vector_ge_u(udata->layout->ndims, udata->offset, rt_key->offset))
             ret_value = 1;
-        else if(H5V_vector_lt_u(udata->layout->ndims, udata->offset, lt_key->offset))
+        else if(H5VM_vector_lt_u(udata->layout->ndims, udata->offset, lt_key->offset))
             ret_value = (-1);
     } /* end else */
 
@@ -540,7 +540,7 @@ H5D__btree_insert(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *_lt_key,
         /* Negative indices not supported yet */
         HGOTO_ERROR(H5E_STORAGE, H5E_UNSUPPORTED, H5B_INS_ERROR, "internal error")
 
-    } else if(H5V_vector_eq_u(udata->common.layout->ndims,
+    } else if(H5VM_vector_eq_u(udata->common.layout->ndims,
 				udata->common.offset, lt_key->offset) &&
 	       lt_key->nbytes > 0) {
         /*
@@ -579,10 +579,10 @@ H5D__btree_insert(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *_lt_key,
             ret_value = H5B_INS_NOOP;
         }
 
-    } else if (H5V_hyper_disjointp(udata->common.layout->ndims,
+    } else if (H5VM_hyper_disjointp(udata->common.layout->ndims,
 				   lt_key->offset, udata->common.layout->dim,
 				   udata->common.offset, udata->common.layout->dim)) {
-        HDassert(H5V_hyper_disjointp(udata->common.layout->ndims,
+        HDassert(H5VM_hyper_disjointp(udata->common.layout->ndims,
 				   rt_key->offset, udata->common.layout->dim,
 				   udata->common.offset, udata->common.layout->dim));
         /*
diff --git a/src/H5Dchunk.c b/src/H5Dchunk.c
index f588645..2330daa 100644
--- a/src/H5Dchunk.c
+++ b/src/H5Dchunk.c
@@ -59,7 +59,7 @@
 #include "H5FLprivate.h"	/* Free Lists                           */
 #include "H5Iprivate.h"		/* IDs			  		*/
 #include "H5MMprivate.h"	/* Memory management			*/
-#include "H5Vprivate.h"		/* Vector and array functions		*/
+#include "H5VMprivate.h"		/* Vector and array functions		*/
 
 
 /****************/
@@ -324,7 +324,7 @@ H5D__chunk_direct_write(const H5D_t *dset, hid_t dxpl_id, uint32_t filters, hsiz
          HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to get simple dataspace info")
 
     /* Calculate the index of this chunk */
-    if(H5V_chunk_index((unsigned)space_ndims, offset,
+    if(H5VM_chunk_index((unsigned)space_ndims, offset,
 	layout->u.chunk.dim, layout->u.chunk.down_chunks, &chunk_idx) < 0)
         HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "can't get chunk index")
 
@@ -419,7 +419,7 @@ H5D__chunk_set_info_real(H5O_layout_chunk_t *layout, unsigned ndims, const hsize
     } /* end for */
 
     /* Get the "down" sizes for each dimension */
-    if(H5V_array_down(ndims, layout->chunks, layout->down_chunks) < 0)
+    if(H5VM_array_down(ndims, layout->chunks, layout->down_chunks) < 0)
         HGOTO_ERROR(H5E_DATASET, H5E_CANTSET, FAIL, "can't compute 'down' chunk size value")
 
 done:
@@ -1137,7 +1137,7 @@ H5D__create_chunk_map_single(H5D_chunk_map_t *fm, const H5D_io_info_t
     chunk_info->coords[fm->f_ndims] = 0;
 
     /* Calculate the index of this chunk */
-    if(H5V_chunk_index(fm->f_ndims, chunk_info->coords, fm->layout->u.chunk.dim, fm->layout->u.chunk.down_chunks, &chunk_info->index) < 0)
+    if(H5VM_chunk_index(fm->f_ndims, chunk_info->coords, fm->layout->u.chunk.dim, fm->layout->u.chunk.down_chunks, &chunk_info->index) < 0)
         HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "can't get chunk index")
 
     /* Copy selection for file's dataspace into chunk dataspace */
@@ -1222,7 +1222,7 @@ H5D__create_chunk_file_map_hyper(H5D_chunk_map_t *fm, const H5D_io_info_t
     } /* end for */
 
     /* Calculate the index of this chunk */
-    if(H5V_chunk_index(fm->f_ndims, coords, fm->layout->u.chunk.dim, fm->layout->u.chunk.down_chunks, &chunk_index) < 0)
+    if(H5VM_chunk_index(fm->f_ndims, coords, fm->layout->u.chunk.dim, fm->layout->u.chunk.down_chunks, &chunk_index) < 0)
         HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "can't get chunk index")
 
     /* Iterate through each chunk in the dataset */
@@ -1340,7 +1340,7 @@ H5D__create_chunk_file_map_hyper(H5D_chunk_map_t *fm, const H5D_io_info_t
             } while(coords[curr_dim] > sel_end[curr_dim]);
 
             /* Re-calculate the index of this chunk */
-            if(H5V_chunk_index(fm->f_ndims, coords, fm->layout->u.chunk.dim, fm->layout->u.chunk.down_chunks, &chunk_index) < 0)
+            if(H5VM_chunk_index(fm->f_ndims, coords, fm->layout->u.chunk.dim, fm->layout->u.chunk.down_chunks, &chunk_index) < 0)
                 HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "can't get chunk index")
         } /* end if */
     } /* end while */
@@ -1488,7 +1488,7 @@ H5D__chunk_file_cb(void UNUSED *elem, hid_t UNUSED type_id, unsigned ndims, cons
     FUNC_ENTER_STATIC
 
     /* Calculate the index of this chunk */
-    if(H5V_chunk_index(ndims, coords, fm->layout->u.chunk.dim, fm->layout->u.chunk.down_chunks, &chunk_index) < 0)
+    if(H5VM_chunk_index(ndims, coords, fm->layout->u.chunk.dim, fm->layout->u.chunk.down_chunks, &chunk_index) < 0)
         HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "can't get chunk index")
 
     /* Find correct chunk in file & memory skip list */
@@ -1600,7 +1600,7 @@ H5D__chunk_mem_cb(void UNUSED *elem, hid_t UNUSED type_id, unsigned ndims, const
     FUNC_ENTER_STATIC
 
     /* Calculate the index of this chunk */
-    if(H5V_chunk_index(ndims, coords, fm->layout->u.chunk.dim, fm->layout->u.chunk.down_chunks, &chunk_index) < 0)
+    if(H5VM_chunk_index(ndims, coords, fm->layout->u.chunk.dim, fm->layout->u.chunk.down_chunks, &chunk_index) < 0)
         HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "can't get chunk index")
 
     /* Find correct chunk in file & memory skip list */
@@ -3405,7 +3405,7 @@ H5D__chunk_allocate(H5D_t *dset, hid_t dxpl_id, hbool_t full_overwrite,
                 hsize_t chunk_idx;
 
                 /* Calculate the index of this chunk */
-                if(H5V_chunk_index((unsigned)space_ndims, chunk_offset,
+                if(H5VM_chunk_index((unsigned)space_ndims, chunk_offset,
                         layout->u.chunk.dim, layout->u.chunk.down_chunks,
                         &chunk_idx) < 0)
                     HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "can't get chunk index")
@@ -3979,7 +3979,7 @@ H5D__chunk_prune_by_extent(H5D_t *dset, hid_t dxpl_id, const hsize_t *old_dim)
 
         while(!carry) {
             /* Calculate the index of this chunk */
-            if(H5V_chunk_index((unsigned)space_ndims, chunk_offset,
+            if(H5VM_chunk_index((unsigned)space_ndims, chunk_offset,
                     layout->u.chunk.dim, layout->u.chunk.down_chunks,
                     &(chk_io_info.store->chunk.index)) < 0)
                 HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "can't get chunk index")
@@ -4120,7 +4120,7 @@ H5D__chunk_addrmap_cb(const H5D_chunk_rec_t *chunk_rec, void *_udata)
     FUNC_ENTER_STATIC
 
     /* Compute the index for this chunk */
-    if(H5V_chunk_index(rank, chunk_rec->offset, udata->common.layout->dim, udata->common.layout->down_chunks, &chunk_index) < 0)
+    if(H5VM_chunk_index(rank, chunk_rec->offset, udata->common.layout->dim, udata->common.layout->down_chunks, &chunk_index) < 0)
        HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, H5_ITER_ERROR, "can't get chunk index")
 
     /* Set it in the userdata to return */
@@ -4311,7 +4311,7 @@ H5D__chunk_update_cache(H5D_t *dset, hid_t dxpl_id)
         next = ent->next;
 
         /* Calculate the index of this chunk */
-        if(H5V_chunk_index(rank, ent->offset, dset->shared->layout.u.chunk.dim, dset->shared->layout.u.chunk.down_chunks, &idx) < 0)
+        if(H5VM_chunk_index(rank, ent->offset, dset->shared->layout.u.chunk.dim, dset->shared->layout.u.chunk.down_chunks, &idx) < 0)
             HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "can't get chunk index")
 
         /* Compute the index for the chunk entry */
@@ -5074,7 +5074,7 @@ static herr_t
 H5D__nonexistent_readvv_cb(hsize_t UNUSED dst_off, hsize_t src_off, size_t len,
     void *_udata)
 {
-    H5D_chunk_readvv_ud_t *udata = (H5D_chunk_readvv_ud_t *)_udata; /* User data for H5V_opvv() operator */
+    H5D_chunk_readvv_ud_t *udata = (H5D_chunk_readvv_ud_t *)_udata; /* User data for H5VM_opvv() operator */
     H5D_fill_buf_info_t fb_info;    /* Dataset's fill buffer info */
     hbool_t fb_info_init = FALSE;   /* Whether the fill value buffer has been initialized */
     herr_t ret_value = SUCCEED;     /* Return value */
@@ -5126,7 +5126,7 @@ H5D__nonexistent_readvv(const H5D_io_info_t *io_info,
     size_t chunk_max_nseq, size_t *chunk_curr_seq, size_t chunk_len_arr[], hsize_t chunk_off_arr[],
     size_t mem_max_nseq, size_t *mem_curr_seq, size_t mem_len_arr[], hsize_t mem_off_arr[])
 {
-    H5D_chunk_readvv_ud_t udata;        /* User data for H5V_opvv() operator */
+    H5D_chunk_readvv_ud_t udata;        /* User data for H5VM_opvv() operator */
     ssize_t ret_value;                  /* Return value */
 
     FUNC_ENTER_STATIC
@@ -5140,13 +5140,13 @@ H5D__nonexistent_readvv(const H5D_io_info_t *io_info,
     HDassert(mem_len_arr);
     HDassert(mem_off_arr);
 
-    /* Set up user data for H5V_opvv() */
+    /* Set up user data for H5VM_opvv() */
     udata.rbuf = (unsigned char *)io_info->u.rbuf;
     udata.dset = io_info->dset;
     udata.dxpl_id = io_info->dxpl_id;
 
     /* Call generic sequence operation routine */
-    if((ret_value = H5V_opvv(chunk_max_nseq, chunk_curr_seq, chunk_len_arr, chunk_off_arr,
+    if((ret_value = H5VM_opvv(chunk_max_nseq, chunk_curr_seq, chunk_len_arr, chunk_off_arr,
             mem_max_nseq, mem_curr_seq, mem_len_arr, mem_off_arr,
             H5D__nonexistent_readvv_cb, &udata)) < 0)
         HGOTO_ERROR(H5E_DATASET, H5E_CANTOPERATE, FAIL, "can't perform vectorized fill value init")
diff --git a/src/H5Dcompact.c b/src/H5Dcompact.c
index c692c2b..0b34c07 100644
--- a/src/H5Dcompact.c
+++ b/src/H5Dcompact.c
@@ -40,7 +40,7 @@
 #include "H5Iprivate.h"		/* IDs			  		*/
 #include "H5MMprivate.h"	/* Memory management			*/
 #include "H5Oprivate.h"		/* Object headers		  	*/
-#include "H5Vprivate.h"		/* Vector and array functions		*/
+#include "H5VMprivate.h"		/* Vector and array functions		*/
 
 
 /****************/
@@ -297,7 +297,7 @@ H5D__compact_readvv(const H5D_io_info_t *io_info,
     HDassert(io_info);
 
     /* Use the vectorized memory copy routine to do actual work */
-    if((ret_value = H5V_memcpyvv(io_info->u.rbuf, mem_max_nseq, mem_curr_seq, mem_size_arr, mem_offset_arr, io_info->store->compact.buf, dset_max_nseq, dset_curr_seq, dset_size_arr, dset_offset_arr)) < 0)
+    if((ret_value = H5VM_memcpyvv(io_info->u.rbuf, mem_max_nseq, mem_curr_seq, mem_size_arr, mem_offset_arr, io_info->store->compact.buf, dset_max_nseq, dset_curr_seq, dset_size_arr, dset_offset_arr)) < 0)
         HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "vectorized memcpy failed")
 
 done:
@@ -338,7 +338,7 @@ H5D__compact_writevv(const H5D_io_info_t *io_info,
     HDassert(io_info);
 
     /* Use the vectorized memory copy routine to do actual work */
-    if((ret_value = H5V_memcpyvv(io_info->store->compact.buf, dset_max_nseq, dset_curr_seq, dset_size_arr, dset_offset_arr, io_info->u.wbuf, mem_max_nseq, mem_curr_seq, mem_size_arr, mem_offset_arr)) < 0)
+    if((ret_value = H5VM_memcpyvv(io_info->store->compact.buf, dset_max_nseq, dset_curr_seq, dset_size_arr, dset_offset_arr, io_info->u.wbuf, mem_max_nseq, mem_curr_seq, mem_size_arr, mem_offset_arr)) < 0)
         HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "vectorized memcpy failed")
 
     /* Mark the compact dataset's buffer as dirty */
diff --git a/src/H5Dcontig.c b/src/H5Dcontig.c
index 98743ac..bf8c001 100644
--- a/src/H5Dcontig.c
+++ b/src/H5Dcontig.c
@@ -43,7 +43,7 @@
 #include "H5MFprivate.h"	/* File memory management		*/
 #include "H5Oprivate.h"		/* Object headers		  	*/
 #include "H5Pprivate.h"		/* Property lists			*/
-#include "H5Vprivate.h"		/* Vector and array functions		*/
+#include "H5VMprivate.h"		/* Vector and array functions		*/
 
 
 /****************/
@@ -638,7 +638,7 @@ static herr_t
 H5D__contig_readvv_sieve_cb(hsize_t dst_off, hsize_t src_off, size_t len,
     void *_udata)
 {
-    H5D_contig_readvv_sieve_ud_t *udata = (H5D_contig_readvv_sieve_ud_t *)_udata; /* User data for H5V_opvv() operator */
+    H5D_contig_readvv_sieve_ud_t *udata = (H5D_contig_readvv_sieve_ud_t *)_udata; /* User data for H5VM_opvv() operator */
     H5F_t *file = udata->file;        /* File for dataset */
     H5D_rdcdc_t *dset_contig = udata->dset_contig; /* Cached information about contiguous data */
     const H5D_contig_storage_t *store_contig = udata->store_contig;    /* Contiguous storage info for this I/O operation */
@@ -804,7 +804,7 @@ done:
 static herr_t
 H5D__contig_readvv_cb(hsize_t dst_off, hsize_t src_off, size_t len, void *_udata)
 {
-    H5D_contig_readvv_ud_t *udata = (H5D_contig_readvv_ud_t *)_udata; /* User data for H5V_opvv() operator */
+    H5D_contig_readvv_ud_t *udata = (H5D_contig_readvv_ud_t *)_udata; /* User data for H5VM_opvv() operator */
     herr_t ret_value = SUCCEED;         /* Return value */
 
     FUNC_ENTER_STATIC
@@ -857,9 +857,9 @@ H5D__contig_readvv(const H5D_io_info_t *io_info,
 
     /* Check if data sieving is enabled */
     if(H5F_HAS_FEATURE(io_info->dset->oloc.file, H5FD_FEAT_DATA_SIEVE)) {
-        H5D_contig_readvv_sieve_ud_t udata;     /* User data for H5V_opvv() operator */
+        H5D_contig_readvv_sieve_ud_t udata;     /* User data for H5VM_opvv() operator */
 
-        /* Set up user data for H5V_opvv() */
+        /* Set up user data for H5VM_opvv() */
         udata.file = io_info->dset->oloc.file;
         udata.dset_contig = &(io_info->dset->shared->cache.contig);
         udata.store_contig = &(io_info->store->contig);
@@ -867,22 +867,22 @@ H5D__contig_readvv(const H5D_io_info_t *io_info,
         udata.dxpl_id = io_info->dxpl_id;
 
         /* Call generic sequence operation routine */
-        if((ret_value = H5V_opvv(dset_max_nseq, dset_curr_seq, dset_len_arr, dset_off_arr,
+        if((ret_value = H5VM_opvv(dset_max_nseq, dset_curr_seq, dset_len_arr, dset_off_arr,
                 mem_max_nseq, mem_curr_seq, mem_len_arr, mem_off_arr,
                 H5D__contig_readvv_sieve_cb, &udata)) < 0)
             HGOTO_ERROR(H5E_DATASET, H5E_CANTOPERATE, FAIL, "can't perform vectorized sieve buffer read")
     } /* end if */
     else {
-        H5D_contig_readvv_ud_t udata;     /* User data for H5V_opvv() operator */
+        H5D_contig_readvv_ud_t udata;     /* User data for H5VM_opvv() operator */
 
-        /* Set up user data for H5V_opvv() */
+        /* Set up user data for H5VM_opvv() */
         udata.file = io_info->dset->oloc.file;
         udata.dset_addr = io_info->store->contig.dset_addr;
         udata.rbuf = (unsigned char *)io_info->u.rbuf;
         udata.dxpl_id = io_info->dxpl_id;
 
         /* Call generic sequence operation routine */
-        if((ret_value = H5V_opvv(dset_max_nseq, dset_curr_seq, dset_len_arr, dset_off_arr,
+        if((ret_value = H5VM_opvv(dset_max_nseq, dset_curr_seq, dset_len_arr, dset_off_arr,
                 mem_max_nseq, mem_curr_seq, mem_len_arr, mem_off_arr,
                 H5D__contig_readvv_cb, &udata)) < 0)
             HGOTO_ERROR(H5E_DATASET, H5E_CANTOPERATE, FAIL, "can't perform vectorized read")
@@ -909,7 +909,7 @@ static herr_t
 H5D__contig_writevv_sieve_cb(hsize_t dst_off, hsize_t src_off, size_t len,
     void *_udata)
 {
-    H5D_contig_writevv_sieve_ud_t *udata = (H5D_contig_writevv_sieve_ud_t *)_udata; /* User data for H5V_opvv() operator */
+    H5D_contig_writevv_sieve_ud_t *udata = (H5D_contig_writevv_sieve_ud_t *)_udata; /* User data for H5VM_opvv() operator */
     H5F_t *file = udata->file;        /* File for dataset */
     H5D_rdcdc_t *dset_contig = udata->dset_contig; /* Cached information about contiguous data */
     const H5D_contig_storage_t *store_contig = udata->store_contig;    /* Contiguous storage info for this I/O operation */
@@ -1126,7 +1126,7 @@ done:
 static herr_t
 H5D__contig_writevv_cb(hsize_t dst_off, hsize_t src_off, size_t len, void *_udata)
 {
-    H5D_contig_writevv_ud_t *udata = (H5D_contig_writevv_ud_t *)_udata; /* User data for H5V_opvv() operator */
+    H5D_contig_writevv_ud_t *udata = (H5D_contig_writevv_ud_t *)_udata; /* User data for H5VM_opvv() operator */
     herr_t ret_value = SUCCEED; /* Return value */
 
     FUNC_ENTER_STATIC
@@ -1178,9 +1178,9 @@ H5D__contig_writevv(const H5D_io_info_t *io_info,
 
     /* Check if data sieving is enabled */
     if(H5F_HAS_FEATURE(io_info->dset->oloc.file, H5FD_FEAT_DATA_SIEVE)) {
-        H5D_contig_writevv_sieve_ud_t udata;    /* User data for H5V_opvv() operator */
+        H5D_contig_writevv_sieve_ud_t udata;    /* User data for H5VM_opvv() operator */
 
-        /* Set up user data for H5V_opvv() */
+        /* Set up user data for H5VM_opvv() */
         udata.file = io_info->dset->oloc.file;
         udata.dset_contig = &(io_info->dset->shared->cache.contig);
         udata.store_contig = &(io_info->store->contig);
@@ -1188,22 +1188,22 @@ H5D__contig_writevv(const H5D_io_info_t *io_info,
         udata.dxpl_id = io_info->dxpl_id;
 
         /* Call generic sequence operation routine */
-        if((ret_value = H5V_opvv(dset_max_nseq, dset_curr_seq, dset_len_arr, dset_off_arr,
+        if((ret_value = H5VM_opvv(dset_max_nseq, dset_curr_seq, dset_len_arr, dset_off_arr,
                 mem_max_nseq, mem_curr_seq, mem_len_arr, mem_off_arr,
                 H5D__contig_writevv_sieve_cb, &udata)) < 0)
             HGOTO_ERROR(H5E_DATASET, H5E_CANTOPERATE, FAIL, "can't perform vectorized sieve buffer write")
     } /* end if */
     else {
-        H5D_contig_writevv_ud_t udata;     /* User data for H5V_opvv() operator */
+        H5D_contig_writevv_ud_t udata;     /* User data for H5VM_opvv() operator */
 
-        /* Set up user data for H5V_opvv() */
+        /* Set up user data for H5VM_opvv() */
         udata.file = io_info->dset->oloc.file;
         udata.dset_addr = io_info->store->contig.dset_addr;
         udata.wbuf = (const unsigned char *)io_info->u.wbuf;
         udata.dxpl_id = io_info->dxpl_id;
 
         /* Call generic sequence operation routine */
-        if((ret_value = H5V_opvv(dset_max_nseq, dset_curr_seq, dset_len_arr, dset_off_arr,
+        if((ret_value = H5VM_opvv(dset_max_nseq, dset_curr_seq, dset_len_arr, dset_off_arr,
                 mem_max_nseq, mem_curr_seq, mem_len_arr, mem_off_arr,
                 H5D__contig_writevv_cb, &udata)) < 0)
             HGOTO_ERROR(H5E_DATASET, H5E_CANTOPERATE, FAIL, "can't perform vectorized read")
diff --git a/src/H5Defl.c b/src/H5Defl.c
index c5cf8e2..38c8ccd 100644
--- a/src/H5Defl.c
+++ b/src/H5Defl.c
@@ -33,7 +33,7 @@
 #include "H5Eprivate.h"		/* Error handling		  	*/
 #include "H5Fprivate.h"		/* Files				*/
 #include "H5HLprivate.h"	/* Local Heaps				*/
-#include "H5Vprivate.h"		/* Vector and array functions		*/
+#include "H5VMprivate.h"		/* Vector and array functions		*/
 
 
 /****************/
@@ -425,7 +425,7 @@ done:
 static herr_t
 H5D__efl_readvv_cb(hsize_t dst_off, hsize_t src_off, size_t len, void *_udata)
 {
-    H5D_efl_readvv_ud_t *udata = (H5D_efl_readvv_ud_t *)_udata; /* User data for H5V_opvv() operator */
+    H5D_efl_readvv_ud_t *udata = (H5D_efl_readvv_ud_t *)_udata; /* User data for H5VM_opvv() operator */
     herr_t ret_value = SUCCEED;         /* Return value */
 
     FUNC_ENTER_STATIC
@@ -459,7 +459,7 @@ H5D__efl_readvv(const H5D_io_info_t *io_info,
     size_t dset_max_nseq, size_t *dset_curr_seq, size_t dset_len_arr[], hsize_t dset_off_arr[],
     size_t mem_max_nseq, size_t *mem_curr_seq, size_t mem_len_arr[], hsize_t mem_off_arr[])
 {
-    H5D_efl_readvv_ud_t udata;  /* User data for H5V_opvv() operator */
+    H5D_efl_readvv_ud_t udata;  /* User data for H5VM_opvv() operator */
     ssize_t ret_value;          /* Return value (Total size of sequence in bytes) */
 
     FUNC_ENTER_STATIC
@@ -475,12 +475,12 @@ H5D__efl_readvv(const H5D_io_info_t *io_info,
     HDassert(mem_len_arr);
     HDassert(mem_off_arr);
 
-    /* Set up user data for H5V_opvv() */
+    /* Set up user data for H5VM_opvv() */
     udata.efl = &(io_info->store->efl);
     udata.rbuf = (unsigned char *)io_info->u.rbuf;
 
     /* Call generic sequence operation routine */
-    if((ret_value = H5V_opvv(dset_max_nseq, dset_curr_seq, dset_len_arr, dset_off_arr,
+    if((ret_value = H5VM_opvv(dset_max_nseq, dset_curr_seq, dset_len_arr, dset_off_arr,
             mem_max_nseq, mem_curr_seq, mem_len_arr, mem_off_arr,
             H5D__efl_readvv_cb, &udata)) < 0)
         HGOTO_ERROR(H5E_DATASET, H5E_CANTOPERATE, FAIL, "can't perform vectorized EFL read")
@@ -505,7 +505,7 @@ done:
 static herr_t
 H5D__efl_writevv_cb(hsize_t dst_off, hsize_t src_off, size_t len, void *_udata)
 {
-    H5D_efl_writevv_ud_t *udata = (H5D_efl_writevv_ud_t *)_udata; /* User data for H5V_opvv() operator */
+    H5D_efl_writevv_ud_t *udata = (H5D_efl_writevv_ud_t *)_udata; /* User data for H5VM_opvv() operator */
     herr_t ret_value = SUCCEED;         /* Return value */
 
     FUNC_ENTER_STATIC
@@ -539,7 +539,7 @@ H5D__efl_writevv(const H5D_io_info_t *io_info,
     size_t dset_max_nseq, size_t *dset_curr_seq, size_t dset_len_arr[], hsize_t dset_off_arr[],
     size_t mem_max_nseq, size_t *mem_curr_seq, size_t mem_len_arr[], hsize_t mem_off_arr[])
 {
-    H5D_efl_writevv_ud_t udata;  /* User data for H5V_opvv() operator */
+    H5D_efl_writevv_ud_t udata;  /* User data for H5VM_opvv() operator */
     ssize_t ret_value;          /* Return value (Total size of sequence in bytes) */
 
     FUNC_ENTER_STATIC
@@ -555,12 +555,12 @@ H5D__efl_writevv(const H5D_io_info_t *io_info,
     HDassert(mem_len_arr);
     HDassert(mem_off_arr);
 
-    /* Set up user data for H5V_opvv() */
+    /* Set up user data for H5VM_opvv() */
     udata.efl = &(io_info->store->efl);
     udata.wbuf = (const unsigned char *)io_info->u.wbuf;
 
     /* Call generic sequence operation routine */
-    if((ret_value = H5V_opvv(dset_max_nseq, dset_curr_seq, dset_len_arr, dset_off_arr,
+    if((ret_value = H5VM_opvv(dset_max_nseq, dset_curr_seq, dset_len_arr, dset_off_arr,
             mem_max_nseq, mem_curr_seq, mem_len_arr, mem_off_arr,
             H5D__efl_writevv_cb, &udata)) < 0)
         HGOTO_ERROR(H5E_DATASET, H5E_CANTOPERATE, FAIL, "can't perform vectorized EFL write")
diff --git a/src/H5Dfill.c b/src/H5Dfill.c
index 2edb363..e682dd6 100644
--- a/src/H5Dfill.c
+++ b/src/H5Dfill.c
@@ -38,7 +38,7 @@
 #include "H5Eprivate.h"		/* Error handling		  	*/
 #include "H5FLprivate.h"	/* Free Lists                           */
 #include "H5Iprivate.h"		/* IDs			  		*/
-#include "H5Vprivate.h"		/* Vector and array functions		*/
+#include "H5VMprivate.h"		/* Vector and array functions		*/
 #include "H5WBprivate.h"        /* Wrapped Buffers                      */
 
 
@@ -262,7 +262,7 @@ H5D__fill(const void *fill, const H5T_t *fill_type, void *buf,
                 HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed")
 
             /* Replicate the file's fill value into the temporary buffer */
-            H5V_array_fill(tmp_buf, fill, src_type_size, (size_t)nelmts);
+            H5VM_array_fill(tmp_buf, fill, src_type_size, (size_t)nelmts);
 
             /* Convert from file's fill value into memory form */
             if(H5T_convert(tpath, src_id, dst_id, (size_t)nelmts, (size_t)0, (size_t)0, tmp_buf, bkg_buf, dxpl_id) < 0)
@@ -494,7 +494,7 @@ H5D__fill_init(H5D_fill_buf_info_t *fb_info, void *caller_fill_buf,
             } /* end else */
 
             /* Replicate the fill value into the cached buffer */
-            H5V_array_fill(fb_info->fill_buf, fill->buf, fb_info->max_elmt_size, fb_info->elmts_per_buf);
+            H5VM_array_fill(fb_info->fill_buf, fill->buf, fb_info->max_elmt_size, fb_info->elmts_per_buf);
         } /* end else */
     } /* end if */
     else {      /* Fill the buffer with the default fill value */
@@ -588,7 +588,7 @@ H5D__fill_refill_vl(H5D_fill_buf_info_t *fb_info, size_t nelmts, hid_t dxpl_id)
 
     /* Replicate the fill value into the cached buffer */
     if(nelmts > 1)
-        H5V_array_fill((void *)((unsigned char *)fb_info->fill_buf + fb_info->mem_elmt_size), fb_info->fill_buf, fb_info->mem_elmt_size, (nelmts - 1));
+        H5VM_array_fill((void *)((unsigned char *)fb_info->fill_buf + fb_info->mem_elmt_size), fb_info->fill_buf, fb_info->mem_elmt_size, (nelmts - 1));
 
     /* Reset the entire background buffer, if necessary */
     if(H5T_path_bkg(fb_info->mem_to_dset_tpath))
diff --git a/src/H5Dmpio.c b/src/H5Dmpio.c
index 4d4c2bf..3b5bb30 100644
--- a/src/H5Dmpio.c
+++ b/src/H5Dmpio.c
@@ -43,7 +43,7 @@
 #include "H5Oprivate.h"       /* Object headers    */
 #include "H5Pprivate.h"       /* Property lists    */
 #include "H5Sprivate.h"       /* Dataspaces        */
-#include "H5Vprivate.h"       /* Vector            */
+#include "H5VMprivate.h"       /* Vector            */
 
 #ifdef H5_HAVE_PARALLEL
 
diff --git a/src/H5FScache.c b/src/H5FScache.c
index 9450c4c..6fc3227 100644
--- a/src/H5FScache.c
+++ b/src/H5FScache.c
@@ -38,7 +38,7 @@
 #include "H5Eprivate.h"		/* Error handling		  	*/
 #include "H5FSpkg.h"		/* File free space			*/
 #include "H5MFprivate.h"	/* File memory management		*/
-#include "H5Vprivate.h"		/* Vectors and arrays 			*/
+#include "H5VMprivate.h"		/* Vectors and arrays 			*/
 #include "H5WBprivate.h"        /* Wrapped Buffers                      */
 
 /****************/
@@ -619,7 +619,7 @@ H5FS_cache_sinfo_load(H5F_t *f, hid_t dxpl_id, haddr_t UNUSED addr, void *_udata
         unsigned sect_cnt_size;         /* The size of the section size counts */
 
         /* Compute the size of the section counts */
-        sect_cnt_size = H5V_limit_enc_size((uint64_t)udata->fspace->serial_sect_count);
+        sect_cnt_size = H5VM_limit_enc_size((uint64_t)udata->fspace->serial_sect_count);
 
         /* Reset the section count, the "add" routine will update it */
         old_tot_sect_count = udata->fspace->tot_sect_count;
@@ -869,7 +869,7 @@ H5FS_cache_sinfo_flush(H5F_t *f, hid_t dxpl_id, hbool_t destroy, haddr_t addr, H
         /* Set up user data for iterator */
         udata.sinfo = sinfo;
         udata.p = &p;
-        udata.sect_cnt_size = H5V_limit_enc_size((uint64_t)sinfo->fspace->serial_sect_count);
+        udata.sect_cnt_size = H5VM_limit_enc_size((uint64_t)sinfo->fspace->serial_sect_count);
 
         /* Iterate over all the bins */
         for(bin = 0; bin < sinfo->nbins; bin++) {
diff --git a/src/H5FSsection.c b/src/H5FSsection.c
index 0aa007e..c16f7a5 100644
--- a/src/H5FSsection.c
+++ b/src/H5FSsection.c
@@ -35,7 +35,7 @@
 #include "H5Eprivate.h"		/* Error handling		  	*/
 #include "H5FSpkg.h"		/* File free space			*/
 #include "H5MFprivate.h"	/* File memory management		*/
-#include "H5Vprivate.h"		/* Vectors and arrays 			*/
+#include "H5VMprivate.h"		/* Vectors and arrays 			*/
 
 
 /****************/
@@ -143,10 +143,10 @@ HDfprintf(stderr, "%s: fspace->addr = %a\n", FUNC, fspace->addr);
 	HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed")
 
     /* Set non-zero values */
-    sinfo->nbins = H5V_log2_gen(fspace->max_sect_size);
+    sinfo->nbins = H5VM_log2_gen(fspace->max_sect_size);
     sinfo->sect_prefix_size = (size_t)H5FS_SINFO_PREFIX_SIZE(f);
     sinfo->sect_off_size = (fspace->max_sect_addr + 7) / 8;
-    sinfo->sect_len_size = H5V_limit_enc_size((uint64_t)fspace->max_sect_size);
+    sinfo->sect_len_size = H5VM_limit_enc_size((uint64_t)fspace->max_sect_size);
 #ifdef H5FS_SINFO_DEBUG
 HDfprintf(stderr, "%s: fspace->max_sect_size = %Hu\n", FUNC, fspace->max_sect_size);
 HDfprintf(stderr, "%s: fspace->max_sect_addr = %u\n", FUNC, fspace->max_sect_addr);
@@ -496,7 +496,7 @@ HDfprintf(stderr, "%s: fspace->sinfo->serial_size_count = %Zu\n", "H5FS_sect_ser
 HDfprintf(stderr, "%s: fspace->sinfo->serial_size_count = %Zu\n", "H5FS_sect_serialize_size", fspace->sinfo->serial_size_count);
 HDfprintf(stderr, "%s: fspace->serial_sect_count = %Hu\n", "H5FS_sect_serialize_size", fspace->serial_sect_count);
 #endif /* QAK */
-        sect_buf_size += fspace->sinfo->serial_size_count * H5V_limit_enc_size((uint64_t)fspace->serial_sect_count);
+        sect_buf_size += fspace->sinfo->serial_size_count * H5VM_limit_enc_size((uint64_t)fspace->serial_sect_count);
 
         /* Size for each differently sized serializable section */
         sect_buf_size += fspace->sinfo->serial_size_count * fspace->sinfo->sect_len_size;
@@ -762,7 +762,7 @@ H5FS_sect_unlink_size(H5FS_sinfo_t *sinfo, const H5FS_section_class_t *cls,
     HDassert(cls);
 
     /* Determine correct bin which holds items of at least the section's size */
-    bin = H5V_log2_gen(sect->size);
+    bin = H5VM_log2_gen(sect->size);
     HDassert(bin < sinfo->nbins);
     if(sinfo->bins[bin].bin_list == NULL)
         HGOTO_ERROR(H5E_FSPACE, H5E_NOTFOUND, FAIL, "node's bin is empty?")
@@ -963,7 +963,7 @@ HDfprintf(stderr, "%s: sect->size = %Hu, sect->addr = %a\n", FUNC, sect->size, s
     HDassert(sect->size);
 
     /* Determine correct bin which holds items of the section's size */
-    bin = H5V_log2_gen(sect->size);
+    bin = H5VM_log2_gen(sect->size);
     HDassert(bin < sinfo->nbins);
     if(sinfo->bins[bin].bin_list == NULL) {
         if(NULL == (sinfo->bins[bin].bin_list = H5SL_create(H5SL_TYPE_HSIZE, NULL)))
@@ -1619,7 +1619,7 @@ H5FS_sect_find_node(H5FS_t *fspace, hsize_t request, H5FS_section_info_t **node)
     HDassert(node);
 
     /* Determine correct bin which holds items of at least the section's size */
-    bin = H5V_log2_gen(request);
+    bin = H5VM_log2_gen(request);
     HDassert(bin < fspace->sinfo->nbins);
 #ifdef QAK
 HDfprintf(stderr, "%s: fspace->sinfo->nbins = %u\n", FUNC, fspace->sinfo->nbins);
@@ -2053,7 +2053,7 @@ HDfprintf(stderr, "%s: to_ghost = %u\n", FUNC, to_ghost);
         HDassert(fspace->sinfo->bins);
 
         /* Determine correct bin which holds items of at least the section's size */
-        bin = H5V_log2_gen(sect->size);
+        bin = H5VM_log2_gen(sect->size);
         HDassert(bin < fspace->sinfo->nbins);
         HDassert(fspace->sinfo->bins[bin].bin_list);
 
diff --git a/src/H5Faccum.c b/src/H5Faccum.c
index 5bc3024..6855918 100644
--- a/src/H5Faccum.c
+++ b/src/H5Faccum.c
@@ -40,7 +40,7 @@
 #include "H5Eprivate.h"		/* Error handling		  	*/
 #include "H5Fpkg.h"             /* File access				*/
 #include "H5FDprivate.h"	/* File drivers				*/
-#include "H5Vprivate.h"		/* Vectors and arrays 			*/
+#include "H5VMprivate.h"		/* Vectors and arrays 			*/
 
 
 /****************/
@@ -151,7 +151,7 @@ H5F_accum_read(const H5F_t *f, hid_t dxpl_id, H5FD_mem_t type, haddr_t addr,
                     size_t new_alloc_size;        /* New size of accumulator */
 
                     /* Adjust the buffer size to be a power of 2 that is large enough to hold data */
-                    new_alloc_size = (size_t)1 << (1 + H5V_log2_gen((uint64_t)(new_size - 1)));
+                    new_alloc_size = (size_t)1 << (1 + H5VM_log2_gen((uint64_t)(new_size - 1)));
 
                     /* Reallocate the metadata accumulator buffer */
                     if(NULL == (f->shared->accum.buf = H5FL_BLK_REALLOC(meta_accum, f->shared->accum.buf, new_alloc_size)))
@@ -295,7 +295,7 @@ H5F_accum_adjust(H5F_meta_accum_t *accum, H5FD_t *lf, hid_t dxpl_id,
         size_t new_size;        /* New size of accumulator */
 
         /* Adjust the buffer size to be a power of 2 that is large enough to hold data */
-        new_size = (size_t)1 << (1 + H5V_log2_gen((uint64_t)((size + accum->size) - 1)));
+        new_size = (size_t)1 << (1 + H5VM_log2_gen((uint64_t)((size + accum->size) - 1)));
 
         /* Check for accumulator getting too big */
         if(new_size > H5F_ACCUM_MAX_SIZE) {
@@ -606,7 +606,7 @@ H5F_accum_write(const H5F_t *f, hid_t dxpl_id, H5FD_mem_t type, haddr_t addr,
                             size_t new_alloc_size;        /* New size of accumulator */
 
                             /* Adjust the buffer size to be a power of 2 that is large enough to hold data */
-                            new_alloc_size = (size_t)1 << (1 + H5V_log2_gen((uint64_t)(size - 1)));
+                            new_alloc_size = (size_t)1 << (1 + H5VM_log2_gen((uint64_t)(size - 1)));
 
                             /* Reallocate the metadata accumulator buffer */
                             if(NULL == (f->shared->accum.buf = H5FL_BLK_REALLOC(meta_accum, f->shared->accum.buf, new_alloc_size)))
@@ -649,7 +649,7 @@ HDmemset(f->shared->accum.buf + size, 0, (f->shared->accum.alloc_size - size));
                         size_t new_size;        /* New size of accumulator */
 
                         /* Adjust the buffer size to be a power of 2 that is large enough to hold data */
-                        new_size = (size_t)1 << (1 + H5V_log2_gen((uint64_t)(size - 1)));
+                        new_size = (size_t)1 << (1 + H5VM_log2_gen((uint64_t)(size - 1)));
 
                         /* Grow the metadata accumulator buffer */
                         if(NULL == (f->shared->accum.buf = H5FL_BLK_REALLOC(meta_accum, f->shared->accum.buf, new_size)))
@@ -699,7 +699,7 @@ HDmemset(f->shared->accum.buf + clear_size, 0, (f->shared->accum.alloc_size - cl
                     size_t new_size;        /* New size of accumulator */
 
                     /* Adjust the buffer size to be a power of 2 that is large enough to hold data */
-                    new_size = (size_t)1 << (1 + H5V_log2_gen((uint64_t)(size - 1)));
+                    new_size = (size_t)1 << (1 + H5VM_log2_gen((uint64_t)(size - 1)));
 
                     /* Reallocate the metadata accumulator buffer */
                     if(NULL == (f->shared->accum.buf = H5FL_BLK_REALLOC(meta_accum, f->shared->accum.buf, new_size)))
diff --git a/src/H5HFcache.c b/src/H5HFcache.c
index ad119a8..7f1cf12 100644
--- a/src/H5HFcache.c
+++ b/src/H5HFcache.c
@@ -40,7 +40,7 @@
 #include "H5HFpkg.h"		/* Fractal heaps			*/
 #include "H5MFprivate.h"	/* File memory management		*/
 #include "H5MMprivate.h"	/* Memory management			*/
-#include "H5Vprivate.h"		/* Vectors and arrays 			*/
+#include "H5VMprivate.h"		/* Vectors and arrays 			*/
 #include "H5WBprivate.h"        /* Wrapped Buffers                      */
 
 
diff --git a/src/H5HFdbg.c b/src/H5HFdbg.c
index 3e4515f..1dc2f2e 100644
--- a/src/H5HFdbg.c
+++ b/src/H5HFdbg.c
@@ -39,7 +39,7 @@
 #include "H5FLprivate.h"	/* Free Lists                           */
 #include "H5HFpkg.h"		/* Fractal heaps			*/
 #include "H5MMprivate.h"	/* Memory management			*/
-#include "H5Vprivate.h"		/* Vectors and arrays 			*/
+#include "H5VMprivate.h"		/* Vectors and arrays 			*/
 
 /****************/
 /* Local Macros */
@@ -641,10 +641,10 @@ H5HF_iblock_print(const H5HF_indirect_t *iblock,
         unsigned    first_row_bits;         /* Number of bits used bit addresses in first row */
         unsigned    num_indirect_rows;      /* Number of rows of blocks in each indirect block */
 
-        first_row_bits = H5V_log2_of2((uint32_t)hdr->man_dtable.cparam.start_block_size) +
-                            H5V_log2_of2(hdr->man_dtable.cparam.width);
+        first_row_bits = H5VM_log2_of2((uint32_t)hdr->man_dtable.cparam.start_block_size) +
+                            H5VM_log2_of2(hdr->man_dtable.cparam.width);
         for(u = hdr->man_dtable.max_direct_rows; u < iblock->nrows; u++) {
-            num_indirect_rows = (H5V_log2_gen(hdr->man_dtable.row_block_size[u]) - first_row_bits) + 1;
+            num_indirect_rows = (H5VM_log2_gen(hdr->man_dtable.row_block_size[u]) - first_row_bits) + 1;
             HDsnprintf(temp_str, sizeof(temp_str), "Row #%u: (# of rows: %u)", (unsigned)u, num_indirect_rows);
             HDfprintf(stream, "%*s%-*s\n", indent + 3, "", MAX(0, fwidth - 3),
                     temp_str);
diff --git a/src/H5HFdblock.c b/src/H5HFdblock.c
index d6c8134..6ee7070 100644
--- a/src/H5HFdblock.c
+++ b/src/H5HFdblock.c
@@ -38,7 +38,7 @@
 #include "H5Fprivate.h"		/* File access				*/
 #include "H5HFpkg.h"		/* Fractal heaps			*/
 #include "H5MFprivate.h"	/* File memory management		*/
-#include "H5Vprivate.h"		/* Vectors and arrays 			*/
+#include "H5VMprivate.h"		/* Vectors and arrays 			*/
 
 /****************/
 /* Local Macros */
@@ -355,7 +355,7 @@ H5HF_man_dblock_new(H5HF_hdr_t *hdr, hid_t dxpl_id, size_t request,
     if(request < hdr->man_dtable.cparam.start_block_size)
         min_dblock_size = hdr->man_dtable.cparam.start_block_size;
     else {
-        min_dblock_size = ((size_t)1) << (1 + H5V_log2_gen((uint64_t)request));
+        min_dblock_size = ((size_t)1) << (1 + H5VM_log2_gen((uint64_t)request));
         HDassert(min_dblock_size <= hdr->man_dtable.cparam.max_direct_size);
     } /* end else */
 
@@ -550,7 +550,7 @@ H5HF_man_dblock_locate(H5HF_hdr_t *hdr, hid_t dxpl_id, hsize_t obj_off,
         unsigned cache_flags = H5AC__NO_FLAGS_SET;      /* Flags for unprotecting parent indirect block */
 
         /* Compute # of rows in child indirect block */
-        nrows = (H5V_log2_gen(hdr->man_dtable.row_block_size[row]) - hdr->man_dtable.first_row_bits) + 1;
+        nrows = (H5VM_log2_gen(hdr->man_dtable.row_block_size[row]) - hdr->man_dtable.first_row_bits) + 1;
         HDassert(nrows < iblock->nrows);        /* child must be smaller than parent */
 
         /* Compute indirect block's entry */
diff --git a/src/H5HFdtable.c b/src/H5HFdtable.c
index a7d95bc..607862a 100644
--- a/src/H5HFdtable.c
+++ b/src/H5HFdtable.c
@@ -37,7 +37,7 @@
 #include "H5Eprivate.h"		/* Error handling		  	*/
 #include "H5HFpkg.h"		/* Fractal heaps			*/
 #include "H5MMprivate.h"	/* Memory management			*/
-#include "H5Vprivate.h"		/* Vectors and arrays 			*/
+#include "H5VMprivate.h"		/* Vectors and arrays 			*/
 
 /****************/
 /* Local Macros */
@@ -104,10 +104,10 @@ H5HF_dtable_init(H5HF_dtable_t *dtable)
     HDassert(dtable);
 
     /* Compute/cache some values */
-    dtable->start_bits = H5V_log2_of2((uint32_t)dtable->cparam.start_block_size);
-    dtable->first_row_bits = dtable->start_bits + H5V_log2_of2(dtable->cparam.width);
+    dtable->start_bits = H5VM_log2_of2((uint32_t)dtable->cparam.start_block_size);
+    dtable->first_row_bits = dtable->start_bits + H5VM_log2_of2(dtable->cparam.width);
     dtable->max_root_rows = (dtable->cparam.max_index - dtable->first_row_bits) + 1;
-    dtable->max_direct_bits = H5V_log2_of2((uint32_t)dtable->cparam.max_direct_size);
+    dtable->max_direct_bits = H5VM_log2_of2((uint32_t)dtable->cparam.max_direct_size);
     dtable->max_direct_rows = (dtable->max_direct_bits - dtable->start_bits) + 2;
     dtable->num_id_first_row = dtable->cparam.start_block_size * dtable->cparam.width;
     dtable->max_dir_blk_off_size = H5HF_SIZEOF_OFFSET_LEN(dtable->cparam.max_direct_size);
@@ -171,7 +171,7 @@ HDfprintf(stderr, "%s: off = %Hu\n", "H5HF_dtable_lookup", off);
         H5_ASSIGN_OVERFLOW(/* To: */ *col, /* From: */ (off / dtable->cparam.start_block_size), /* From: */ hsize_t, /* To: */ unsigned);
     } /* end if */
     else {
-        unsigned high_bit = H5V_log2_gen(off);  /* Determine the high bit in the offset */
+        unsigned high_bit = H5VM_log2_gen(off);  /* Determine the high bit in the offset */
         hsize_t off_mask = ((hsize_t)1) << high_bit;       /* Compute mask for determining column */
 
 #ifdef QAK
@@ -252,7 +252,7 @@ H5HF_dtable_size_to_row(const H5HF_dtable_t *dtable, size_t block_size)
     if(block_size == dtable->cparam.start_block_size)
         row = 0;
     else
-        row = (H5V_log2_of2((uint32_t)block_size) - H5V_log2_of2((uint32_t)dtable->cparam.start_block_size)) + 1;
+        row = (H5VM_log2_of2((uint32_t)block_size) - H5VM_log2_of2((uint32_t)dtable->cparam.start_block_size)) + 1;
 
     FUNC_LEAVE_NOAPI(row)
 } /* end H5HF_dtable_size_to_row() */
@@ -283,7 +283,7 @@ H5HF_dtable_size_to_rows(const H5HF_dtable_t *dtable, hsize_t size)
      */
     HDassert(dtable);
 
-    rows = (H5V_log2_gen(size) - dtable->first_row_bits) + 1;
+    rows = (H5VM_log2_gen(size) - dtable->first_row_bits) + 1;
 
     FUNC_LEAVE_NOAPI(rows)
 } /* end H5HF_dtable_size_to_rows() */
diff --git a/src/H5HFhdr.c b/src/H5HFhdr.c
index e4b89ba..d3c4473 100644
--- a/src/H5HFhdr.c
+++ b/src/H5HFhdr.c
@@ -37,7 +37,7 @@
 #include "H5Eprivate.h"		/* Error handling		  	*/
 #include "H5HFpkg.h"		/* Fractal heaps			*/
 #include "H5MFprivate.h"	/* File memory management		*/
-#include "H5Vprivate.h"		/* Vectors and arrays 			*/
+#include "H5VMprivate.h"		/* Vectors and arrays 			*/
 
 /****************/
 /* Local Macros */
@@ -46,7 +46,7 @@
 #ifndef NDEBUG
 /* Limit on the size of the max. direct block size */
 /* (This is limited to 32-bits currently, because I think it's unlikely to
- *      need to be larger, the 32-bit limit for H5V_log2_of2(n), and
+ *      need to be larger, the 32-bit limit for H5VM_log2_of2(n), and
  *      some offsets/sizes are encoded with a maxiumum of 32-bits  - QAK)
  */
 #define H5HF_MAX_DIRECT_SIZE_LIMIT ((hsize_t)2 * 1024 * 1024 * 1024)
@@ -224,7 +224,7 @@ H5HF_hdr_finish_init_phase1(H5HF_hdr_t *hdr)
 
     /* Set the size of heap IDs */
     hdr->heap_len_size = MIN(hdr->man_dtable.max_dir_blk_off_size,
-            H5V_limit_enc_size((uint64_t)hdr->max_man_size));
+            H5VM_limit_enc_size((uint64_t)hdr->max_man_size));
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
@@ -1089,7 +1089,7 @@ H5HF_hdr_update_iter(H5HF_hdr_t *hdr, hid_t dxpl_id, size_t min_dblock_size)
                     unsigned child_entry;           /* Entry of child indirect block */
 
                     /* Compute # of rows needed in child indirect block */
-                    child_rows_needed = (H5V_log2_of2((uint32_t)min_dblock_size) - H5V_log2_of2((uint32_t)hdr->man_dtable.cparam.start_block_size)) + 2;
+                    child_rows_needed = (H5VM_log2_of2((uint32_t)min_dblock_size) - H5VM_log2_of2((uint32_t)hdr->man_dtable.cparam.start_block_size)) + 2;
                     HDassert(child_rows_needed > child_nrows);
                     child_entry = (next_row + (child_rows_needed - child_nrows)) * hdr->man_dtable.cparam.width;
                     if(child_entry > (iblock->nrows * hdr->man_dtable.cparam.width))
diff --git a/src/H5HFiblock.c b/src/H5HFiblock.c
index 3c5303a..c989bfc 100644
--- a/src/H5HFiblock.c
+++ b/src/H5HFiblock.c
@@ -38,7 +38,7 @@
 #include "H5Fprivate.h"		/* File access				*/
 #include "H5HFpkg.h"		/* Fractal heaps			*/
 #include "H5MFprivate.h"	/* File memory management		*/
-#include "H5Vprivate.h"		/* Vectors and arrays 			*/
+#include "H5VMprivate.h"		/* Vectors and arrays 			*/
 
 /****************/
 /* Local Macros */
@@ -409,7 +409,7 @@ H5HF_man_iblock_root_create(H5HF_hdr_t *hdr, hid_t dxpl_id, size_t min_dblock_si
 
         nrows = hdr->man_dtable.cparam.start_root_rows;
 
-        block_row_off = H5V_log2_of2((uint32_t)min_dblock_size) - H5V_log2_of2((uint32_t)hdr->man_dtable.cparam.start_block_size);
+        block_row_off = H5VM_log2_of2((uint32_t)min_dblock_size) - H5VM_log2_of2((uint32_t)hdr->man_dtable.cparam.start_block_size);
         if(block_row_off > 0)
             block_row_off++;        /* Account for the pair of initial rows of the initial block size */
         rows_needed = 1 + block_row_off;
@@ -730,7 +730,7 @@ H5HF_man_iblock_root_halve(H5HF_indirect_t *iblock, hid_t dxpl_id)
     max_child_row = iblock->max_child / hdr->man_dtable.cparam.width;
 
     /* Compute new # of rows in root indirect block */
-    new_nrows = 1 << (1 + H5V_log2_gen((uint64_t)max_child_row));
+    new_nrows = 1 << (1 + H5VM_log2_gen((uint64_t)max_child_row));
 
     /* Check if the indirect block is NOT currently allocated in temp. file space */
     /* (temp. file space does not need to be freed) */
@@ -1662,10 +1662,10 @@ H5HF_man_iblock_size(H5F_t *f, hid_t dxpl_id, H5HF_hdr_t *hdr, haddr_t iblock_ad
         size_t      u;                  /* Local index variable */
 
         entry = hdr->man_dtable.max_direct_rows * hdr->man_dtable.cparam.width;
-	first_row_bits = H5V_log2_of2((uint32_t)hdr->man_dtable.cparam.start_block_size) +
-			    H5V_log2_of2(hdr->man_dtable.cparam.width);
-	num_indirect_rows =
-            (H5V_log2_gen(hdr->man_dtable.row_block_size[hdr->man_dtable.max_direct_rows]) - first_row_bits) + 1;
+	first_row_bits = H5VM_log2_of2((uint32_t)hdr->man_dtable.cparam.start_block_size) +
+			    H5VM_log2_of2(hdr->man_dtable.cparam.width);
+        num_indirect_rows =
+	    (H5VM_log2_gen(hdr->man_dtable.row_block_size[hdr->man_dtable.max_direct_rows]) - first_row_bits) + 1;
         for(u = hdr->man_dtable.max_direct_rows; u < iblock->nrows; u++, num_indirect_rows++) {
             size_t      v;                      /* Local index variable */
 
diff --git a/src/H5HFiter.c b/src/H5HFiter.c
index 0f2f7a4..137d0ee 100644
--- a/src/H5HFiter.c
+++ b/src/H5HFiter.c
@@ -36,7 +36,7 @@
 #include "H5private.h"		/* Generic Functions			*/
 #include "H5Eprivate.h"		/* Error handling		  	*/
 #include "H5HFpkg.h"		/* Fractal heaps			*/
-#include "H5Vprivate.h"		/* Vectors and arrays 			*/
+#include "H5VMprivate.h"		/* Vectors and arrays 			*/
 
 /****************/
 /* Local Macros */
@@ -213,7 +213,7 @@ H5HF_man_iter_start_offset(H5HF_hdr_t *hdr, hid_t dxpl_id,
 
             /* Compute # of rows in context indirect block */
             child_size = hdr->man_dtable.row_block_size[biter->curr->up->row];
-            iblock_nrows = (H5V_log2_gen(child_size) - hdr->man_dtable.first_row_bits) + 1;
+            iblock_nrows = (H5VM_log2_gen(child_size) - hdr->man_dtable.first_row_bits) + 1;
         } /* end else */
 
         /* Load indirect block for this context location */
diff --git a/src/H5HFman.c b/src/H5HFman.c
index 62f5580..9784e94 100644
--- a/src/H5HFman.c
+++ b/src/H5HFman.c
@@ -38,7 +38,7 @@
 #include "H5HFpkg.h"		/* Fractal heaps			*/
 #include "H5MFprivate.h"	/* File memory management		*/
 #include "H5MMprivate.h"	/* Memory management			*/
-#include "H5Vprivate.h"		/* Vectors and arrays 			*/
+#include "H5VMprivate.h"		/* Vectors and arrays 			*/
 
 /****************/
 /* Local Macros */
diff --git a/src/H5HFpkg.h b/src/H5HFpkg.h
index becec94..9c9c34c 100644
--- a/src/H5HFpkg.h
+++ b/src/H5HFpkg.h
@@ -136,7 +136,7 @@
 
 /* Compute the # of bytes required to store an offset into a given buffer size */
 #define H5HF_SIZEOF_OFFSET_BITS(b)   (((b) + 7) / 8)
-#define H5HF_SIZEOF_OFFSET_LEN(l)   H5HF_SIZEOF_OFFSET_BITS(H5V_log2_of2((unsigned)(l)))
+#define H5HF_SIZEOF_OFFSET_LEN(l)   H5HF_SIZEOF_OFFSET_BITS(H5VM_log2_of2((unsigned)(l)))
 
 /* Heap ID bit flags */
 /* Heap ID version (2 bits: 6-7) */
diff --git a/src/H5HFsection.c b/src/H5HFsection.c
index 72ea100..b3faebc 100644
--- a/src/H5HFsection.c
+++ b/src/H5HFsection.c
@@ -34,7 +34,7 @@
 #include "H5Eprivate.h"		/* Error handling		  	*/
 #include "H5HFpkg.h"		/* Fractal heaps			*/
 #include "H5MMprivate.h"	/* Memory management			*/
-#include "H5Vprivate.h"		/* Vectors and arrays 			*/
+#include "H5VMprivate.h"		/* Vectors and arrays 			*/
 
 /****************/
 /* Local Macros */
diff --git a/src/H5MF.c b/src/H5MF.c
index 57002c8..763d15e 100644
--- a/src/H5MF.c
+++ b/src/H5MF.c
@@ -39,7 +39,7 @@
 #include "H5Eprivate.h"		/* Error handling		  	*/
 #include "H5Fpkg.h"             /* File access				*/
 #include "H5MFpkg.h"		/* File memory management		*/
-#include "H5Vprivate.h"		/* Vectors and arrays 			*/
+#include "H5VMprivate.h"		/* Vectors and arrays 			*/
 
 
 /****************/
@@ -294,7 +294,7 @@ H5MF_alloc_create(H5F_t *f, hid_t dxpl_id, H5FD_mem_t type)
     fs_create.client = H5FS_CLIENT_FILE_ID;
     fs_create.shrink_percent = H5MF_FSPACE_SHRINK;
     fs_create.expand_percent = H5MF_FSPACE_EXPAND;
-    fs_create.max_sect_addr = 1 + H5V_log2_gen((uint64_t)f->shared->maxaddr);
+    fs_create.max_sect_addr = 1 + H5VM_log2_gen((uint64_t)f->shared->maxaddr);
     fs_create.max_sect_size = f->shared->maxaddr;
 
     if(NULL == (f->shared->fs_man[type] = H5FS_create(f, dxpl_id, NULL,
diff --git a/src/H5Odtype.c b/src/H5Odtype.c
index b482115..cb6bf98 100644
--- a/src/H5Odtype.c
+++ b/src/H5Odtype.c
@@ -25,7 +25,7 @@
 #include "H5MMprivate.h"	/* Memory management			*/
 #include "H5Opkg.h"             /* Object headers			*/
 #include "H5Tpkg.h"		/* Datatypes				*/
-#include "H5Vprivate.h"		/* Vectors and arrays 			*/
+#include "H5VMprivate.h"		/* Vectors and arrays 			*/
 
 
 /* PRIVATE PROTOTYPES */
@@ -266,7 +266,7 @@ H5O_dtype_decode_helper(H5F_t *f, unsigned *ioflags/*in,out*/, const uint8_t **p
                 unsigned j;
 
                 /* Compute the # of bytes required to store a member offset */
-                offset_nbytes = H5V_limit_enc_size((uint64_t)dt->shared->size);
+                offset_nbytes = H5VM_limit_enc_size((uint64_t)dt->shared->size);
 
                 /*
                  * Compound datatypes...
@@ -891,7 +891,7 @@ H5O_dtype_encode_helper(const H5F_t *f, uint8_t **pp, const H5T_t *dt)
                 unsigned offset_nbytes;         /* Size needed to encode member offsets */
 
                 /* Compute the # of bytes required to store a member offset */
-                offset_nbytes = H5V_limit_enc_size((uint64_t)dt->shared->size);
+                offset_nbytes = H5VM_limit_enc_size((uint64_t)dt->shared->size);
 
                 /*
                  * Compound datatypes...
@@ -1262,7 +1262,7 @@ H5O_dtype_size(const H5F_t *f, const void *_mesg)
                 unsigned offset_nbytes;         /* Size needed to encode member offsets */
 
                 /* Compute the # of bytes required to store a member offset */
-                offset_nbytes = H5V_limit_enc_size((uint64_t)dt->shared->size);
+                offset_nbytes = H5VM_limit_enc_size((uint64_t)dt->shared->size);
 
                 /* Compute the total size needed to encode compound datatype */
                 for(u = 0; u < dt->shared->u.compnd.nmembs; u++) {
diff --git a/src/H5Sall.c b/src/H5Sall.c
index 19d1efc..24caad2 100644
--- a/src/H5Sall.c
+++ b/src/H5Sall.c
@@ -27,7 +27,7 @@
 #include "H5Eprivate.h"		/* Error handling		        */
 #include "H5Iprivate.h"		/* ID Functions		                */
 #include "H5Spkg.h"		/* Dataspace functions			*/
-#include "H5Vprivate.h"         /* Vector functions                     */
+#include "H5VMprivate.h"         /* Vector functions                     */
 
 /* Static function prototypes */
 
@@ -162,7 +162,7 @@ H5S_all_iter_coords (const H5S_sel_iter_t *iter, hsize_t *coords)
     HDassert (coords);
 
     /* Calculate the coordinates for the current iterator offset */
-    if(H5V_array_calc(iter->u.all.elmt_offset,iter->rank,iter->dims,coords)<0)
+    if(H5VM_array_calc(iter->u.all.elmt_offset,iter->rank,iter->dims,coords)<0)
         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTGET, FAIL, "can't retrieve coordinates");
 
 done:
diff --git a/src/H5Shyper.c b/src/H5Shyper.c
index f8d87e4..c97c9b6 100644
--- a/src/H5Shyper.c
+++ b/src/H5Shyper.c
@@ -28,7 +28,7 @@
 #include "H5FLprivate.h"	/* Free Lists				*/
 #include "H5Iprivate.h"		/* ID Functions				*/
 #include "H5Spkg.h"		/* Dataspace functions			*/
-#include "H5Vprivate.h"         /* Vector functions			*/
+#include "H5VMprivate.h"         /* Vector functions			*/
 
 /* Local datatypes */
 
@@ -464,7 +464,7 @@ H5S_hyper_iter_coords (const H5S_sel_iter_t *iter, hsize_t *coords)
                     HDassert(v >= 0);
 
                     /* Compute the coords for the flattened dimensions */
-                    H5V_array_calc(iter->u.hyp.off[v], (unsigned)((begin - u) + 1), &(iter->dims[u]), &(coords[u]));
+                    H5VM_array_calc(iter->u.hyp.off[v], (unsigned)((begin - u) + 1), &(iter->dims[u]), &(coords[u]));
 
                     /* Continue to faster dimension in both indices */
                     u--;
@@ -4102,7 +4102,7 @@ H5S_hyper_project_scalar(const H5S_t *space, hsize_t *offset)
     } /* end else */
 
     /* Calculate offset of selection in projected buffer */
-    *offset = H5V_array_offset(space->extent.rank, space->extent.size, block); 
+    *offset = H5VM_array_offset(space->extent.rank, space->extent.size, block); 
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
@@ -4294,7 +4294,7 @@ H5S_hyper_project_simple(const H5S_t *base_space, H5S_t *new_space, hsize_t *off
             HDmemset(block, 0, sizeof(block));
             for(u = 0; u < (base_space->extent.rank - new_space->extent.rank); u++)
                 block[u] = opt_diminfo[u].start;
-            *offset = H5V_array_offset(base_space->extent.rank, base_space->extent.size, block); 
+            *offset = H5VM_array_offset(base_space->extent.rank, base_space->extent.size, block); 
 
             /* Set the correct dimensions for the base & new spaces */
             base_space_dim = base_space->extent.rank - new_space->extent.rank;
@@ -4377,7 +4377,7 @@ H5S_hyper_project_simple(const H5S_t *base_space, H5S_t *new_space, hsize_t *off
             } /* end while */
 
             /* Compute the offset for the down-projection */
-            *offset = H5V_array_offset(base_space->extent.rank, base_space->extent.size, block); 
+            *offset = H5VM_array_offset(base_space->extent.rank, base_space->extent.size, block); 
 
             /* Project the base space's selection down in less dimensions */
             if(H5S_hyper_project_simple_lower(base_space, new_space) < 0)
diff --git a/src/H5Smpio.c b/src/H5Smpio.c
index 868a00f..77e902f 100644
--- a/src/H5Smpio.c
+++ b/src/H5Smpio.c
@@ -35,7 +35,7 @@
 #include "H5Oprivate.h"		/* Object headers		  	*/
 #include "H5Pprivate.h"         /* Property lists                       */
 #include "H5Spkg.h"		/* Dataspaces 				*/
-#include "H5Vprivate.h"		/* Vector and array functions		*/
+#include "H5VMprivate.h"		/* Vector and array functions		*/
 
 #ifdef H5_HAVE_PARALLEL
 
@@ -453,7 +453,7 @@ H5S_mpio_span_hyper_type(const H5S_t *space, size_t elmt_size,
     elmt_type_is_derived = TRUE;
 
     /* Compute 'down' sizes for each dimension */
-    if(H5V_array_down(space->extent.rank, space->extent.size, down) < 0)
+    if(H5VM_array_down(space->extent.rank, space->extent.size, down) < 0)
         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTGETSIZE, FAIL, "couldn't compute 'down' dimension sizes")
 
     /* Obtain derived data type */
diff --git a/src/H5Snone.c b/src/H5Snone.c
index 021dd61..3c5eccc 100644
--- a/src/H5Snone.c
+++ b/src/H5Snone.c
@@ -27,7 +27,7 @@
 #include "H5Eprivate.h"
 #include "H5Iprivate.h"
 #include "H5Spkg.h"
-#include "H5Vprivate.h"
+#include "H5VMprivate.h"
 #include "H5Dprivate.h"
 
 /* Static function prototypes */
diff --git a/src/H5Spoint.c b/src/H5Spoint.c
index b758a92..70842df 100644
--- a/src/H5Spoint.c
+++ b/src/H5Spoint.c
@@ -29,7 +29,7 @@
 #include "H5Iprivate.h"		/* ID Functions		  */
 #include "H5MMprivate.h"	/* Memory Management functions		  */
 #include "H5Spkg.h"		/* Dataspace functions			  */
-#include "H5Vprivate.h"         /* Vector functions */
+#include "H5VMprivate.h"         /* Vector functions */
 
 /* Static function prototypes */
 
@@ -1383,7 +1383,7 @@ H5S_point_project_scalar(const H5S_t *space, hsize_t *offset)
         HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "point selection of one element has more than one node!")
 
     /* Calculate offset of selection in projected buffer */
-    *offset = H5V_array_offset(space->extent.rank, space->extent.size, node->pnt); 
+    *offset = H5VM_array_offset(space->extent.rank, space->extent.size, node->pnt); 
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
@@ -1437,7 +1437,7 @@ H5S_point_project_simple(const H5S_t *base_space, H5S_t *new_space, hsize_t *off
         /* Calculate offset of selection in projected buffer */
         HDmemset(block, 0, sizeof(block));
         HDmemcpy(block, base_space->select.sel_info.pnt_lst->head->pnt, sizeof(hsize_t) * rank_diff);
-        *offset = H5V_array_offset(base_space->extent.rank, base_space->extent.size, block); 
+        *offset = H5VM_array_offset(base_space->extent.rank, base_space->extent.size, block); 
 
         /* Iterate through base space's point nodes, copying the point information */
         base_node = base_space->select.sel_info.pnt_lst->head;
diff --git a/src/H5Sselect.c b/src/H5Sselect.c
index 1eb0cbc..44688b6 100644
--- a/src/H5Sselect.c
+++ b/src/H5Sselect.c
@@ -29,7 +29,7 @@
 #include "H5Iprivate.h"		/* IDs			  		*/
 #include "H5MMprivate.h"        /* Memory management                    */
 #include "H5Spkg.h"		/* Dataspaces 				*/
-#include "H5Vprivate.h"		/* Vector and array functions		*/
+#include "H5VMprivate.h"		/* Vector and array functions		*/
 #include "H5WBprivate.h"        /* Wrapped Buffers                      */
 
 /* Local functions */
@@ -1872,8 +1872,8 @@ H5S_select_construct_projection(const H5S_t *base_space, H5S_t **new_space_ptr,
              * and set the remaining dimensions to 1
              */
             rank_diff = new_space_rank - base_space_rank;
-            H5V_array_fill(new_space_dims, &tmp_dim_size, sizeof(tmp_dim_size), rank_diff);
-            H5V_array_fill(new_space_maxdims, &tmp_dim_size, sizeof(tmp_dim_size), rank_diff);
+            H5VM_array_fill(new_space_dims, &tmp_dim_size, sizeof(tmp_dim_size), rank_diff);
+            H5VM_array_fill(new_space_maxdims, &tmp_dim_size, sizeof(tmp_dim_size), rank_diff);
             HDmemcpy(&new_space_dims[rank_diff], base_space_dims, sizeof(new_space_dims[0]) * base_space_rank);
             HDmemcpy(&new_space_maxdims[rank_diff], base_space_maxdims, sizeof(new_space_maxdims[0]) * base_space_rank);
         } /* end if */
@@ -2038,7 +2038,7 @@ H5S_select_fill(const void *fill, size_t fill_size, const H5S_t *space, void *_b
 
             /* Fill each sequence in memory with fill value */
             HDassert((len[curr_seq] % fill_size) == 0);
-            H5V_array_fill(buf, fill, fill_size, (len[curr_seq] / fill_size));
+            H5VM_array_fill(buf, fill, fill_size, (len[curr_seq] / fill_size));
         } /* end for */
 
         /* Decrement number of elements left to process */
diff --git a/src/H5V.c b/src/H5VM.c
index 3277b90..6f72c57 100644
--- a/src/H5V.c
+++ b/src/H5VM.c
@@ -22,34 +22,34 @@
 #include "H5private.h"
 #include "H5Eprivate.h"
 #include "H5Oprivate.h"
-#include "H5Vprivate.h"
+#include "H5VMprivate.h"
 
 /* Local typedefs */
-typedef struct H5V_memcpy_ud_t {
+typedef struct H5VM_memcpy_ud_t {
     unsigned char *dst;         /* Pointer to destination buffer */
     const unsigned char *src;   /* Pointer to source buffer */
-} H5V_memcpy_ud_t;
+} H5VM_memcpy_ud_t;
 
 /* Local macros */
-#define H5V_HYPER_NDIMS H5O_LAYOUT_NDIMS
+#define H5VM_HYPER_NDIMS H5O_LAYOUT_NDIMS
 
 /* Local prototypes */
 static void
-H5V_stride_optimize1(unsigned *np/*in,out*/, hsize_t *elmt_size/*in,out*/,
+H5VM_stride_optimize1(unsigned *np/*in,out*/, hsize_t *elmt_size/*in,out*/,
 		     const hsize_t *size, hsize_t *stride1);
 static void
-H5V_stride_optimize2(unsigned *np/*in,out*/, hsize_t *elmt_size/*in,out*/,
+H5VM_stride_optimize2(unsigned *np/*in,out*/, hsize_t *elmt_size/*in,out*/,
 		     const hsize_t *size, hsize_t *stride1, hsize_t *stride2);
 #ifdef LATER
 static void
-H5V_stride_copy2(hsize_t nelmts, hsize_t elmt_size,
+H5VM_stride_copy2(hsize_t nelmts, hsize_t elmt_size,
      unsigned dst_n, const hsize_t *dst_size, const ssize_t *dst_stride, void *_dst,
      unsigned src_n, const hsize_t *src_size, const ssize_t *src_stride, const void *_src);
 #endif /* LATER */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5V_stride_optimize1
+ * Function:	H5VM_stride_optimize1
  *
  * Purpose:	Given a stride vector which references elements of the
  *		specified size, optimize the dimensionality, the stride
@@ -69,7 +69,7 @@ H5V_stride_copy2(hsize_t nelmts, hsize_t elmt_size,
  *-------------------------------------------------------------------------
  */
 static void
-H5V_stride_optimize1(unsigned *np/*in,out*/, hsize_t *elmt_size/*in,out*/,
+H5VM_stride_optimize1(unsigned *np/*in,out*/, hsize_t *elmt_size/*in,out*/,
 		     const hsize_t *size, hsize_t *stride1)
 {
     FUNC_ENTER_NOAPI_NOINIT_NOERR
@@ -78,7 +78,7 @@ H5V_stride_optimize1(unsigned *np/*in,out*/, hsize_t *elmt_size/*in,out*/,
      * This has to be true because if we optimize the dimensionality down to
      * zero we still must make one reference.
      */
-    HDassert(1 == H5V_vector_reduce_product(0, NULL));
+    HDassert(1 == H5VM_vector_reduce_product(0, NULL));
 
     /*
      * Combine adjacent memory accesses
@@ -95,7 +95,7 @@ H5V_stride_optimize1(unsigned *np/*in,out*/, hsize_t *elmt_size/*in,out*/,
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5V_stride_optimize2
+ * Function:	H5VM_stride_optimize2
  *
  * Purpose:	Given two stride vectors which reference elements of the
  *		specified size, optimize the dimensionality, the stride
@@ -118,7 +118,7 @@ H5V_stride_optimize1(unsigned *np/*in,out*/, hsize_t *elmt_size/*in,out*/,
  *-------------------------------------------------------------------------
  */
 static void
-H5V_stride_optimize2(unsigned *np/*in,out*/, hsize_t *elmt_size/*in,out*/,
+H5VM_stride_optimize2(unsigned *np/*in,out*/, hsize_t *elmt_size/*in,out*/,
 		     const hsize_t *size, hsize_t *stride1, hsize_t *stride2)
 {
     FUNC_ENTER_NOAPI_NOINIT_NOERR
@@ -127,7 +127,7 @@ H5V_stride_optimize2(unsigned *np/*in,out*/, hsize_t *elmt_size/*in,out*/,
      * This has to be true because if we optimize the dimensionality down to
      * zero we still must make one reference.
      */
-    HDassert(1 == H5V_vector_reduce_product(0, NULL));
+    HDassert(1 == H5VM_vector_reduce_product(0, NULL));
     HDassert(*elmt_size>0);
 
     /*
@@ -224,7 +224,7 @@ H5V_stride_optimize2(unsigned *np/*in,out*/, hsize_t *elmt_size/*in,out*/,
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5V_hyper_stride
+ * Function:	H5VM_hyper_stride
  *
  * Purpose:	Given a description of a hyperslab, this function returns
  *		(through STRIDE[]) the byte strides appropriate for accessing
@@ -256,7 +256,7 @@ H5V_stride_optimize2(unsigned *np/*in,out*/, hsize_t *elmt_size/*in,out*/,
  *-------------------------------------------------------------------------
  */
 hsize_t
-H5V_hyper_stride(unsigned n, const hsize_t *size,
+H5VM_hyper_stride(unsigned n, const hsize_t *size,
 		 const hsize_t *total_size, const hsize_t *offset,
 		 hsize_t *stride/*out*/)
 {
@@ -267,7 +267,7 @@ H5V_hyper_stride(unsigned n, const hsize_t *size,
 
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
-    HDassert(n <= H5V_HYPER_NDIMS);
+    HDassert(n <= H5VM_HYPER_NDIMS);
     HDassert(size);
     HDassert(total_size);
     HDassert(stride);
@@ -333,7 +333,7 @@ H5V_hyper_stride(unsigned n, const hsize_t *size,
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5V_hyper_eq
+ * Function:	H5VM_hyper_eq
  *
  * Purpose:	Determines whether two hyperslabs are equal.  This function
  *		assumes that both hyperslabs are relative to the same array,
@@ -356,7 +356,7 @@ H5V_hyper_stride(unsigned n, const hsize_t *size,
  *-------------------------------------------------------------------------
  */
 htri_t
-H5V_hyper_eq(unsigned n,
+H5VM_hyper_eq(unsigned n,
 	     const hsize_t *offset1, const hsize_t *size1,
 	     const hsize_t *offset2, const hsize_t *size2)
 {
@@ -386,7 +386,7 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5V_hyper_disjointp
+ * Function:	H5VM_hyper_disjointp
  *
  * Purpose:	Determines if two hyperslabs are disjoint.
  *
@@ -404,7 +404,7 @@ done:
  *-------------------------------------------------------------------------
  */
 htri_t
-H5V_hyper_disjointp(unsigned n,
+H5VM_hyper_disjointp(unsigned n,
     const hsize_t *offset1, const uint32_t *size1,
     const hsize_t *offset2, const uint32_t *size2)
 {
@@ -432,11 +432,11 @@ H5V_hyper_disjointp(unsigned n,
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5V_hyper_disjointp() */
+} /* end H5VM_hyper_disjointp() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5V_hyper_fill
+ * Function:	H5VM_hyper_fill
  *
  * Purpose:	Similar to memset() except it operates on hyperslabs...
  *
@@ -457,13 +457,13 @@ done:
  *-------------------------------------------------------------------------
  */
 herr_t
-H5V_hyper_fill(unsigned n, const hsize_t *_size,
+H5VM_hyper_fill(unsigned n, const hsize_t *_size,
 	       const hsize_t *total_size, const hsize_t *offset, void *_dst,
 	       unsigned fill_value)
 {
     uint8_t	*dst = (uint8_t*)_dst;	/*cast for ptr arithmetic	*/
-    hsize_t	size[H5V_HYPER_NDIMS];	/*a modifiable copy of _size	*/
-    hsize_t	dst_stride[H5V_HYPER_NDIMS]; /*destination stride info  */
+    hsize_t	size[H5VM_HYPER_NDIMS];	/*a modifiable copy of _size	*/
+    hsize_t	dst_stride[H5VM_HYPER_NDIMS]; /*destination stride info  */
     hsize_t	dst_start;		/*byte offset to start of stride*/
     hsize_t	elmt_size = 1;		/*bytes per element		*/
     herr_t	ret_value;		/*function return status	*/
@@ -474,7 +474,7 @@ H5V_hyper_fill(unsigned n, const hsize_t *_size,
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
     /* check args */
-    HDassert(n > 0 && n <= H5V_HYPER_NDIMS);
+    HDassert(n > 0 && n <= H5VM_HYPER_NDIMS);
     HDassert(_size);
     HDassert(total_size);
     HDassert(dst);
@@ -486,14 +486,14 @@ H5V_hyper_fill(unsigned n, const hsize_t *_size,
 #endif
 
     /* Copy the size vector so we can modify it */
-    H5V_vector_cpy(n, size, _size);
+    H5VM_vector_cpy(n, size, _size);
 
     /* Compute an optimal destination stride vector */
-    dst_start = H5V_hyper_stride(n, size, total_size, offset, dst_stride);
-    H5V_stride_optimize1(&n, &elmt_size, size, dst_stride);
+    dst_start = H5VM_hyper_stride(n, size, total_size, offset, dst_stride);
+    H5VM_stride_optimize1(&n, &elmt_size, size, dst_stride);
 
     /* Copy */
-    ret_value = H5V_stride_fill(n, elmt_size, size, dst_stride, dst+dst_start,
+    ret_value = H5VM_stride_fill(n, elmt_size, size, dst_stride, dst+dst_start,
 			     fill_value);
 
     FUNC_LEAVE_NOAPI(ret_value)
@@ -501,7 +501,7 @@ H5V_hyper_fill(unsigned n, const hsize_t *_size,
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5V_hyper_copy
+ * Function:	H5VM_hyper_copy
  *
  * Purpose:	Copies a hyperslab from the source to the destination.
  *
@@ -535,7 +535,7 @@ H5V_hyper_fill(unsigned n, const hsize_t *_size,
  *-------------------------------------------------------------------------
  */
 herr_t
-H5V_hyper_copy(unsigned n, const hsize_t *_size,
+H5VM_hyper_copy(unsigned n, const hsize_t *_size,
 
 	       /*destination*/
 	       const hsize_t *dst_size, const hsize_t *dst_offset,
@@ -547,9 +547,9 @@ H5V_hyper_copy(unsigned n, const hsize_t *_size,
 {
     const uint8_t *src = (const uint8_t*)_src;	/*cast for ptr arithmtc */
     uint8_t	*dst = (uint8_t*) _dst;		/*cast for ptr arithmtc */
-    hsize_t	size[H5V_HYPER_NDIMS];		/*a modifiable _size	*/
-    hsize_t	src_stride[H5V_HYPER_NDIMS];	/*source stride info	*/
-    hsize_t	dst_stride[H5V_HYPER_NDIMS];	/*dest stride info	*/
+    hsize_t	size[H5VM_HYPER_NDIMS];		/*a modifiable _size	*/
+    hsize_t	src_stride[H5VM_HYPER_NDIMS];	/*source stride info	*/
+    hsize_t	dst_stride[H5VM_HYPER_NDIMS];	/*dest stride info	*/
     hsize_t	dst_start, src_start;		/*offset to start at	*/
     hsize_t	elmt_size = 1;			/*element size in bytes */
     herr_t	ret_value;			/*return status		*/
@@ -560,7 +560,7 @@ H5V_hyper_copy(unsigned n, const hsize_t *_size,
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
     /* check args */
-    HDassert(n > 0 && n <= H5V_HYPER_NDIMS);
+    HDassert(n > 0 && n <= H5VM_HYPER_NDIMS);
     HDassert(_size);
     HDassert(dst_size);
     HDassert(src_size);
@@ -575,14 +575,14 @@ H5V_hyper_copy(unsigned n, const hsize_t *_size,
 #endif
 
     /* Copy the size vector so we can modify it */
-    H5V_vector_cpy(n, size, _size);
+    H5VM_vector_cpy(n, size, _size);
 
     /* Compute stride vectors for source and destination */
 #ifdef NO_INLINED_CODE
-    dst_start = H5V_hyper_stride(n, size, dst_size, dst_offset, dst_stride);
-    src_start = H5V_hyper_stride(n, size, src_size, src_offset, src_stride);
+    dst_start = H5VM_hyper_stride(n, size, dst_size, dst_offset, dst_stride);
+    src_start = H5VM_hyper_stride(n, size, src_size, src_offset, src_stride);
 #else /* NO_INLINED_CODE */
-    /* in-line version of two calls to H5V_hyper_stride() */
+    /* in-line version of two calls to H5VM_hyper_stride() */
     {
         hsize_t	    dst_acc;	/*accumulator				*/
         hsize_t	    src_acc;	/*accumulator				*/
@@ -675,10 +675,10 @@ H5V_hyper_copy(unsigned n, const hsize_t *_size,
 #endif /* NO_INLINED_CODE */
 
     /* Optimize the strides as a pair */
-    H5V_stride_optimize2(&n, &elmt_size, size, dst_stride, src_stride);
+    H5VM_stride_optimize2(&n, &elmt_size, size, dst_stride, src_stride);
 
     /* Perform the copy in terms of stride */
-    ret_value = H5V_stride_copy(n, elmt_size, size,
+    ret_value = H5VM_stride_copy(n, elmt_size, size,
              dst_stride, dst+dst_start, src_stride, src+src_start);
 
     FUNC_LEAVE_NOAPI(ret_value)
@@ -686,7 +686,7 @@ H5V_hyper_copy(unsigned n, const hsize_t *_size,
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5V_stride_fill
+ * Function:	H5VM_stride_fill
  *
  * Purpose:	Fills all bytes of a hyperslab with the same value using
  *		memset().
@@ -701,11 +701,11 @@ H5V_hyper_copy(unsigned n, const hsize_t *_size,
  *-------------------------------------------------------------------------
  */
 herr_t
-H5V_stride_fill(unsigned n, hsize_t elmt_size, const hsize_t *size,
+H5VM_stride_fill(unsigned n, hsize_t elmt_size, const hsize_t *size,
 		const hsize_t *stride, void *_dst, unsigned fill_value)
 {
     uint8_t	*dst = (uint8_t*)_dst; 	/*cast for ptr arithmetic	*/
-    hsize_t	idx[H5V_HYPER_NDIMS]; 	/*1-origin indices		*/
+    hsize_t	idx[H5VM_HYPER_NDIMS]; 	/*1-origin indices		*/
     hsize_t	nelmts;			/*number of elements to fill	*/
     hsize_t	i;			/*counter			*/
     int	j;			/*counter			*/
@@ -715,8 +715,8 @@ H5V_stride_fill(unsigned n, hsize_t elmt_size, const hsize_t *size,
 
     HDassert(elmt_size < SIZET_MAX);
 
-    H5V_vector_cpy(n, idx, size);
-    nelmts = H5V_vector_reduce_product(n, size);
+    H5VM_vector_cpy(n, idx, size);
+    nelmts = H5VM_vector_reduce_product(n, size);
     for (i=0; i<nelmts; i++) {
         /* Copy an element */
         H5_CHECK_OVERFLOW(elmt_size,hsize_t,size_t);
@@ -740,7 +740,7 @@ H5V_stride_fill(unsigned n, hsize_t elmt_size, const hsize_t *size,
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5V_stride_copy
+ * Function:	H5VM_stride_copy
  *
  * Purpose:	Uses DST_STRIDE and SRC_STRIDE to advance through the arrays
  *		DST and SRC while copying bytes from SRC to DST.  This
@@ -749,7 +749,7 @@ H5V_stride_fill(unsigned n, hsize_t elmt_size, const hsize_t *size,
  *		outside the hyperslab defined by the strides.
  *
  * Note:	If the src_stride is all zero and elmt_size is one, then it's
- *		probably more efficient to use H5V_stride_fill() instead.
+ *		probably more efficient to use H5VM_stride_fill() instead.
  *
  * Return:	Non-negative on success/Negative on failure
  *
@@ -761,13 +761,13 @@ H5V_stride_fill(unsigned n, hsize_t elmt_size, const hsize_t *size,
  *-------------------------------------------------------------------------
  */
 herr_t
-H5V_stride_copy(unsigned n, hsize_t elmt_size, const hsize_t *size,
+H5VM_stride_copy(unsigned n, hsize_t elmt_size, const hsize_t *size,
 		const hsize_t *dst_stride, void *_dst,
 		const hsize_t *src_stride, const void *_src)
 {
     uint8_t	*dst = (uint8_t*)_dst;		/*cast for ptr arithmetic*/
     const uint8_t *src = (const uint8_t*) _src;	/*cast for ptr arithmetic*/
-    hsize_t	idx[H5V_HYPER_NDIMS];		/*1-origin indices	*/
+    hsize_t	idx[H5VM_HYPER_NDIMS];		/*1-origin indices	*/
     hsize_t	nelmts;				/*num elements to copy	*/
     hsize_t	i;				/*counter		*/
     int	j;				/*counters		*/
@@ -778,8 +778,8 @@ H5V_stride_copy(unsigned n, hsize_t elmt_size, const hsize_t *size,
     HDassert(elmt_size<SIZET_MAX);
 
     if (n) {
-        H5V_vector_cpy(n, idx, size);
-        nelmts = H5V_vector_reduce_product(n, size);
+        H5VM_vector_cpy(n, idx, size);
+        nelmts = H5VM_vector_reduce_product(n, size);
         for (i=0; i<nelmts; i++) {
 
             /* Copy an element */
@@ -809,7 +809,7 @@ H5V_stride_copy(unsigned n, hsize_t elmt_size, const hsize_t *size,
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5V_stride_copy_s
+ * Function:	H5VM_stride_copy_s
  *
  * Purpose:	Uses DST_STRIDE and SRC_STRIDE to advance through the arrays
  *		DST and SRC while copying bytes from SRC to DST.  This
@@ -818,7 +818,7 @@ H5V_stride_copy(unsigned n, hsize_t elmt_size, const hsize_t *size,
  *		outside the hyperslab defined by the strides.
  *
  * Note:	If the src_stride is all zero and elmt_size is one, then it's
- *		probably more efficient to use H5V_stride_fill() instead.
+ *		probably more efficient to use H5VM_stride_fill() instead.
  *
  * Return:	Non-negative on success/Negative on failure
  *
@@ -830,13 +830,13 @@ H5V_stride_copy(unsigned n, hsize_t elmt_size, const hsize_t *size,
  *-------------------------------------------------------------------------
  */
 herr_t
-H5V_stride_copy_s(unsigned n, hsize_t elmt_size, const hsize_t *size,
+H5VM_stride_copy_s(unsigned n, hsize_t elmt_size, const hsize_t *size,
 		const hssize_t *dst_stride, void *_dst,
 		const hssize_t *src_stride, const void *_src)
 {
     uint8_t	*dst = (uint8_t*)_dst;		/*cast for ptr arithmetic*/
     const uint8_t *src = (const uint8_t*) _src;	/*cast for ptr arithmetic*/
-    hsize_t	idx[H5V_HYPER_NDIMS];		/*1-origin indices	*/
+    hsize_t	idx[H5VM_HYPER_NDIMS];		/*1-origin indices	*/
     hsize_t	nelmts;				/*num elements to copy	*/
     hsize_t	i;				/*counter		*/
     int	j;				/*counters		*/
@@ -847,8 +847,8 @@ H5V_stride_copy_s(unsigned n, hsize_t elmt_size, const hsize_t *size,
     HDassert(elmt_size<SIZET_MAX);
 
     if (n) {
-        H5V_vector_cpy(n, idx, size);
-        nelmts = H5V_vector_reduce_product(n, size);
+        H5VM_vector_cpy(n, idx, size);
+        nelmts = H5VM_vector_reduce_product(n, size);
         for (i=0; i<nelmts; i++) {
 
             /* Copy an element */
@@ -879,9 +879,9 @@ H5V_stride_copy_s(unsigned n, hsize_t elmt_size, const hsize_t *size,
 #ifdef LATER
 
 /*-------------------------------------------------------------------------
- * Function:	H5V_stride_copy2
+ * Function:	H5VM_stride_copy2
  *
- * Purpose:	Similar to H5V_stride_copy() except the source and
+ * Purpose:	Similar to H5VM_stride_copy() except the source and
  *		destination each have their own dimensionality and size and
  *		we copy exactly NELMTS elements each of size ELMT_SIZE.	 The
  *		size counters wrap if NELMTS is more than a size counter.
@@ -896,7 +896,7 @@ H5V_stride_copy_s(unsigned n, hsize_t elmt_size, const hsize_t *size,
  *-------------------------------------------------------------------------
  */
 static void
-H5V_stride_copy2(hsize_t nelmts, hsize_t elmt_size,
+H5VM_stride_copy2(hsize_t nelmts, hsize_t elmt_size,
 
 		 /* destination */
 		 unsigned dst_n, const hsize_t *dst_size,
@@ -910,8 +910,8 @@ H5V_stride_copy2(hsize_t nelmts, hsize_t elmt_size,
 {
     uint8_t	*dst = (uint8_t *) _dst;
     const uint8_t *src = (const uint8_t *) _src;
-    hsize_t	dst_idx[H5V_HYPER_NDIMS];
-    hsize_t	src_idx[H5V_HYPER_NDIMS];
+    hsize_t	dst_idx[H5VM_HYPER_NDIMS];
+    hsize_t	src_idx[H5VM_HYPER_NDIMS];
     hsize_t	i;              /* Local index variable */
     int		j;              /* Local index variable */
     hbool_t	carry;
@@ -922,8 +922,8 @@ H5V_stride_copy2(hsize_t nelmts, hsize_t elmt_size,
     HDassert(dst_n>0);
     HDassert(src_n>0);
 
-    H5V_vector_cpy(dst_n, dst_idx, dst_size);
-    H5V_vector_cpy(src_n, src_idx, src_size);
+    H5VM_vector_cpy(dst_n, dst_idx, dst_size);
+    H5VM_vector_cpy(src_n, src_idx, src_size);
 
     for (i=0; i<nelmts; i++) {
 
@@ -958,7 +958,7 @@ H5V_stride_copy2(hsize_t nelmts, hsize_t elmt_size,
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5V_array_fill
+ * Function:	H5VM_array_fill
  *
  * Purpose:	Fills all bytes of an array with the same value using
  *		memset(). Increases amount copied by power of two until the
@@ -974,7 +974,7 @@ H5V_stride_copy2(hsize_t nelmts, hsize_t elmt_size,
  *-------------------------------------------------------------------------
  */
 herr_t
-H5V_array_fill(void *_dst, const void *src, size_t size, size_t count)
+H5VM_array_fill(void *_dst, const void *src, size_t size, size_t count)
 {
     size_t      copy_size;          /* size of the buffer to copy	*/
     size_t      copy_items;         /* number of items currently copying*/
@@ -1010,11 +1010,11 @@ H5V_array_fill(void *_dst, const void *src, size_t size, size_t count)
         HDmemcpy(dst, _dst, items_left * size);
 
     FUNC_LEAVE_NOAPI(SUCCEED)
-}   /* H5V_array_fill() */
+}   /* H5VM_array_fill() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5V_array_down
+ * Function:	H5VM_array_down
  *
  * Purpose:	Given a set of dimension sizes, calculate the size of each
  *              "down" slice.  This is the size of the dimensions for all the
@@ -1031,14 +1031,14 @@ H5V_array_fill(void *_dst, const void *src, size_t size, size_t count)
  *-------------------------------------------------------------------------
  */
 herr_t
-H5V_array_down(unsigned n, const hsize_t *total_size, hsize_t *down)
+H5VM_array_down(unsigned n, const hsize_t *total_size, hsize_t *down)
 {
     hsize_t	acc;	                /*accumulator			*/
     int	        i;		        /*counter			*/
 
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
-    HDassert(n <= H5V_HYPER_NDIMS);
+    HDassert(n <= H5VM_HYPER_NDIMS);
     HDassert(total_size);
     HDassert(down);
 
@@ -1050,11 +1050,11 @@ H5V_array_down(unsigned n, const hsize_t *total_size, hsize_t *down)
     } /* end for */
 
     FUNC_LEAVE_NOAPI(SUCCEED)
-} /* end H5V_array_down() */
+} /* end H5VM_array_down() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5V_array_offset_pre
+ * Function:	H5VM_array_offset_pre
  *
  * Purpose:	Given a coordinate description of a location in an array, this
  *      function returns the byte offset of the coordinate.
@@ -1077,14 +1077,14 @@ H5V_array_down(unsigned n, const hsize_t *total_size, hsize_t *down)
  *-------------------------------------------------------------------------
  */
 hsize_t
-H5V_array_offset_pre(unsigned n, const hsize_t *acc, const hsize_t *offset)
+H5VM_array_offset_pre(unsigned n, const hsize_t *acc, const hsize_t *offset)
 {
     int             i;		/*counter				*/
     hsize_t	    ret_value;  /* Return value */
 
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
-    HDassert(n <= H5V_HYPER_NDIMS);
+    HDassert(n <= H5VM_HYPER_NDIMS);
     HDassert(acc);
     HDassert(offset);
 
@@ -1093,11 +1093,11 @@ H5V_array_offset_pre(unsigned n, const hsize_t *acc, const hsize_t *offset)
         ret_value += acc[i] * offset[i];
 
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5V_array_offset_pre() */
+} /* end H5VM_array_offset_pre() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5V_array_offset
+ * Function:	H5VM_array_offset
  *
  * Purpose:	Given a coordinate description of a location in an array, this
  *      function returns the byte offset of the coordinate.
@@ -1117,31 +1117,31 @@ H5V_array_offset_pre(unsigned n, const hsize_t *acc, const hsize_t *offset)
  *-------------------------------------------------------------------------
  */
 hsize_t
-H5V_array_offset(unsigned n, const hsize_t *total_size, const hsize_t *offset)
+H5VM_array_offset(unsigned n, const hsize_t *total_size, const hsize_t *offset)
 {
-    hsize_t	acc_arr[H5V_HYPER_NDIMS];	/* Accumulated size of down dimensions */
+    hsize_t	acc_arr[H5VM_HYPER_NDIMS];	/* Accumulated size of down dimensions */
     hsize_t	ret_value;  /* Return value */
 
     FUNC_ENTER_NOAPI((HDabort(), 0)) /*lint !e527 Don't worry about unreachable statement */
 
-    HDassert(n <= H5V_HYPER_NDIMS);
+    HDassert(n <= H5VM_HYPER_NDIMS);
     HDassert(total_size);
     HDassert(offset);
 
     /* Build the sizes of each dimension in the array */
-    if(H5V_array_down(n,total_size,acc_arr)<0)
+    if(H5VM_array_down(n,total_size,acc_arr)<0)
         HGOTO_ERROR(H5E_INTERNAL, H5E_BADVALUE, UFAIL, "can't compute down sizes")
 
     /* Set return value */
-    ret_value=H5V_array_offset_pre(n,acc_arr,offset);
+    ret_value=H5VM_array_offset_pre(n,acc_arr,offset);
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5V_array_offset() */
+} /* end H5VM_array_offset() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5V_array_calc_pre
+ * Function:	H5VM_array_calc_pre
  *
  * Purpose:	Given a linear offset in an array, the dimensions of that
  *              array and the pre-computed 'down' (accumulator) sizes, this
@@ -1159,7 +1159,7 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5V_array_calc_pre(hsize_t offset, unsigned n, const hsize_t *down,
+H5VM_array_calc_pre(hsize_t offset, unsigned n, const hsize_t *down,
     hsize_t *coords)
 {
     unsigned    u;                      /* Local index variable */
@@ -1167,7 +1167,7 @@ H5V_array_calc_pre(hsize_t offset, unsigned n, const hsize_t *down,
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
     /* Sanity check */
-    HDassert(n <= H5V_HYPER_NDIMS);
+    HDassert(n <= H5VM_HYPER_NDIMS);
     HDassert(coords);
 
     /* Compute the coordinates from the offset */
@@ -1177,11 +1177,11 @@ H5V_array_calc_pre(hsize_t offset, unsigned n, const hsize_t *down,
     } /* end for */
 
     FUNC_LEAVE_NOAPI(SUCCEED)
-} /* end H5V_array_calc_pre() */
+} /* end H5VM_array_calc_pre() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5V_array_calc
+ * Function:	H5VM_array_calc
  *
  * Purpose:	Given a linear offset in an array and the dimensions of that
  *              array, this function computes the coordinates of that offset
@@ -1201,33 +1201,33 @@ H5V_array_calc_pre(hsize_t offset, unsigned n, const hsize_t *down,
  *-------------------------------------------------------------------------
  */
 herr_t
-H5V_array_calc(hsize_t offset, unsigned n, const hsize_t *total_size, hsize_t *coords)
+H5VM_array_calc(hsize_t offset, unsigned n, const hsize_t *total_size, hsize_t *coords)
 {
-    hsize_t	idx[H5V_HYPER_NDIMS];	/* Size of each dimension in bytes */
+    hsize_t	idx[H5VM_HYPER_NDIMS];	/* Size of each dimension in bytes */
     herr_t      ret_value = SUCCEED;    /* Return value */
 
     FUNC_ENTER_NOAPI(FAIL)
 
     /* Sanity check */
-    HDassert(n <= H5V_HYPER_NDIMS);
+    HDassert(n <= H5VM_HYPER_NDIMS);
     HDassert(total_size);
     HDassert(coords);
 
     /* Build the sizes of each dimension in the array */
-    if(H5V_array_down(n, total_size, idx) < 0)
+    if(H5VM_array_down(n, total_size, idx) < 0)
         HGOTO_ERROR(H5E_INTERNAL, H5E_BADVALUE, FAIL, "can't compute down sizes")
 
     /* Compute the coordinates from the offset */
-    if(H5V_array_calc_pre(offset, n, idx, coords) < 0)
+    if(H5VM_array_calc_pre(offset, n, idx, coords) < 0)
         HGOTO_ERROR(H5E_INTERNAL, H5E_BADVALUE, FAIL, "can't compute coordinates")
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5V_array_calc() */
+} /* end H5VM_array_calc() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5V_chunk_index
+ * Function:	H5VM_chunk_index
  *
  * Purpose:	Given a coordinate offset (COORD), the size of each chunk
  *              (CHUNK), the number of chunks in each dimension (NCHUNKS)
@@ -1269,16 +1269,16 @@ done:
  *-------------------------------------------------------------------------
  */
 herr_t
-H5V_chunk_index(unsigned ndims, const hsize_t *coord, const uint32_t *chunk,
+H5VM_chunk_index(unsigned ndims, const hsize_t *coord, const uint32_t *chunk,
     const hsize_t *down_nchunks, hsize_t *chunk_idx)
 {
-    hsize_t	scaled_coord[H5V_HYPER_NDIMS];	/* Scaled, coordinates, in terms of chunks */
+    hsize_t	scaled_coord[H5VM_HYPER_NDIMS];	/* Scaled, coordinates, in terms of chunks */
     unsigned    u;                      /* Local index variable */
 
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
     /* Sanity check */
-    HDassert(ndims <= H5V_HYPER_NDIMS);
+    HDassert(ndims <= H5VM_HYPER_NDIMS);
     HDassert(coord);
     HDassert(chunk);
     HDassert(chunk_idx);
@@ -1288,14 +1288,14 @@ H5V_chunk_index(unsigned ndims, const hsize_t *coord, const uint32_t *chunk,
         scaled_coord[u]=coord[u]/chunk[u];
 
     /* Compute the chunk index */
-    *chunk_idx=H5V_array_offset_pre(ndims,down_nchunks,scaled_coord); /*lint !e772 scaled_coord will always be initialized */
+    *chunk_idx=H5VM_array_offset_pre(ndims,down_nchunks,scaled_coord); /*lint !e772 scaled_coord will always be initialized */
 
     FUNC_LEAVE_NOAPI(SUCCEED)
-} /* end H5V_chunk_index() */
+} /* end H5VM_chunk_index() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5V_opvv
+ * Function:	H5VM_opvv
  *
  * Purpose:	Perform an operation on a source & destination sequences
  *		of offset/length pairs.  Each set of sequnces has an array
@@ -1307,7 +1307,7 @@ H5V_chunk_index(unsigned ndims, const hsize_t *coord, const uint32_t *chunk,
  *              source or destination sequence runs out of information.
  *
  * Note:	The algorithm in this routine is [basically] the same as for
- *		H5V_memcpyvv().  Changes should be made to both!
+ *		H5VM_memcpyvv().  Changes should be made to both!
  *
  * Return:	Non-negative # of bytes operated on, on success/Negative on failure
  *
@@ -1317,11 +1317,11 @@ H5V_chunk_index(unsigned ndims, const hsize_t *coord, const uint32_t *chunk,
  *-------------------------------------------------------------------------
  */
 ssize_t
-H5V_opvv(size_t dst_max_nseq, size_t *dst_curr_seq, size_t dst_len_arr[],
+H5VM_opvv(size_t dst_max_nseq, size_t *dst_curr_seq, size_t dst_len_arr[],
     hsize_t dst_off_arr[],
     size_t src_max_nseq, size_t *src_curr_seq, size_t src_len_arr[],
     hsize_t src_off_arr[],
-    H5V_opvv_func_t op, void *op_data)
+    H5VM_opvv_func_t op, void *op_data)
 {
     hsize_t *max_dst_off_ptr, *max_src_off_ptr;  /* Pointers to max. source and destination offset locations */
     hsize_t *dst_off_ptr, *src_off_ptr; /* Pointers to source and destination offset arrays */
@@ -1497,11 +1497,11 @@ finished:
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5V_opvv() */
+} /* end H5VM_opvv() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5V_memcpyvv
+ * Function:	H5VM_memcpyvv
  *
  * Purpose:	Given source and destination buffers in memory (SRC & DST)
  *              copy sequences of from the source buffer into the destination
@@ -1514,7 +1514,7 @@ done:
  *              source or destination buffer runs out of sequence information.
  *
  * Note:	The algorithm in this routine is [basically] the same as for
- *		H5V_opvv().  Changes should be made to both!
+ *		H5VM_opvv().  Changes should be made to both!
  *
  * Return:	Non-negative # of bytes copied on success/Negative on failure
  *
@@ -1524,7 +1524,7 @@ done:
  *-------------------------------------------------------------------------
  */
 ssize_t
-H5V_memcpyvv(void *_dst,
+H5VM_memcpyvv(void *_dst,
     size_t dst_max_nseq, size_t *dst_curr_seq, size_t dst_len_arr[], hsize_t dst_off_arr[],
     const void *_src,
     size_t src_max_nseq, size_t *src_curr_seq, size_t src_len_arr[], hsize_t src_off_arr[])
@@ -1708,5 +1708,5 @@ finished:
     *src_curr_seq = (size_t)(src_off_ptr - src_off_arr);
 
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5V_memcpyvv() */
+} /* end H5VM_memcpyvv() */
 
diff --git a/src/H5Vprivate.h b/src/H5VMprivate.h
index 2692824..4706b5f 100644
--- a/src/H5Vprivate.h
+++ b/src/H5VMprivate.h
@@ -17,93 +17,93 @@
  * Programmer: Robb Matzke <matzke@llnl.gov>
  *             Friday, October 10, 1997
  */
-#ifndef H5Vprivate_H
-#define H5Vprivate_H
+#ifndef H5VMprivate_H
+#define H5VMprivate_H
 
 /* Private headers needed by this file */
 #include "H5private.h"		/* Generic Functions			*/
 #include "H5Eprivate.h"		/* Error handling		  	*/
 
 /* Vector-Vector sequence operation callback */
-typedef herr_t (*H5V_opvv_func_t)(hsize_t dst_off, hsize_t src_off,
+typedef herr_t (*H5VM_opvv_func_t)(hsize_t dst_off, hsize_t src_off,
     size_t len, void *udata);
 
 /* Vector comparison functions like Fortran66 comparison operators */
-#define H5V_vector_eq_s(N,V1,V2) (H5V_vector_cmp_s (N, V1, V2)==0)
-#define H5V_vector_lt_s(N,V1,V2) (H5V_vector_cmp_s (N, V1, V2)<0)
-#define H5V_vector_gt_s(N,V1,V2) (H5V_vector_cmp_s (N, V1, V2)>0)
-#define H5V_vector_le_s(N,V1,V2) (H5V_vector_cmp_s (N, V1, V2)<=0)
-#define H5V_vector_ge_s(N,V1,V2) (H5V_vector_cmp_s (N, V1, V2)>=0)
-#define H5V_vector_eq_u(N,V1,V2) (H5V_vector_cmp_u (N, V1, V2)==0)
-#define H5V_vector_lt_u(N,V1,V2) (H5V_vector_cmp_u (N, V1, V2)<0)
-#define H5V_vector_gt_u(N,V1,V2) (H5V_vector_cmp_u (N, V1, V2)>0)
-#define H5V_vector_le_u(N,V1,V2) (H5V_vector_cmp_u (N, V1, V2)<=0)
-#define H5V_vector_ge_u(N,V1,V2) (H5V_vector_cmp_u (N, V1, V2)>=0)
+#define H5VM_vector_eq_s(N,V1,V2) (H5VM_vector_cmp_s (N, V1, V2)==0)
+#define H5VM_vector_lt_s(N,V1,V2) (H5VM_vector_cmp_s (N, V1, V2)<0)
+#define H5VM_vector_gt_s(N,V1,V2) (H5VM_vector_cmp_s (N, V1, V2)>0)
+#define H5VM_vector_le_s(N,V1,V2) (H5VM_vector_cmp_s (N, V1, V2)<=0)
+#define H5VM_vector_ge_s(N,V1,V2) (H5VM_vector_cmp_s (N, V1, V2)>=0)
+#define H5VM_vector_eq_u(N,V1,V2) (H5VM_vector_cmp_u (N, V1, V2)==0)
+#define H5VM_vector_lt_u(N,V1,V2) (H5VM_vector_cmp_u (N, V1, V2)<0)
+#define H5VM_vector_gt_u(N,V1,V2) (H5VM_vector_cmp_u (N, V1, V2)>0)
+#define H5VM_vector_le_u(N,V1,V2) (H5VM_vector_cmp_u (N, V1, V2)<=0)
+#define H5VM_vector_ge_u(N,V1,V2) (H5VM_vector_cmp_u (N, V1, V2)>=0)
 
 /* Other functions */
-#define H5V_vector_cpy(N,DST,SRC) {                                           \
+#define H5VM_vector_cpy(N,DST,SRC) {                                           \
     HDassert(sizeof(*(DST))==sizeof(*(SRC)));				                  \
     if (SRC) HDmemcpy (DST, SRC, (N)*sizeof(*(DST)));                         \
     else HDmemset (DST, 0, (N)*sizeof(*(DST)));                               \
 }
 
-#define H5V_vector_zero(N,DST) HDmemset(DST,0,(N)*sizeof(*(DST)))
+#define H5VM_vector_zero(N,DST) HDmemset(DST,0,(N)*sizeof(*(DST)))
 
 /* A null pointer is equivalent to a zero vector */
-#define H5V_ZERO        NULL
+#define H5VM_ZERO        NULL
 
-H5_DLL hsize_t H5V_hyper_stride(unsigned n, const hsize_t *size,
+H5_DLL hsize_t H5VM_hyper_stride(unsigned n, const hsize_t *size,
 				 const hsize_t *total_size,
 				 const hsize_t *offset,
 				 hsize_t *stride);
-H5_DLL htri_t H5V_hyper_disjointp(unsigned n, const hsize_t *offset1,
+H5_DLL htri_t H5VM_hyper_disjointp(unsigned n, const hsize_t *offset1,
     const uint32_t *size1, const hsize_t *offset2, const uint32_t *size2);
-H5_DLL htri_t H5V_hyper_eq(unsigned n, const hsize_t *offset1,
+H5_DLL htri_t H5VM_hyper_eq(unsigned n, const hsize_t *offset1,
 			    const hsize_t *size1, const hsize_t *offset2,
 			    const hsize_t *size2);
-H5_DLL herr_t H5V_hyper_fill(unsigned n, const hsize_t *_size,
+H5_DLL herr_t H5VM_hyper_fill(unsigned n, const hsize_t *_size,
 			      const hsize_t *total_size,
 			      const hsize_t *offset, void *_dst,
 			      unsigned fill_value);
-H5_DLL herr_t H5V_hyper_copy(unsigned n, const hsize_t *size,
+H5_DLL herr_t H5VM_hyper_copy(unsigned n, const hsize_t *size,
 			      const hsize_t *dst_total_size,
 			      const hsize_t *dst_offset, void *_dst,
 			      const hsize_t *src_total_size,
 			      const hsize_t *src_offset, const void *_src);
-H5_DLL herr_t H5V_stride_fill(unsigned n, hsize_t elmt_size, const hsize_t *size,
+H5_DLL herr_t H5VM_stride_fill(unsigned n, hsize_t elmt_size, const hsize_t *size,
 			       const hsize_t *stride, void *_dst,
 			       unsigned fill_value);
-H5_DLL herr_t H5V_stride_copy(unsigned n, hsize_t elmt_size, const hsize_t *_size,
+H5_DLL herr_t H5VM_stride_copy(unsigned n, hsize_t elmt_size, const hsize_t *_size,
 			       const hsize_t *dst_stride, void *_dst,
 			       const hsize_t *src_stride, const void *_src);
-H5_DLL herr_t H5V_stride_copy_s(unsigned n, hsize_t elmt_size, const hsize_t *_size,
+H5_DLL herr_t H5VM_stride_copy_s(unsigned n, hsize_t elmt_size, const hsize_t *_size,
 			       const hssize_t *dst_stride, void *_dst,
 			       const hssize_t *src_stride, const void *_src);
-H5_DLL herr_t H5V_array_fill(void *_dst, const void *src, size_t size,
+H5_DLL herr_t H5VM_array_fill(void *_dst, const void *src, size_t size,
 			      size_t count);
-H5_DLL herr_t H5V_array_down(unsigned n, const hsize_t *total_size,
+H5_DLL herr_t H5VM_array_down(unsigned n, const hsize_t *total_size,
     hsize_t *down);
-H5_DLL hsize_t H5V_array_offset_pre(unsigned n,
+H5_DLL hsize_t H5VM_array_offset_pre(unsigned n,
     const hsize_t *acc, const hsize_t *offset);
-H5_DLL hsize_t H5V_array_offset(unsigned n, const hsize_t *total_size,
+H5_DLL hsize_t H5VM_array_offset(unsigned n, const hsize_t *total_size,
     const hsize_t *offset);
-H5_DLL herr_t H5V_array_calc(hsize_t offset, unsigned n,
+H5_DLL herr_t H5VM_array_calc(hsize_t offset, unsigned n,
     const hsize_t *total_size, hsize_t *coords);
-H5_DLL herr_t H5V_chunk_index(unsigned ndims, const hsize_t *coord,
+H5_DLL herr_t H5VM_chunk_index(unsigned ndims, const hsize_t *coord,
     const uint32_t *chunk, const hsize_t *down_nchunks, hsize_t *chunk_idx);
-H5_DLL ssize_t H5V_opvv(size_t dst_max_nseq, size_t *dst_curr_seq, size_t dst_len_arr[],
+H5_DLL ssize_t H5VM_opvv(size_t dst_max_nseq, size_t *dst_curr_seq, size_t dst_len_arr[],
     hsize_t dst_off_arr[],
     size_t src_max_nseq, size_t *src_curr_seq, size_t src_len_arr[],
     hsize_t src_off_arr[],
-    H5V_opvv_func_t op, void *op_data);
-H5_DLL ssize_t H5V_memcpyvv(void *_dst,
+    H5VM_opvv_func_t op, void *op_data);
+H5_DLL ssize_t H5VM_memcpyvv(void *_dst,
     size_t dst_max_nseq, size_t *dst_curr_seq, size_t dst_len_arr[], hsize_t dst_off_arr[],
     const void *_src,
     size_t src_max_nseq, size_t *src_curr_seq, size_t src_len_arr[], hsize_t src_off_arr[]);
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5V_vector_reduce_product
+ * Function:    H5VM_vector_reduce_product
  *
  * Purpose:     Product reduction of a vector.  Vector elements and return
  *              value are size_t because we usually want the number of
@@ -122,7 +122,7 @@ H5_DLL ssize_t H5V_memcpyvv(void *_dst,
  *-------------------------------------------------------------------------
  */
 static H5_inline hsize_t UNUSED
-H5V_vector_reduce_product(unsigned n, const hsize_t *v)
+H5VM_vector_reduce_product(unsigned n, const hsize_t *v)
 {
     hsize_t                  ret_value = 1;
 
@@ -137,7 +137,7 @@ done:
 }
 
 /*-------------------------------------------------------------------------
- * Function:    H5V_vector_zerop_u
+ * Function:    H5VM_vector_zerop_u
  *
  * Purpose:     Determines if all elements of a vector are zero.
  *
@@ -154,7 +154,7 @@ done:
  *-------------------------------------------------------------------------
  */
 static H5_inline htri_t UNUSED
-H5V_vector_zerop_u(int n, const hsize_t *v)
+H5VM_vector_zerop_u(int n, const hsize_t *v)
 {
     htri_t      ret_value=TRUE;       /* Return value */
 
@@ -172,7 +172,7 @@ done:
 }
 
 /*-------------------------------------------------------------------------
- * Function:    H5V_vector_zerop_s
+ * Function:    H5VM_vector_zerop_s
  *
  * Purpose:     Determines if all elements of a vector are zero.
  *
@@ -189,7 +189,7 @@ done:
  *-------------------------------------------------------------------------
  */
 static H5_inline htri_t UNUSED
-H5V_vector_zerop_s(int n, const hssize_t *v)
+H5VM_vector_zerop_s(int n, const hssize_t *v)
 {
     htri_t      ret_value=TRUE;       /* Return value */
 
@@ -207,7 +207,7 @@ done:
 }
 
 /*-------------------------------------------------------------------------
- * Function:    H5V_vector_cmp_u
+ * Function:    H5VM_vector_cmp_u
  *
  * Purpose:     Compares two vectors of the same size and determines if V1 is
  *              lexicographically less than, equal, or greater than V2.
@@ -226,7 +226,7 @@ done:
  *-------------------------------------------------------------------------
  */
 static H5_inline int UNUSED
-H5V_vector_cmp_u (unsigned n, const hsize_t *v1, const hsize_t *v2)
+H5VM_vector_cmp_u (unsigned n, const hsize_t *v1, const hsize_t *v2)
 {
     int ret_value=0;    /* Return value */
 
@@ -249,7 +249,7 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5V_vector_cmp_s
+ * Function:	H5VM_vector_cmp_s
  *
  * Purpose:     Compares two vectors of the same size and determines if V1 is
  *              lexicographically less than, equal, or greater than V2.
@@ -268,7 +268,7 @@ done:
  *-------------------------------------------------------------------------
  */
 static H5_inline int UNUSED
-H5V_vector_cmp_s (unsigned n, const hssize_t *v1, const hssize_t *v2)
+H5VM_vector_cmp_s (unsigned n, const hssize_t *v1, const hssize_t *v2)
 {
     int ret_value=0;    /* Return value */
 
@@ -291,7 +291,7 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5V_vector_inc
+ * Function:    H5VM_vector_inc
  *
  * Purpose:     Increments V1 by V2
  *
@@ -305,7 +305,7 @@ done:
  *-------------------------------------------------------------------------
  */
 static H5_inline void UNUSED
-H5V_vector_inc(int n, hsize_t *v1, const hsize_t *v2)
+H5VM_vector_inc(int n, hsize_t *v1, const hsize_t *v2)
 {
     while (n--) *v1++ += *v2++;
 }
@@ -333,7 +333,7 @@ static const unsigned char LogTable256[] =
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5V_log2_gen
+ * Function:    H5VM_log2_gen
  *
  * Purpose:     Determines the log base two of a number (i.e. log2(n)).
  *              (i.e. the highest bit set in a number)
@@ -352,7 +352,7 @@ static const unsigned char LogTable256[] =
  *-------------------------------------------------------------------------
  */
 static H5_inline unsigned UNUSED
-H5V_log2_gen(uint64_t n)
+H5VM_log2_gen(uint64_t n)
 {
     unsigned r;                         /* r will be log2(n) */
     register unsigned int t, tt, ttt;   /* temporaries */
@@ -379,7 +379,7 @@ H5V_log2_gen(uint64_t n)
 #endif /* H5_BAD_LOG2_CODE_GENERATED  */
 
     return(r);
-} /* H5V_log2_gen() */
+} /* H5VM_log2_gen() */
 
 
 /* Lookup table for specialized log2(n) of power of two routine */
@@ -391,7 +391,7 @@ static const unsigned MultiplyDeBruijnBitPosition[32] =
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5V_log2_of2
+ * Function:    H5VM_log2_of2
  *
  * Purpose:     Determines the log base two of a number (i.e. log2(n)).
  *              (i.e. the highest bit set in a number)
@@ -409,17 +409,17 @@ static const unsigned MultiplyDeBruijnBitPosition[32] =
  *-------------------------------------------------------------------------
  */
 static H5_inline unsigned UNUSED
-H5V_log2_of2(uint32_t n)
+H5VM_log2_of2(uint32_t n)
 {
 #ifndef NDEBUG
     HDassert(POWER_OF_TWO(n));
 #endif /* NDEBUG */
     return(MultiplyDeBruijnBitPosition[(n * (uint32_t)0x077CB531UL) >> 27]);
-} /* H5V_log2_of2() */
+} /* H5VM_log2_of2() */
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5V_limit_enc_size
+ * Function:    H5VM_limit_enc_size
  *
  * Purpose:     Determine the # of bytes needed to encode values within a
  *              range from 0 to a given limit
@@ -432,10 +432,70 @@ H5V_log2_of2(uint32_t n)
  *-------------------------------------------------------------------------
  */
 static H5_inline unsigned UNUSED
-H5V_limit_enc_size(uint64_t limit)
+H5VM_limit_enc_size(uint64_t limit)
 {
-    return (H5V_log2_gen(limit) / 8) + 1;
-} /* end H5V_limit_enc_size() */
+    return (H5VM_log2_gen(limit) / 8) + 1;
+} /* end H5VM_limit_enc_size() */
 
-#endif /* H5Vprivate_H */
+static const unsigned char H5VM_bit_set_g[8] = {0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01};
+static const unsigned char H5VM_bit_clear_g[8] = {0x7F, 0xBF, 0xDF, 0xEF, 0xF7, 0xFB, 0xFD, 0xFE};
+
+
+/*-------------------------------------------------------------------------
+ * Function:    H5VM_bit_get
+ *
+ * Purpose:     Determine the value of the n'th bit in a buffer.
+ *
+ * Note:	No range checking on <offset> is performed!
+ *
+ * Note #2:	Bits are sequentially stored in the buffer, starting with bit
+ *              offset 0 in the first byte's high-bit position, proceeding down
+ *              to bit offset 7 in the first byte's low-bit position, then to
+ *              bit offset 8 in the second byte's high-bit position, etc.
+ *
+ * Return:      TRUE/FALSE
+ *
+ * Programmer:  Quincey Koziol
+ *              Tuesday, November 25, 2008
+ *
+ *-------------------------------------------------------------------------
+ */
+static H5_inline hbool_t UNUSED
+H5VM_bit_get(const unsigned char *buf, size_t offset)
+{
+    /* Test the appropriate bit in the buffer */
+    return (hbool_t)((buf[offset / 8] & (H5VM_bit_set_g[offset % 8])) ? TRUE : FALSE);
+} /* end H5VM_bit_get() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:    H5VM_bit_set
+ *
+ * Purpose:     Set/reset the n'th bit in a buffer.
+ *
+ * Note:	No range checking on <offset> is performed!
+ *
+ * Note #2:	Bits are sequentially stored in the buffer, starting with bit
+ *              offset 0 in the first byte's high-bit position, proceeding down
+ *              to bit offset 7 in the first byte's low-bit position, then to
+ *              bit offset 8 in the second byte's high-bit position, etc.
+ *
+ * Return:      None
+ *
+ * Programmer:  Quincey Koziol
+ *              Tuesday, November 25, 2008
+ *
+ *-------------------------------------------------------------------------
+ */
+static H5_inline void UNUSED
+H5VM_bit_set(unsigned char *buf, size_t offset, hbool_t val)
+{
+    /* Set/reset the appropriate bit in the buffer */
+    if(val)
+        buf[offset / 8] |= H5VM_bit_set_g[offset % 8];
+    else
+        buf[offset / 8] &= H5VM_bit_clear_g[offset % 8];
+} /* end H5VM_bit_set() */
+
+#endif /* H5VMprivate_H */
 
diff --git a/src/H5Ztrans.c b/src/H5Ztrans.c
index f9e7186..1b8c096 100644
--- a/src/H5Ztrans.c
+++ b/src/H5Ztrans.c
@@ -20,7 +20,7 @@
 #include "H5Eprivate.h"		/* Error handling		  	*/
 #include "H5Iprivate.h"		/* IDs			  		*/
 #include "H5MMprivate.h"	/* Memory management			*/
-#include "H5Vprivate.h"		/* H5V_array_fill			*/
+#include "H5VMprivate.h"		/* H5VM_array_fill			*/
 #include "H5Zpkg.h"		/* Data filters				*/
 
 
@@ -292,7 +292,7 @@ static void H5Z_print(H5Z_node *tree, FILE *stream);
 #define H5Z_XFORM_DO_OP5(TYPE, SIZE)                                                               \
 {                                                                                                  \
     TYPE val = ((tree->type == H5Z_XFORM_INTEGER) ? (TYPE)tree->value.int_val : (TYPE)tree->value.float_val); \
-    H5V_array_fill(array, &val, sizeof(TYPE), (SIZE));                                             \
+    H5VM_array_fill(array, &val, sizeof(TYPE), (SIZE));                                             \
 }
 
 /* The difference of this macro from H5Z_XFORM_DO_OP3 is that it handles the operations when the left operand is empty, like -x or +x.  
diff --git a/src/Makefile.am b/src/Makefile.am
index c26eba7..e7c1968 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -99,7 +99,7 @@ libhdf5_la_SOURCES= H5.c H5checksum.c H5dbg.c H5system.c H5timer.c H5trace.c \
         H5Tfloat.c H5Tinit.c H5Tnative.c H5Toffset.c H5Toh.c \
         H5Topaque.c \
         H5Torder.c \
-        H5Tpad.c H5Tprecis.c H5Tstrpad.c H5Tvisit.c H5Tvlen.c H5TS.c H5V.c H5WB.c H5Z.c  \
+        H5Tpad.c H5Tprecis.c H5Tstrpad.c H5Tvisit.c H5Tvlen.c H5TS.c H5VM.c H5WB.c H5Z.c  \
         H5Zdeflate.c H5Zfletcher32.c H5Znbit.c H5Zshuffle.c H5Zszip.c  \
         H5Zscaleoffset.c H5Ztrans.c
 
diff --git a/src/Makefile.in b/src/Makefile.in
index 85026a3..cd117d8 100644
--- a/src/Makefile.in
+++ b/src/Makefile.in
@@ -164,7 +164,7 @@ am_libhdf5_la_OBJECTS = H5.lo H5checksum.lo H5dbg.lo H5system.lo \
 	H5Tfields.lo H5Tfixed.lo H5Tfloat.lo H5Tinit.lo H5Tnative.lo \
 	H5Toffset.lo H5Toh.lo H5Topaque.lo H5Torder.lo H5Tpad.lo \
 	H5Tprecis.lo H5Tstrpad.lo H5Tvisit.lo H5Tvlen.lo H5TS.lo \
-	H5V.lo H5WB.lo H5Z.lo H5Zdeflate.lo H5Zfletcher32.lo \
+	H5VM.lo H5WB.lo H5Z.lo H5Zdeflate.lo H5Zfletcher32.lo \
 	H5Znbit.lo H5Zshuffle.lo H5Zszip.lo H5Zscaleoffset.lo \
 	H5Ztrans.lo
 libhdf5_la_OBJECTS = $(am_libhdf5_la_OBJECTS)
@@ -588,7 +588,7 @@ libhdf5_la_SOURCES = H5.c H5checksum.c H5dbg.c H5system.c H5timer.c H5trace.c \
         H5Tfloat.c H5Tinit.c H5Tnative.c H5Toffset.c H5Toh.c \
         H5Topaque.c \
         H5Torder.c \
-        H5Tpad.c H5Tprecis.c H5Tstrpad.c H5Tvisit.c H5Tvlen.c H5TS.c H5V.c H5WB.c H5Z.c  \
+        H5Tpad.c H5Tprecis.c H5Tstrpad.c H5Tvisit.c H5Tvlen.c H5TS.c H5VM.c H5WB.c H5Z.c  \
         H5Zdeflate.c H5Zfletcher32.c H5Znbit.c H5Zshuffle.c H5Zszip.c  \
         H5Zscaleoffset.c H5Ztrans.c
 
@@ -965,7 +965,7 @@ distclean-compile:
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5Tstrpad.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5Tvisit.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5Tvlen.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5V.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5VM.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5WB.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5Z.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5Zdeflate.Plo@am__quote@
diff --git a/src/hdf5.lnt b/src/hdf5.lnt
index 1d02039..28d8807 100644
--- a/src/hdf5.lnt
+++ b/src/hdf5.lnt
@@ -1,9 +1,9 @@
 // Lint options shared by both PC-Lint for Windows and Flexelint for Linux
 
 // Turn off warnings about not using the inlined H5V* functions:
--esym(528, H5V_vector_reduce_product, H5V_vector_inc)
--esym(528, H5V_vector_cmp, H5V_vector_cmp_s, H5V_vector_cmp_u)
--esym(528, H5V_vector_zerop_s, H5V_vector_zerop_u)
+-esym(528, H5VM_vector_reduce_product, H5VM_vector_inc)
+-esym(528, H5VM_vector_cmp, H5VM_vector_cmp_s, H5VM_vector_cmp_u)
+-esym(528, H5VM_vector_zerop_s, H5VM_vector_zerop_u)
 
 // Suppress message about using 'goto' in a few functions
 -efunc(801,H5_term_library,H5_trace)
@@ -34,7 +34,7 @@
 -esym(534, H5I_clear_type, H5I_dec_type_ref)
 -esym(534, H5MM_xfree)
 -esym(534, H5RC_decr)
--esym(534, H5V_array_fill)
+-esym(534, H5VM_array_fill)
 
 
 // Turn off warnings about "Expression-like macro not parenthesized" for