@nxtedition/rocksdb 8.2.8 → 9.0.1

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

@@ -18,10 +18,21 @@ void BlockBasedTableIterator::Seek(const Slice& target) {
 
 void BlockBasedTableIterator::SeekImpl(const Slice* target,
                                        bool async_prefetch) {
-  bool is_first_pass = true;
+  ResetBlockCacheLookupVar();
+  bool is_first_pass = !async_read_in_progress_;
+  bool autotune_readaheadsize = is_first_pass &&
+                                read_options_.auto_readahead_size &&
+                                read_options_.iterate_upper_bound;
+
+  if (autotune_readaheadsize &&
+      table_->get_rep()->table_options.block_cache.get() &&
+      !read_options_.async_io && direction_ == IterDirection::kForward) {
+    readahead_cache_lookup_ = true;
+  }
+
+  // Second pass.
   if (async_read_in_progress_) {
     AsyncInitDataBlock(false);
-    is_first_pass = false;
   }
 
   is_out_of_bound_ = false;
@@ -44,7 +55,11 @@ void BlockBasedTableIterator::SeekImpl(const Slice* target,
   }
 
   bool need_seek_index = true;
-  if (block_iter_points_to_real_block_ && block_iter_.Valid()) {
+
+  //  In case of readahead_cache_lookup_, index_iter_ could change to find the
+  //  readahead size in BlockCacheLookupForReadAheadSize so it needs to reseek.
+  if (IsIndexAtCurr() && block_iter_points_to_real_block_ &&
+      block_iter_.Valid()) {
     // Reseek.
     prev_block_offset_ = index_iter_->value().handle.offset();
 
@@ -72,13 +87,31 @@ void BlockBasedTableIterator::SeekImpl(const Slice* target,
     } else {
       index_iter_->SeekToFirst();
     }
+    is_index_at_curr_block_ = true;
+    if (!index_iter_->Valid()) {
+      ResetDataIter();
+      return;
+    }
+  }
+
+  if (autotune_readaheadsize) {
+    FindReadAheadSizeUpperBound();
+    if (target) {
+      index_iter_->Seek(*target);
+    } else {
+      index_iter_->SeekToFirst();
+    }
 
+    // Check for IO error.
     if (!index_iter_->Valid()) {
       ResetDataIter();
       return;
     }
   }
 
+  // After reseek, index_iter_ point to the right key i.e. target in
+  // case of readahead_cache_lookup_. So index_iter_ can be used directly.
+
   IndexValue v = index_iter_->value();
   const bool same_block = block_iter_points_to_real_block_ &&
                           v.handle.offset() == prev_block_offset_;
@@ -135,6 +168,8 @@ void BlockBasedTableIterator::SeekImpl(const Slice* target,
 }
 
 void BlockBasedTableIterator::SeekForPrev(const Slice& target) {
+  direction_ = IterDirection::kBackward;
+  ResetBlockCacheLookupVar();
   is_out_of_bound_ = false;
   is_at_first_key_from_index_ = false;
   seek_stat_state_ = kNone;
@@ -171,6 +206,7 @@ void BlockBasedTableIterator::SeekForPrev(const Slice& target) {
   // to distinguish the two unless we read the second block. In this case, we'll
   // end up with reading two blocks.
   index_iter_->Seek(target);
+  is_index_at_curr_block_ = true;
 
   if (!index_iter_->Valid()) {
     auto seek_status = index_iter_->status();
@@ -206,15 +242,22 @@ void BlockBasedTableIterator::SeekForPrev(const Slice& target) {
 }
 
 void BlockBasedTableIterator::SeekToLast() {
+  direction_ = IterDirection::kBackward;
+  ResetBlockCacheLookupVar();
   is_out_of_bound_ = false;
   is_at_first_key_from_index_ = false;
   seek_stat_state_ = kNone;
+
   SavePrevIndexValue();
+
   index_iter_->SeekToLast();
+  is_index_at_curr_block_ = true;
+
   if (!index_iter_->Valid()) {
     ResetDataIter();
     return;
   }
+
   InitDataBlock();
   block_iter_.SeekToLast();
   FindKeyBackward();
@@ -243,6 +286,14 @@ bool BlockBasedTableIterator::NextAndGetResult(IterateResult* result) {
 }
 
 void BlockBasedTableIterator::Prev() {
+  // Return Error.
+  if (readahead_cache_lookup_) {
+    block_iter_.Invalidate(Status::NotSupported(
+        "auto tuning of readahead_size is not supported with Prev operation."));
+    return;
+  }
+
+  ResetBlockCacheLookupVar();
   if (is_at_first_key_from_index_) {
     is_at_first_key_from_index_ = false;
 
@@ -262,7 +313,18 @@ void BlockBasedTableIterator::Prev() {
 }
 
 void BlockBasedTableIterator::InitDataBlock() {
-  BlockHandle data_block_handle = index_iter_->value().handle;
+  BlockHandle data_block_handle;
+  bool is_in_cache = false;
+  bool use_block_cache_for_lookup = true;
+
+  if (DoesContainBlockHandles()) {
+    data_block_handle = block_handles_.front().handle_;
+    is_in_cache = block_handles_.front().is_cache_hit_;
+    use_block_cache_for_lookup = false;
+  } else {
+    data_block_handle = index_iter_->value().handle;
+  }
+
   if (!block_iter_points_to_real_block_ ||
       data_block_handle.offset() != prev_block_offset_ ||
       // if previous attempt of reading the block missed cache, try again
@@ -270,25 +332,50 @@ void BlockBasedTableIterator::InitDataBlock() {
     if (block_iter_points_to_real_block_) {
       ResetDataIter();
     }
-    auto* rep = table_->get_rep();
 
     bool is_for_compaction =
         lookup_context_.caller == TableReaderCaller::kCompaction;
-    // Prefetch additional data for range scans (iterators).
-    // Implicit auto readahead:
-    //   Enabled after 2 sequential IOs when ReadOptions.readahead_size == 0.
-    // Explicit user requested readahead:
-    //   Enabled from the very first IO when ReadOptions.readahead_size is set.
-    block_prefetcher_.PrefetchIfNeeded(
-        rep, data_block_handle, read_options_.readahead_size, is_for_compaction,
-        /*no_sequential_checking=*/false, read_options_.rate_limiter_priority);
-    Status s;
-    table_->NewDataBlockIterator<DataBlockIter>(
-        read_options_, data_block_handle, &block_iter_, BlockType::kData,
-        /*get_context=*/nullptr, &lookup_context_,
-        block_prefetcher_.prefetch_buffer(),
-        /*for_compaction=*/is_for_compaction, /*async_read=*/false, s);
+
+    // Initialize Data Block From CacheableEntry.
+    if (is_in_cache) {
+      Status s;
+      block_iter_.Invalidate(Status::OK());
+      table_->NewDataBlockIterator<DataBlockIter>(
+          read_options_, (block_handles_.front().cachable_entry_).As<Block>(),
+          &block_iter_, s);
+    } else {
+      auto* rep = table_->get_rep();
+
+      std::function<void(uint64_t offset, size_t, size_t&)> readaheadsize_cb =
+          nullptr;
+      if (readahead_cache_lookup_) {
+        readaheadsize_cb = std::bind(
+            &BlockBasedTableIterator::BlockCacheLookupForReadAheadSize, this,
+            std::placeholders::_1, std::placeholders::_2,
+            std::placeholders::_3);
+      }
+
+      // Prefetch additional data for range scans (iterators).
+      // Implicit auto readahead:
+      //   Enabled after 2 sequential IOs when ReadOptions.readahead_size == 0.
+      // Explicit user requested readahead:
+      //   Enabled from the very first IO when ReadOptions.readahead_size is
+      //   set.
+      block_prefetcher_.PrefetchIfNeeded(
+          rep, data_block_handle, read_options_.readahead_size,
+          is_for_compaction,
+          /*no_sequential_checking=*/false, read_options_, readaheadsize_cb);
+
+      Status s;
+      table_->NewDataBlockIterator<DataBlockIter>(
+          read_options_, data_block_handle, &block_iter_, BlockType::kData,
+          /*get_context=*/nullptr, &lookup_context_,
+          block_prefetcher_.prefetch_buffer(),
+          /*for_compaction=*/is_for_compaction, /*async_read=*/false, s,
+          use_block_cache_for_lookup);
+    }
     block_iter_points_to_real_block_ = true;
+
     CheckDataBlockWithinUpperBound();
     if (!is_for_compaction &&
         (seek_stat_state_ & kDataBlockReadSinceLastSeek) == 0) {
@@ -314,6 +401,16 @@ void BlockBasedTableIterator::AsyncInitDataBlock(bool is_first_pass) {
         ResetDataIter();
       }
       auto* rep = table_->get_rep();
+
+      std::function<void(uint64_t offset, size_t, size_t&)> readaheadsize_cb =
+          nullptr;
+      if (readahead_cache_lookup_) {
+        readaheadsize_cb = std::bind(
+            &BlockBasedTableIterator::BlockCacheLookupForReadAheadSize, this,
+            std::placeholders::_1, std::placeholders::_2,
+            std::placeholders::_3);
+      }
+
       // Prefetch additional data for range scans (iterators).
       // Implicit auto readahead:
       //   Enabled after 2 sequential IOs when ReadOptions.readahead_size == 0.
@@ -326,14 +423,15 @@ void BlockBasedTableIterator::AsyncInitDataBlock(bool is_first_pass) {
       block_prefetcher_.PrefetchIfNeeded(
           rep, data_block_handle, read_options_.readahead_size,
           is_for_compaction, /*no_sequential_checking=*/read_options_.async_io,
-          read_options_.rate_limiter_priority);
+          read_options_, readaheadsize_cb);
 
       Status s;
       table_->NewDataBlockIterator<DataBlockIter>(
           read_options_, data_block_handle, &block_iter_, BlockType::kData,
           /*get_context=*/nullptr, &lookup_context_,
           block_prefetcher_.prefetch_buffer(),
-          /*for_compaction=*/is_for_compaction, /*async_read=*/true, s);
+          /*for_compaction=*/is_for_compaction, /*async_read=*/true, s,
+          /*use_block_cache_for_lookup=*/true);
 
       if (s.IsTryAgain()) {
         async_read_in_progress_ = true;
@@ -348,7 +446,8 @@ void BlockBasedTableIterator::AsyncInitDataBlock(bool is_first_pass) {
         read_options_, data_block_handle, &block_iter_, BlockType::kData,
         /*get_context=*/nullptr, &lookup_context_,
         block_prefetcher_.prefetch_buffer(),
-        /*for_compaction=*/is_for_compaction, /*async_read=*/false, s);
+        /*for_compaction=*/is_for_compaction, /*async_read=*/false, s,
+        /*use_block_cache_for_lookup=*/false);
   }
   block_iter_points_to_real_block_ = true;
   CheckDataBlockWithinUpperBound();
@@ -379,20 +478,29 @@ bool BlockBasedTableIterator::MaterializeCurrentBlock() {
 
   block_iter_.SeekToFirst();
 
+  // MaterializeCurrentBlock is called when block is actually read by
+  // calling InitDataBlock. is_at_first_key_from_index_ will be false for block
+  // handles placed in blockhandle. So index_ will be pointing to current block.
+  // After InitDataBlock, index_iter_ can point to different block if
+  // BlockCacheLookupForReadAheadSize is called.
+  Slice first_internal_key;
+  if (DoesContainBlockHandles()) {
+    first_internal_key = block_handles_.front().first_internal_key_;
+  } else {
+    first_internal_key = index_iter_->value().first_internal_key;
+  }
+
   if (!block_iter_.Valid() ||
-      icomp_.Compare(block_iter_.key(),
-                     index_iter_->value().first_internal_key) != 0) {
+      icomp_.Compare(block_iter_.key(), first_internal_key) != 0) {
     block_iter_.Invalidate(Status::Corruption(
         "first key in index doesn't match first key in block"));
     return false;
   }
-
   return true;
 }
 
 void BlockBasedTableIterator::FindKeyForward() {
   // This method's code is kept short to make it likely to be inlined.
-
   assert(!is_out_of_bound_);
   assert(block_iter_points_to_real_block_);
 
@@ -415,40 +523,72 @@ void BlockBasedTableIterator::FindBlockForward() {
       return;
     }
     // Whether next data block is out of upper bound, if there is one.
-    const bool next_block_is_out_of_bound =
-        read_options_.iterate_upper_bound != nullptr &&
+    //  index_iter_ can point to different block in case of
+    //  readahead_cache_lookup_. readahead_cache_lookup_ will be handle the
+    //  upper_bound check.
+    bool next_block_is_out_of_bound =
+        IsIndexAtCurr() && read_options_.iterate_upper_bound != nullptr &&
         block_iter_points_to_real_block_ &&
         block_upper_bound_check_ == BlockUpperBound::kUpperBoundInCurBlock;
+
     assert(!next_block_is_out_of_bound ||
            user_comparator_.CompareWithoutTimestamp(
                *read_options_.iterate_upper_bound, /*a_has_ts=*/false,
                index_iter_->user_key(), /*b_has_ts=*/true) <= 0);
+
     ResetDataIter();
-    index_iter_->Next();
-    if (next_block_is_out_of_bound) {
-      // The next block is out of bound. No need to read it.
-      TEST_SYNC_POINT_CALLBACK("BlockBasedTableIterator:out_of_bound", nullptr);
-      // We need to make sure this is not the last data block before setting
-      // is_out_of_bound_, since the index key for the last data block can be
-      // larger than smallest key of the next file on the same level.
-      if (index_iter_->Valid()) {
-        is_out_of_bound_ = true;
-      }
-      return;
-    }
 
-    if (!index_iter_->Valid()) {
-      return;
+    if (DoesContainBlockHandles()) {
+      // Advance and point to that next Block handle to make that block handle
+      // current.
+      block_handles_.pop_front();
     }
 
-    IndexValue v = index_iter_->value();
+    if (!DoesContainBlockHandles()) {
+      // For readahead_cache_lookup_ enabled scenario -
+      // 1. In case of Seek, block_handle will be empty and it should be follow
+      //    as usual doing index_iter_->Next().
+      // 2. If block_handles is empty and index is not at current because of
+      //    lookup (during Next), it should skip doing index_iter_->Next(), as
+      //    it's already pointing to next block;
+      // 3. Last block could be out of bound and it won't iterate over that
+      // during BlockCacheLookup. We need to set for that block here.
+      if (IsIndexAtCurr() || is_index_out_of_bound_) {
+        index_iter_->Next();
+        if (is_index_out_of_bound_) {
+          next_block_is_out_of_bound = is_index_out_of_bound_;
+          is_index_out_of_bound_ = false;
+        }
+      } else {
+        // Skip Next as index_iter_ already points to correct index when it
+        // iterates in BlockCacheLookupForReadAheadSize.
+        is_index_at_curr_block_ = true;
+      }
 
-    if (!v.first_internal_key.empty() && allow_unprepared_value_) {
-      // Index contains the first key of the block. Defer reading the block.
-      is_at_first_key_from_index_ = true;
-      return;
-    }
+      if (next_block_is_out_of_bound) {
+        // The next block is out of bound. No need to read it.
+        TEST_SYNC_POINT_CALLBACK("BlockBasedTableIterator:out_of_bound",
+                                 nullptr);
+        // We need to make sure this is not the last data block before setting
+        // is_out_of_bound_, since the index key for the last data block can be
+        // larger than smallest key of the next file on the same level.
+        if (index_iter_->Valid()) {
+          is_out_of_bound_ = true;
+        }
+        return;
+      }
+
+      if (!index_iter_->Valid()) {
+        return;
+      }
+      IndexValue v = index_iter_->value();
 
+      if (!v.first_internal_key.empty() && allow_unprepared_value_) {
+        // Index contains the first key of the block. Defer reading the block.
+        is_at_first_key_from_index_ = true;
+        return;
+      }
+    }
     InitDataBlock();
     block_iter_.SeekToFirst();
   } while (!block_iter_.Valid());
@@ -487,7 +627,7 @@ void BlockBasedTableIterator::CheckOutOfBound() {
 }
 
 void BlockBasedTableIterator::CheckDataBlockWithinUpperBound() {
-  if (read_options_.iterate_upper_bound != nullptr &&
+  if (IsIndexAtCurr() && read_options_.iterate_upper_bound != nullptr &&
       block_iter_points_to_real_block_) {
     block_upper_bound_check_ = (user_comparator_.CompareWithoutTimestamp(
                                     *read_options_.iterate_upper_bound,
@@ -497,4 +637,136 @@ void BlockBasedTableIterator::CheckDataBlockWithinUpperBound() {
                                    : BlockUpperBound::kUpperBoundInCurBlock;
   }
 }
+
+void BlockBasedTableIterator::FindReadAheadSizeUpperBound() {
+  size_t total_bytes_till_upper_bound = 0;
+  size_t footer = table_->get_rep()->footer.GetBlockTrailerSize();
+  uint64_t start_offset = index_iter_->value().handle.offset();
+
+  do {
+    BlockHandle block_handle = index_iter_->value().handle;
+    total_bytes_till_upper_bound += block_handle.size();
+    total_bytes_till_upper_bound += footer;
+
+    // Can't figure out for current block if current block
+    // is out of bound. But for next block we can find that.
+    // If curr block's index key >= iterate_upper_bound, it
+    // means all the keys in next block or above are out of
+    // bound.
+    if (IsNextBlockOutOfBound()) {
+      break;
+    }
+
+    // Since next block is not out of bound, iterate to that
+    // index block and add it's Data block size to
+    // readahead_size.
+    index_iter_->Next();
+
+    if (!index_iter_->Valid()) {
+      break;
+    }
+
+  } while (true);
+
+  block_prefetcher_.SetUpperBoundOffset(start_offset +
+                                        total_bytes_till_upper_bound);
+}
+
+void BlockBasedTableIterator::BlockCacheLookupForReadAheadSize(
+    uint64_t offset, size_t readahead_size, size_t& updated_readahead_size) {
+  updated_readahead_size = readahead_size;
+
+  // readahead_cache_lookup_ can be set false after Seek, if after Seek or Next
+  // there is SeekForPrev or any other backward operation.
+  if (!readahead_cache_lookup_) {
+    return;
+  }
+
+  assert(!DoesContainBlockHandles());
+  assert(index_iter_->value().handle.offset() == offset);
+
+  // Error. current offset should be equal to what's requested for prefetching.
+  if (index_iter_->value().handle.offset() != offset) {
+    return;
+  }
+
+  if (IsNextBlockOutOfBound()) {
+    updated_readahead_size = 0;
+    return;
+  }
+
+  size_t current_readahead_size = 0;
+  size_t footer = table_->get_rep()->footer.GetBlockTrailerSize();
+
+  // Add the current block to block_handles_.
+  {
+    BlockHandleInfo block_handle_info;
+    block_handle_info.handle_ = index_iter_->value().handle;
+    block_handle_info.SetFirstInternalKey(
+        index_iter_->value().first_internal_key);
+    block_handles_.emplace_back(std::move(block_handle_info));
+  }
+
+  // Current block is included in length. Readahead should start from next
+  // block.
+  index_iter_->Next();
+  is_index_at_curr_block_ = false;
+
+  while (index_iter_->Valid()) {
+    BlockHandle block_handle = index_iter_->value().handle;
+
+    // Adding this data block exceeds passed down readahead_size. So this data
+    // block won't be added.
+    if (current_readahead_size + block_handle.size() + footer >
+        readahead_size) {
+      break;
+    }
+
+    current_readahead_size += block_handle.size();
+    current_readahead_size += footer;
+
+    // For current data block, do the lookup in the cache. Lookup should pin the
+    // data block and add the placeholder for cache.
+    BlockHandleInfo block_handle_info;
+    block_handle_info.handle_ = index_iter_->value().handle;
+    block_handle_info.SetFirstInternalKey(
+        index_iter_->value().first_internal_key);
+
+    Status s = table_->LookupAndPinBlocksInCache<Block_kData>(
+        read_options_, block_handle,
+        &(block_handle_info.cachable_entry_).As<Block_kData>());
+    if (!s.ok()) {
+      break;
+    }
+
+    block_handle_info.is_cache_hit_ =
+        (block_handle_info.cachable_entry_.GetValue() ||
+         block_handle_info.cachable_entry_.GetCacheHandle());
+
+    // Add the handle to the queue.
+    block_handles_.emplace_back(std::move(block_handle_info));
+
+    // Can't figure out for current block if current block
+    // is out of bound. But for next block we can find that.
+    // If curr block's index key >= iterate_upper_bound, it
+    // means all the keys in next block or above are out of
+    // bound.
+    if (IsNextBlockOutOfBound()) {
+      is_index_out_of_bound_ = true;
+      break;
+    }
+    index_iter_->Next();
+  };
+
+  // Iterate cache hit block handles from the end till a Miss is there, to
+  // update the readahead_size.
+  for (auto it = block_handles_.rbegin();
+       it != block_handles_.rend() && (*it).is_cache_hit_ == true; ++it) {
+    current_readahead_size -= (*it).handle_.size();
+    current_readahead_size -= footer;
+  }
+  updated_readahead_size = current_readahead_size;
+  ResetPreviousBlockOffset();
+}
+
 }  // namespace ROCKSDB_NAMESPACE

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

@@ -7,6 +7,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file. See the AUTHORS file for names of contributors.
 #pragma once
+#include <deque>
+
 #include "table/block_based/block_based_table_reader.h"
 #include "table/block_based/block_based_table_reader_impl.h"
 #include "table/block_based/block_prefetcher.h"
@@ -44,7 +46,7 @@ class BlockBasedTableIterator : public InternalIteratorBase<Slice> {
         async_read_in_progress_(false),
         is_last_level_(table->IsLastLevel()) {}
 
-  ~BlockBasedTableIterator() {}
+  ~BlockBasedTableIterator() override { ClearBlockHandles(); }
 
   void Seek(const Slice& target) override;
   void SeekForPrev(const Slice& target) override;
@@ -58,6 +60,11 @@ class BlockBasedTableIterator : public InternalIteratorBase<Slice> {
            (is_at_first_key_from_index_ ||
             (block_iter_points_to_real_block_ && block_iter_.Valid()));
   }
+
+  // For block cache readahead lookup scenario -
+  // If is_at_first_key_from_index_ is true, InitDataBlock hasn't been
+  // called. It means block_handles is empty and index_ point to current block.
+  // So index_iter_ can be accessed directly.
   Slice key() const override {
     assert(Valid());
     if (is_at_first_key_from_index_) {
@@ -74,6 +81,7 @@ class BlockBasedTableIterator : public InternalIteratorBase<Slice> {
       return block_iter_.user_key();
     }
   }
+
   bool PrepareValue() override {
     assert(Valid());
 
@@ -104,8 +112,12 @@ class BlockBasedTableIterator : public InternalIteratorBase<Slice> {
     return block_iter_.value();
   }
   Status status() const override {
-    // Prefix index set status to NotFound when the prefix does not exist
-    if (!index_iter_->status().ok() && !index_iter_->status().IsNotFound()) {
+    // 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.
+    // Prefix index set status to NotFound when the prefix does not exist.
+    if (IsIndexAtCurr() && !index_iter_->status().ok() &&
+        !index_iter_->status().IsNotFound()) {
       return index_iter_->status();
     } else if (block_iter_points_to_real_block_) {
       return block_iter_.status();
@@ -159,7 +171,7 @@ class BlockBasedTableIterator : public InternalIteratorBase<Slice> {
   }
 
   void SavePrevIndexValue() {
-    if (block_iter_points_to_real_block_) {
+    if (block_iter_points_to_real_block_ && IsIndexAtCurr()) {
       // Reseek. If they end up with the same data block, we shouldn't re-fetch
       // the same data block.
       prev_block_offset_ = index_iter_->value().handle.offset();
@@ -235,6 +247,28 @@ class BlockBasedTableIterator : public InternalIteratorBase<Slice> {
     kReportOnUseful = 1 << 2,
   };
 
+  // BlockHandleInfo is used to store the info needed when block cache lookup
+  // ahead is enabled to tune readahead_size.
+  struct BlockHandleInfo {
+    void SetFirstInternalKey(const Slice& key) {
+      if (key.empty()) {
+        return;
+      }
+      size_t size = key.size();
+      buf_ = std::unique_ptr<char[]>(new char[size]);
+      memcpy(buf_.get(), key.data(), size);
+      first_internal_key_ = Slice(buf_.get(), size);
+    }
+
+    BlockHandle handle_;
+    bool is_cache_hit_ = false;
+    CachableEntry<Block> cachable_entry_;
+    Slice first_internal_key_;
+    std::unique_ptr<char[]> buf_;
+  };
+
+  bool IsIndexAtCurr() const { return is_index_at_curr_block_; }
+
   const BlockBasedTable* table_;
   const ReadOptions& read_options_;
   const InternalKeyComparator& icomp_;
@@ -268,6 +302,29 @@ class BlockBasedTableIterator : public InternalIteratorBase<Slice> {
   mutable SeekStatState seek_stat_state_ = SeekStatState::kNone;
   bool is_last_level_;
 
+  // If set to true, it'll lookup in the cache ahead to estimate the readahead
+  // size based on cache hit and miss.
+  bool readahead_cache_lookup_ = false;
+
+  // It stores all the block handles that are lookuped in cache ahead when
+  // BlockCacheLookupForReadAheadSize is called. Since index_iter_ may point to
+  // different blocks when readahead_size is calculated in
+  // BlockCacheLookupForReadAheadSize, to avoid index_iter_ reseek,
+  // block_handles_ is used.
+  std::deque<BlockHandleInfo> block_handles_;
+
+  // During cache lookup to find readahead size, index_iter_ is iterated and it
+  // can point to a different block. is_index_at_curr_block_ keeps track of
+  // that.
+  bool is_index_at_curr_block_ = true;
+  bool is_index_out_of_bound_ = false;
+
+  // Used in case of auto_readahead_size to disable the block_cache lookup if
+  // direction is reversed from forward to backward. In case of backward
+  // direction, SeekForPrev or Prev might call Seek from db_iter. So direction
+  // is used to disable the lookup.
+  IterDirection direction_ = IterDirection::kForward;
+
   // If `target` is null, seek to first.
   void SeekImpl(const Slice* target, bool async_prefetch);
 
@@ -306,5 +363,42 @@ class BlockBasedTableIterator : public InternalIteratorBase<Slice> {
     }
     return true;
   }
+
+  // *** BEGIN APIs relevant to auto tuning of readahead_size ***
+  void FindReadAheadSizeUpperBound();
+
+  // This API is called to lookup the data blocks ahead in the cache to estimate
+  // the current readahead_size.
+  void BlockCacheLookupForReadAheadSize(uint64_t offset, size_t readahead_size,
+                                        size_t& updated_readahead_size);
+
+  void ResetBlockCacheLookupVar() {
+    is_index_out_of_bound_ = false;
+    readahead_cache_lookup_ = false;
+    ClearBlockHandles();
+  }
+
+  bool IsNextBlockOutOfBound() {
+    // If curr block's index key >= iterate_upper_bound, it means all the keys
+    // in next block or above are out of bound.
+    return (user_comparator_.CompareWithoutTimestamp(
+                index_iter_->user_key(),
+                /*a_has_ts=*/true, *read_options_.iterate_upper_bound,
+                /*b_has_ts=*/false) >= 0
+                ? true
+                : false);
+  }
+
+  void ClearBlockHandles() { block_handles_.clear(); }
+
+  // Reset prev_block_offset_. If index_iter_ has moved ahead, it won't get
+  // accurate prev_block_offset_.
+  void ResetPreviousBlockOffset() {
+    prev_block_offset_ = std::numeric_limits<uint64_t>::max();
+  }
+
+  bool DoesContainBlockHandles() { return !block_handles_.empty(); }
+
+  // *** END APIs relevant to auto tuning of readahead_size ***
 };
 }  // namespace ROCKSDB_NAMESPACE