Merge pull request #162 in HDFFV/hdf5 from ~KOZIOL/hdf5:develop_merge_revise_chunks_07 to develop

* commit 'be27e1ad79dfa0507f589b29d938b7e1020a5b2d':
  Remove explicit support within the metadata cache for tracked compressed entries, they are now completely handled in the clients.

1 files changed, 40 insertions, 197 deletions

diff --git a/src/H5C.c b/src/H5C.c
index d2812b3..3b32aa7 100644
--- a/src/H5C.c
+++ b/src/H5C.c
@@ -1273,24 +1273,10 @@ H5C_insert_entry(H5F_t *             f,
     /* not protected, so can't be dirtied */
     entry_ptr->dirtied  = FALSE;
 
-    /* Retrieve the size of the thing.  Set the compressed field to FALSE
-     * and the compressed_size field to zero first, as they may not be 
-     * initialized by the image_len call.
-     */
-    entry_ptr->compressed = FALSE;
-    entry_ptr->compressed_size = 0;
-    if((type->image_len)(thing, &(entry_ptr->size), &(entry_ptr->compressed), &(entry_ptr->compressed_size)) < 0)
-        HGOTO_ERROR(H5E_CACHE, H5E_CANTGETSIZE, FAIL, "Can't get size of thing")
+    /* Retrieve the size of the thing */
+    if((type->image_len)(thing, &(entry_ptr->size)) < 0)
+        HGOTO_ERROR(H5E_CACHE, H5E_CANTGETSIZE, FAIL, "can't get size of thing")
     HDassert(entry_ptr->size > 0 &&  entry_ptr->size < H5C_MAX_ENTRY_SIZE);
-    HDassert(((type->flags & H5C__CLASS_COMPRESSED_FLAG) != 0) ||
-             (entry_ptr->compressed == FALSE));
-
-    /* entry has just been inserted -- thus compressed size cannot have 
-     * been computed yet.  Thus if entry_ptr->compressed is TRUE, 
-     * entry_ptr->size must equal entry_ptr->compressed_size.
-     */
-    HDassert(!entry_ptr->compressed || (entry_ptr->size == entry_ptr->compressed_size));
-    HDassert(entry_ptr->compressed || (entry_ptr->compressed_size == 0));
 
     entry_ptr->in_slist = FALSE;
 
@@ -2119,22 +2105,14 @@ H5C_protect(H5F_t *		f,
 
                 if(entry_ptr->image_ptr == NULL) {
                     int mpi_rank;
-                    size_t image_size;
 
                     if((mpi_rank = H5F_mpi_get_rank(f)) < 0)
                         HGOTO_ERROR(H5E_FILE, H5E_CANTGET, NULL, "Can't get MPI rank")
 
-                    if(entry_ptr->compressed)
-                        image_size = entry_ptr->compressed_size;
-                    else
-                        image_size = entry_ptr->size;
-                    HDassert(image_size > 0);
-
-                    if(NULL == (entry_ptr->image_ptr = H5MM_malloc(image_size + H5C_IMAGE_EXTRA_SPACE)))
+                    if(NULL == (entry_ptr->image_ptr = H5MM_malloc(entry_ptr->size + H5C_IMAGE_EXTRA_SPACE)))
                         HGOTO_ERROR(H5E_CACHE, H5E_CANTALLOC, NULL, "memory allocation failed for on disk image buffer")
 #if H5C_DO_MEMORY_SANITY_CHECKS
-                    HDmemcpy(((uint8_t *)entry_ptr->image_ptr) + image_size, 
-                             H5C_IMAGE_SANITY_VALUE, H5C_IMAGE_EXTRA_SPACE);
+                    HDmemcpy(((uint8_t *)entry_ptr->image_ptr) + entry_ptr->size, H5C_IMAGE_SANITY_VALUE, H5C_IMAGE_EXTRA_SPACE);
 #endif /* H5C_DO_MEMORY_SANITY_CHECKS */
                     if(0 == mpi_rank)
                         if(H5C__generate_image(f, cache_ptr, entry_ptr, dxpl_id) < 0)
@@ -5862,19 +5840,10 @@ H5C__flush_single_entry(const H5F_t *f, hid_t dxpl_id, H5C_cache_entry_t *entry_
 #endif /* H5C_DO_SANITY_CHECKS */
 
         if(NULL == entry_ptr->image_ptr) {
-            size_t image_size;
-
-            if(entry_ptr->compressed)
-                image_size = entry_ptr->compressed_size;
-            else
-                image_size = entry_ptr->size;
-            HDassert(image_size > 0);
-
-
-            if(NULL == (entry_ptr->image_ptr = H5MM_malloc(image_size + H5C_IMAGE_EXTRA_SPACE)))
+            if(NULL == (entry_ptr->image_ptr = H5MM_malloc(entry_ptr->size + H5C_IMAGE_EXTRA_SPACE)))
                 HGOTO_ERROR(H5E_CACHE, H5E_CANTALLOC, FAIL, "memory allocation failed for on disk image buffer")
 #if H5C_DO_MEMORY_SANITY_CHECKS
-            HDmemcpy(((uint8_t *)entry_ptr->image_ptr) + image_size, H5C_IMAGE_SANITY_VALUE, H5C_IMAGE_EXTRA_SPACE);
+            HDmemcpy(((uint8_t *)entry_ptr->image_ptr) + entry_ptr->size, H5C_IMAGE_SANITY_VALUE, H5C_IMAGE_EXTRA_SPACE);
 #endif /* H5C_DO_MEMORY_SANITY_CHECKS */
         } /* end if */
 
@@ -5890,19 +5859,7 @@ H5C__flush_single_entry(const H5F_t *f, hid_t dxpl_id, H5C_cache_entry_t *entry_
          * in the entry's type, we silently skip the write.  This
          * flag should only be used in test code. 
          */
-        if(((entry_ptr->type->flags) & H5C__CLASS_SKIP_WRITES) == 0)
-        {
-	    /* If compression is not enabled, the size of the entry on 
-             * disk is entry_prt->size.  However if entry_ptr->compressed
-             * is TRUE, the on disk size is entry_ptr->compressed_size.
-             */
-            size_t image_size;
-
-            if(entry_ptr->compressed)
-                image_size = entry_ptr->compressed_size;
-            else
-                image_size = entry_ptr->size;
-
+        if(((entry_ptr->type->flags) & H5C__CLASS_SKIP_WRITES) == 0) {
 #ifdef H5_HAVE_PARALLEL
             if(collective_write_list) {
                 H5C_collective_write_t *item;
@@ -5910,7 +5867,7 @@ H5C__flush_single_entry(const H5F_t *f, hid_t dxpl_id, H5C_cache_entry_t *entry_
                 if(NULL == (item = (H5C_collective_write_t *)H5FL_MALLOC(H5C_collective_write_t)))
                     HGOTO_ERROR(H5E_CACHE, H5E_CANTALLOC, FAIL, "unable to allocate skip list item")
 
-                item->length = image_size;
+                item->length = entry_ptr->size;
                 item->free_buf = FALSE;
                 item->buf = entry_ptr->image_ptr;
                 item->offset = entry_ptr->addr;
@@ -5922,10 +5879,9 @@ H5C__flush_single_entry(const H5F_t *f, hid_t dxpl_id, H5C_cache_entry_t *entry_
             } /* end if */
             else
 #endif /* H5_HAVE_PARALLEL */
-            if(H5F_block_write(f, entry_ptr->type->mem_type, entry_ptr->addr,
-                    image_size, dxpl_id, entry_ptr->image_ptr) < 0)
+            if(H5F_block_write(f, entry_ptr->type->mem_type, entry_ptr->addr, entry_ptr->size, dxpl_id, entry_ptr->image_ptr) < 0)
                 HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "Can't write image to file.")
-        }
+        } /* end if */
 
         /* if the entry has a notify callback, notify it that we have 
          * just flushed the entry.
@@ -6082,30 +6038,22 @@ H5C__flush_single_entry(const H5F_t *f, hid_t dxpl_id, H5C_cache_entry_t *entry_
             HDassert(!H5F_IS_TMP_ADDR(f, entry_ptr->addr));
 #ifndef NDEBUG
             {
-                hbool_t curr_compressed = FALSE;
                 size_t curr_len;
-                size_t curr_compressed_len = 0;
 
                 /* Get the actual image size for the thing again */
-                entry_ptr->type->image_len((void *)entry_ptr, &curr_len, &curr_compressed, &curr_compressed_len);
+                entry_ptr->type->image_len((void *)entry_ptr, &curr_len);
                 HDassert(curr_len == entry_ptr->size);
-                HDassert(curr_compressed == entry_ptr->compressed);
-                HDassert(curr_compressed_len == entry_ptr->compressed_size);
             }
 #endif /* NDEBUG */
 
-            /* if the file space free size callback is defined, use
+            /* If the file space free size callback is defined, use
              * it to get the size of the block of file space to free.
-             * Otherwise use entry_ptr->compressed_size if 
-             * entry_ptr->compressed == TRUE, and entry_ptr->size
-             * if entry_ptr->compressed == FALSE.
+             * Otherwise use entry_ptr->size.
              */
             if(entry_ptr->type->fsf_size) {
                 if((entry_ptr->type->fsf_size)((void *)entry_ptr, &fsf_size) < 0)
                     HGOTO_ERROR(H5E_CACHE, H5E_CANTFREE, FAIL, "unable to get file space free size")
             } /* end if */
-            else if(entry_ptr->compressed) /* use compressed size */
-                fsf_size = entry_ptr->compressed_size;
             else    /* no file space free size callback -- use entry size */
                 fsf_size = entry_ptr->size;
 
@@ -6228,14 +6176,6 @@ H5C_load_entry(H5F_t *              f,
                 void *              udata)
 {
     hbool_t     dirty = FALSE;          /* Flag indicating whether thing was dirtied during deserialize */
-    hbool_t     compressed = FALSE;     /* flag indicating whether thing            */
-                                        /* will be run through filters on           */
-                                        /* on read and write.  Usually FALSE        */
-                                        /* set to true if appropriate.              */
-    size_t      compressed_size = 0;    /* entry compressed size if                 */
-                                        /* known -- otherwise uncompressed.         */
-                                        /* Zero indicates compression not           */
-                                        /* enabled.                                 */
     void *      image = NULL;           /* Buffer for disk image                    */
     void *      thing = NULL;           /* Pointer to thing loaded                  */
     H5C_cache_entry_t *entry = NULL;    /* Alias for thing loaded, as cache entry   */
@@ -6254,17 +6194,11 @@ H5C_load_entry(H5F_t *              f,
     HDassert(f->shared->cache);
     HDassert(type);
 
-    /* for now, we do not combine the speculative load and compressed flags */
-    HDassert(!((type->flags & H5C__CLASS_SPECULATIVE_LOAD_FLAG) &&
-               (type->flags & H5C__CLASS_COMPRESSED_FLAG)));
-
     /* Can't see how skip reads could be usefully combined with
-     * either the speculative read or compressed flags.  Hence disallow.
+     * the speculative read flag.  Hence disallow.
      */
     HDassert(!((type->flags & H5C__CLASS_SKIP_READS) &&
                (type->flags & H5C__CLASS_SPECULATIVE_LOAD_FLAG)));
-    HDassert(!((type->flags & H5C__CLASS_SKIP_READS) &&
-               (type->flags & H5C__CLASS_COMPRESSED_FLAG)));
 
     HDassert(H5F_addr_defined(addr));
     HDassert(type->get_load_size);
@@ -6378,54 +6312,19 @@ H5C_load_entry(H5F_t *              f,
         entry->magic = H5C__H5C_CACHE_ENTRY_T_MAGIC;
         entry->type  = type;
 
-        /* verify that compressed and compressed_len are initialized */
-        HDassert(compressed == FALSE);
-        HDassert(compressed_size == 0);
-
         /* Get the actual image size for the thing */
-        if(type->image_len(thing, &new_len, &compressed, &compressed_size) < 0)
+        if(type->image_len(thing, &new_len) < 0)
             HGOTO_ERROR(H5E_CACHE, H5E_CANTGET, NULL, "can't retrieve image length")
 
         if(new_len == 0)
             HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, NULL, "image length is 0")
 
-        HDassert(((type->flags & H5C__CLASS_COMPRESSED_FLAG) != 0) ||
-                 ((compressed == FALSE) && (compressed_size == 0)));
-        HDassert((compressed == TRUE) || (compressed_size == 0));
-
         if(new_len != len) {
 
-            if(type->flags & H5C__CLASS_COMPRESSED_FLAG) {
-
-                /* if new_len != len, then compression must be 
-                 * enabled on the entry.  In this case, the image_len
-                 * callback should have set compressed to TRUE, set 
-                 * new_len equal to the uncompressed size of the 
-                 * entry, and compressed_len equal to the compressed
-                 * size -- which must equal len.
-                 *
-                 * We can't verify the uncompressed size, but we can 
-                 * verify the rest with the following assertions.
-                 */
-                HDassert(compressed);
-                HDassert(compressed_size == len);
-
-                /* new_len should contain the uncompressed size.  Set len
-                 * equal to new_len, so that the cache will use the 
-                 * uncompressed size for purposes of space allocation, etc.
-                 */
-                len = new_len;
-
-            } else if (type->flags & H5C__CLASS_SPECULATIVE_LOAD_FLAG) {
+            if (type->flags & H5C__CLASS_SPECULATIVE_LOAD_FLAG) {
 
                 void *new_image;       /* Buffer for disk image */
 
-                /* compressed must be FALSE, and compressed_size 
-                 * must be zero.
-                 */
-                HDassert(!compressed);
-                HDassert(compressed_size == 0);
-
                 /* Adjust the size of the image to match new_len */
                 if(NULL == (new_image = H5MM_realloc(image, 
                                             new_len + H5C_IMAGE_EXTRA_SPACE)))
@@ -6486,13 +6385,6 @@ H5C_load_entry(H5F_t *              f,
 
 #ifndef NDEBUG
                     {
-                        /* new_compressed and new_compressed_size must be 
-                         * initialize to FALSE / 0 respectively, as clients
-                         * that don't use compression may ignore these two 
-                         * parameters.
-                         */
-                        hbool_t new_compressed = FALSE;
-                        size_t new_compressed_size = 0;
                         size_t new_new_len;
 
                         /* Get the actual image size for the thing again.  Note
@@ -6504,10 +6396,8 @@ H5C_load_entry(H5F_t *              f,
                         entry->magic = H5C__H5C_CACHE_ENTRY_T_MAGIC;
                         entry->type  = type;
 
-                        type->image_len(thing, &new_new_len, &new_compressed, &new_compressed_size);
+                        type->image_len(thing, &new_new_len);
                         HDassert(new_new_len == new_len);
-                        HDassert(!new_compressed);
-                        HDassert(new_compressed_size == 0);
                     } /* end block */
 #endif /* NDEBUG */
                 } /* end if (new_len > len) */
@@ -6518,7 +6408,7 @@ H5C_load_entry(H5F_t *              f,
             } else { /* throw an error */
 
                 HGOTO_ERROR(H5E_CACHE, H5E_UNSUPPORTED, NULL, \
-                     "size of non-speculative, non-compressed object changed")
+                     "size of non-speculative object changed")
             }
         } /* end if (new_len != len) */
     } /* end if */
@@ -6551,8 +6441,6 @@ H5C_load_entry(H5F_t *              f,
     entry->addr                 = addr;
     entry->size                 = len;
     HDassert(entry->size < H5C_MAX_ENTRY_SIZE);
-    entry->compressed           = compressed;
-    entry->compressed_size      = compressed_size;
     entry->image_ptr            = image;
     entry->image_up_to_date     = TRUE;
     entry->type                 = type;
@@ -7710,7 +7598,6 @@ H5C__generate_image(const H5F_t *f, H5C_t *cache_ptr, H5C_cache_entry_t *entry_p
     haddr_t		new_addr = HADDR_UNDEF;
     haddr_t		old_addr = HADDR_UNDEF;
     size_t		new_len = 0;
-    size_t		new_compressed_len = 0;
     unsigned            serialize_flags = H5C__SERIALIZE_NO_FLAGS_SET;
     herr_t              ret_value = SUCCEED;
 
@@ -7724,18 +7611,15 @@ H5C__generate_image(const H5F_t *f, H5C_t *cache_ptr, H5C_cache_entry_t *entry_p
 
     /* Call client's pre-serialize callback, if there's one */
     if(entry_ptr->type->pre_serialize && 
-         (entry_ptr->type->pre_serialize)(f, dxpl_id, 
-                (void *)entry_ptr, entry_ptr->addr, entry_ptr->size,
-                entry_ptr->compressed_size, &new_addr, &new_len, 
-                &new_compressed_len, &serialize_flags) < 0)
+            (entry_ptr->type->pre_serialize)(f, dxpl_id, (void *)entry_ptr,
+                entry_ptr->addr, entry_ptr->size, &new_addr, &new_len, &serialize_flags) < 0)
         HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "unable to pre-serialize entry")
 
     /* Check for any flags set in the pre-serialize callback */
     if(serialize_flags != H5C__SERIALIZE_NO_FLAGS_SET) {
         /* Check for unexpected flags from serialize callback */
         if(serialize_flags & ~(H5C__SERIALIZE_RESIZED_FLAG | 
-                               H5C__SERIALIZE_MOVED_FLAG |
-                               H5C__SERIALIZE_COMPRESSED_FLAG))
+                               H5C__SERIALIZE_MOVED_FLAG))
             HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "unknown serialize flag(s)")
 
 #ifdef H5_HAVE_PARALLEL
@@ -7769,49 +7653,31 @@ H5C__generate_image(const H5F_t *f, H5C_t *cache_ptr, H5C_cache_entry_t *entry_p
             HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "resize/move in serialize occured in parallel case.")
 #endif
 
-        /* Resize the buffer if required */
-        if(((!entry_ptr->compressed) && (serialize_flags & H5C__SERIALIZE_RESIZED_FLAG)) ||
-                ((entry_ptr->compressed) && (serialize_flags & H5C__SERIALIZE_COMPRESSED_FLAG))) {
-            size_t new_image_size;
-
-            if(entry_ptr->compressed)
-                new_image_size = new_compressed_len;
-            else
-                new_image_size = new_len;
-            HDassert(new_image_size > 0);
-
-            /* Release the current image */
-            if(entry_ptr->image_ptr)
-                entry_ptr->image_ptr = H5MM_xfree(entry_ptr->image_ptr);
-
+        /* If required, resize the buffer and update the entry and the cache
+         * data structures */
+        if(serialize_flags & H5C__SERIALIZE_RESIZED_FLAG) {
             /* Allocate a new image buffer */
-            if(NULL == (entry_ptr->image_ptr = H5MM_malloc(new_image_size + H5C_IMAGE_EXTRA_SPACE)))
+            if(NULL == (entry_ptr->image_ptr = H5MM_realloc(entry_ptr->image_ptr, new_len + H5C_IMAGE_EXTRA_SPACE)))
                 HGOTO_ERROR(H5E_CACHE, H5E_CANTALLOC, FAIL, "memory allocation failed for on disk image buffer")
-
 #if H5C_DO_MEMORY_SANITY_CHECKS
-            HDmemcpy(((uint8_t *)entry_ptr->image_ptr) + new_image_size, H5C_IMAGE_SANITY_VALUE, H5C_IMAGE_EXTRA_SPACE);
+            HDmemcpy(((uint8_t *)entry_ptr->image_ptr) + new_len, H5C_IMAGE_SANITY_VALUE, H5C_IMAGE_EXTRA_SPACE);
 #endif /* H5C_DO_MEMORY_SANITY_CHECKS */
-        } /* end if */
 
-        /* If required, update the entry and the cache data structures
-         * for a resize.
-         */
-        if(serialize_flags & H5C__SERIALIZE_RESIZED_FLAG) {
+            /* Update statistics for resizing the entry */
             H5C__UPDATE_STATS_FOR_ENTRY_SIZE_CHANGE(cache_ptr, entry_ptr, new_len);
 
-            /* update the hash table for the size change*/
+            /* update the hash table for the size change */
             H5C__UPDATE_INDEX_FOR_SIZE_CHANGE(cache_ptr, entry_ptr->size, \
                                               new_len, entry_ptr, !(entry_ptr->is_dirty));
 
-            /* The entry can't be protected since we are
-             * in the process of flushing it.  Thus we must
-             * update the replacement policy data
-             * structures for the size change.  The macro
-             * deals with the pinned case.
+            /* The entry can't be protected since we are in the process of
+             * flushing it.  Thus we must update the replacement policy data
+             * structures for the size change.  The macro deals with the pinned
+             * case.
              */
             H5C__UPDATE_RP_FOR_SIZE_CHANGE(cache_ptr, entry_ptr, new_len);
 
-            /* as we haven't updated the cache data structures for 
+            /* As we haven't updated the cache data structures for 
              * for the flush or flush destroy yet, the entry should
              * be in the slist.  Thus update it for the size change.
              */
@@ -7828,12 +7694,9 @@ H5C__generate_image(const H5F_t *f, H5C_t *cache_ptr, H5C_cache_entry_t *entry_p
         if(serialize_flags & H5C__SERIALIZE_MOVED_FLAG) {
             H5C__UPDATE_STATS_FOR_MOVE(cache_ptr, entry_ptr);
 
+            /* We must update cache data structures for the change in address */
             if(entry_ptr->addr == old_addr) {
-                /* we must update cache data structures for the 
-                 * change in address.
-                 */
-
-                /* delete the entry from the hash table and the slist */
+                /* Delete the entry from the hash table and the slist */
                 H5C__DELETE_FROM_INDEX(cache_ptr, entry_ptr);
                 H5C__REMOVE_ENTRY_FROM_SLIST(cache_ptr, entry_ptr, FALSE);
 
@@ -7847,35 +7710,15 @@ H5C__generate_image(const H5F_t *f, H5C_t *cache_ptr, H5C_cache_entry_t *entry_p
             else /* move is already done for us -- just do sanity checks */
                 HDassert(entry_ptr->addr == new_addr);
         } /* end if */
-
-        if(serialize_flags & H5C__SERIALIZE_COMPRESSED_FLAG) {
-            /* just save the new compressed entry size in 
-             * entry_ptr->compressed_size.  We don't need to 
-             * do more, as compressed size is only used for I/O.
-             */
-            HDassert(entry_ptr->compressed);
-            entry_ptr->compressed_size = new_compressed_len;
-        } /* end if */
     } /* end if(serialize_flags != H5C__SERIALIZE_NO_FLAGS_SET) */
 
     /* Serialize object into buffer */
-    {
-        size_t image_len;
-
-        if(entry_ptr->compressed)
-            image_len = entry_ptr->compressed_size;
-        else
-            image_len = entry_ptr->size;
-
-        if(entry_ptr->type->serialize(f, entry_ptr->image_ptr, image_len, (void *)entry_ptr) < 0)
-            HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "unable to serialize entry")
-
+    if(entry_ptr->type->serialize(f, entry_ptr->image_ptr, entry_ptr->size, (void *)entry_ptr) < 0)
+        HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "unable to serialize entry")
 #if H5C_DO_MEMORY_SANITY_CHECKS
-        HDassert(0 == HDmemcmp(((uint8_t *)entry_ptr->image_ptr) + image_len, 
-                               H5C_IMAGE_SANITY_VALUE, H5C_IMAGE_EXTRA_SPACE));
+    HDassert(0 == HDmemcmp(((uint8_t *)entry_ptr->image_ptr) + entry_ptr->size, H5C_IMAGE_SANITY_VALUE, H5C_IMAGE_EXTRA_SPACE));
 #endif /* H5C_DO_MEMORY_SANITY_CHECKS */
-        entry_ptr->image_up_to_date = TRUE;
-    } /* end block */
+    entry_ptr->image_up_to_date = TRUE;
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)