@nxtedition/rocksdb 8.2.7 → 9.0.0

package/deps/rocksdb/rocksdb/file/prefetch_test.cc

@@ -25,10 +25,12 @@ class MockFS;
 class MockRandomAccessFile : public FSRandomAccessFileOwnerWrapper {
  public:
   MockRandomAccessFile(std::unique_ptr<FSRandomAccessFile>& file,
-                       bool support_prefetch, std::atomic_int& prefetch_count)
+                       bool support_prefetch, std::atomic_int& prefetch_count,
+                       bool small_buffer_alignment = false)
       : FSRandomAccessFileOwnerWrapper(std::move(file)),
         support_prefetch_(support_prefetch),
-        prefetch_count_(prefetch_count) {}
+        prefetch_count_(prefetch_count),
+        small_buffer_alignment_(small_buffer_alignment) {}
 
   IOStatus Prefetch(uint64_t offset, size_t n, const IOOptions& options,
                     IODebugContext* dbg) override {
@@ -40,16 +42,25 @@ class MockRandomAccessFile : public FSRandomAccessFileOwnerWrapper {
     }
   }
 
+  size_t GetRequiredBufferAlignment() const override {
+    return small_buffer_alignment_
+               ? 1
+               : FSRandomAccessFileOwnerWrapper::GetRequiredBufferAlignment();
+  }
+
  private:
   const bool support_prefetch_;
   std::atomic_int& prefetch_count_;
+  const bool small_buffer_alignment_;
 };
 
 class MockFS : public FileSystemWrapper {
  public:
   explicit MockFS(const std::shared_ptr<FileSystem>& wrapped,
-                  bool support_prefetch)
-      : FileSystemWrapper(wrapped), support_prefetch_(support_prefetch) {}
+                  bool support_prefetch, bool small_buffer_alignment = false)
+      : FileSystemWrapper(wrapped),
+        support_prefetch_(support_prefetch),
+        small_buffer_alignment_(small_buffer_alignment) {}
 
   static const char* kClassName() { return "MockFS"; }
   const char* Name() const override { return kClassName(); }
@@ -61,8 +72,8 @@ class MockFS : public FileSystemWrapper {
     std::unique_ptr<FSRandomAccessFile> file;
     IOStatus s;
     s = target()->NewRandomAccessFile(fname, opts, &file, dbg);
-    result->reset(
-        new MockRandomAccessFile(file, support_prefetch_, prefetch_count_));
+    result->reset(new MockRandomAccessFile(
+        file, support_prefetch_, prefetch_count_, small_buffer_alignment_));
     return s;
   }
 
@@ -76,6 +87,7 @@ class MockFS : public FileSystemWrapper {
 
  private:
   const bool support_prefetch_;
+  const bool small_buffer_alignment_;
   std::atomic_int prefetch_count_{0};
 };
 
@@ -85,7 +97,8 @@ class PrefetchTest
  public:
   PrefetchTest() : DBTestBase("prefetch_test", true) {}
 
-  void SetGenericOptions(Env* env, bool use_direct_io, Options& options) {
+  virtual void SetGenericOptions(Env* env, bool use_direct_io,
+                                 Options& options) {
     options = CurrentOptions();
     options.write_buffer_size = 1024;
     options.create_if_missing = true;
@@ -115,7 +128,14 @@ std::string BuildKey(int num, std::string postfix = "") {
   return "my_key_" + std::to_string(num) + postfix;
 }
 
-// This test verifies the basic functionality of prefetching.
+// This test verifies the following basic functionalities of prefetching:
+// (1) If underline file system supports prefetch, and directIO is not enabled
+// make sure prefetch() is called and FilePrefetchBuffer is not used.
+// (2) If underline file system doesn't support prefetch, or directIO is
+// enabled, make sure prefetch() is not called and FilePrefetchBuffer is
+// used.
+// (3) Measure read bytes, hit and miss of SST's tail prefetching during table
+// open.
 TEST_P(PrefetchTest, Basic) {
   // First param is if the mockFS support_prefetch or not
   bool support_prefetch =
@@ -152,6 +172,7 @@ TEST_P(PrefetchTest, Basic) {
     ASSERT_OK(batch.Put(BuildKey(i), "value for range 1 key"));
   }
   ASSERT_OK(db_->Write(WriteOptions(), &batch));
+  ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable());
 
   // create second key range
   batch.Clear();
@@ -159,6 +180,7 @@ TEST_P(PrefetchTest, Basic) {
     ASSERT_OK(batch.Put(BuildKey(i, "key2"), "value for range 2 key"));
   }
   ASSERT_OK(db_->Write(WriteOptions(), &batch));
+  ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable());
 
   // delete second key range
   batch.Clear();
@@ -166,6 +188,20 @@ TEST_P(PrefetchTest, Basic) {
     ASSERT_OK(batch.Delete(BuildKey(i, "key2")));
   }
   ASSERT_OK(db_->Write(WriteOptions(), &batch));
+  ASSERT_OK(db_->Flush(FlushOptions()));
+
+  // To verify SST file tail prefetch (once per file) during flush output
+  // verification
+  if (support_prefetch && !use_direct_io) {
+    ASSERT_TRUE(fs->IsPrefetchCalled());
+    ASSERT_EQ(3, fs->GetPrefetchCount());
+    ASSERT_EQ(0, buff_prefetch_count);
+    fs->ClearPrefetchCount();
+  } else {
+    ASSERT_FALSE(fs->IsPrefetchCalled());
+    ASSERT_EQ(buff_prefetch_count, 3);
+    buff_prefetch_count = 0;
+  }
 
   // compact database
   std::string start_key = BuildKey(0);
@@ -192,25 +228,27 @@ TEST_P(PrefetchTest, Basic) {
   const uint64_t cur_table_open_prefetch_tail_hit =
       options.statistics->getTickerCount(TABLE_OPEN_PREFETCH_TAIL_HIT);
 
+  // To verify prefetch during compaction input read
   if (support_prefetch && !use_direct_io) {
-    // If underline file system supports prefetch, and directIO is not enabled
-    // make sure prefetch() is called and FilePrefetchBuffer is not used.
     ASSERT_TRUE(fs->IsPrefetchCalled());
-    fs->ClearPrefetchCount();
+    // To rule out false positive by the SST file tail prefetch during
+    // compaction output verification
+    ASSERT_GT(fs->GetPrefetchCount(), 1);
     ASSERT_EQ(0, buff_prefetch_count);
+    fs->ClearPrefetchCount();
   } else {
-    // If underline file system doesn't support prefetch, or directIO is
-    // enabled, make sure prefetch() is not called and FilePrefetchBuffer is
-    // used.
     ASSERT_FALSE(fs->IsPrefetchCalled());
-    ASSERT_GT(buff_prefetch_count, 0);
+    // To rule out false positive by the SST file tail prefetch during
+    // compaction output verification
+    ASSERT_GT(buff_prefetch_count, 1);
+    buff_prefetch_count = 0;
+
     ASSERT_GT(cur_table_open_prefetch_tail_read.count,
               prev_table_open_prefetch_tail_read.count);
     ASSERT_GT(cur_table_open_prefetch_tail_hit,
               prev_table_open_prefetch_tail_hit);
     ASSERT_GE(cur_table_open_prefetch_tail_miss,
               prev_table_open_prefetch_tail_miss);
-    buff_prefetch_count = 0;
   }
 
   // count the keys
@@ -223,7 +261,7 @@ TEST_P(PrefetchTest, Basic) {
     (void)num_keys;
   }
 
-  // Make sure prefetch is called only if file system support prefetch.
+  // To verify prefetch during user scan
   if (support_prefetch && !use_direct_io) {
     ASSERT_TRUE(fs->IsPrefetchCalled());
     fs->ClearPrefetchCount();
@@ -236,30 +274,79 @@ TEST_P(PrefetchTest, Basic) {
   Close();
 }
 
-TEST_P(PrefetchTest, BlockBasedTableTailPrefetch) {
-  const bool support_prefetch =
-      std::get<0>(GetParam()) &&
-      test::IsPrefetchSupported(env_->GetFileSystem(), dbname_);
-  // Second param is if directIO is enabled or not
-  const bool use_direct_io = std::get<1>(GetParam());
-  const bool use_file_prefetch_buffer = !support_prefetch || use_direct_io;
+class PrefetchTailTest : public PrefetchTest {
+ public:
+  bool SupportPrefetch() const {
+    return std::get<0>(GetParam()) &&
+           test::IsPrefetchSupported(env_->GetFileSystem(), dbname_);
+  }
 
-  std::shared_ptr<MockFS> fs =
-      std::make_shared<MockFS>(env_->GetFileSystem(), support_prefetch);
-  std::unique_ptr<Env> env(new CompositeEnvWrapper(env_, fs));
+  bool UseDirectIO() const { return std::get<1>(GetParam()); }
+
+  bool UseFilePrefetchBuffer() const {
+    return !SupportPrefetch() || UseDirectIO();
+  }
+
+  Env* GetEnv(bool small_buffer_alignment = false) const {
+    std::shared_ptr<MockFS> fs = std::make_shared<MockFS>(
+        env_->GetFileSystem(), SupportPrefetch(), small_buffer_alignment);
+
+    return new CompositeEnvWrapper(env_, fs);
+  }
+
+  void SetGenericOptions(Env* env, bool use_direct_io,
+                         Options& options) override {
+    PrefetchTest::SetGenericOptions(env, use_direct_io, options);
+    options.statistics = CreateDBStatistics();
+  }
 
+  void SetBlockBasedTableOptions(
+      BlockBasedTableOptions& table_options, bool partition_filters = true,
+      uint64_t metadata_block_size =
+          BlockBasedTableOptions().metadata_block_size,
+      bool use_small_cache = false) {
+    table_options.index_type = BlockBasedTableOptions::kTwoLevelIndexSearch;
+    table_options.partition_filters = partition_filters;
+    if (table_options.partition_filters) {
+      table_options.filter_policy.reset(NewBloomFilterPolicy(10, false));
+    }
+    table_options.metadata_block_size = metadata_block_size;
+
+    if (use_small_cache) {
+      LRUCacheOptions co;
+      co.capacity = 1;
+      std::shared_ptr<Cache> cache = NewLRUCache(co);
+      table_options.block_cache = cache;
+    }
+  }
+
+  int64_t GetNumIndexPartition() const {
+    int64_t index_partition_counts = 0;
+    TablePropertiesCollection all_table_props;
+    assert(db_->GetPropertiesOfAllTables(&all_table_props).ok());
+    for (const auto& name_and_table_props : all_table_props) {
+      const auto& table_props = name_and_table_props.second;
+      index_partition_counts += table_props->index_partitions;
+    }
+    return index_partition_counts;
+  }
+};
+
+INSTANTIATE_TEST_CASE_P(PrefetchTailTest, PrefetchTailTest,
+                        ::testing::Combine(::testing::Bool(),
+                                           ::testing::Bool()));
+
+TEST_P(PrefetchTailTest, Basic) {
+  std::unique_ptr<Env> env(GetEnv());
   Options options;
-  SetGenericOptions(env.get(), use_direct_io, options);
-  options.statistics = CreateDBStatistics();
+  SetGenericOptions(env.get(), UseDirectIO(), options);
 
   BlockBasedTableOptions bbto;
-  bbto.index_type = BlockBasedTableOptions::kTwoLevelIndexSearch;
-  bbto.partition_filters = true;
-  bbto.filter_policy.reset(NewBloomFilterPolicy(10, false));
+  SetBlockBasedTableOptions(bbto);
   options.table_factory.reset(NewBlockBasedTableFactory(bbto));
 
   Status s = TryReopen(options);
-  if (use_direct_io && (s.IsNotSupported() || s.IsInvalidArgument())) {
+  if (UseDirectIO() && (s.IsNotSupported() || s.IsInvalidArgument())) {
     // If direct IO is not supported, skip the test
     ROCKSDB_GTEST_BYPASS("Direct IO is not supported");
     return;
@@ -276,7 +363,7 @@ TEST_P(PrefetchTest, BlockBasedTableTailPrefetch) {
   HistogramData post_flush_file_read;
   options.statistics->histogramData(FILE_READ_FLUSH_MICROS,
                                     &post_flush_file_read);
-  if (use_file_prefetch_buffer) {
+  if (UseFilePrefetchBuffer()) {
     // `PartitionedFilterBlockReader/PartitionIndexReader::CacheDependencies()`
     // should read from the prefetched tail in file prefetch buffer instead of
     // initiating extra SST reads. Therefore `BlockBasedTable::PrefetchTail()`
@@ -300,7 +387,7 @@ TEST_P(PrefetchTest, BlockBasedTableTailPrefetch) {
   HistogramData post_compaction_file_read;
   options.statistics->histogramData(FILE_READ_COMPACTION_MICROS,
                                     &post_compaction_file_read);
-  if (use_file_prefetch_buffer) {
+  if (UseFilePrefetchBuffer()) {
     // `PartitionedFilterBlockReader/PartitionIndexReader::CacheDependencies()`
     // should read from the prefetched tail in file prefetch buffer instead of
     // initiating extra SST reads.
@@ -323,6 +410,85 @@ TEST_P(PrefetchTest, BlockBasedTableTailPrefetch) {
   Close();
 }
 
+TEST_P(PrefetchTailTest, UpgradeToTailSizeInManifest) {
+  if (!UseFilePrefetchBuffer()) {
+    ROCKSDB_GTEST_BYPASS(
+        "Upgrade to tail size in manifest is only relevant when RocksDB file "
+        "prefetch buffer is used.");
+  }
+  if (UseDirectIO()) {
+    ROCKSDB_GTEST_BYPASS(
+        "To simplify testing logics with setting file's buffer alignment to "
+        "be "
+        "1, direct IO is required to be disabled.");
+  }
+
+  std::unique_ptr<Env> env(GetEnv(true /* small_buffer_alignment */));
+  Options options;
+  SetGenericOptions(env.get(), false /* use_direct_io*/, options);
+  options.max_open_files = -1;
+  options.write_buffer_size = 1024 * 1024;
+
+  BlockBasedTableOptions table_options;
+  SetBlockBasedTableOptions(table_options, false /* partition_filters */,
+                            1 /* metadata_block_size*/,
+                            true /* use_small_cache */);
+  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
+
+  SyncPoint::GetInstance()->EnableProcessing();
+  // To simulate a pre-upgrade DB where file tail size is not recorded in
+  // manifest
+  SyncPoint::GetInstance()->SetCallBack(
+      "FileMetaData::FileMetaData", [&](void* arg) {
+        FileMetaData* meta = static_cast<FileMetaData*>(arg);
+        meta->tail_size = 0;
+      });
+
+  ASSERT_OK(TryReopen(options));
+  for (int i = 0; i < 10000; ++i) {
+    ASSERT_OK(Put("k" + std::to_string(i), "v"));
+  }
+  ASSERT_OK(Flush());
+
+  SyncPoint::GetInstance()->ClearAllCallBacks();
+
+  // To simulate a DB undergoing the upgrade where tail size to prefetch is
+  // inferred to be a small number for files with no tail size recorded in
+  // manifest.
+  // "1" is chosen to be such number so that with `small_buffer_alignment ==
+  // true` and `use_small_cache == true`, it would have caused one file read
+  // per index partition during db open if the upgrade is done wrong.
+  SyncPoint::GetInstance()->SetCallBack(
+      "BlockBasedTable::Open::TailPrefetchLen", [&](void* arg) {
+        std::pair<size_t*, size_t*>* prefetch_off_len_pair =
+            static_cast<std::pair<size_t*, size_t*>*>(arg);
+        size_t* prefetch_off = prefetch_off_len_pair->first;
+        size_t* tail_size = prefetch_off_len_pair->second;
+        const size_t file_size = *prefetch_off + *tail_size;
+
+        *tail_size = 1;
+        *prefetch_off = file_size - (*tail_size);
+      });
+
+  ASSERT_OK(TryReopen(options));
+
+  SyncPoint::GetInstance()->ClearAllCallBacks();
+  SyncPoint::GetInstance()->DisableProcessing();
+
+  HistogramData db_open_file_read;
+  options.statistics->histogramData(FILE_READ_DB_OPEN_MICROS,
+                                    &db_open_file_read);
+
+  int64_t num_index_partition = GetNumIndexPartition();
+  // If the upgrade is done right, db open will prefetch all the index
+  // partitions at once, instead of doing one read per partition.
+  // That is, together with `metadata_block_size == 1`, there will be more
+  // index partitions than number of non index partitions reads.
+  ASSERT_LT(db_open_file_read.count, num_index_partition);
+
+  Close();
+}
+
 // This test verifies BlockBasedTableOptions.max_auto_readahead_size is
 // configured dynamically.
 TEST_P(PrefetchTest, ConfigureAutoMaxReadaheadSize) {
@@ -385,7 +551,7 @@ TEST_P(PrefetchTest, ConfigureAutoMaxReadaheadSize) {
   }
   Close();
   std::vector<int> buff_prefectch_level_count = {0, 0, 0};
-  TryReopen(options);
+  ASSERT_OK(TryReopen(options));
   {
     auto iter = std::unique_ptr<Iterator>(db_->NewIterator(ReadOptions()));
     fs->ClearPrefetchCount();
@@ -513,7 +679,7 @@ TEST_P(PrefetchTest, ConfigureInternalAutoReadaheadSize) {
   }
   Close();
 
-  TryReopen(options);
+  ASSERT_OK(TryReopen(options));
   {
     auto iter = std::unique_ptr<Iterator>(db_->NewIterator(ReadOptions()));
     fs->ClearPrefetchCount();
@@ -530,8 +696,8 @@ TEST_P(PrefetchTest, ConfigureInternalAutoReadaheadSize) {
                                       "{initial_auto_readahead_size=0;}"}}));
           break;
         case 1:
-          // intial_auto_readahead_size and max_auto_readahead_size are set same
-          // so readahead_size remains same.
+          // intial_auto_readahead_size and max_auto_readahead_size are set
+          // same so readahead_size remains same.
           ASSERT_OK(db_->SetOptions({{"block_based_table_factory",
                                       "{initial_auto_readahead_size=4096;max_"
                                       "auto_readahead_size=4096;}"}}));
@@ -628,7 +794,7 @@ TEST_P(PrefetchTest, ConfigureNumFilesReadsForReadaheadSize) {
   ASSERT_OK(db_->CompactRange(CompactRangeOptions(), &least, &greatest));
 
   Close();
-  TryReopen(options);
+  ASSERT_OK(TryReopen(options));
 
   fs->ClearPrefetchCount();
   buff_prefetch_count = 0;
@@ -638,8 +804,9 @@ TEST_P(PrefetchTest, ConfigureNumFilesReadsForReadaheadSize) {
     /*
      * Reseek keys from sequential Data Blocks within same partitioned
      * index. It will prefetch the data block at the first seek since
-     * num_file_reads_for_auto_readahead = 0. Data Block size is nearly 4076 so
-     * readahead will fetch 8 * 1024 data more initially (2 more data blocks).
+     * num_file_reads_for_auto_readahead = 0. Data Block size is nearly 4076
+     * so readahead will fetch 8 * 1024 data more initially (2 more data
+     * blocks).
      */
     iter->Seek(BuildKey(0));  // Prefetch data + index block since
                               // num_file_reads_for_auto_readahead = 0.
@@ -737,8 +904,8 @@ TEST_P(PrefetchTest, PrefetchWhenReseek) {
     /*
      * Reseek keys from sequential Data Blocks within same partitioned
      * index. After 2 sequential reads it will prefetch the data block.
-     * Data Block size is nearly 4076 so readahead will fetch 8 * 1024 data more
-     * initially (2 more data blocks).
+     * Data Block size is nearly 4076 so readahead will fetch 8 * 1024 data
+     * more initially (2 more data blocks).
      */
     iter->Seek(BuildKey(0));
     ASSERT_TRUE(iter->Valid());
@@ -815,9 +982,9 @@ TEST_P(PrefetchTest, PrefetchWhenReseek) {
   {
     /*
      * Reseek keys from  sequential data blocks to set implicit auto readahead
-     * and prefetch data but after that iterate over different (non sequential)
-     * data blocks which won't prefetch any data further. So buff_prefetch_count
-     * will be 1 for the first one.
+     * and prefetch data but after that iterate over different (non
+     * sequential) data blocks which won't prefetch any data further. So
+     * buff_prefetch_count will be 1 for the first one.
      */
     auto iter = std::unique_ptr<Iterator>(db_->NewIterator(ReadOptions()));
     iter->Seek(BuildKey(0));
@@ -844,8 +1011,8 @@ TEST_P(PrefetchTest, PrefetchWhenReseek) {
       buff_prefetch_count = 0;
     }
 
-    // Read sequentially to confirm readahead_size is reset to initial value (2
-    // more data blocks)
+    // Read sequentially to confirm readahead_size is reset to initial value
+    // (2 more data blocks)
     iter->Seek(BuildKey(1011));
     ASSERT_TRUE(iter->Valid());
     iter->Seek(BuildKey(1015));
@@ -895,8 +1062,8 @@ TEST_P(PrefetchTest, PrefetchWhenReseek) {
   }
   {
     /*
-     * Reseek over different keys from different blocks. buff_prefetch_count is
-     * set 0.
+     * Reseek over different keys from different blocks. buff_prefetch_count
+     * is set 0.
      */
     auto iter = std::unique_ptr<Iterator>(db_->NewIterator(ReadOptions()));
     int i = 0;
@@ -1000,8 +1167,8 @@ TEST_P(PrefetchTest, PrefetchWhenReseekwithCache) {
     /*
      * Reseek keys from sequential Data Blocks within same partitioned
      * index. After 2 sequential reads it will prefetch the data block.
-     * Data Block size is nearly 4076 so readahead will fetch 8 * 1024 data more
-     * initially (2 more data blocks).
+     * Data Block size is nearly 4076 so readahead will fetch 8 * 1024 data
+     * more initially (2 more data blocks).
      */
     auto iter = std::unique_ptr<Iterator>(db_->NewIterator(ReadOptions()));
     // Warm up the cache
@@ -1028,8 +1195,8 @@ TEST_P(PrefetchTest, PrefetchWhenReseekwithCache) {
     ASSERT_TRUE(iter->Valid());
     iter->Seek(BuildKey(1004));  // Prefetch data (not in cache).
     ASSERT_TRUE(iter->Valid());
-    // Missed one sequential block but next is in already in buffer so readahead
-    // will not be reset.
+    // Missed one sequential block but next is in already in buffer so
+    // readahead will not be reset.
     iter->Seek(BuildKey(1011));
     ASSERT_TRUE(iter->Valid());
     // Prefetch data but blocks are in cache so no prefetch and reset.
@@ -1164,10 +1331,14 @@ TEST_P(PrefetchTest, DBIterLevelReadAhead) {
 // This test verifies the functionality of ReadOptions.adaptive_readahead when
 // async_io is enabled.
 TEST_P(PrefetchTest, DBIterLevelReadAheadWithAsyncIO) {
+  if (mem_env_ || encrypted_env_) {
+    ROCKSDB_GTEST_BYPASS("Test requires non-mem or non-encrypted environment");
+    return;
+  }
   const int kNumKeys = 1000;
   // Set options
   std::shared_ptr<MockFS> fs =
-      std::make_shared<MockFS>(env_->GetFileSystem(), false);
+      std::make_shared<MockFS>(FileSystem::Default(), false);
   std::unique_ptr<Env> env(new CompositeEnvWrapper(env_, fs));
 
   bool use_direct_io = std::get<0>(GetParam());
@@ -1201,16 +1372,26 @@ TEST_P(PrefetchTest, DBIterLevelReadAheadWithAsyncIO) {
   }
   MoveFilesToLevel(2);
   int buff_async_prefetch_count = 0;
+  int buff_prefetch_count = 0;
   int readahead_carry_over_count = 0;
   int num_sst_files = NumTableFilesAtLevel(2);
   size_t current_readahead_size = 0;
+  bool read_async_called = false;
 
   // Test - Iterate over the keys sequentially.
   {
+    SyncPoint::GetInstance()->SetCallBack(
+        "FilePrefetchBuffer::Prefetch:Start",
+        [&](void*) { buff_prefetch_count++; });
+
     SyncPoint::GetInstance()->SetCallBack(
         "FilePrefetchBuffer::PrefetchAsyncInternal:Start",
         [&](void*) { buff_async_prefetch_count++; });
 
+    SyncPoint::GetInstance()->SetCallBack(
+        "UpdateResults::io_uring_result",
+        [&](void* /*arg*/) { read_async_called = true; });
+
     // The callback checks, since reads are sequential, readahead_size doesn't
     // start from 8KB when iterator moves to next file and its called
     // num_sst_files-1 times (excluding for first file).
@@ -1253,15 +1434,18 @@ TEST_P(PrefetchTest, DBIterLevelReadAheadWithAsyncIO) {
     } else {
       ASSERT_EQ(readahead_carry_over_count, 0);
     }
-    ASSERT_GT(buff_async_prefetch_count, 0);
 
     // Check stats to make sure async prefetch is done.
     {
       HistogramData async_read_bytes;
       options.statistics->histogramData(ASYNC_READ_BYTES, &async_read_bytes);
-      if (ro.async_io) {
+      // Not all platforms support iouring. In that case, ReadAsync in posix
+      // won't submit async requests.
+      if (read_async_called) {
+        ASSERT_GT(buff_async_prefetch_count, 0);
         ASSERT_GT(async_read_bytes.count, 0);
       } else {
+        ASSERT_GT(buff_prefetch_count, 0);
         ASSERT_EQ(async_read_bytes.count, 0);
       }
     }
@@ -1294,6 +1478,7 @@ TEST_P(PrefetchTest, DBIterAsyncIONoIOUring) {
   Status s = TryReopen(options);
   if (use_direct_io && (s.IsNotSupported() || s.IsInvalidArgument())) {
     // If direct IO is not supported, skip the test
+    enable_io_uring = true;
     return;
   } else {
     ASSERT_OK(s);
@@ -1375,7 +1560,8 @@ class PrefetchTest1 : public DBTestBase,
  public:
   PrefetchTest1() : DBTestBase("prefetch_test1", true) {}
 
-  void SetGenericOptions(Env* env, bool use_direct_io, Options& options) {
+  virtual void SetGenericOptions(Env* env, bool use_direct_io,
+                                 Options& options) {
     options = CurrentOptions();
     options.write_buffer_size = 1024;
     options.create_if_missing = true;
@@ -1399,6 +1585,106 @@ class PrefetchTest1 : public DBTestBase,
 
 INSTANTIATE_TEST_CASE_P(PrefetchTest1, PrefetchTest1, ::testing::Bool());
 
+TEST_P(PrefetchTest1, SeekWithExtraPrefetchAsyncIO) {
+  const int kNumKeys = 2000;
+  // Set options
+  std::shared_ptr<MockFS> fs =
+      std::make_shared<MockFS>(env_->GetFileSystem(), false);
+  std::unique_ptr<Env> env(new CompositeEnvWrapper(env_, fs));
+
+  Options options;
+  SetGenericOptions(env.get(), GetParam(), options);
+  options.statistics = CreateDBStatistics();
+  BlockBasedTableOptions table_options;
+  SetBlockBasedTableOptions(table_options);
+  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
+
+  Status s = TryReopen(options);
+  if (GetParam() && (s.IsNotSupported() || s.IsInvalidArgument())) {
+    // If direct IO is not supported, skip the test
+    return;
+  } else {
+    ASSERT_OK(s);
+  }
+
+  WriteBatch batch;
+  Random rnd(309);
+  for (int i = 0; i < kNumKeys; i++) {
+    ASSERT_OK(batch.Put(BuildKey(i), rnd.RandomString(1000)));
+  }
+  ASSERT_OK(db_->Write(WriteOptions(), &batch));
+
+  std::string start_key = BuildKey(0);
+  std::string end_key = BuildKey(kNumKeys - 1);
+  Slice least(start_key.data(), start_key.size());
+  Slice greatest(end_key.data(), end_key.size());
+
+  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), &least, &greatest));
+  Close();
+
+  for (size_t i = 0; i < 3; i++) {
+    table_options.num_file_reads_for_auto_readahead = i;
+    options.table_factory.reset(NewBlockBasedTableFactory(table_options));
+
+    s = TryReopen(options);
+    ASSERT_OK(s);
+
+    int buff_prefetch_count = 0;
+    int extra_prefetch_buff_cnt = 0;
+    SyncPoint::GetInstance()->SetCallBack(
+        "FilePrefetchBuffer::PrefetchAsync:ExtraPrefetching",
+        [&](void*) { extra_prefetch_buff_cnt++; });
+
+    SyncPoint::GetInstance()->SetCallBack(
+        "FilePrefetchBuffer::PrefetchAsyncInternal:Start",
+        [&](void*) { buff_prefetch_count++; });
+
+    SyncPoint::GetInstance()->EnableProcessing();
+
+    ReadOptions ro;
+    ro.async_io = true;
+    {
+      auto iter = std::unique_ptr<Iterator>(db_->NewIterator(ro));
+      // First Seek
+      iter->Seek(BuildKey(
+          0));  // Prefetch data on seek because of seek parallelization.
+      ASSERT_TRUE(iter->Valid());
+
+      // Do extra prefetching in Seek only if
+      // num_file_reads_for_auto_readahead = 0.
+      ASSERT_EQ(extra_prefetch_buff_cnt, (i == 0 ? 1 : 0));
+      // buff_prefetch_count is 2 because of index block when
+      // num_file_reads_for_auto_readahead = 0.
+      // If num_file_reads_for_auto_readahead > 0, index block isn't
+      // prefetched.
+      ASSERT_EQ(buff_prefetch_count, i == 0 ? 2 : 1);
+
+      extra_prefetch_buff_cnt = 0;
+      buff_prefetch_count = 0;
+      // Reset all values of FilePrefetchBuffer on new seek.
+      iter->Seek(
+          BuildKey(22));  // Prefetch data because of seek parallelization.
+      ASSERT_TRUE(iter->Valid());
+      // Do extra prefetching in Seek only if
+      // num_file_reads_for_auto_readahead = 0.
+      ASSERT_EQ(extra_prefetch_buff_cnt, (i == 0 ? 1 : 0));
+      ASSERT_EQ(buff_prefetch_count, 1);
+
+      extra_prefetch_buff_cnt = 0;
+      buff_prefetch_count = 0;
+      // Reset all values of FilePrefetchBuffer on new seek.
+      iter->Seek(
+          BuildKey(33));  // Prefetch data because of seek parallelization.
+      ASSERT_TRUE(iter->Valid());
+      // Do extra prefetching in Seek only if
+      // num_file_reads_for_auto_readahead = 0.
+      ASSERT_EQ(extra_prefetch_buff_cnt, (i == 0 ? 1 : 0));
+      ASSERT_EQ(buff_prefetch_count, 1);
+    }
+    Close();
+  }
+}
+
 // This test verifies the functionality of ReadOptions.adaptive_readahead when
 // reads are not sequential.
 TEST_P(PrefetchTest1, NonSequentialReadsWithAdaptiveReadahead) {
@@ -1482,8 +1768,8 @@ TEST_P(PrefetchTest1, NonSequentialReadsWithAdaptiveReadahead) {
   Close();
 }
 
-// This test verifies the functionality of adaptive_readaheadsize with cache and
-// if block is found in cache, decrease the readahead_size if
+// This test verifies the functionality of adaptive_readaheadsize with cache
+// and if block is found in cache, decrease the readahead_size if
 // - its enabled internally by RocksDB (implicit_auto_readahead_) and,
 // - readahead_size is greater than 0 and,
 // - the block would have called prefetch API if not found in cache for
@@ -1605,8 +1891,8 @@ TEST_P(PrefetchTest1, DecreaseReadAheadIfInCache) {
     ASSERT_TRUE(iter->Valid());
 
     // Prefetch data (not in buffer) but found in cache. So decrease
-    // readahead_size. Since it will 0 after decrementing so readahead_size will
-    // be set to initial value.
+    // readahead_size. Since it will 0 after decrementing so readahead_size
+    // will be set to initial value.
     iter->Seek(BuildKey(1019));
     ASSERT_TRUE(iter->Valid());
     expected_current_readahead_size = std::max(
@@ -1629,10 +1915,14 @@ TEST_P(PrefetchTest1, DecreaseReadAheadIfInCache) {
 // This test verifies the basic functionality of seek parallelization for
 // async_io.
 TEST_P(PrefetchTest1, SeekParallelizationTest) {
+  if (mem_env_ || encrypted_env_) {
+    ROCKSDB_GTEST_BYPASS("Test requires non-mem or non-encrypted environment");
+    return;
+  }
   const int kNumKeys = 2000;
   // Set options
-  std::shared_ptr<MockFS> fs =
-      std::make_shared<MockFS>(env_->GetFileSystem(), false);
+  std::shared_ptr<MockFS> fs = std::make_shared<MockFS>(
+      FileSystem::Default(), /*support_prefetch=*/false);
   std::unique_ptr<Env> env(new CompositeEnvWrapper(env_, fs));
 
   Options options;
@@ -1665,10 +1955,19 @@ TEST_P(PrefetchTest1, SeekParallelizationTest) {
   ASSERT_OK(db_->CompactRange(CompactRangeOptions(), &least, &greatest));
 
   int buff_prefetch_count = 0;
+  int buff_prefetch_async_count = 0;
 
   SyncPoint::GetInstance()->SetCallBack(
       "FilePrefetchBuffer::PrefetchAsyncInternal:Start",
-      [&](void*) { buff_prefetch_count++; });
+      [&](void*) { buff_prefetch_async_count++; });
+
+  SyncPoint::GetInstance()->SetCallBack("FilePrefetchBuffer::Prefetch:Start",
+                                        [&](void*) { buff_prefetch_count++; });
+
+  bool read_async_called = false;
+  SyncPoint::GetInstance()->SetCallBack(
+      "UpdateResults::io_uring_result",
+      [&](void* /*arg*/) { read_async_called = true; });
 
   SyncPoint::GetInstance()->EnableProcessing();
   ReadOptions ro;
@@ -1703,17 +2002,276 @@ TEST_P(PrefetchTest1, SeekParallelizationTest) {
     iter->Next();
     ASSERT_TRUE(iter->Valid());
 
-    ASSERT_EQ(buff_prefetch_count, 2);
-
-    // Check stats to make sure async prefetch is done.
-    {
-      HistogramData async_read_bytes;
-      options.statistics->histogramData(ASYNC_READ_BYTES, &async_read_bytes);
+    HistogramData async_read_bytes;
+    options.statistics->histogramData(ASYNC_READ_BYTES, &async_read_bytes);
+    // not all platforms support io_uring. In that case it'll fallback to
+    // normal prefetching without async_io.
+    if (read_async_called) {
+      ASSERT_EQ(buff_prefetch_async_count, 2);
       ASSERT_GT(async_read_bytes.count, 0);
       ASSERT_GT(get_perf_context()->number_async_seek, 0);
+    } else {
+      ASSERT_EQ(buff_prefetch_count, 1);
+    }
+  }
+  Close();
+}
+
+// This test checks if readahead_size is trimmed when upper_bound is reached.
+// It tests with different combinations of async_io disabled/enabled,
+// readahead_size (implicit and explicit), and num_file_reads_for_auto_readahead
+// from 0 to 2.
+TEST_P(PrefetchTest, IterReadAheadSizeWithUpperBound) {
+  if (mem_env_ || encrypted_env_) {
+    ROCKSDB_GTEST_SKIP("Test requires non-mem or non-encrypted environment");
+    return;
+  }
+
+  // First param is if the mockFS support_prefetch or not
+  std::shared_ptr<MockFS> fs =
+      std::make_shared<MockFS>(FileSystem::Default(), false);
+
+  std::unique_ptr<Env> env(new CompositeEnvWrapper(env_, fs));
+  Options options;
+  SetGenericOptions(env.get(), /*use_direct_io=*/false, options);
+  options.statistics = CreateDBStatistics();
+  BlockBasedTableOptions table_options;
+  SetBlockBasedTableOptions(table_options);
+  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
+
+  Status s = TryReopen(options);
+  ASSERT_OK(s);
+
+  Random rnd(309);
+  WriteBatch batch;
+
+  for (int i = 0; i < 26; i++) {
+    std::string key = "my_key_";
+
+    for (int j = 0; j < 10; j++) {
+      key += char('a' + i);
+      ASSERT_OK(batch.Put(key, rnd.RandomString(1000)));
     }
+  }
+  ASSERT_OK(db_->Write(WriteOptions(), &batch));
 
+  std::string start_key = "my_key_a";
+
+  std::string end_key = "my_key_";
+  for (int j = 0; j < 10; j++) {
+    end_key += char('a' + 25);
+  }
+
+  Slice least(start_key.data(), start_key.size());
+  Slice greatest(end_key.data(), end_key.size());
+
+  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), &least, &greatest));
+
+  int buff_prefetch_count = 0;
+
+  // Try with different num_file_reads_for_auto_readahead from 0 to 3.
+  for (size_t i = 0; i < 3; i++) {
+    table_options.num_file_reads_for_auto_readahead = i;
+    options.table_factory.reset(NewBlockBasedTableFactory(table_options));
+
+    s = TryReopen(options);
+    ASSERT_OK(s);
+
+    int buff_count_with_tuning = 0, buff_count_without_tuning = 0;
+    int keys_with_tuning = 0, keys_without_tuning = 0;
     buff_prefetch_count = 0;
+
+    SyncPoint::GetInstance()->SetCallBack(
+        "FilePrefetchBuffer::Prefetch:Start",
+        [&](void*) { buff_prefetch_count++; });
+
+    SyncPoint::GetInstance()->SetCallBack(
+        "FilePrefetchBuffer::PrefetchAsyncInternal:Start",
+        [&](void*) { buff_prefetch_count++; });
+
+    SyncPoint::GetInstance()->EnableProcessing();
+
+    ReadOptions ropts;
+    if (std::get<0>(GetParam())) {
+      ropts.readahead_size = 32768;
+    }
+    if (std::get<1>(GetParam())) {
+      ropts.async_io = true;
+    }
+
+    Slice ub = Slice("my_key_uuu");
+    ropts.iterate_upper_bound = &ub;
+    Slice seek_key = Slice("my_key_aaa");
+
+    // With tuning readahead_size.
+    {
+      ASSERT_OK(options.statistics->Reset());
+      ropts.auto_readahead_size = true;
+
+      auto iter = std::unique_ptr<Iterator>(db_->NewIterator(ropts));
+
+      iter->Seek(seek_key);
+
+      while (iter->Valid()) {
+        keys_with_tuning++;
+        iter->Next();
+      }
+
+      uint64_t readhahead_trimmed =
+          options.statistics->getAndResetTickerCount(READAHEAD_TRIMMED);
+      ASSERT_GT(readhahead_trimmed, 0);
+      buff_count_with_tuning = buff_prefetch_count;
+    }
+
+    // Without tuning readahead_size
+    {
+      buff_prefetch_count = 0;
+      ASSERT_OK(options.statistics->Reset());
+      ropts.auto_readahead_size = false;
+
+      auto iter = std::unique_ptr<Iterator>(db_->NewIterator(ropts));
+
+      iter->Seek(seek_key);
+
+      while (iter->Valid()) {
+        keys_without_tuning++;
+        iter->Next();
+      }
+      buff_count_without_tuning = buff_prefetch_count;
+      uint64_t readhahead_trimmed =
+          options.statistics->getAndResetTickerCount(READAHEAD_TRIMMED);
+      ASSERT_EQ(readhahead_trimmed, 0);
+    }
+
+    {
+      // Verify results with and without tuning.
+      if (std::get<1>(GetParam())) {
+        // In case of async_io.
+        ASSERT_GE(buff_count_with_tuning, buff_count_without_tuning);
+      } else {
+        ASSERT_EQ(buff_count_without_tuning, buff_count_with_tuning);
+      }
+      // Prefetching should happen.
+      ASSERT_GT(buff_count_without_tuning, 0);
+      ASSERT_GT(buff_count_with_tuning, 0);
+      // No of keys should be equal.
+      ASSERT_EQ(keys_without_tuning, keys_with_tuning);
+    }
+    Close();
+  }
+}
+
+// This test checks if readahead_size is trimmed when upper_bound is reached
+// during Seek in async_io and it goes for polling without any extra
+// prefetching.
+TEST_P(PrefetchTest, IterReadAheadSizeWithUpperBoundSeekOnly) {
+  if (mem_env_ || encrypted_env_) {
+    ROCKSDB_GTEST_SKIP("Test requires non-mem or non-encrypted environment");
+    return;
+  }
+
+  // First param is if the mockFS support_prefetch or not
+  std::shared_ptr<MockFS> fs =
+      std::make_shared<MockFS>(FileSystem::Default(), false);
+
+  bool use_direct_io = false;
+  if (std::get<0>(GetParam())) {
+    use_direct_io = true;
+  }
+
+  std::unique_ptr<Env> env(new CompositeEnvWrapper(env_, fs));
+  Options options;
+  SetGenericOptions(env.get(), use_direct_io, options);
+  options.statistics = CreateDBStatistics();
+  BlockBasedTableOptions table_options;
+  SetBlockBasedTableOptions(table_options);
+  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
+
+  Status s = TryReopen(options);
+  if (use_direct_io && (s.IsNotSupported() || s.IsInvalidArgument())) {
+    // If direct IO is not supported, skip the test
+    return;
+  } else {
+    ASSERT_OK(s);
+  }
+
+  Random rnd(309);
+  WriteBatch batch;
+
+  for (int i = 0; i < 26; i++) {
+    std::string key = "my_key_";
+
+    for (int j = 0; j < 10; j++) {
+      key += char('a' + i);
+      ASSERT_OK(batch.Put(key, rnd.RandomString(1000)));
+    }
+  }
+  ASSERT_OK(db_->Write(WriteOptions(), &batch));
+
+  std::string start_key = "my_key_a";
+
+  std::string end_key = "my_key_";
+  for (int j = 0; j < 10; j++) {
+    end_key += char('a' + 25);
+  }
+
+  Slice least(start_key.data(), start_key.size());
+  Slice greatest(end_key.data(), end_key.size());
+
+  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), &least, &greatest));
+
+  s = TryReopen(options);
+  ASSERT_OK(s);
+
+  int buff_count_with_tuning = 0;
+
+  SyncPoint::GetInstance()->SetCallBack(
+      "FilePrefetchBuffer::PrefetchAsyncInternal:Start",
+      [&](void*) { buff_count_with_tuning++; });
+
+  bool read_async_called = false;
+  SyncPoint::GetInstance()->SetCallBack(
+      "UpdateResults::io_uring_result",
+      [&](void* /*arg*/) { read_async_called = true; });
+
+  SyncPoint::GetInstance()->EnableProcessing();
+
+  SyncPoint::GetInstance()->EnableProcessing();
+
+  ReadOptions ropts;
+  if (std::get<1>(GetParam())) {
+    ropts.readahead_size = 32768;
+  }
+  ropts.async_io = true;
+
+  Slice ub = Slice("my_key_aaa");
+  ropts.iterate_upper_bound = &ub;
+  Slice seek_key = Slice("my_key_aaa");
+
+  // With tuning readahead_size.
+  {
+    ASSERT_OK(options.statistics->Reset());
+    ropts.auto_readahead_size = true;
+
+    auto iter = std::unique_ptr<Iterator>(db_->NewIterator(ropts));
+
+    iter->Seek(seek_key);
+
+    ASSERT_OK(iter->status());
+
+    // Verify results.
+    uint64_t readhahead_trimmed =
+        options.statistics->getAndResetTickerCount(READAHEAD_TRIMMED);
+    // Readahead got trimmed.
+    if (read_async_called) {
+      ASSERT_GT(readhahead_trimmed, 0);
+      // Seek called PrefetchAsync to poll the data.
+      ASSERT_EQ(1, buff_count_with_tuning);
+    } else {
+      // async_io disabled.
+      ASSERT_GE(readhahead_trimmed, 0);
+      ASSERT_EQ(0, buff_count_with_tuning);
+    }
   }
   Close();
 }
@@ -2294,7 +2852,7 @@ TEST_F(FilePrefetchBufferTest, SeekWithBlockCacheHit) {
   std::unique_ptr<RandomAccessFileReader> r;
   Read(fname, opts, &r);
 
-  FilePrefetchBuffer fpb(16384, 16384, true, false, false, 0, 0, fs());
+  FilePrefetchBuffer fpb(16384, 16384, true, false, false, 0, 0, 0, fs());
   Slice result;
   // Simulate a seek of 4096 bytes at offset 0. Due to the readahead settings,
   // it will do two reads of 4096+8192 and 8192
@@ -2310,8 +2868,93 @@ TEST_F(FilePrefetchBufferTest, SeekWithBlockCacheHit) {
   fpb.UpdateReadPattern(0, 4096, false);
   // Now read some data that straddles the two prefetch buffers - offset 8192 to
   // 16384
-  ASSERT_TRUE(fpb.TryReadFromCacheAsync(IOOptions(), r.get(), 8192, 8192,
-                                        &result, &s, Env::IOPriority::IO_LOW));
+  IOOptions io_opts;
+  io_opts.rate_limiter_priority = Env::IOPriority::IO_LOW;
+  ASSERT_TRUE(
+      fpb.TryReadFromCacheAsync(io_opts, r.get(), 8192, 8192, &result, &s));
+}
+
+// Test to ensure when PrefetchAsync is called during seek, it doesn't do any
+// alignment or prefetch extra if readahead is not enabled during seek.
+TEST_F(FilePrefetchBufferTest, SeekWithoutAlignment) {
+  std::string fname = "seek-wwithout-alignment";
+  Random rand(0);
+  std::string content = rand.RandomString(32768);
+  Write(fname, content);
+
+  FileOptions opts;
+  std::unique_ptr<RandomAccessFileReader> r;
+  Read(fname, opts, &r);
+
+  size_t alignment = r->file()->GetRequiredBufferAlignment();
+  size_t n = alignment / 2;
+
+  int read_async_called = 0;
+  SyncPoint::GetInstance()->SetCallBack(
+      "FilePrefetchBuffer::ReadAsync",
+      [&](void* /*arg*/) { read_async_called++; });
+  SyncPoint::GetInstance()->EnableProcessing();
+
+  // Without readahead enabled, there will be no alignment and offset of buffer
+  // will be n.
+  {
+    FilePrefetchBuffer fpb(
+        /*readahead_size=*/8192, /*max_readahead_size=*/16384, /*enable=*/true,
+        /*track_min_offset=*/false, /*implicit_auto_readahead=*/true,
+        /*num_file_reads=*/0, /*num_file_reads_for_auto_readahead=*/2,
+        /*upper_bound_offset=*/0, fs());
+
+    Slice result;
+    // Simulate a seek of half of alignment bytes at offset n. Due to the
+    // readahead settings, it won't prefetch extra or do any alignment and
+    // offset of buffer will be n.
+    Status s = fpb.PrefetchAsync(IOOptions(), r.get(), n, n, &result);
+
+    // Platforms that don't have IO uring may not support async IO.
+    if (s.IsNotSupported()) {
+      return;
+    }
+
+    ASSERT_TRUE(s.IsTryAgain());
+
+    IOOptions io_opts;
+    io_opts.rate_limiter_priority = Env::IOPriority::IO_LOW;
+    ASSERT_TRUE(fpb.TryReadFromCacheAsync(io_opts, r.get(), n, n, &result, &s));
+
+    if (read_async_called) {
+      ASSERT_EQ(fpb.GetPrefetchOffset(), n);
+    }
+  }
+
+  // With readahead enabled, it will do the alignment and prefetch and offset of
+  // buffer will be 0.
+  {
+    read_async_called = false;
+    FilePrefetchBuffer fpb(
+        /*readahead_size=*/16384, /*max_readahead_size=*/16384, /*enable=*/true,
+        /*track_min_offset=*/false, /*implicit_auto_readahead=*/false,
+        /*num_file_reads=*/0, /*num_file_reads_for_auto_readahead=*/2,
+        /*upper_bound_offset=*/0, fs());
+
+    Slice result;
+    // Simulate a seek of half of alignment bytes at offset n.
+    Status s = fpb.PrefetchAsync(IOOptions(), r.get(), n, n, &result);
+
+    // Platforms that don't have IO uring may not support async IO.
+    if (s.IsNotSupported()) {
+      return;
+    }
+
+    ASSERT_TRUE(s.IsTryAgain());
+
+    IOOptions io_opts;
+    io_opts.rate_limiter_priority = Env::IOPriority::IO_LOW;
+    ASSERT_TRUE(fpb.TryReadFromCacheAsync(io_opts, r.get(), n, n, &result, &s));
+
+    if (read_async_called) {
+      ASSERT_EQ(fpb.GetPrefetchOffset(), 0);
+    }
+  }
 }
 
 TEST_F(FilePrefetchBufferTest, NoSyncWithAsyncIO) {
@@ -2327,7 +2970,8 @@ TEST_F(FilePrefetchBufferTest, NoSyncWithAsyncIO) {
   FilePrefetchBuffer fpb(
       /*readahead_size=*/8192, /*max_readahead_size=*/16384, /*enable=*/true,
       /*track_min_offset=*/false, /*implicit_auto_readahead=*/false,
-      /*num_file_reads=*/0, /*num_file_reads_for_auto_readahead=*/0, fs());
+      /*num_file_reads=*/0, /*num_file_reads_for_auto_readahead=*/0,
+      /*upper_bound_offset=*/0, fs());
 
   int read_async_called = 0;
   SyncPoint::GetInstance()->SetCallBack(
@@ -2346,9 +2990,10 @@ TEST_F(FilePrefetchBufferTest, NoSyncWithAsyncIO) {
   }
 
   ASSERT_TRUE(s.IsTryAgain());
-  ASSERT_TRUE(fpb.TryReadFromCacheAsync(IOOptions(), r.get(), /*offset=*/3000,
-                                        /*length=*/4000, &async_result, &s,
-                                        Env::IOPriority::IO_LOW));
+  IOOptions io_opts;
+  io_opts.rate_limiter_priority = Env::IOPriority::IO_LOW;
+  ASSERT_TRUE(fpb.TryReadFromCacheAsync(io_opts, r.get(), /*offset=*/3000,
+                                        /*length=*/4000, &async_result, &s));
   // No sync call should be made.
   HistogramData sst_read_micros;
   stats()->histogramData(SST_READ_MICROS, &sst_read_micros);