@nxtedition/rocksdb 13.5.12 → 14.0.0

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

@@ -45,7 +45,9 @@ class BlockBasedTableIterator : public InternalIteratorBase<Slice> {
         need_upper_bound_check_(need_upper_bound_check),
         async_read_in_progress_(false),
         is_last_level_(table->IsLastLevel()),
-        block_iter_points_to_real_block_(false) {}
+        block_iter_points_to_real_block_(false) {
+    multi_scan_status_.PermitUncheckedError();
+  }
 
   ~BlockBasedTableIterator() override { ClearBlockHandles(); }
 
@@ -57,7 +59,7 @@ class BlockBasedTableIterator : public InternalIteratorBase<Slice> {
   bool NextAndGetResult(IterateResult* result) override;
   void Prev() override;
   bool Valid() const override {
-    return !is_out_of_bound_ &&
+    return !is_out_of_bound_ && multi_scan_status_.ok() &&
            (is_at_first_key_from_index_ ||
             (block_iter_points_to_real_block_ && block_iter_.Valid()));
   }
@@ -136,6 +138,9 @@ class BlockBasedTableIterator : public InternalIteratorBase<Slice> {
     return block_iter_.value();
   }
   Status status() const override {
+    if (!multi_scan_status_.ok()) {
+      return multi_scan_status_;
+    }
     // In case of block cache readahead lookup, it won't add the block to
     // block_handles if it's index is invalid. So index_iter_->status check can
     // be skipped.
@@ -145,10 +150,13 @@ class BlockBasedTableIterator : public InternalIteratorBase<Slice> {
       assert(!multi_scan_);
       return index_iter_->status();
     } else if (block_iter_points_to_real_block_) {
+      // This is the common case.
       return block_iter_.status();
     } else if (async_read_in_progress_) {
       assert(!multi_scan_);
       return Status::TryAgain("Async read in progress");
+    } else if (multi_scan_) {
+      return multi_scan_status_;
     } else {
       return Status::OK();
     }
@@ -160,6 +168,8 @@ class BlockBasedTableIterator : public InternalIteratorBase<Slice> {
     } else if (block_upper_bound_check_ ==
                BlockUpperBound::kUpperBoundBeyondCurBlock) {
       assert(!is_out_of_bound_);
+      // MultiScan does not do block level upper bound check yet.
+      assert(!multi_scan_);
       return IterBoundCheck::kInbound;
     } else {
       return IterBoundCheck::kUnknown;
@@ -225,7 +235,7 @@ class BlockBasedTableIterator : public InternalIteratorBase<Slice> {
     }
   }
 
-  void Prepare(const std::vector<ScanOptions>* scan_opts) override;
+  void Prepare(const MultiScanArgs* scan_opts) override;
 
   FilePrefetchBuffer* prefetch_buffer() {
     return block_prefetcher_.prefetch_buffer();
@@ -233,6 +243,16 @@ class BlockBasedTableIterator : public InternalIteratorBase<Slice> {
 
   std::unique_ptr<InternalIteratorBase<IndexValue>> index_iter_;
 
+  bool TEST_IsBlockPinnedByMultiScan(size_t block_idx) {
+    if (!multi_scan_) {
+      return false;
+    }
+    if (block_idx >= multi_scan_->pinned_data_blocks.size()) {
+      return false;
+    }
+    return !multi_scan_->pinned_data_blocks[block_idx].IsEmpty();
+  }
+
  private:
   enum class IterDirection {
     kForward,
@@ -371,29 +391,107 @@ class BlockBasedTableIterator : public InternalIteratorBase<Slice> {
   // *** END States used by both regular scan and multiscan
 
   // *** BEGIN MultiScan related states ***
+  struct AsyncReadState {
+    std::unique_ptr<char[]> buf{nullptr};
+    // Indices into pinned_data_blocks that this request reads.
+    std::vector<size_t> block_indices;
+    // BlockHandle for each block in block_indices.
+    std::vector<BlockHandle> blocks;
+    void* io_handle{nullptr};
+    IOHandleDeleter del_fn{nullptr};
+    // offset for this async read request.
+    uint64_t offset{0};
+
+    // These two states are populated from the FSReadRequest
+    // by ReadAsync callback
+    Status status;
+    Slice result;
+
+    // For direct I/O support
+    AlignedBuf aligned_buf{nullptr};
+
+    bool finished{false};
+
+    AsyncReadState() = default;
+    DECLARE_DEFAULT_MOVES(AsyncReadState);
+    // Delete copy operations
+    AsyncReadState(const AsyncReadState&) = delete;
+    AsyncReadState& operator=(const AsyncReadState&) = delete;
+
+    void CleanUpIOHandle() {
+      if (io_handle != nullptr) {
+        assert(del_fn);
+        del_fn(io_handle);
+        io_handle = nullptr;
+      }
+      finished = true;
+    }
+
+    ~AsyncReadState() {
+      // Should be cleaned up before destruction.
+      assert(io_handle == nullptr);
+    }
+  };
+
   struct MultiScanState {
-    // bool prepared_ = false;
-    const std::vector<ScanOptions>* scan_opts;
+    // For Aborting async I/Os in destructor.
+    const std::shared_ptr<FileSystem> fs;
+    const MultiScanArgs* scan_opts;
     std::vector<CachableEntry<Block>> pinned_data_blocks;
-
-    // Indicies into multiscan_pinned_data_blocks_ for data blocks that are
-    // relevant for each scan range.
+    // The separator of each data block in above pinned_data_blocks vector.
+    // Its size is same as pinned_data_blocks.
+    // The value of separator is larger than or equal to the last key in the
+    // corresponding data block.
+    std::vector<std::string> data_block_separators;
+    // Track previously seeked key in multi-scan.
+    // This is used to ensure that the seek key is keep moving forward, as
+    // blocks that are smaller than the seek key are unpinned from memory.
+    std::string prev_seek_key_;
+
+    // Indicies into pinned_data_blocks for data blocks for each scan range.
     // inclusive start, exclusive end
-    std::vector<std::tuple<size_t, size_t>> block_ranges_per_scan;
+    std::vector<std::tuple<size_t, size_t>> block_index_ranges_per_scan;
     size_t next_scan_idx;
     size_t cur_data_block_idx;
 
+    // States for async reads.
+    //
+    // Each async state correspond to an async read request.
+    // Each async read request may read content for multiple blocks
+    // (potentially coalesced). In PollForBlock(idx), we will poll for the
+    // completion of the async read request responsible for
+    // pinned_data_blocks[idx], and populate `pinned_data_blocks` with all the
+    // blocks read. To find out the async read request responsible for
+    // pinned_data_blocks[idx], we store the mapping in
+    // block_idx_to_readreq_idx. Index i is in block_idx_to_readreq_idx and
+    // block_idx_to_readreq_idx[i] = j iff pinned_data_blocks[i] is read by
+    // async_states[j].
+    std::vector<AsyncReadState> async_states;
+    UnorderedMap<size_t, size_t> block_idx_to_readreq_idx;
+    size_t prefetch_max_idx;
+
     MultiScanState(
-        const std::vector<ScanOptions>* _scan_opts,
+        const std::shared_ptr<FileSystem>& _fs, const MultiScanArgs* _scan_opts,
         std::vector<CachableEntry<Block>>&& _pinned_data_blocks,
-        std::vector<std::tuple<size_t, size_t>>&& _block_ranges_per_scan)
-        : scan_opts(_scan_opts),
+        std::vector<std::string>&& _data_block_separators,
+        std::vector<std::tuple<size_t, size_t>>&& _block_index_ranges_per_scan,
+        UnorderedMap<size_t, size_t>&& _block_idx_to_readreq_idx,
+        std::vector<AsyncReadState>&& _async_states, size_t _prefetch_max_idx)
+        : fs(_fs),
+          scan_opts(_scan_opts),
           pinned_data_blocks(std::move(_pinned_data_blocks)),
-          block_ranges_per_scan(std::move(_block_ranges_per_scan)),
+          data_block_separators(std::move(_data_block_separators)),
+          block_index_ranges_per_scan(std::move(_block_index_ranges_per_scan)),
           next_scan_idx(0),
-          cur_data_block_idx(0) {}
+          cur_data_block_idx(0),
+          async_states(std::move(_async_states)),
+          block_idx_to_readreq_idx(std::move(_block_idx_to_readreq_idx)),
+          prefetch_max_idx(_prefetch_max_idx) {}
+
+    ~MultiScanState();
   };
 
+  Status multi_scan_status_;
   std::unique_ptr<MultiScanState> multi_scan_;
   // *** END MultiScan related APIs and states ***
 
@@ -513,10 +611,121 @@ class BlockBasedTableIterator : public InternalIteratorBase<Slice> {
   // *** END APIs relevant to auto tuning of readahead_size ***
 
   // *** BEGIN APIs relevant to multiscan ***
-  // Returns true iff seek is successful.
-  bool SeekMultiScan(const Slice* target);
+
+  // Wrapper for SeekMultiScanImpl for handling out of bound
+  void SeekMultiScan(const Slice* target);
+
+  // Return true if the result is out of bound
+  bool SeekMultiScanImpl(const Slice* seek_target);
 
   void FindBlockForwardInMultiScan();
+
+  // Unpins blocks from the immediately previous scan range.
+  void UnpinPreviousScanBlocks(size_t current_scan_idx);
+
+  void PrepareReadAsyncCallBack(FSReadRequest& req, void* cb_arg) {
+    // Record status, result and sanity check offset from `req`.
+    AsyncReadState* async_state = static_cast<AsyncReadState*>(cb_arg);
+
+    async_state->status = req.status;
+    async_state->result = req.result;
+
+    if (async_state->status.ok()) {
+      assert(async_state->offset == req.offset);
+      if (async_state->offset != req.offset) {
+        async_state->status = Status::InvalidArgument(
+            "offset mismatch between async read request " +
+            std::to_string(async_state->offset) + " and async callback " +
+            std::to_string(req.offset));
+      }
+    } else {
+      assert(async_state->status.IsAborted());
+    }
+  }
+
+  void MultiScanSeekTargetFromBlock(const Slice* seek_target, size_t block_idx);
+  void MultiScanUnexpectedSeekTarget(const Slice* seek_target,
+                                     size_t block_idx);
+
+  // Return true, if there is an error, or end of file
+  bool MultiScanLoadDataBlock(size_t idx) {
+    if (idx >= multi_scan_->prefetch_max_idx) {
+      // TODO: Fix the max_prefetch_size support for multiple files.
+      // The goal is to limit the memory usage, prefetch could be done
+      // incrementally.
+      if (multi_scan_->scan_opts->max_prefetch_size == 0) {
+        // If max_prefetch_size is not set, treat this as end of file.
+        ResetDataIter();
+        assert(!is_out_of_bound_);
+        assert(!Valid());
+      } else {
+        // If max_prefetch_size is set, treat this as error.
+        multi_scan_status_ = Status::PrefetchLimitReached();
+      }
+      return true;
+    }
+
+    if (!multi_scan_->async_states.empty()) {
+      multi_scan_status_ = PollForBlock(idx);
+      if (!multi_scan_status_.ok()) {
+        return true;
+      }
+    }
+    // This block should have been initialized
+    assert(multi_scan_->pinned_data_blocks[idx].GetValue());
+    // Note that the block_iter_ takes ownership of the pinned data block
+    // TODO: we can delegate the clean up like with pinned_iters_mgr_ if
+    // need to pin blocks longer.
+    table_->NewDataBlockIterator<DataBlockIter>(
+        read_options_, multi_scan_->pinned_data_blocks[idx], &block_iter_,
+        Status::OK());
+    return false;
+  }
+
+  // After PollForBlock(idx), the async request that contains
+  // pinned_data_blocks[idx] should be done, and all blocks contained in this
+  // read request will be initialzed in pinned_data_blocks and pinned in block
+  // cache.
+  Status PollForBlock(size_t idx);
+
+  // Helper function to create and pin a block in cache from buffer data
+  // Handles decompressor setup with dictionary loading and block
+  // creation/pinning. The buffer_start_offset is the file offset where
+  // buffer_data starts.
+  Status CreateAndPinBlockFromBuffer(const BlockHandle& block,
+                                     uint64_t buffer_start_offset,
+                                     const Slice& buffer_data,
+                                     CachableEntry<Block>& pinned_block_entry);
+
+  Status CollectBlockHandles(
+      const std::vector<ScanOptions>& scan_opts,
+      std::vector<BlockHandle>* scan_block_handles,
+      std::vector<std::tuple<size_t, size_t>>* block_index_ranges_per_scan,
+      std::vector<std::string>* data_block_boundary_keys);
+
+  Status FilterAndPinCachedBlocks(
+      const std::vector<BlockHandle>& scan_block_handles,
+      const MultiScanArgs* multiscan_opts,
+      std::vector<size_t>* block_indices_to_read,
+      std::vector<CachableEntry<Block>>* pinned_data_blocks_guard,
+      size_t* prefetched_max_idx);
+
+  void PrepareIORequests(
+      const std::vector<size_t>& block_indices_to_read,
+      const std::vector<BlockHandle>& scan_block_handles,
+      const MultiScanArgs* multiscan_opts,
+      std::vector<FSReadRequest>* read_reqs,
+      UnorderedMap<size_t, size_t>* block_idx_to_readreq_idx,
+      std::vector<std::vector<size_t>>* coalesced_block_indices);
+
+  Status ExecuteIO(
+      const std::vector<BlockHandle>& scan_block_handles,
+      const MultiScanArgs* multiscan_opts,
+      const std::vector<std::vector<size_t>>& coalesced_block_indices,
+      std::vector<FSReadRequest>* read_reqs,
+      std::vector<AsyncReadState>* async_states,
+      std::vector<CachableEntry<Block>>* pinned_data_blocks_guard);
+
   // *** END APIs relevant to multiscan ***
 };
 }  // namespace ROCKSDB_NAMESPACE

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

@@ -109,8 +109,8 @@ CacheAllocationPtr CopyBufferToHeap(MemoryAllocator* allocator, Slice& buf) {
       CachableEntry<T>* out_parsed_block) const;                               \
   template Status BlockBasedTable::CreateAndPinBlockInCache<T>(                \
       const ReadOptions& ro, const BlockHandle& handle,                        \
-      BlockContents* block_contents, CachableEntry<T>* out_parsed_block)       \
-      const;
+      UnownedPtr<Decompressor> decomp, BlockContents* block_contents,          \
+      CachableEntry<T>* out_parsed_block) const;
 
 INSTANTIATE_BLOCKLIKE_TEMPLATES(ParsedFullFilterBlock);
 INSTANTIATE_BLOCKLIKE_TEMPLATES(DecompressorDict);
@@ -1333,25 +1333,59 @@ Status BlockBasedTable::PrefetchIndexAndFilterBlocks(
     s = FindMetaBlock(meta_iter, kUserDefinedIndexPrefix + udi_name,
                       &udi_block_handle);
     if (!s.ok()) {
-      return s;
-    }
-    // Read the block, and allocate on heap or pin in cache. The UDI block is
-    // not compressed. RetrieveBlock will verify the checksum.
-    s = RetrieveBlock(prefetch_buffer, ro, udi_block_handle,
-                      rep_->decompressor.get(), &rep_->udi_block,
-                      /*get_context=*/nullptr, lookup_context,
-                      /*for_compaction=*/false, use_cache, /*async_read=*/false,
-                      /*use_block_cache_for_lookup=*/false);
-    if (!s.ok()) {
-      return s;
+      RecordTick(rep_->ioptions.statistics.get(),
+                 SST_USER_DEFINED_INDEX_LOAD_FAIL_COUNT);
+      if (table_options.fail_if_no_udi_on_open) {
+        ROCKS_LOG_ERROR(rep_->ioptions.logger,
+                        "Failed to find the the UDI block %s in file %s; %s",
+                        udi_name.c_str(), rep_->file->file_name().c_str(),
+                        s.ToString().c_str());
+        // MAke the status more informative
+        s = Status::Corruption(s.ToString(), rep_->file->file_name());
+        return s;
+      } else {
+        // Emit a warning, but ignore the error status
+        ROCKS_LOG_WARN(rep_->ioptions.logger,
+                       "Failed to find the the UDI block %s in file %s; %s",
+                       udi_name.c_str(), rep_->file->file_name().c_str(),
+                       s.ToString().c_str());
+        s = Status::OK();
+      }
     }
-    assert(!rep_->udi_block.IsEmpty());
 
-    std::unique_ptr<UserDefinedIndexReader> udi_reader =
-        table_options.user_defined_index_factory->NewReader(
-            rep_->udi_block.GetValue()->data);
-    index_reader = std::make_unique<UserDefinedIndexReaderWrapper>(
-        udi_name, std::move(index_reader), std::move(udi_reader));
+    // If the UDI block size is 0, that means there's effectively no user
+    // defined index. In that case, skip setting up the reader.
+    if (udi_block_handle.size() > 0) {
+      // Read the block, and allocate on heap or pin in cache. The UDI block is
+      // not compressed. RetrieveBlock will verify the checksum.
+      if (s.ok()) {
+        s = RetrieveBlock(prefetch_buffer, ro, udi_block_handle,
+                          rep_->decompressor.get(), &rep_->udi_block,
+                          /*get_context=*/nullptr, lookup_context,
+                          /*for_compaction=*/false, use_cache,
+                          /*async_read=*/false,
+                          /*use_block_cache_for_lookup=*/false);
+      }
+      if (s.ok()) {
+        assert(!rep_->udi_block.IsEmpty());
+
+        std::unique_ptr<UserDefinedIndexReader> udi_reader;
+        UserDefinedIndexOption udi_option;
+        udi_option.comparator = rep_->internal_comparator.user_comparator();
+        s = table_options.user_defined_index_factory->NewReader(
+            udi_option, rep_->udi_block.GetValue()->data, udi_reader);
+        if (s.ok()) {
+          if (udi_reader) {
+            index_reader = std::make_unique<UserDefinedIndexReaderWrapper>(
+                udi_name, std::move(index_reader), std::move(udi_reader));
+          } else {
+            s = Status::Corruption("Failed to create UDI reader for " +
+                                   udi_name + " in file " +
+                                   rep_->file->file_name());
+          }
+        }
+      }
+    }
   }
 
   rep_->index_reader = std::move(index_reader);
@@ -1359,7 +1393,7 @@ Status BlockBasedTable::PrefetchIndexAndFilterBlocks(
   // The partitions of partitioned index are always stored in cache. They
   // are hence follow the configuration for pin and prefetch regardless of
   // the value of cache_index_and_filter_blocks
-  if (prefetch_all || pin_partition) {
+  if (s.ok() && (prefetch_all || pin_partition)) {
     s = rep_->index_reader->CacheDependencies(ro, pin_partition,
                                               prefetch_buffer);
   }
@@ -1741,13 +1775,55 @@ Status BlockBasedTable::LookupAndPinBlocksInCache(
 
 template <typename TBlocklike>
 Status BlockBasedTable::CreateAndPinBlockInCache(
-    const ReadOptions& ro, const BlockHandle& handle, BlockContents* contents,
+    const ReadOptions& ro, const BlockHandle& handle,
+    UnownedPtr<Decompressor> decomp, BlockContents* contents,
     CachableEntry<TBlocklike>* out_parsed_block) const {
-  return MaybeReadBlockAndLoadToCache(
-      nullptr, ro, handle, rep_->decompressor.get(),
-      /*for_compaction=*/false, out_parsed_block, nullptr, nullptr, contents,
-      /*async_read=*/false,
-      /*use_block_cache_for_lookup=*/true);
+  CompressionType compression_type = GetBlockCompressionType(*contents);
+  // If we don't own the contents and we don't need to decompress, copy
+  // the block to heap in order to have ownership. If decompression is
+  // needed, then the decompressor will allocate a buffer.
+  if (!contents->own_bytes() && compression_type == kNoCompression) {
+    Slice src = Slice(contents->data.data(), BlockSizeWithTrailer(handle));
+    *contents = BlockContents(
+        CopyBufferToHeap(GetMemoryAllocator(rep_->table_options), src),
+        handle.size());
+#ifndef NDEBUG
+    contents->has_trailer = true;
+#endif
+  }
+
+  Status s;
+  if (ro.fill_cache) {
+    s = MaybeReadBlockAndLoadToCache(nullptr, ro, handle, decomp,
+                                     /*for_compaction=*/false, out_parsed_block,
+                                     nullptr, nullptr, contents,
+                                     /*async_read=*/false,
+                                     /*use_block_cache_for_lookup=*/true);
+  }
+
+  if (!s.ok()) {
+    return s;
+  }
+
+  // fill_cache could be false, or no block cache is configured. In that
+  // case, decompress if necessary and take ownership of the block
+  if (out_parsed_block->GetValue() == nullptr && contents != nullptr) {
+    BlockContents tmp_contents;
+    if (compression_type != kNoCompression) {
+      s = DecompressSerializedBlock(contents->data.data(), handle.size(),
+                                    compression_type, *decomp, &tmp_contents,
+                                    rep_->ioptions,
+                                    GetMemoryAllocator(rep_->table_options));
+    } else {
+      tmp_contents = std::move(*contents);
+    }
+    if (s.ok()) {
+      std::unique_ptr<TBlocklike> block_holder;
+      rep_->create_context.Create(&block_holder, std::move(tmp_contents));
+      out_parsed_block->SetOwnedValue(std::move(block_holder));
+    }
+  }
+  return s;
 }
 
 // If contents is nullptr, this function looks up the block caches for the

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

@@ -311,7 +311,7 @@ class BlockBasedTable : public TableReader {
   template <typename TBlocklike>
   Status CreateAndPinBlockInCache(
       const ReadOptions& ro, const BlockHandle& handle,
-      BlockContents* block_contents,
+      UnownedPtr<Decompressor> decomp, BlockContents* block_contents,
       CachableEntry<TBlocklike>* out_parsed_block) const;
 
   struct Rep;

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

@@ -37,8 +37,6 @@ DEFINE_SYNC_AND_ASYNC(void, BlockBasedTable::RetrieveMultipleBlocks)
   RandomAccessFileReader* file = rep_->file.get();
   const Footer& footer = rep_->footer;
   const ImmutableOptions& ioptions = rep_->ioptions;
-  size_t read_amp_bytes_per_bit = rep_->table_options.read_amp_bytes_per_bit;
-  MemoryAllocator* memory_allocator = GetMemoryAllocator(rep_->table_options);
 
   if (ioptions.allow_mmap_reads) {
     size_t idx_in_batch = 0;
@@ -266,79 +264,8 @@ 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
-      // 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 serialized block is either uncompressed into a
-      // heap buffer or there is no cache at all.
-      CompressionType compression_type =
-          GetBlockCompressionType(serialized_block);
-      if ((use_fs_scratch || use_shared_buffer) &&
-          compression_type == kNoCompression) {
-        Slice serialized =
-            Slice(req.result.data() + req_offset, BlockSizeWithTrailer(handle));
-        serialized_block = BlockContents(
-            CopyBufferToHeap(GetMemoryAllocator(rep_->table_options),
-                             serialized),
-            handle.size());
-#ifndef NDEBUG
-        serialized_block.has_trailer = true;
-#endif
-      }
-    }
-
-    if (s.ok()) {
-      if (options.fill_cache) {
-        CachableEntry<Block_kData>* block_entry = &results[idx_in_batch];
-        // MaybeReadBlockAndLoadToCache will insert into the block caches if
-        // necessary. Since we're passing the serialized block contents, it
-        // will avoid looking up the block cache
-        s = MaybeReadBlockAndLoadToCache(
-            nullptr, options, handle, decomp,
-            /*for_compaction=*/false, block_entry, mget_iter->get_context,
-            /*lookup_context=*/nullptr, &serialized_block,
-            /*async_read=*/false, /*use_block_cache_for_lookup=*/true);
-
-        if (!s.ok()) {
-          statuses[idx_in_batch] = s;
-          continue;
-        }
-        // block_entry value could be null if no block cache is present, i.e
-        // BlockBasedTableOptions::no_block_cache is true and no compressed
-        // block cache is configured. In that case, fall
-        // through and set up the block explicitly
-        if (block_entry->GetValue() != nullptr) {
-          continue;
-        }
-      }
-
-      CompressionType compression_type =
-          GetBlockCompressionType(serialized_block);
-      BlockContents contents;
-      if (compression_type != kNoCompression) {
-        s = DecompressSerializedBlock(
-            req.result.data() + req_offset, handle.size(), compression_type,
-            *decomp, &contents, rep_->ioptions, memory_allocator);
-      } else {
-        // There are two cases here:
-        // 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 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(std::make_unique<Block_kData>(
-            std::move(contents), read_amp_bytes_per_bit, ioptions.stats));
-      }
+      s = CreateAndPinBlockInCache(options, handle, decomp, &serialized_block,
+                                   &results[idx_in_batch]);
     }
     statuses[idx_in_batch] = s;
   }