@nxtedition/rocksdb 7.1.14 → 7.1.15

package/deps/rocksdb/rocksdb/table/block_based/block_based_table_reader.h

@@ -70,9 +70,6 @@ class BlockBasedTable : public TableReader {
   static const std::string kFullFilterBlockPrefix;
   static const std::string kPartitionedFilterBlockPrefix;
 
-  // All the below fields control iterator readahead
-  static const int kMinNumFileReadsToStartAutoReadahead = 2;
-
   // 1-byte compression type + 32-bit checksum
   static constexpr size_t kBlockTrailerSize = 5;
 
@@ -111,7 +108,8 @@ class BlockBasedTable : public TableReader {
       TailPrefetchStats* tail_prefetch_stats = nullptr,
       BlockCacheTracer* const block_cache_tracer = nullptr,
       size_t max_file_size_for_l0_meta_pin = 0,
-      const std::string& cur_db_session_id = "", uint64_t cur_file_num = 0);
+      const std::string& cur_db_session_id = "", uint64_t cur_file_num = 0,
+      UniqueId64x2 expected_unique_id = {});
 
   bool PrefixRangeMayMatch(const Slice& internal_key,
                            const ReadOptions& read_options,
@@ -251,16 +249,16 @@ class BlockBasedTable : public TableReader {
     return static_cast<size_t>(handle.size() + kBlockTrailerSize);
   }
 
-  // It's the caller's responsibility to make sure that this is
-  // for raw block contents, which contains the compression
-  // byte in the end.
+  // It is the caller's responsibility to make sure that this is called with
+  // block-based table serialized block contents, which contains the compression
+  // byte in the trailer after `block_size`.
   static inline CompressionType GetBlockCompressionType(const char* block_data,
                                                         size_t block_size) {
     return static_cast<CompressionType>(block_data[block_size]);
   }
   static inline CompressionType GetBlockCompressionType(
       const BlockContents& contents) {
-    assert(contents.is_raw_block);
+    assert(contents.has_trailer);
     return GetBlockCompressionType(contents.data.data(), contents.data.size());
   }
 
@@ -329,7 +327,7 @@ class BlockBasedTable : public TableReader {
   Status InsertEntryToCache(const CacheTier& cache_tier, Cache* block_cache,
                             const Slice& key,
                             const Cache::CacheItemHelper* cache_helper,
-                            std::unique_ptr<TBlocklike>& block_holder,
+                            std::unique_ptr<TBlocklike>&& block_holder,
                             size_t charge, Cache::Handle** cache_handle,
                             Cache::Priority priority) const;
 
@@ -413,13 +411,13 @@ class BlockBasedTable : public TableReader {
                                BlockType block_type, const bool wait,
                                GetContext* get_context) const;
 
-  // Put a raw block (maybe compressed) to the corresponding block caches.
-  // This method will perform decompression against raw_block if needed and then
-  // populate the block caches.
+  // Put a maybe compressed block to the corresponding block caches.
+  // This method will perform decompression against block_contents if needed
+  // and then populate the block caches.
   // On success, Status::OK will be returned; also @block will be populated with
   // uncompressed block and its cache handle.
   //
-  // Allocated memory managed by raw_block_contents will be transferred to
+  // Allocated memory managed by block_contents will be transferred to
   // PutDataBlockToCache(). After the call, the object will be invalid.
   // @param uncompression_dict Data for presetting the compression library's
   //    dictionary.
@@ -427,8 +425,8 @@ class BlockBasedTable : public TableReader {
   Status PutDataBlockToCache(const Slice& cache_key, Cache* block_cache,
                              Cache* block_cache_compressed,
                              CachableEntry<TBlocklike>* cached_block,
-                             BlockContents* raw_block_contents,
-                             CompressionType raw_block_comp_type,
+                             BlockContents&& block_contents,
+                             CompressionType block_comp_type,
                              const UncompressionDict& uncompression_dict,
                              MemoryAllocator* memory_allocator,
                              BlockType block_type,
@@ -659,25 +657,28 @@ struct BlockBasedTable::Rep {
   uint64_t sst_number_for_tracing() const {
     return file ? TableFileNameToNumber(file->file_name()) : UINT64_MAX;
   }
-  void CreateFilePrefetchBuffer(size_t readahead_size,
-                                size_t max_readahead_size,
-                                std::unique_ptr<FilePrefetchBuffer>* fpb,
-                                bool implicit_auto_readahead,
-                                uint64_t num_file_reads) const {
+  void CreateFilePrefetchBuffer(
+      size_t readahead_size, size_t max_readahead_size,
+      std::unique_ptr<FilePrefetchBuffer>* fpb, bool implicit_auto_readahead,
+      uint64_t num_file_reads,
+      uint64_t num_file_reads_for_auto_readahead) const {
     fpb->reset(new FilePrefetchBuffer(
         readahead_size, max_readahead_size,
         !ioptions.allow_mmap_reads /* enable */, false /* track_min_offset */,
-        implicit_auto_readahead, num_file_reads, ioptions.fs.get(),
-        ioptions.clock, ioptions.stats));
+        implicit_auto_readahead, num_file_reads,
+        num_file_reads_for_auto_readahead, ioptions.fs.get(), ioptions.clock,
+        ioptions.stats));
   }
 
   void CreateFilePrefetchBufferIfNotExists(
       size_t readahead_size, size_t max_readahead_size,
       std::unique_ptr<FilePrefetchBuffer>* fpb, bool implicit_auto_readahead,
-      uint64_t num_file_reads) const {
+      uint64_t num_file_reads,
+      uint64_t num_file_reads_for_auto_readahead) const {
     if (!(*fpb)) {
       CreateFilePrefetchBuffer(readahead_size, max_readahead_size, fpb,
-                               implicit_auto_readahead, num_file_reads);
+                               implicit_auto_readahead, num_file_reads,
+                               num_file_reads_for_auto_readahead);
     }
   }
 

package/deps/rocksdb/rocksdb/table/block_based/block_based_table_reader_sync_and_async.h

@@ -191,7 +191,7 @@ DEFINE_SYNC_AND_ASYNC(void, BlockBasedTable::RetrieveMultipleBlocks)
       }
     }
 
-    BlockContents raw_block_contents;
+    BlockContents serialized_block;
     if (s.ok()) {
       if (!use_shared_buffer) {
         // We allocated a buffer for this block. Give ownership of it to
@@ -199,17 +199,17 @@ DEFINE_SYNC_AND_ASYNC(void, BlockBasedTable::RetrieveMultipleBlocks)
         assert(req.result.data() == req.scratch);
         assert(req.result.size() == BlockSizeWithTrailer(handle));
         assert(req_offset == 0);
-        std::unique_ptr<char[]> raw_block(req.scratch);
-        raw_block_contents = BlockContents(std::move(raw_block), handle.size());
+        serialized_block =
+            BlockContents(std::unique_ptr<char[]>(req.scratch), handle.size());
       } else {
         // We used the scratch buffer or direct io buffer
         // which are shared by the blocks.
-        // raw_block_contents does not have the ownership.
-        raw_block_contents =
+        // serialized_block does not have the ownership.
+        serialized_block =
             BlockContents(Slice(req.result.data() + req_offset, handle.size()));
       }
 #ifndef NDEBUG
-      raw_block_contents.is_raw_block = true;
+      serialized_block.has_trailer = true;
 #endif
 
       if (options.verify_checksums) {
@@ -232,28 +232,29 @@ DEFINE_SYNC_AND_ASYNC(void, BlockBasedTable::RetrieveMultipleBlocks)
 
     if (s.ok()) {
       // When the blocks share the same underlying buffer (scratch or direct io
-      // buffer), we may need to manually copy the block into heap if the raw
-      // block has to be inserted into a cache. That falls into th following
-      // cases -
-      // 1. Raw block is not compressed, it needs to be inserted into the
-      //    uncompressed block cache if there is one
-      // 2. If the raw block is compressed, it needs to be inserted into the
-      //    compressed block cache if there is one
+      // buffer), we may need to manually copy the block into heap if the
+      // serialized block has to be inserted into a cache. That falls into the
+      // following cases -
+      // 1. serialized block is not compressed, it needs to be inserted into
+      //    the uncompressed block cache if there is one
+      // 2. If the serialized block is compressed, it needs to be inserted
+      //    into the compressed block cache if there is one
       //
-      // In all other cases, the raw block is either uncompressed into a heap
-      // buffer or there is no cache at all.
+      // In all other cases, the serialized block is either uncompressed into a
+      // heap buffer or there is no cache at all.
       CompressionType compression_type =
-          GetBlockCompressionType(raw_block_contents);
+          GetBlockCompressionType(serialized_block);
       if (use_shared_buffer && (compression_type == kNoCompression ||
                                 (compression_type != kNoCompression &&
                                  rep_->table_options.block_cache_compressed))) {
-        Slice raw =
+        Slice serialized =
             Slice(req.result.data() + req_offset, BlockSizeWithTrailer(handle));
-        raw_block_contents = BlockContents(
-            CopyBufferToHeap(GetMemoryAllocator(rep_->table_options), raw),
+        serialized_block = BlockContents(
+            CopyBufferToHeap(GetMemoryAllocator(rep_->table_options),
+                             serialized),
             handle.size());
 #ifndef NDEBUG
-        raw_block_contents.is_raw_block = true;
+        serialized_block.has_trailer = true;
 #endif
       }
     }
@@ -264,13 +265,13 @@ DEFINE_SYNC_AND_ASYNC(void, BlockBasedTable::RetrieveMultipleBlocks)
             TableReaderCaller::kUserMultiGet);
         CachableEntry<Block>* block_entry = &(*results)[idx_in_batch];
         // MaybeReadBlockAndLoadToCache will insert into the block caches if
-        // necessary. Since we're passing the raw block contents, it will
-        // avoid looking up the block cache
+        // necessary. Since we're passing the serialized block contents, it
+        // will avoid looking up the block cache
         s = MaybeReadBlockAndLoadToCache(
             nullptr, options, handle, uncompression_dict, /*wait=*/true,
             /*for_compaction=*/false, block_entry, BlockType::kData,
             mget_iter->get_context, &lookup_data_block_context,
-            &raw_block_contents, /*async_read=*/false);
+            &serialized_block, /*async_read=*/false);
 
         // block_entry value could be null if no block cache is present, i.e
         // BlockBasedTableOptions::no_block_cache is true and no compressed
@@ -283,12 +284,12 @@ DEFINE_SYNC_AND_ASYNC(void, BlockBasedTable::RetrieveMultipleBlocks)
       }
 
       CompressionType compression_type =
-          GetBlockCompressionType(raw_block_contents);
+          GetBlockCompressionType(serialized_block);
       BlockContents contents;
       if (compression_type != kNoCompression) {
         UncompressionContext context(compression_type);
         UncompressionInfo info(context, uncompression_dict, compression_type);
-        s = UncompressBlockContents(
+        s = UncompressSerializedBlock(
             info, req.result.data() + req_offset, handle.size(), &contents,
             footer.format_version(), rep_->ioptions, memory_allocator);
       } else {
@@ -296,13 +297,13 @@ DEFINE_SYNC_AND_ASYNC(void, BlockBasedTable::RetrieveMultipleBlocks)
         // 1) caller uses the shared buffer (scratch or direct io buffer);
         // 2) we use the requst buffer.
         // If scratch buffer or direct io buffer is used, we ensure that
-        // all raw blocks are copyed to the heap as single blocks. If scratch
-        // buffer is not used, we also have no combined read, so the raw
-        // block can be used directly.
-        contents = std::move(raw_block_contents);
+        // all serialized blocks are copyed to the heap as single blocks. If
+        // scratch buffer is not used, we also have no combined read, so the
+        // serialized block can be used directly.
+        contents = std::move(serialized_block);
       }
       if (s.ok()) {
-        (*results)[idx_in_batch].SetOwnedValue(new Block(
+        (*results)[idx_in_batch].SetOwnedValue(std::make_unique<Block>(
             std::move(contents), read_amp_bytes_per_bit, ioptions.stats));
       }
     }

package/deps/rocksdb/rocksdb/table/block_based/block_prefetcher.cc

@@ -23,7 +23,7 @@ void BlockPrefetcher::PrefetchIfNeeded(
     rep->CreateFilePrefetchBufferIfNotExists(
         compaction_readahead_size_, compaction_readahead_size_,
         &prefetch_buffer_, /*implicit_auto_readahead=*/false,
-        /*num_file_reads=*/0);
+        /*num_file_reads=*/0, /*num_file_reads_for_auto_readahead=*/0);
     return;
   }
 
@@ -31,7 +31,8 @@ void BlockPrefetcher::PrefetchIfNeeded(
   if (readahead_size > 0) {
     rep->CreateFilePrefetchBufferIfNotExists(
         readahead_size, readahead_size, &prefetch_buffer_,
-        /*implicit_auto_readahead=*/false, /*num_file_reads=*/0);
+        /*implicit_auto_readahead=*/false, /*num_file_reads=*/0,
+        /*num_file_reads_for_auto_readahead=*/0);
     return;
   }
 
@@ -44,13 +45,18 @@ void BlockPrefetcher::PrefetchIfNeeded(
     return;
   }
 
+  if (initial_auto_readahead_size_ > max_auto_readahead_size) {
+    initial_auto_readahead_size_ = max_auto_readahead_size;
+  }
+
   // In case of no_sequential_checking, it will skip the num_file_reads_ and
   // will always creates the FilePrefetchBuffer.
   if (no_sequential_checking) {
     rep->CreateFilePrefetchBufferIfNotExists(
         initial_auto_readahead_size_, max_auto_readahead_size,
         &prefetch_buffer_, /*implicit_auto_readahead=*/true,
-        /*num_file_reads=*/0);
+        /*num_file_reads=*/0,
+        rep->table_options.num_file_reads_for_auto_readahead);
     return;
   }
 
@@ -72,22 +78,18 @@ void BlockPrefetcher::PrefetchIfNeeded(
   UpdateReadPattern(offset, len);
 
   // Implicit auto readahead, which will be enabled if the number of reads
-  // reached `kMinNumFileReadsToStartAutoReadahead` (default: 2)  and scans are
-  // sequential.
+  // reached `table_options.num_file_reads_for_auto_readahead` (default: 2)  and
+  // scans are sequential.
   num_file_reads_++;
-  if (num_file_reads_ <=
-      BlockBasedTable::kMinNumFileReadsToStartAutoReadahead) {
+  if (num_file_reads_ <= rep->table_options.num_file_reads_for_auto_readahead) {
     return;
   }
 
-  if (initial_auto_readahead_size_ > max_auto_readahead_size) {
-    initial_auto_readahead_size_ = max_auto_readahead_size;
-  }
-
   if (rep->file->use_direct_io()) {
     rep->CreateFilePrefetchBufferIfNotExists(
         initial_auto_readahead_size_, max_auto_readahead_size,
-        &prefetch_buffer_, /*implicit_auto_readahead=*/true, num_file_reads_);
+        &prefetch_buffer_, /*implicit_auto_readahead=*/true, num_file_reads_,
+        rep->table_options.num_file_reads_for_auto_readahead);
     return;
   }
 
@@ -105,7 +107,8 @@ void BlockPrefetcher::PrefetchIfNeeded(
   if (s.IsNotSupported()) {
     rep->CreateFilePrefetchBufferIfNotExists(
         initial_auto_readahead_size_, max_auto_readahead_size,
-        &prefetch_buffer_, /*implicit_auto_readahead=*/true, num_file_reads_);
+        &prefetch_buffer_, /*implicit_auto_readahead=*/true, num_file_reads_,
+        rep->table_options.num_file_reads_for_auto_readahead);
     return;
   }
 

package/deps/rocksdb/rocksdb/table/block_based/cachable_entry.h

@@ -132,17 +132,17 @@ public:
     ResetFields();
   }
 
-  void SetOwnedValue(T* value) {
-    assert(value != nullptr);
+  void SetOwnedValue(std::unique_ptr<T>&& value) {
+    assert(value.get() != nullptr);
 
-    if (UNLIKELY(value_ == value && own_value_)) {
+    if (UNLIKELY(value_ == value.get() && own_value_)) {
       assert(cache_ == nullptr && cache_handle_ == nullptr);
       return;
     }
 
     Reset();
 
-    value_ = value;
+    value_ = value.release();
     own_value_ = true;
   }
 

package/deps/rocksdb/rocksdb/table/block_based/partitioned_filter_block.cc

@@ -493,9 +493,9 @@ Status PartitionedFilterBlockReader::CacheDependencies(const ReadOptions& ro,
       handle.offset() + handle.size() + BlockBasedTable::kBlockTrailerSize;
   uint64_t prefetch_len = last_off - prefetch_off;
   std::unique_ptr<FilePrefetchBuffer> prefetch_buffer;
-  rep->CreateFilePrefetchBuffer(0, 0, &prefetch_buffer,
-                                false /* Implicit autoreadahead */,
-                                0 /*num_reads_*/);
+  rep->CreateFilePrefetchBuffer(
+      0, 0, &prefetch_buffer, false /* Implicit autoreadahead */,
+      0 /*num_reads_*/, 0 /*num_file_reads_for_auto_readahead*/);
 
   IOOptions opts;
   s = rep->file->PrepareIOOptions(ro, opts);

package/deps/rocksdb/rocksdb/table/block_based/partitioned_index_reader.cc

@@ -156,9 +156,9 @@ Status PartitionIndexReader::CacheDependencies(const ReadOptions& ro,
       handle.offset() + BlockBasedTable::BlockSizeWithTrailer(handle);
   uint64_t prefetch_len = last_off - prefetch_off;
   std::unique_ptr<FilePrefetchBuffer> prefetch_buffer;
-  rep->CreateFilePrefetchBuffer(0, 0, &prefetch_buffer,
-                                false /*Implicit auto readahead*/,
-                                0 /*num_reads_*/);
+  rep->CreateFilePrefetchBuffer(
+      0, 0, &prefetch_buffer, false /*Implicit auto readahead*/,
+      0 /*num_reads_*/, 0 /*num_file_reads_for_auto_readahead*/);
   IOOptions opts;
   {
     Status s = rep->file->PrepareIOOptions(ro, opts);

package/deps/rocksdb/rocksdb/table/block_fetcher.cc

@@ -49,7 +49,7 @@ inline void BlockFetcher::ProcessTrailerIfPresent() {
 inline bool BlockFetcher::TryGetUncompressBlockFromPersistentCache() {
   if (cache_options_.persistent_cache &&
       !cache_options_.persistent_cache->IsCompressed()) {
-    Status status = PersistentCacheHelper::LookupUncompressedPage(
+    Status status = PersistentCacheHelper::LookupUncompressed(
         cache_options_, handle_, contents_);
     if (status.ok()) {
       // uncompressed page is found for the block handle
@@ -99,15 +99,14 @@ inline bool BlockFetcher::TryGetFromPrefetchBuffer() {
   return got_from_prefetch_buffer_;
 }
 
-inline bool BlockFetcher::TryGetCompressedBlockFromPersistentCache() {
+inline bool BlockFetcher::TryGetSerializedBlockFromPersistentCache() {
   if (cache_options_.persistent_cache &&
       cache_options_.persistent_cache->IsCompressed()) {
-    // lookup uncompressed cache mode p-cache
-    std::unique_ptr<char[]> raw_data;
-    io_status_ = status_to_io_status(PersistentCacheHelper::LookupRawPage(
-        cache_options_, handle_, &raw_data, block_size_with_trailer_));
+    std::unique_ptr<char[]> buf;
+    io_status_ = status_to_io_status(PersistentCacheHelper::LookupSerialized(
+        cache_options_, handle_, &buf, block_size_with_trailer_));
     if (io_status_.ok()) {
-      heap_buf_ = CacheAllocationPtr(raw_data.release());
+      heap_buf_ = CacheAllocationPtr(buf.release());
       used_buf_ = heap_buf_.get();
       slice_ = Slice(heap_buf_.get(), block_size_);
       ProcessTrailerIfPresent();
@@ -162,9 +161,8 @@ inline void BlockFetcher::InsertCompressedBlockToPersistentCacheIfNeeded() {
   if (io_status_.ok() && read_options_.fill_cache &&
       cache_options_.persistent_cache &&
       cache_options_.persistent_cache->IsCompressed()) {
-    // insert to raw cache
-    PersistentCacheHelper::InsertRawPage(cache_options_, handle_, used_buf_,
-                                         block_size_with_trailer_);
+    PersistentCacheHelper::InsertSerialized(cache_options_, handle_, used_buf_,
+                                            block_size_with_trailer_);
   }
 }
 
@@ -173,8 +171,8 @@ inline void BlockFetcher::InsertUncompressedBlockToPersistentCacheIfNeeded() {
       read_options_.fill_cache && cache_options_.persistent_cache &&
       !cache_options_.persistent_cache->IsCompressed()) {
     // insert to uncompressed cache
-    PersistentCacheHelper::InsertUncompressedPage(cache_options_, handle_,
-                                                  *contents_);
+    PersistentCacheHelper::InsertUncompressed(cache_options_, handle_,
+                                              *contents_);
   }
 }
 
@@ -234,7 +232,7 @@ inline void BlockFetcher::GetBlockContents() {
     *contents_ = BlockContents(std::move(heap_buf_), block_size_);
   }
 #ifndef NDEBUG
-  contents_->is_raw_block = true;
+  contents_->has_trailer = footer_.GetBlockTrailerSize() > 0;
 #endif
 }
 
@@ -242,7 +240,7 @@ IOStatus BlockFetcher::ReadBlockContents() {
   if (TryGetUncompressBlockFromPersistentCache()) {
     compression_type_ = kNoCompression;
 #ifndef NDEBUG
-    contents_->is_raw_block = true;
+    contents_->has_trailer = footer_.GetBlockTrailerSize() > 0;
 #endif  // NDEBUG
     return IOStatus::OK();
   }
@@ -250,7 +248,7 @@ IOStatus BlockFetcher::ReadBlockContents() {
     if (!io_status_.ok()) {
       return io_status_;
     }
-  } else if (!TryGetCompressedBlockFromPersistentCache()) {
+  } else if (!TryGetSerializedBlockFromPersistentCache()) {
     IOOptions opts;
     io_status_ = file_->PrepareIOOptions(read_options_, opts);
     // Actual file read
@@ -327,7 +325,7 @@ IOStatus BlockFetcher::ReadBlockContents() {
     // compressed page, uncompress, update cache
     UncompressionContext context(compression_type_);
     UncompressionInfo info(context, uncompression_dict_, compression_type_);
-    io_status_ = status_to_io_status(UncompressBlockContents(
+    io_status_ = status_to_io_status(UncompressSerializedBlock(
         info, slice_.data(), block_size_, contents_, footer_.format_version(),
         ioptions_, memory_allocator_));
 #ifndef NDEBUG
@@ -347,10 +345,10 @@ IOStatus BlockFetcher::ReadAsyncBlockContents() {
   if (TryGetUncompressBlockFromPersistentCache()) {
     compression_type_ = kNoCompression;
 #ifndef NDEBUG
-    contents_->is_raw_block = true;
+    contents_->has_trailer = footer_.GetBlockTrailerSize() > 0;
 #endif  // NDEBUG
     return IOStatus::OK();
-  } else if (!TryGetCompressedBlockFromPersistentCache()) {
+  } else if (!TryGetSerializedBlockFromPersistentCache()) {
     assert(prefetch_buffer_ != nullptr);
     if (!for_compaction_) {
       IOOptions opts;
@@ -378,7 +376,7 @@ IOStatus BlockFetcher::ReadAsyncBlockContents() {
           UncompressionContext context(compression_type_);
           UncompressionInfo info(context, uncompression_dict_,
                                  compression_type_);
-          io_status_ = status_to_io_status(UncompressBlockContents(
+          io_status_ = status_to_io_status(UncompressSerializedBlock(
               info, slice_.data(), block_size_, contents_,
               footer_.format_version(), ioptions_, memory_allocator_));
 #ifndef NDEBUG

package/deps/rocksdb/rocksdb/table/block_fetcher.h

@@ -128,7 +128,7 @@ class BlockFetcher {
   bool TryGetUncompressBlockFromPersistentCache();
   // return true if found
   bool TryGetFromPrefetchBuffer();
-  bool TryGetCompressedBlockFromPersistentCache();
+  bool TryGetSerializedBlockFromPersistentCache();
   void PrepareBufferForBlockFromFile();
   // Copy content from used_buf_ to new heap_buf_.
   void CopyBufferToHeapBuf();

package/deps/rocksdb/rocksdb/table/format.cc

@@ -390,6 +390,10 @@ Status ReadFooterFromFile(const IOOptions& opts, RandomAccessFileReader* file,
   // Check that we actually read the whole footer from the file. It may be
   // that size isn't correct.
   if (footer_input.size() < Footer::kMinEncodedLength) {
+    // FIXME: this error message is bad. We should be checking whether the
+    // provided file_size matches what's on disk, at least in this case.
+    // Unfortunately FileSystem/Env does not provide a way to get the size
+    // of an open file, so getting file size requires a full path seek.
     return Status::Corruption("file is too short (" +
                               std::to_string(file_size) +
                               " bytes) to be an "
@@ -494,10 +498,11 @@ uint32_t ComputeBuiltinChecksumWithLastByte(ChecksumType type, const char* data,
   }
 }
 
-Status UncompressBlockContentsForCompressionType(
-    const UncompressionInfo& uncompression_info, const char* data, size_t n,
-    BlockContents* contents, uint32_t format_version,
-    const ImmutableOptions& ioptions, MemoryAllocator* allocator) {
+Status UncompressBlockData(const UncompressionInfo& uncompression_info,
+                           const char* data, size_t size,
+                           BlockContents* out_contents, uint32_t format_version,
+                           const ImmutableOptions& ioptions,
+                           MemoryAllocator* allocator) {
   Status ret = Status::OK();
 
   assert(uncompression_info.type() != kNoCompression &&
@@ -507,7 +512,7 @@ Status UncompressBlockContentsForCompressionType(
                       ShouldReportDetailedTime(ioptions.env, ioptions.stats));
   size_t uncompressed_size = 0;
   CacheAllocationPtr ubuf =
-      UncompressData(uncompression_info, data, n, &uncompressed_size,
+      UncompressData(uncompression_info, data, size, &uncompressed_size,
                      GetCompressFormatForVersion(format_version), allocator);
   if (!ubuf) {
     if (!CompressionTypeSupported(uncompression_info.type())) {
@@ -521,44 +526,36 @@ Status UncompressBlockContentsForCompressionType(
     }
   }
 
-  *contents = BlockContents(std::move(ubuf), uncompressed_size);
+  *out_contents = BlockContents(std::move(ubuf), uncompressed_size);
 
   if (ShouldReportDetailedTime(ioptions.env, ioptions.stats)) {
     RecordTimeToHistogram(ioptions.stats, DECOMPRESSION_TIMES_NANOS,
                           timer.ElapsedNanos());
   }
   RecordTimeToHistogram(ioptions.stats, BYTES_DECOMPRESSED,
-                        contents->data.size());
+                        out_contents->data.size());
   RecordTick(ioptions.stats, NUMBER_BLOCK_DECOMPRESSED);
 
+  TEST_SYNC_POINT_CALLBACK("UncompressBlockData:TamperWithReturnValue",
+                           static_cast<void*>(&ret));
   TEST_SYNC_POINT_CALLBACK(
-      "UncompressBlockContentsForCompressionType:TamperWithReturnValue",
-      static_cast<void*>(&ret));
-  TEST_SYNC_POINT_CALLBACK(
-      "UncompressBlockContentsForCompressionType:"
+      "UncompressBlockData:"
       "TamperWithDecompressionOutput",
-      static_cast<void*>(contents));
+      static_cast<void*>(out_contents));
 
   return ret;
 }
 
-//
-// The 'data' points to the raw block contents that was read in from file.
-// This method allocates a new heap buffer and the raw block
-// contents are uncompresed into this buffer. This
-// buffer is returned via 'result' and it is upto the caller to
-// free this buffer.
-// format_version is the block format as defined in include/rocksdb/table.h
-Status UncompressBlockContents(const UncompressionInfo& uncompression_info,
-                               const char* data, size_t n,
-                               BlockContents* contents, uint32_t format_version,
-                               const ImmutableOptions& ioptions,
-                               MemoryAllocator* allocator) {
-  assert(data[n] != kNoCompression);
-  assert(data[n] == static_cast<char>(uncompression_info.type()));
-  return UncompressBlockContentsForCompressionType(uncompression_info, data, n,
-                                                   contents, format_version,
-                                                   ioptions, allocator);
+Status UncompressSerializedBlock(const UncompressionInfo& uncompression_info,
+                                 const char* data, size_t size,
+                                 BlockContents* out_contents,
+                                 uint32_t format_version,
+                                 const ImmutableOptions& ioptions,
+                                 MemoryAllocator* allocator) {
+  assert(data[size] != kNoCompression);
+  assert(data[size] == static_cast<char>(uncompression_info.type()));
+  return UncompressBlockData(uncompression_info, data, size, out_contents,
+                             format_version, ioptions, allocator);
 }
 
 // Replace the contents of db_host_id with the actual hostname, if db_host_id