[svn-r13883] Description:

    Fixed bugs w/VL-datatype fill values for chunked dataset storage.

Tested on:
    Mac OS X/32 10.4.9 (amazon)
    FreeBSD/32 6.2 (duty)
    FreeBSD/64 6.2 (liberty)
    Linux/32 2.6 (chicago)
    Linux/64 2.6 (chicago2)

2 files changed, 634 insertions, 349 deletions

diff --git a/src/H5Distore.c b/src/H5Distore.c
index 0807a76..3246467 100644
--- a/src/H5Distore.c
+++ b/src/H5Distore.c
@@ -1843,13 +1843,101 @@ H5D_istore_lock(const H5D_io_info_t *io_info, H5D_istore_ud1_t *udata,
 
             if(fill->fill_time == H5D_FILL_TIME_ALLOC ||
                     (fill->fill_time == H5D_FILL_TIME_IFSET && fill_status == H5D_FILL_VALUE_USER_DEFINED)) {
+                /*
+                 * The chunk doesn't exist in the file.  Replicate the fill
+                 * value throughout the chunk, if the fill value is defined.
+                 */
                 if(fill->buf) {
-                    /*
-                     * The chunk doesn't exist in the file.  Replicate the fill
-                     * value throughout the chunk.
-                     */
-                    HDassert(0 == (chunk_size % (size_t)fill->size));
-                    H5V_array_fill(chunk, fill->buf, (size_t)fill->size, chunk_size / fill->size);
+                    size_t elmts_per_chunk;             /* # of elements per chunk */
+
+                    /* Sanity check */
+                    HDassert(0 == (chunk_size % fill->size));
+                    elmts_per_chunk = chunk_size / fill->size;
+
+                    /* If necessary, convert fill value datatypes (which copies VL components, etc.) */
+                    if(H5T_detect_class(dset->shared->type, H5T_VLEN) > 0) {
+                        H5T_path_t *tpath;      /* Datatype conversion path */
+                        uint8_t *bkg_buf = NULL;    /* Background conversion buffer */
+                        H5T_t *mem_type;            /* Pointer to memory datatype */
+                        size_t mem_type_size, file_type_size;       /* Size of datatype in memory and on disk */
+                        hid_t mem_tid;              /* Memory version of disk datatype */
+
+                        /* Create temporary datatype for conversion operation */
+                        if(NULL == (mem_type = H5T_copy(dset->shared->type, H5T_COPY_REOPEN)))
+                            HGOTO_ERROR(H5E_DATATYPE, H5E_CANTCOPY, NULL, "unable to copy file datatype")
+                        if((mem_tid = H5I_register(H5I_DATATYPE, mem_type)) < 0) {
+                            H5T_close(mem_type);
+                            HGOTO_ERROR(H5E_DATATYPE, H5E_CANTREGISTER, NULL, "unable to register memory datatype")
+                        } /* end if */
+
+                        /* Retrieve sizes of memory & file datatypes */
+                        mem_type_size = H5T_get_size(mem_type);
+                        HDassert(mem_type_size > 0);
+                        file_type_size = H5T_get_size(dset->shared->type);
+                        HDassert(file_type_size == (size_t)fill->size);
+
+                        /* Get the datatype conversion path for this operation */
+                        if(NULL == (tpath = H5T_path_find(dset->shared->type, mem_type, NULL, NULL, io_info->dxpl_id, FALSE))) {
+                            H5I_dec_ref(mem_tid);
+                            HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, NULL, "unable to convert between src and dst datatypes")
+                        } /* end if */
+
+                        /* Allocate a background buffer, if necessary */
+                        if(H5T_path_bkg(tpath) && NULL == (bkg_buf = H5FL_BLK_CALLOC(type_conv, (elmts_per_chunk * MAX(mem_type_size, file_type_size))))) {
+                            H5I_dec_ref(mem_tid);
+                            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed")
+                        } /* end if */
+
+                        /* Make a copy of the (disk-based) fill value into the chunk buffer */
+                        HDmemcpy(chunk, fill->buf, file_type_size);
+
+                        /* Type convert the chunk buffer, to copy any VL components */
+                        if(H5T_convert(tpath, dset->shared->type_id, mem_tid, (size_t)1, (size_t)0, (size_t)0, chunk, bkg_buf, io_info->dxpl_id) < 0) {
+                            if(bkg_buf)
+                                H5FL_BLK_FREE(type_conv, bkg_buf);
+                            H5I_dec_ref(mem_tid);
+                            HGOTO_ERROR(H5E_DATASET, H5E_CANTCONVERT, NULL, "data type conversion failed")
+                        } /* end if */
+
+                        /* Replicate the fill value into the cached buffer */
+                        H5V_array_fill(chunk, chunk, mem_type_size, elmts_per_chunk);
+
+                        /* Get the inverse datatype conversion path for this operation */
+                        if(NULL == (tpath = H5T_path_find(mem_type, dset->shared->type, NULL, NULL, io_info->dxpl_id, FALSE))) {
+                            if(bkg_buf)
+                                H5FL_BLK_FREE(type_conv, bkg_buf);
+                            H5I_dec_ref(mem_tid);
+                            HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, NULL, "unable to convert between src and dst datatypes")
+                        } /* end if */
+
+                        /* Allocate or reset the background buffer, if necessary */
+                        if(H5T_path_bkg(tpath)) {
+                            if(bkg_buf)
+                                HDmemset(bkg_buf, 0, MAX(mem_type_size, file_type_size));
+                            else {
+                                if(NULL == (bkg_buf = H5FL_BLK_CALLOC(type_conv, (elmts_per_chunk * MAX(mem_type_size, file_type_size))))) {
+                                    H5I_dec_ref(mem_tid);
+                                    HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed")
+                                } /* end if */
+                            } /* end else */
+                        } /* end if */
+
+                        /* Type convert the chunk buffer, to copy any VL components */
+                        if(H5T_convert(tpath, mem_tid, dset->shared->type_id, elmts_per_chunk, (size_t)0, (size_t)0, chunk, bkg_buf, io_info->dxpl_id) < 0) {
+                            if(bkg_buf)
+                                H5FL_BLK_FREE(type_conv, bkg_buf);
+                            H5I_dec_ref(mem_tid);
+                            HGOTO_ERROR(H5E_DATASET, H5E_CANTCONVERT, NULL, "data type conversion failed")
+                        } /* end if */
+
+                        /* Release resources used */
+                        if(bkg_buf)
+                            H5FL_BLK_FREE(type_conv, bkg_buf);
+                        H5I_dec_ref(mem_tid);
+                    } /* end if */
+                    else 
+                        /* Replicate the [non-VL] fill value into chunk */
+                        H5V_array_fill(chunk, fill->buf, (size_t)fill->size, elmts_per_chunk);
                 } /* end if */
                 else {
                     /*
@@ -2715,13 +2803,14 @@ H5D_istore_allocate(H5D_t *dset, hid_t dxpl_id, hbool_t full_overwrite)
     H5D_io_info_t io_info;      /* Dataset I/O info */
     H5D_storage_t store;        /* Dataset storage information */
     hsize_t	chunk_offset[H5O_LAYOUT_NDIMS]; /* Offset of current chunk */
-    hsize_t	chunk_size;     /* Size of chunk in bytes */
-    unsigned filter_mask = 0;     /* Filter mask for chunks that have them */
+    size_t      elmts_per_chunk; /* # of elements which fit in a chunk */
+    size_t	orig_chunk_size; /* Original size of chunk in bytes */
+    unsigned    filter_mask = 0; /* Filter mask for chunks that have them */
     const H5O_pline_t *pline = &(dset->shared->dcpl_cache.pline);    /* I/O pipeline info */
     const H5O_fill_t *fill = &(dset->shared->dcpl_cache.fill);    /* Fill value info */
     H5D_fill_value_t fill_status; /* The fill value status */
-    hbool_t   should_fill = FALSE; /* Whether fill values should be written */
-    void *chunk = NULL;           /* Chunk buffer for writing fill values */
+    hbool_t     should_fill = FALSE; /* Whether fill values should be written */
+    void        *chunk = NULL;  /* Chunk buffer for writing fill values */
     H5D_dxpl_cache_t _dxpl_cache;       /* Data transfer property cache buffer */
     H5D_dxpl_cache_t *dxpl_cache = &_dxpl_cache;   /* Data transfer property cache */
 #ifdef H5_HAVE_PARALLEL
@@ -2734,8 +2823,15 @@ H5D_istore_allocate(H5D_t *dset, hid_t dxpl_id, hbool_t full_overwrite)
     hbool_t	carry;          /* Flag to indicate that chunk increment carrys to higher dimension (sorta) */
     int         space_ndims;    /* Dataset's space rank */
     hsize_t     space_dim[H5O_LAYOUT_NDIMS];    /* Dataset's dataspace dimensions */
-    int		i;              /* Local index variable */
-    unsigned	u;              /* Local index variable */
+    H5T_path_t *fill_to_mem_tpath;      /* Datatype conversion path for converting the fill value to the memory buffer */
+    H5T_path_t *mem_to_dset_tpath;      /* Datatype conversion path for converting the memory buffer to the dataset elements */
+    uint8_t    *bkg_buf = NULL;         /* Background conversion buffer */
+    H5T_t      *mem_type = NULL;        /* Pointer to memory datatype */
+    size_t      mem_type_size, file_type_size;       /* Size of datatype in memory and on disk */
+    size_t      elmt_size;              /* Size of each element */
+    hid_t       mem_tid = (-1);         /* Memory version of disk datatype */
+    size_t      bkg_buf_size;           /* Size of background buffer */
+    hbool_t     has_vlen_fill_type = FALSE;  /* Whether the datatype for the fill value has a variable-length component */
     herr_t	ret_value = SUCCEED;	/* Return value */
 
     FUNC_ENTER_NOAPI(H5D_istore_allocate, FAIL)
@@ -2746,9 +2842,9 @@ H5D_istore_allocate(H5D_t *dset, hid_t dxpl_id, hbool_t full_overwrite)
     HDassert(H5F_addr_defined(dset->shared->layout.u.chunk.addr));
     HDassert(TRUE == H5P_isa_class(dxpl_id, H5P_DATASET_XFER));
 
-    /* We only handle simple data spaces so far */
+    /* Retrieve the dataset dimensions */
     if((space_ndims = H5S_get_simple_extent_dims(dset->shared->space, space_dim, NULL)) < 0)
-         HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to get simple data space info")
+         HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to get simple dataspace info")
     space_dim[space_ndims] = dset->shared->layout.u.chunk.dim[space_ndims];
 
     /* Fill the DXPL cache values for later use */
@@ -2771,13 +2867,9 @@ H5D_istore_allocate(H5D_t *dset, hid_t dxpl_id, hbool_t full_overwrite)
     } /* end if */
 #endif  /* H5_HAVE_PARALLEL */
 
-    /*
-     * Setup indice to go through all chunks. (Future improvement:
-     *  should allocate only chunks that have no file space assigned yet).
-     */
-    for(u = 0; u < dset->shared->layout.u.chunk.ndims; u++)
-        chunk_offset[u] = 0;
-    chunk_size = dset->shared->layout.u.chunk.size;
+    /* Get original chunk size */
+    H5_CHECK_OVERFLOW(dset->shared->layout.u.chunk.size, hsize_t, size_t);
+    orig_chunk_size = (size_t)dset->shared->layout.u.chunk.size;
 
     /* Check the dataset's fill-value status */
     if(H5P_is_fill_value_defined(fill, &fill_status) < 0)
@@ -2793,34 +2885,92 @@ H5D_istore_allocate(H5D_t *dset, hid_t dxpl_id, hbool_t full_overwrite)
             || pline->nused > 0)
         should_fill = TRUE;
 
-    /* Check if fill values should be written to blocks */
+    /* Check if fill values should be written to chunks */
     if(should_fill) {
-        /* Allocate chunk buffer for processes to use when writing fill values */
-        H5_CHECK_OVERFLOW(chunk_size, hsize_t, size_t);
-        if(NULL == (chunk = H5D_istore_chunk_alloc((size_t)chunk_size, pline)))
-            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for chunk")
-
         /* Fill the chunk with the proper values */
         if(fill->buf) {
-            /* Replicate the fill value throughout the chunk */
-            HDassert(0 == (chunk_size % (size_t)fill->size));
-            H5V_array_fill(chunk, fill->buf, (size_t)fill->size, (size_t)(chunk_size / fill->size));
+            /* Detect whether the datatype has a VL component */
+            has_vlen_fill_type = H5T_detect_class(dset->shared->type, H5T_VLEN);
+
+            /* If necessary, convert fill value datatypes (which copies VL components, etc.) */
+            if(has_vlen_fill_type) {
+                /* Create temporary datatype for conversion operation */
+                if(NULL == (mem_type = H5T_copy(dset->shared->type, H5T_COPY_REOPEN)))
+                    HGOTO_ERROR(H5E_DATATYPE, H5E_CANTCOPY, FAIL, "unable to copy file datatype")
+                if((mem_tid = H5I_register(H5I_DATATYPE, mem_type)) < 0)
+                    HGOTO_ERROR(H5E_DATATYPE, H5E_CANTREGISTER, FAIL, "unable to register memory datatype")
+
+                /* Retrieve sizes of memory & file datatypes */
+                mem_type_size = H5T_get_size(mem_type);
+                HDassert(mem_type_size > 0);
+                file_type_size = H5T_get_size(dset->shared->type);
+                HDassert(file_type_size == (size_t)fill->size);
+
+                /* Compute the base size for a chunk to operate on */
+                elmt_size = MAX(mem_type_size, file_type_size);
+                elmts_per_chunk = dset->shared->layout.u.chunk.size / file_type_size;
+                orig_chunk_size = elmts_per_chunk * elmt_size;
+
+                /* Allocate a chunk buffer now, if _no_ filters are used */
+                if(pline->nused == 0)
+                    if(NULL == (chunk = H5D_istore_chunk_alloc(orig_chunk_size, pline)))
+                        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for chunk")
+
+                /* Get the datatype conversion path for this operation */
+                if(NULL == (fill_to_mem_tpath = H5T_path_find(dset->shared->type, mem_type, NULL, NULL, dxpl_id, FALSE)))
+                    HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "unable to convert between src and dst datatypes")
+
+                /* Get the inverse datatype conversion path for this operation */
+                if(NULL == (mem_to_dset_tpath = H5T_path_find(mem_type, dset->shared->type, NULL, NULL, dxpl_id, FALSE)))
+                    HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "unable to convert between src and dst datatypes")
+
+                /* Check if we need to allocate a background buffer */
+                if(H5T_path_bkg(fill_to_mem_tpath) || H5T_path_bkg(mem_to_dset_tpath)) {
+                    /* Check for inverse datatype conversion needing a background buffer */
+                    /* (do this first, since it needs a larger buffer) */
+                    if(H5T_path_bkg(mem_to_dset_tpath))
+                        bkg_buf_size = elmts_per_chunk * elmt_size;
+                    else
+                        bkg_buf_size = elmt_size;
+
+                    /* Allocate the background buffer */
+                    if(NULL == (bkg_buf = H5FL_BLK_MALLOC(type_conv, bkg_buf_size)))
+                        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed")
+                } /* end if */
+            } /* end if */
+            else {
+                /* Allocate chunk buffer for processes to use when writing fill values */
+                if(NULL == (chunk = H5D_istore_chunk_alloc(orig_chunk_size, pline)))
+                    HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for chunk")
+
+                /*
+                 * Replicate the fill value throughout the chunk.
+                 */
+                HDassert(0 == (orig_chunk_size % fill->size));
+                H5V_array_fill(chunk, fill->buf, (size_t)fill->size, (size_t)(orig_chunk_size / fill->size));
+            } /* end else */
         } /* end if */
-        else
-            /* No fill value was specified, assume all zeros. */
-            HDmemset(chunk, 0, (size_t)chunk_size);
+        else {
+            /* Allocate chunk buffer for processes to use when writing fill values */
+            if(NULL == (chunk = H5D_istore_chunk_alloc(orig_chunk_size, pline)))
+                HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for chunk")
+
+            /*
+             * No fill value was specified, assume all zeros.
+             */
+            HDmemset(chunk, 0, orig_chunk_size);
+        } /* end else */
 
         /* Check if there are filters which need to be applied to the chunk */
-        if(pline->nused > 0) {
-            size_t buf_size = (size_t)chunk_size;
-            size_t nbytes = (size_t)chunk_size;
+        /* (only do this in advance when the chunk info can be re-used (i.e.
+         *      it doesn't contain any non-default VL datatype fill values)
+         */
+        if(!has_vlen_fill_type && pline->nused > 0) {
+            size_t buf_size = orig_chunk_size;
 
             /* Push the chunk through the filters */
-            if(H5Z_pipeline(pline, 0, &filter_mask, dxpl_cache->err_detect, dxpl_cache->filter_cb, &nbytes, &buf_size, &chunk) < 0)
-                HGOTO_ERROR(H5E_PLINE, H5E_CANTFILTER, FAIL, "output pipeline failed")
-
-            /* Keep the number of bytes the chunk turned in to */
-            chunk_size = nbytes;
+            if(H5Z_pipeline(pline, 0, &filter_mask, dxpl_cache->err_detect, dxpl_cache->filter_cb, &orig_chunk_size, &buf_size, &chunk) < 0)
+                HGOTO_ERROR(H5E_PLINE, H5E_WRITEERROR, FAIL, "output pipeline failed")
         } /* end if */
     } /* end if */
 
@@ -2828,16 +2978,20 @@ H5D_istore_allocate(H5D_t *dset, hid_t dxpl_id, hbool_t full_overwrite)
     store.chunk.offset = chunk_offset;
     H5D_BUILD_IO_INFO(&io_info, dset, dxpl_cache, dxpl_id, &store);
 
+    /* Reset the chunk offset indices */
+    HDmemset(chunk_offset, 0, (dset->shared->layout.u.chunk.ndims * sizeof(chunk_offset[0])));
+
     /* Loop over all chunks */
     carry = FALSE;
     while(!carry) {
-        hbool_t	chunk_exists;   /* Flag to indicate whether a chunk exists already */
+        int i;                  /* Local index variable */
 
         /* Check if the chunk exists yet on disk */
-        chunk_exists = TRUE;
-        if(H5D_istore_get_addr(&io_info, NULL) == HADDR_UNDEF) {
-            const H5D_rdcc_t       *rdcc = &(dset->shared->cache.chunk);	/*raw data chunk cache */
-            H5D_rdcc_ent_t         *ent;              	/*cache entry  */
+        if(!H5F_addr_defined(H5D_istore_get_addr(&io_info, NULL))) {
+            const H5D_rdcc_t *rdcc = &(dset->shared->cache.chunk);  /* Raw data chunk cache */
+            H5D_rdcc_ent_t *ent;    /* Cache entry  */
+            hbool_t chunk_exists;   /* Flag to indicate whether a chunk exists already */
+            unsigned u;             /* Local index variable */
 
             /* Didn't find the chunk on disk */
             chunk_exists = FALSE;
@@ -2846,72 +3000,128 @@ H5D_istore_allocate(H5D_t *dset, hid_t dxpl_id, hbool_t full_overwrite)
             for(ent = rdcc->head; ent && !chunk_exists; ent = ent->next) {
                 /* Assume a match */
                 chunk_exists = TRUE;
-                for(u = 0; u < dset->shared->layout.u.chunk.ndims && chunk_exists; u++) {
-                    if(ent->offset[u] != chunk_offset[u])
+                for(u = 0; u < dset->shared->layout.u.chunk.ndims; u++)
+                    if(ent->offset[u] != chunk_offset[u]) {
                         chunk_exists = FALSE;       /* Reset if no match */
-                } /* end for */
+                        break;
+                    } /* end if */
             } /* end for */
-        } /* end if */
-
-        if(!chunk_exists) {
-            H5D_istore_ud1_t udata;	/* B-tree pass-through for creating chunk */
-
-            /* Initialize the chunk information */
-            udata.common.mesg = &dset->shared->layout;
-            udata.common.key.filter_mask = filter_mask;
-            udata.addr = HADDR_UNDEF;
-            H5_CHECK_OVERFLOW(chunk_size,hsize_t,size_t);
-            udata.common.key.nbytes = (size_t)chunk_size;
-            for(u = 0; u < dset->shared->layout.u.chunk.ndims; u++)
-                udata.common.key.offset[u] = chunk_offset[u];
 
-            /* Allocate the chunk with all processes */
-            if(H5B_insert(dset->oloc.file, dxpl_id, H5B_ISTORE, dset->shared->layout.u.chunk.addr, &udata)<0)
-                HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "unable to allocate chunk")
-
-            /* Check if fill values should be written to blocks */
-            if(should_fill) {
-#ifdef H5_HAVE_PARALLEL
-                /* Check if this file is accessed with an MPI-capable file driver */
-                if(using_mpi) {
-                    /* Write the chunks out from only one process */
-                    /* !! Use the internal "independent" DXPL!! -QAK */
-                    if(H5_PAR_META_WRITE == mpi_rank)
-                        if(H5F_block_write(dset->oloc.file, H5FD_MEM_DRAW, udata.addr, udata.common.key.nbytes, H5AC_ind_dxpl_id, chunk) < 0)
-                            HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "unable to write raw data to file")
-
-                    /* Indicate that blocks are being written */
-                    blocks_written = TRUE;
+            /* Chunk wasn't in cache either, create it now */
+            if(!chunk_exists) {
+                H5D_istore_ud1_t udata;	/* B-tree pass-through for creating chunk */
+                size_t	chunk_size;     /* Size of chunk in bytes, possibly filtered */
+
+                /* Check for VL datatype & non-default fill value */
+                if(has_vlen_fill_type) {
+                    /* Allocate a new chunk buffer each time, if filters are used */
+                    if(pline->nused > 0)
+                        if(NULL == (chunk = H5D_istore_chunk_alloc(orig_chunk_size, pline)))
+                            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for chunk")
+
+                    /* Make a copy of the (disk-based) fill value into the buffer */
+                    HDmemcpy(chunk, fill->buf, file_type_size);
+
+                    /* Reset first element of background buffer, if necessary */
+                    if(H5T_path_bkg(fill_to_mem_tpath))
+                        HDmemset(bkg_buf, 0, elmt_size);
+
+                    /* Type convert the dataset buffer, to copy any VL components */
+                    if(H5T_convert(fill_to_mem_tpath, dset->shared->type_id, mem_tid, (size_t)1, (size_t)0, (size_t)0, chunk, bkg_buf, dxpl_id) < 0)
+                        HGOTO_ERROR(H5E_DATASET, H5E_CANTCONVERT, FAIL, "data type conversion failed")
+
+                    /* Replicate the fill value into the cached buffer */
+                    H5V_array_fill(chunk, chunk, mem_type_size, elmts_per_chunk);
+
+                    /* Reset the entire background buffer, if necessary */
+                    if(H5T_path_bkg(mem_to_dset_tpath))
+                        HDmemset(bkg_buf, 0, bkg_buf_size);
+
+                    /* Type convert the dataset buffer, to copy any VL components */
+                    if(H5T_convert(mem_to_dset_tpath, mem_tid, dset->shared->type_id, elmts_per_chunk, (size_t)0, (size_t)0, chunk, bkg_buf, dxpl_id) < 0)
+                        HGOTO_ERROR(H5E_DATASET, H5E_CANTCONVERT, FAIL, "data type conversion failed")
+
+                    /* Check if there are filters which need to be applied to the chunk */
+                    if(pline->nused > 0) {
+                        size_t buf_size = orig_chunk_size;
+                        size_t nbytes = (size_t)dset->shared->layout.u.chunk.size;
+
+                        /* Push the chunk through the filters */
+                        if(H5Z_pipeline(pline, 0, &filter_mask, dxpl_cache->err_detect, dxpl_cache->filter_cb, &nbytes, &buf_size, &chunk) < 0)
+                            HGOTO_ERROR(H5E_PLINE, H5E_WRITEERROR, FAIL, "output pipeline failed")
+
+                        /* Keep the number of bytes the chunk turned in to */
+                        chunk_size = nbytes;
+                    } /* end if */
+                    else
+                        chunk_size = (size_t)dset->shared->layout.u.chunk.size;
                 } /* end if */
-                else {
+                else
+                    chunk_size = orig_chunk_size;
+
+                /* Initialize the chunk information */
+                udata.common.mesg = &dset->shared->layout;
+                udata.common.key.filter_mask = filter_mask;
+                udata.addr = HADDR_UNDEF;
+                udata.common.key.nbytes = chunk_size;
+                for(u = 0; u < dset->shared->layout.u.chunk.ndims; u++)
+                    udata.common.key.offset[u] = chunk_offset[u];
+
+                /* Allocate the chunk with all processes */
+                if(H5B_insert(dset->oloc.file, dxpl_id, H5B_ISTORE, dset->shared->layout.u.chunk.addr, &udata) < 0)
+                    HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "unable to allocate chunk")
+
+                /* Check if fill values should be written to chunks */
+                if(should_fill) {
+#ifdef H5_HAVE_PARALLEL
+                    /* Check if this file is accessed with an MPI-capable file driver */
+                    if(using_mpi) {
+                        /* Write the chunks out from only one process */
+                        /* !! Use the internal "independent" DXPL!! -QAK */
+                        if(H5_PAR_META_WRITE == mpi_rank)
+                            if(H5F_block_write(dset->oloc.file, H5FD_MEM_DRAW, udata.addr, udata.common.key.nbytes, H5AC_ind_dxpl_id, chunk) < 0)
+                                HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "unable to write raw data to file")
+
+                        /* Indicate that blocks are being written */
+                        blocks_written = TRUE;
+                    } /* end if */
+                    else {
 #endif /* H5_HAVE_PARALLEL */
-                    if(H5F_block_write(dset->oloc.file, H5FD_MEM_DRAW, udata.addr, udata.common.key.nbytes, dxpl_id, chunk) < 0)
-                        HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "unable to write raw data to file")
+                        if(H5F_block_write(dset->oloc.file, H5FD_MEM_DRAW, udata.addr, udata.common.key.nbytes, dxpl_id, chunk) < 0)
+                            HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "unable to write raw data to file")
 #ifdef H5_HAVE_PARALLEL
-                } /* end else */
+                    } /* end else */
 #endif /* H5_HAVE_PARALLEL */
+                } /* end if */
+
+                /* Release the chunk if we need to re-allocate it each time */
+                if(has_vlen_fill_type && pline->nused > 0)
+                    chunk = H5D_istore_chunk_xfree(chunk, pline);
             } /* end if */
         } /* end if */
 
         /* Increment indices */
-        for(i = (int)dset->shared->layout.u.chunk.ndims - 1, carry = TRUE; i >= 0 && carry; --i) {
+        carry = TRUE;
+        for(i = (int)dset->shared->layout.u.chunk.ndims - 1; i >= 0; --i) {
             chunk_offset[i] += dset->shared->layout.u.chunk.dim[i];
-            if (chunk_offset[i] >= space_dim[i])
+            if(chunk_offset[i] >= space_dim[i])
                 chunk_offset[i] = 0;
-            else
+            else {
                 carry = FALSE;
+                break;
+            } /* end else */
         } /* end for */
     } /* end while */
 
 #ifdef H5_HAVE_PARALLEL
-    /* Only need to block at the barrier if we actually allocated a chunk */
-    /* And if we are using an MPI-capable file driver */
+    /* Only need to block at the barrier if we actually initialized a chunk */
+    /* using an MPI-capable file driver */
     if(using_mpi && blocks_written) {
         /* Wait at barrier to avoid race conditions where some processes are
          * still writing out chunks and other processes race ahead to read
          * them in, getting bogus data.
          */
-        if (MPI_SUCCESS != (mpi_code=MPI_Barrier(mpi_comm)))
+        if(MPI_SUCCESS != (mpi_code = MPI_Barrier(mpi_comm)))
             HMPI_GOTO_ERROR(FAIL, "MPI_Barrier failed", mpi_code)
     } /* end if */
 #endif /* H5_HAVE_PARALLEL */
@@ -2921,6 +3131,16 @@ done:
     if(chunk)
         chunk = H5D_istore_chunk_xfree(chunk, pline);
 
+    /* Free other resources for vlen fill values */
+    if(has_vlen_fill_type) {
+        if(mem_tid > 0)
+            H5I_dec_ref(mem_tid);
+        else if(mem_type)
+            H5T_close(mem_type);
+        if(bkg_buf)
+            H5FL_BLK_FREE(type_conv, bkg_buf);
+    } /* end if */
+
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5D_istore_allocate() */
 
diff --git a/test/tvltypes.c b/test/tvltypes.c
index 446ba07..cb8b46a 100644
--- a/test/tvltypes.c
+++ b/test/tvltypes.c
@@ -2521,68 +2521,91 @@ test_vltypes_fill_value(void)
     CHECK(file_id, FAIL, "H5Fcreate");
 
     /* Create datasets with different storage layouts */
-HDfprintf(stderr, "Uncomment loop!\n");
-/*     for(layout = H5D_COMPACT; layout <= H5D_CHUNKED; layout++) { */
-    for(layout = H5D_COMPACT; layout <= H5D_CONTIGUOUS; layout++) {
-        hid_t tmp_dcpl_id;      /* Temporary copy of the dataset creation property list */
-
-        /* Make a copy of the dataset creation property list */
-        tmp_dcpl_id = H5Pcopy(dcpl_id);
-        CHECK(tmp_dcpl_id, FAIL, "H5Pcopy");
-
-        /* Layout specific actions */
-        switch(layout) {
-            case H5D_COMPACT:
-                HDstrcpy(dset_name1, "dataset1-compact");
-                HDstrcpy(dset_name2, "dataset2-compact");
-                dset_dspace_id = small_dspace_id;
-                ret = H5Pset_layout(tmp_dcpl_id, H5D_COMPACT);
-                CHECK(ret, FAIL, "H5Pset_layout");
-                break;
-
-            case H5D_CONTIGUOUS:
-                HDstrcpy(dset_name1, "dataset1-contig");
-                HDstrcpy(dset_name2, "dataset2-contig");
-                dset_dspace_id = large_dspace_id;
-                break;
-
-            case H5D_CHUNKED:
-                {
-                    hsize_t chunk_dims[1] = {SPACE4_DIM_LARGE / 4};
-
-                    HDstrcpy(dset_name1, "dataset1-chunked");
-                    HDstrcpy(dset_name2, "dataset2-chunked");
+    for(layout = H5D_COMPACT; layout <= H5D_CHUNKED; layout++) {
+        unsigned compress_loop;         /* # of times to run loop, for testing compressed chunked dataset */
+        unsigned test_loop;             /* Loop over datasets */
+
+#ifdef H5_HAVE_FILTER_DEFLATE
+        if(layout == H5D_CHUNKED)
+            compress_loop = 2;
+        else
+#endif /* H5_HAVE_FILTER_DEFLATE */
+            compress_loop = 1;
+
+        /* Loop over dataset operations */
+        for(test_loop = 0; test_loop < compress_loop; test_loop++) {
+            hid_t tmp_dcpl_id;      /* Temporary copy of the dataset creation property list */
+
+            /* Make a copy of the dataset creation property list */
+            tmp_dcpl_id = H5Pcopy(dcpl_id);
+            CHECK(tmp_dcpl_id, FAIL, "H5Pcopy");
+
+            /* Layout specific actions */
+            switch(layout) {
+                case H5D_COMPACT:
+                    HDstrcpy(dset_name1, "dataset1-compact");
+                    HDstrcpy(dset_name2, "dataset2-compact");
+                    dset_dspace_id = small_dspace_id;
+                    ret = H5Pset_layout(tmp_dcpl_id, H5D_COMPACT);
+                    CHECK(ret, FAIL, "H5Pset_layout");
+                    break;
+
+                case H5D_CONTIGUOUS:
+                    HDstrcpy(dset_name1, "dataset1-contig");
+                    HDstrcpy(dset_name2, "dataset2-contig");
                     dset_dspace_id = large_dspace_id;
-                    ret = H5Pset_chunk(tmp_dcpl_id, 1, chunk_dims);
-                    CHECK(ret, FAIL, "H5Pset_chunk");
-                }
-                break;
-        } /* end switch */
-
-        /* Create first data set with default setting - no space is allocated */
-        dset_id = H5Dcreate(file_id, dset_name1, dtype1_id, dset_dspace_id, tmp_dcpl_id);
-        CHECK(dset_id, FAIL, "H5Dcreate");
-
-        ret = H5Dclose(dset_id);
-        CHECK(ret, FAIL, "H5Dclose");
-
-
-        /* Create a second data set with space allocated and fill value written */
-        ret = H5Pset_fill_time(tmp_dcpl_id, H5D_FILL_TIME_IFSET);
-        CHECK(ret, FAIL, "H5Pset_fill_time");
-
-        ret = H5Pset_alloc_time(tmp_dcpl_id, H5D_ALLOC_TIME_EARLY);
-        CHECK(ret, FAIL, "H5Pset_alloc_time");
-
-        dset_id = H5Dcreate(file_id, dset_name2, dtype1_id, dset_dspace_id, tmp_dcpl_id);
-        CHECK(dset_id, FAIL, "H5Dcreate");
-
-        ret = H5Dclose(dset_id);
-        CHECK(ret, FAIL, "H5Dclose");
-
-        /* Close temporary DCPL */
-        ret = H5Pclose(tmp_dcpl_id);
-        CHECK(ret, FAIL, "H5Pclose");
+                    break;
+
+                case H5D_CHUNKED:
+                    {
+                        hsize_t chunk_dims[1] = {SPACE4_DIM_LARGE / 4};
+
+                        dset_dspace_id = large_dspace_id;
+                        ret = H5Pset_chunk(tmp_dcpl_id, 1, chunk_dims);
+                        CHECK(ret, FAIL, "H5Pset_chunk");
+#ifdef H5_HAVE_FILTER_DEFLATE
+                        if(test_loop == 1) {
+                            HDstrcpy(dset_name1, "dataset1-chunked-compressed");
+                            HDstrcpy(dset_name2, "dataset2-chunked-compressed");
+                            ret = H5Pset_deflate(tmp_dcpl_id, 3);
+                            CHECK(ret, FAIL, "H5Pset_deflate");
+                        } /* end if */
+                        else {
+#endif /* H5_HAVE_FILTER_DEFLATE */
+                            HDstrcpy(dset_name1, "dataset1-chunked");
+                            HDstrcpy(dset_name2, "dataset2-chunked");
+#ifdef H5_HAVE_FILTER_DEFLATE
+                        } /* end else */
+#endif /* H5_HAVE_FILTER_DEFLATE */
+                    }
+                    break;
+            } /* end switch */
+
+            /* Create first data set with default setting - no space is allocated */
+            dset_id = H5Dcreate(file_id, dset_name1, dtype1_id, dset_dspace_id, tmp_dcpl_id);
+            CHECK(dset_id, FAIL, "H5Dcreate");
+
+            ret = H5Dclose(dset_id);
+            CHECK(ret, FAIL, "H5Dclose");
+
+
+            /* Create a second data set with space allocated and fill value written */
+            ret = H5Pset_fill_time(tmp_dcpl_id, H5D_FILL_TIME_IFSET);
+            CHECK(ret, FAIL, "H5Pset_fill_time");
+
+            ret = H5Pset_alloc_time(tmp_dcpl_id, H5D_ALLOC_TIME_EARLY);
+            CHECK(ret, FAIL, "H5Pset_alloc_time");
+
+            dset_id = H5Dcreate(file_id, dset_name2, dtype1_id, dset_dspace_id, tmp_dcpl_id);
+            CHECK(dset_id, FAIL, "H5Dcreate");
+
+            ret = H5Dclose(dset_id);
+            CHECK(ret, FAIL, "H5Dclose");
+
+            /* Close temporary DCPL */
+            ret = H5Pclose(tmp_dcpl_id);
+            CHECK(ret, FAIL, "H5Pclose");
+        } /* end for */
     } /* end for */
 
     ret = H5Fclose(file_id);
@@ -2604,235 +2627,277 @@ HDfprintf(stderr, "Uncomment loop!\n");
     CHECK(file_id, FAIL, "H5Fopen");
 
     /* Read datasets with different storage layouts */
-HDfprintf(stderr, "Uncomment loop!\n");
-/*     for(layout = H5D_COMPACT; layout <= H5D_CHUNKED; layout++) { */
-    for(layout = H5D_COMPACT; layout <= H5D_CONTIGUOUS; layout++) {
-
-        /* Layout specific actions */
-        switch(layout) {
-            case H5D_COMPACT:
-                HDstrcpy(dset_name1, "dataset1-compact");
-                HDstrcpy(dset_name2, "dataset2-compact");
-                dset_dspace_id = small_dspace_id;
-                dset_elmts = SPACE4_DIM_SMALL;
-                break;
-
-            case H5D_CONTIGUOUS:
-                HDstrcpy(dset_name1, "dataset1-contig");
-                HDstrcpy(dset_name2, "dataset2-contig");
-                dset_dspace_id = large_dspace_id;
-                dset_elmts = SPACE4_DIM_LARGE;
-                break;
-
-            case H5D_CHUNKED:
-                HDstrcpy(dset_name1, "dataset1-chunked");
-                HDstrcpy(dset_name2, "dataset2-chunked");
-                dset_dspace_id = large_dspace_id;
-                dset_elmts = SPACE4_DIM_LARGE;
-                break;
-        } /* end switch */
-
-        /* Open first data set */
-        dset_id = H5Dopen(file_id, dset_name1);
-        CHECK(dset_id, FAIL, "H5Dopen");
-
-        /* Read in the data of fill value */
-        ret = H5Dread(dset_id, dtype1_id, dset_dspace_id, dset_dspace_id, xfer_pid, rbuf);
-        CHECK(ret, FAIL, "H5Dread");
-
-        /* Compare data read in */
-        for(i = 0; i < dset_elmts; i++) {
-            if(HDstrcmp(rbuf[i].str_id, "foobar")
-                    || HDstrcmp(rbuf[i].str_name, "")
-                    || rbuf[i].str_desc
-                    || HDstrcmp(rbuf[i].str_orig, "\0")
-                    || HDstrcmp(rbuf[i].str_stat, "dead")
-                    || HDstrcmp(rbuf[i].str_form, "liquid")
-                    || HDstrcmp(rbuf[i].str_unit, "meter")) {
-                TestErrPrintf("%d: VL data doesn't match!, index(i) = %d\n", __LINE__, (int)i);
-                continue;
-            } /* end if */
-        } /* end for */
-
-        ret = H5Dclose(dset_id);
-        CHECK(ret, FAIL, "H5Dclose");
-
-        /* Release the space */
-        ret = H5Dvlen_reclaim(dtype1_id, dset_dspace_id, xfer_pid, rbuf);
-        CHECK(ret, FAIL, "H5Dvlen_reclaim");
-
-
-        /* Open the second data set to check the value of data */
-        dset_id = H5Dopen(file_id, dset_name2);
-        CHECK(dset_id, FAIL, "H5Dopen");
-
-        ret = H5Dread(dset_id, dtype1_id, dset_dspace_id, dset_dspace_id, xfer_pid, rbuf);
-        CHECK(ret, FAIL, "H5Dread");
-
-        /* Compare data read in */
-        for(i = 0; i < dset_elmts; i++) {
-            if(HDstrcmp(rbuf[i].str_id, "foobar")
-                    || HDstrcmp(rbuf[i].str_name, "")
-                    || rbuf[i].str_desc
-                    || HDstrcmp(rbuf[i].str_orig, "\0")
-                    || HDstrcmp(rbuf[i].str_stat, "dead")
-                    || HDstrcmp(rbuf[i].str_form, "liquid")
-                    || HDstrcmp(rbuf[i].str_unit, "meter")) {
-                TestErrPrintf("%d: VL data doesn't match!, index(i)=%d\n",__LINE__,(int)i);
-                continue;
-            } /* end if */
-        } /* end for */
-
-        ret = H5Dclose(dset_id);
-        CHECK(ret, FAIL, "H5Dclose");
-
-        /* Release the space */
-        ret = H5Dvlen_reclaim(dtype1_id, dset_dspace_id, xfer_pid, rbuf);
-        CHECK(ret, FAIL, "H5Dvlen_reclaim");
-    } /* end for */
-
-    ret = H5Fclose(file_id);
-    CHECK(ret, FAIL, "H5Fclose");
+    for(layout = H5D_COMPACT; layout <= H5D_CHUNKED; layout++) {
+        unsigned compress_loop;         /* # of times to run loop, for testing compressed chunked dataset */
+        unsigned test_loop;             /* Loop over datasets */
+
+#ifdef H5_HAVE_FILTER_DEFLATE
+        if(layout == H5D_CHUNKED)
+            compress_loop = 2;
+        else
+#endif /* H5_HAVE_FILTER_DEFLATE */
+            compress_loop = 1;
+
+        /* Loop over dataset operations */
+        for(test_loop = 0; test_loop < compress_loop; test_loop++) {
+
+            /* Layout specific actions */
+            switch(layout) {
+                case H5D_COMPACT:
+                    HDstrcpy(dset_name1, "dataset1-compact");
+                    HDstrcpy(dset_name2, "dataset2-compact");
+                    dset_dspace_id = small_dspace_id;
+                    dset_elmts = SPACE4_DIM_SMALL;
+                    break;
+
+                case H5D_CONTIGUOUS:
+                    HDstrcpy(dset_name1, "dataset1-contig");
+                    HDstrcpy(dset_name2, "dataset2-contig");
+                    dset_dspace_id = large_dspace_id;
+                    dset_elmts = SPACE4_DIM_LARGE;
+                    break;
+
+                case H5D_CHUNKED:
+#ifdef H5_HAVE_FILTER_DEFLATE
+                    if(test_loop == 1) {
+                        HDstrcpy(dset_name1, "dataset1-chunked-compressed");
+                        HDstrcpy(dset_name2, "dataset2-chunked-compressed");
+                    } /* end if */
+                    else {
+#endif /* H5_HAVE_FILTER_DEFLATE */
+                        HDstrcpy(dset_name1, "dataset1-chunked");
+                        HDstrcpy(dset_name2, "dataset2-chunked");
+#ifdef H5_HAVE_FILTER_DEFLATE
+                    } /* end else */
+#endif /* H5_HAVE_FILTER_DEFLATE */
+                    dset_dspace_id = large_dspace_id;
+                    dset_elmts = SPACE4_DIM_LARGE;
+                    break;
+            } /* end switch */
 
+            /* Open first data set */
+            dset_id = H5Dopen(file_id, dset_name1);
+            CHECK(dset_id, FAIL, "H5Dopen");
 
-    /* Open the file to check data set value */
-    file_id = H5Fopen(FILENAME, H5F_ACC_RDWR, H5P_DEFAULT);
-    CHECK(file_id, FAIL, "H5Fopen");
+            /* Read in the data of fill value */
+            ret = H5Dread(dset_id, dtype1_id, dset_dspace_id, dset_dspace_id, xfer_pid, rbuf);
+            CHECK(ret, FAIL, "H5Dread");
 
-    /* Write one element & fill values to  datasets with different storage layouts */
-HDfprintf(stderr, "Uncomment loop!\n");
-/*     for(layout = H5D_COMPACT; layout <= H5D_CHUNKED; layout++) { */
-    for(layout = H5D_COMPACT; layout <= H5D_CONTIGUOUS; layout++) {
-
-        /* Layout specific actions */
-        switch(layout) {
-            case H5D_COMPACT:
-                HDstrcpy(dset_name1, "dataset1-compact");
-                HDstrcpy(dset_name2, "dataset2-compact");
-                dset_dspace_id = small_dspace_id;
-                dset_elmts = SPACE4_DIM_SMALL;
-                break;
-
-            case H5D_CONTIGUOUS:
-                HDstrcpy(dset_name1, "dataset1-contig");
-                HDstrcpy(dset_name2, "dataset2-contig");
-                dset_dspace_id = large_dspace_id;
-                dset_elmts = SPACE4_DIM_LARGE;
-                break;
-
-            case H5D_CHUNKED:
-                HDstrcpy(dset_name1, "dataset1-chunked");
-                HDstrcpy(dset_name2, "dataset2-chunked");
-                dset_dspace_id = large_dspace_id;
-                dset_elmts = SPACE4_DIM_LARGE;
-                break;
-        } /* end switch */
-
-        /* Copy the dataset's dataspace */
-        single_dspace_id = H5Scopy(dset_dspace_id);
-        CHECK(single_dspace_id, FAIL, "H5Scopy");
-
-        /* Set a single element in the dataspace */
-        ret = H5Sselect_hyperslab(single_dspace_id, H5S_SELECT_SET, single_offset,
-                NULL, single_block, NULL);
-        CHECK(ret, FAIL, "H5Sselect_hyperslab");
-
-        /* Open first data set */
-        dset_id = H5Dopen(file_id, dset_name1);
-        CHECK(dset_id, FAIL, "H5Dopen");
-
-        /* Write one element in the dataset */
-        ret = H5Dwrite(dset_id, dtype1_id, scalar_dspace_id, single_dspace_id, xfer_pid, &wdata);
-        CHECK(ret, FAIL, "H5Dwrite");
-
-        ret = H5Dread(dset_id, dtype1_id, dset_dspace_id, dset_dspace_id, xfer_pid, rbuf);
-        CHECK(ret, FAIL, "H5Dread");
-
-        /* Compare data read in */
-        for(i = 0; i < dset_elmts; i++) {
-            if(i == single_offset[0]) {
-                if(HDstrcmp(rbuf[i].str_id, wdata.str_id)
-                        || rbuf[i].str_name
-                        || HDstrcmp(rbuf[i].str_desc, wdata.str_desc)
-                        || HDstrcmp(rbuf[i].str_orig, wdata.str_orig)
-                        || HDstrcmp(rbuf[i].str_stat, wdata.str_stat)
-                        || HDstrcmp(rbuf[i].str_form, wdata.str_form)
-                        || HDstrcmp(rbuf[i].str_unit, wdata.str_unit)) {
-                    TestErrPrintf("%d: VL data doesn't match!, index(i)=%d\n",__LINE__,(int)i);
-                    continue;
-                } /* end if */
-            } /* end if */
-            else {
+            /* Compare data read in */
+            for(i = 0; i < dset_elmts; i++) {
                 if(HDstrcmp(rbuf[i].str_id, "foobar")
                         || HDstrcmp(rbuf[i].str_name, "")
                         || rbuf[i].str_desc
-                        || HDstrcmp(rbuf[i].str_orig,"\0")
+                        || HDstrcmp(rbuf[i].str_orig, "\0")
                         || HDstrcmp(rbuf[i].str_stat, "dead")
                         || HDstrcmp(rbuf[i].str_form, "liquid")
                         || HDstrcmp(rbuf[i].str_unit, "meter")) {
-                    TestErrPrintf("%d: VL data doesn't match!, index(i)=%d\n",__LINE__,(int)i);
+                    TestErrPrintf("%d: VL data doesn't match!, index(i) = %d\n", __LINE__, (int)i);
                     continue;
                 } /* end if */
-            } /* end if */
-        } /* end for */
-
-        ret = H5Dclose(dset_id);
-        CHECK(ret, FAIL, "H5Dclose");
+            } /* end for */
 
-        /* Release the space */
-        ret = H5Dvlen_reclaim(dtype1_id, dset_dspace_id, xfer_pid, rbuf);
-        CHECK(ret, FAIL, "H5Dvlen_reclaim");
+            ret = H5Dclose(dset_id);
+            CHECK(ret, FAIL, "H5Dclose");
 
+            /* Release the space */
+            ret = H5Dvlen_reclaim(dtype1_id, dset_dspace_id, xfer_pid, rbuf);
+            CHECK(ret, FAIL, "H5Dvlen_reclaim");
 
-        /* Open the second data set to check the value of data */
-        dset_id = H5Dopen(file_id, dset_name2);
-        CHECK(dset_id, FAIL, "H5Dopen");
 
-        /* Write one element in the dataset */
-        ret = H5Dwrite(dset_id, dtype1_id, scalar_dspace_id, single_dspace_id, xfer_pid, &wdata);
-        CHECK(ret, FAIL, "H5Dwrite");
+            /* Open the second data set to check the value of data */
+            dset_id = H5Dopen(file_id, dset_name2);
+            CHECK(dset_id, FAIL, "H5Dopen");
 
-        ret = H5Dread(dset_id, dtype1_id, dset_dspace_id, dset_dspace_id, xfer_pid, rbuf);
-        CHECK(ret, FAIL, "H5Dread");
+            ret = H5Dread(dset_id, dtype1_id, dset_dspace_id, dset_dspace_id, xfer_pid, rbuf);
+            CHECK(ret, FAIL, "H5Dread");
 
-        /* Compare data read in */
-        for(i = 0; i < dset_elmts; i++) {
-            if(i == single_offset[0]) {
-                if(HDstrcmp(rbuf[i].str_id, wdata.str_id)
-                        || rbuf[i].str_name
-                        || HDstrcmp(rbuf[i].str_desc, wdata.str_desc)
-                        || HDstrcmp(rbuf[i].str_orig, wdata.str_orig)
-                        || HDstrcmp(rbuf[i].str_stat, wdata.str_stat)
-                        || HDstrcmp(rbuf[i].str_form, wdata.str_form)
-                        || HDstrcmp(rbuf[i].str_unit, wdata.str_unit)) {
-                    TestErrPrintf("%d: VL data doesn't match!, index(i)=%d\n",__LINE__,(int)i);
-                    continue;
-                } /* end if */
-            } /* end if */
-            else {
+            /* Compare data read in */
+            for(i = 0; i < dset_elmts; i++) {
                 if(HDstrcmp(rbuf[i].str_id, "foobar")
                         || HDstrcmp(rbuf[i].str_name, "")
                         || rbuf[i].str_desc
-                        || HDstrcmp(rbuf[i].str_orig,"\0")
+                        || HDstrcmp(rbuf[i].str_orig, "\0")
                         || HDstrcmp(rbuf[i].str_stat, "dead")
                         || HDstrcmp(rbuf[i].str_form, "liquid")
                         || HDstrcmp(rbuf[i].str_unit, "meter")) {
                     TestErrPrintf("%d: VL data doesn't match!, index(i)=%d\n",__LINE__,(int)i);
                     continue;
                 } /* end if */
-            } /* end if */
+            } /* end for */
+
+            ret = H5Dclose(dset_id);
+            CHECK(ret, FAIL, "H5Dclose");
+
+            /* Release the space */
+            ret = H5Dvlen_reclaim(dtype1_id, dset_dspace_id, xfer_pid, rbuf);
+            CHECK(ret, FAIL, "H5Dvlen_reclaim");
         } /* end for */
+    } /* end for */
 
-        ret = H5Dclose(dset_id);
-        CHECK(ret, FAIL, "H5Dclose");
+    ret = H5Fclose(file_id);
+    CHECK(ret, FAIL, "H5Fclose");
 
-        /* Release the space */
-        ret = H5Dvlen_reclaim(dtype1_id, dset_dspace_id, xfer_pid, rbuf);
-        CHECK(ret, FAIL, "H5Dvlen_reclaim");
 
-        /* Close the dataspace for the writes */
-        ret = H5Sclose(single_dspace_id);
-        CHECK(ret, FAIL, "H5Sclose");
+    /* Open the file to check data set value */
+    file_id = H5Fopen(FILENAME, H5F_ACC_RDWR, H5P_DEFAULT);
+    CHECK(file_id, FAIL, "H5Fopen");
+
+    /* Write one element & fill values to  datasets with different storage layouts */
+    for(layout = H5D_COMPACT; layout <= H5D_CHUNKED; layout++) {
+        unsigned compress_loop;         /* # of times to run loop, for testing compressed chunked dataset */
+        unsigned test_loop;             /* Loop over datasets */
+
+#ifdef H5_HAVE_FILTER_DEFLATE
+        if(layout == H5D_CHUNKED)
+            compress_loop = 2;
+        else
+#endif /* H5_HAVE_FILTER_DEFLATE */
+            compress_loop = 1;
+
+        /* Loop over dataset operations */
+        for(test_loop = 0; test_loop < compress_loop; test_loop++) {
+
+            /* Layout specific actions */
+            switch(layout) {
+                case H5D_COMPACT:
+                    HDstrcpy(dset_name1, "dataset1-compact");
+                    HDstrcpy(dset_name2, "dataset2-compact");
+                    dset_dspace_id = small_dspace_id;
+                    dset_elmts = SPACE4_DIM_SMALL;
+                    break;
+
+                case H5D_CONTIGUOUS:
+                    HDstrcpy(dset_name1, "dataset1-contig");
+                    HDstrcpy(dset_name2, "dataset2-contig");
+                    dset_dspace_id = large_dspace_id;
+                    dset_elmts = SPACE4_DIM_LARGE;
+                    break;
+
+                case H5D_CHUNKED:
+#ifdef H5_HAVE_FILTER_DEFLATE
+                    if(test_loop == 1) {
+                        HDstrcpy(dset_name1, "dataset1-chunked-compressed");
+                        HDstrcpy(dset_name2, "dataset2-chunked-compressed");
+                    } /* end if */
+                    else {
+#endif /* H5_HAVE_FILTER_DEFLATE */
+                        HDstrcpy(dset_name1, "dataset1-chunked");
+                        HDstrcpy(dset_name2, "dataset2-chunked");
+#ifdef H5_HAVE_FILTER_DEFLATE
+                    } /* end else */
+#endif /* H5_HAVE_FILTER_DEFLATE */
+                    dset_dspace_id = large_dspace_id;
+                    dset_elmts = SPACE4_DIM_LARGE;
+                    break;
+            } /* end switch */
+
+            /* Copy the dataset's dataspace */
+            single_dspace_id = H5Scopy(dset_dspace_id);
+            CHECK(single_dspace_id, FAIL, "H5Scopy");
+
+            /* Set a single element in the dataspace */
+            ret = H5Sselect_hyperslab(single_dspace_id, H5S_SELECT_SET, single_offset,
+                    NULL, single_block, NULL);
+            CHECK(ret, FAIL, "H5Sselect_hyperslab");
+
+            /* Open first data set */
+            dset_id = H5Dopen(file_id, dset_name1);
+            CHECK(dset_id, FAIL, "H5Dopen");
+
+            /* Write one element in the dataset */
+            ret = H5Dwrite(dset_id, dtype1_id, scalar_dspace_id, single_dspace_id, xfer_pid, &wdata);
+            CHECK(ret, FAIL, "H5Dwrite");
+
+            ret = H5Dread(dset_id, dtype1_id, dset_dspace_id, dset_dspace_id, xfer_pid, rbuf);
+            CHECK(ret, FAIL, "H5Dread");
+
+            /* Compare data read in */
+            for(i = 0; i < dset_elmts; i++) {
+                if(i == single_offset[0]) {
+                    if(HDstrcmp(rbuf[i].str_id, wdata.str_id)
+                            || rbuf[i].str_name
+                            || HDstrcmp(rbuf[i].str_desc, wdata.str_desc)
+                            || HDstrcmp(rbuf[i].str_orig, wdata.str_orig)
+                            || HDstrcmp(rbuf[i].str_stat, wdata.str_stat)
+                            || HDstrcmp(rbuf[i].str_form, wdata.str_form)
+                            || HDstrcmp(rbuf[i].str_unit, wdata.str_unit)) {
+                        TestErrPrintf("%d: VL data doesn't match!, index(i)=%d\n",__LINE__,(int)i);
+                        continue;
+                    } /* end if */
+                } /* end if */
+                else {
+                    if(HDstrcmp(rbuf[i].str_id, "foobar")
+                            || HDstrcmp(rbuf[i].str_name, "")
+                            || rbuf[i].str_desc
+                            || HDstrcmp(rbuf[i].str_orig,"\0")
+                            || HDstrcmp(rbuf[i].str_stat, "dead")
+                            || HDstrcmp(rbuf[i].str_form, "liquid")
+                            || HDstrcmp(rbuf[i].str_unit, "meter")) {
+                        TestErrPrintf("%d: VL data doesn't match!, index(i)=%d\n",__LINE__,(int)i);
+                        continue;
+                    } /* end if */
+                } /* end if */
+            } /* end for */
+
+            ret = H5Dclose(dset_id);
+            CHECK(ret, FAIL, "H5Dclose");
+
+            /* Release the space */
+            ret = H5Dvlen_reclaim(dtype1_id, dset_dspace_id, xfer_pid, rbuf);
+            CHECK(ret, FAIL, "H5Dvlen_reclaim");
+
+
+            /* Open the second data set to check the value of data */
+            dset_id = H5Dopen(file_id, dset_name2);
+            CHECK(dset_id, FAIL, "H5Dopen");
+
+            /* Write one element in the dataset */
+            ret = H5Dwrite(dset_id, dtype1_id, scalar_dspace_id, single_dspace_id, xfer_pid, &wdata);
+            CHECK(ret, FAIL, "H5Dwrite");
+
+            ret = H5Dread(dset_id, dtype1_id, dset_dspace_id, dset_dspace_id, xfer_pid, rbuf);
+            CHECK(ret, FAIL, "H5Dread");
+
+            /* Compare data read in */
+            for(i = 0; i < dset_elmts; i++) {
+                if(i == single_offset[0]) {
+                    if(HDstrcmp(rbuf[i].str_id, wdata.str_id)
+                            || rbuf[i].str_name
+                            || HDstrcmp(rbuf[i].str_desc, wdata.str_desc)
+                            || HDstrcmp(rbuf[i].str_orig, wdata.str_orig)
+                            || HDstrcmp(rbuf[i].str_stat, wdata.str_stat)
+                            || HDstrcmp(rbuf[i].str_form, wdata.str_form)
+                            || HDstrcmp(rbuf[i].str_unit, wdata.str_unit)) {
+                        TestErrPrintf("%d: VL data doesn't match!, index(i)=%d\n",__LINE__,(int)i);
+                        continue;
+                    } /* end if */
+                } /* end if */
+                else {
+                    if(HDstrcmp(rbuf[i].str_id, "foobar")
+                            || HDstrcmp(rbuf[i].str_name, "")
+                            || rbuf[i].str_desc
+                            || HDstrcmp(rbuf[i].str_orig,"\0")
+                            || HDstrcmp(rbuf[i].str_stat, "dead")
+                            || HDstrcmp(rbuf[i].str_form, "liquid")
+                            || HDstrcmp(rbuf[i].str_unit, "meter")) {
+                        TestErrPrintf("%d: VL data doesn't match!, index(i)=%d\n",__LINE__,(int)i);
+                        continue;
+                    } /* end if */
+                } /* end if */
+            } /* end for */
+
+            ret = H5Dclose(dset_id);
+            CHECK(ret, FAIL, "H5Dclose");
+
+            /* Release the space */
+            ret = H5Dvlen_reclaim(dtype1_id, dset_dspace_id, xfer_pid, rbuf);
+            CHECK(ret, FAIL, "H5Dvlen_reclaim");
+
+            /* Close the dataspace for the writes */
+            ret = H5Sclose(single_dspace_id);
+            CHECK(ret, FAIL, "H5Sclose");
+        } /* end for */
     } /* end for */
 
     ret = H5Fclose(file_id);