@nxtedition/rocksdb 13.5.8 → 13.5.9

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

@@ -299,9 +299,18 @@ TEST_P(PrefetchTest, Basic) {
   const uint64_t prev_table_open_prefetch_tail_hit =
       options.statistics->getTickerCount(TABLE_OPEN_PREFETCH_TAIL_HIT);
 
+  HistogramData pre_compaction_prefetch_bytes;
+  options.statistics->histogramData(COMPACTION_PREFETCH_BYTES,
+                                    &pre_compaction_prefetch_bytes);
+  ASSERT_EQ(pre_compaction_prefetch_bytes.count, 0);
+
   // commenting out the line below causes the example to work correctly
   ASSERT_OK(db_->CompactRange(CompactRangeOptions(), &least, &greatest));
 
+  HistogramData post_compaction_prefetch_bytes;
+  options.statistics->histogramData(COMPACTION_PREFETCH_BYTES,
+                                    &post_compaction_prefetch_bytes);
+
   HistogramData cur_table_open_prefetch_tail_read;
   options.statistics->histogramData(TABLE_OPEN_PREFETCH_TAIL_READ_BYTES,
                                     &cur_table_open_prefetch_tail_read);
@@ -318,6 +327,7 @@ TEST_P(PrefetchTest, Basic) {
     ASSERT_GT(fs->GetPrefetchCount(), 1);
     ASSERT_EQ(0, buff_prefetch_count);
     fs->ClearPrefetchCount();
+    ASSERT_EQ(post_compaction_prefetch_bytes.count, 0);
   } else {
     ASSERT_FALSE(fs->IsPrefetchCalled());
     // To rule out false positive by the SST file tail prefetch during
@@ -331,6 +341,20 @@ TEST_P(PrefetchTest, Basic) {
               prev_table_open_prefetch_tail_hit);
     ASSERT_GE(cur_table_open_prefetch_tail_miss,
               prev_table_open_prefetch_tail_miss);
+
+    ASSERT_GT(post_compaction_prefetch_bytes.count, 0);
+
+    // Not an exact match due to potential roundup/down for alignment
+    auto expected_compaction_readahead_size =
+        Options().compaction_readahead_size;
+    ASSERT_LE(post_compaction_prefetch_bytes.max,
+              expected_compaction_readahead_size * 1.1);
+    ASSERT_GE(post_compaction_prefetch_bytes.max,
+              expected_compaction_readahead_size * 0.9);
+    ASSERT_LE(post_compaction_prefetch_bytes.average,
+              expected_compaction_readahead_size * 1.1);
+    ASSERT_GE(post_compaction_prefetch_bytes.average,
+              expected_compaction_readahead_size * 0.9);
   }
 
   for (bool disable_io : {false, true}) {
@@ -3251,8 +3275,9 @@ TEST_F(FilePrefetchBufferTest, SyncReadaheadStats) {
   ReadaheadParams readahead_params;
   readahead_params.initial_readahead_size = 8192;
   readahead_params.max_readahead_size = 8192;
-  FilePrefetchBuffer fpb(readahead_params, true, false, fs(), nullptr,
-                         stats.get());
+  FilePrefetchBuffer fpb(
+      readahead_params, true, false, fs(), nullptr, stats.get(),
+      nullptr /* cb */, FilePrefetchBufferUsage::kUserScanPrefetch /* usage */);
   Slice result;
   // Simulate a seek of 4096 bytes at offset 0. Due to the readahead settings,
   // it will do a read of offset 0 and length - (4096 + 8192) 12288.
@@ -3290,8 +3315,71 @@ TEST_F(FilePrefetchBufferTest, SyncReadaheadStats) {
       /* 24576(end offset of the buffer) - 16000(requested offset) =*/8576);
 }
 
-class FSBufferPrefetchTest : public testing::Test,
-                             public ::testing::WithParamInterface<bool> {
+TEST_F(FilePrefetchBufferTest, ForCompaction) {
+  // Make sure TryReadWithCache with for_compaction=true works without file
+  // system buffer reuse optimization
+  std::string fname = "fs-prefetch-buffer-for-compaction";
+  Random rand(0);
+  std::string content = rand.RandomString(64 * 1024);
+  Write(fname, content);
+
+  FileOptions opts;
+  std::unique_ptr<RandomAccessFileReader> r;
+  Read(fname, opts, &r);
+
+  std::shared_ptr<Statistics> stats = CreateDBStatistics();
+  ReadaheadParams readahead_params;
+  readahead_params.initial_readahead_size = 8192;
+  readahead_params.max_readahead_size = 8192;
+  readahead_params.num_buffers = 1;
+
+  FilePrefetchBuffer fpb(readahead_params, true /* enable */,
+                         false /* track_min_offset */, fs(), nullptr,
+                         stats.get());
+
+  Slice result;
+  Status s;
+  ASSERT_TRUE(fpb.TryReadFromCache(IOOptions(), r.get(), 0 /* offset */,
+                                   3000 /* n */, &result, &s, true));
+  ASSERT_EQ(s, Status::OK());
+  ASSERT_EQ(result.size(), 3000);
+  ASSERT_EQ(strncmp(result.data(), content.substr(0, 3000).c_str(), 3000), 0);
+
+  ASSERT_TRUE(fpb.TryReadFromCache(IOOptions(), r.get(), 3000 /* offset */,
+                                   10000 /* n */, &result, &s, true));
+  ASSERT_EQ(s, Status::OK());
+  ASSERT_EQ(result.size(), 10000);
+  ASSERT_EQ(strncmp(result.data(), content.substr(3000, 10000).c_str(), 10000),
+            0);
+
+  ASSERT_TRUE(fpb.TryReadFromCache(IOOptions(), r.get(), 15000 /* offset */,
+                                   4096 /* n */, &result, &s, true));
+  ASSERT_EQ(s, Status::OK());
+  ASSERT_EQ(result.size(), 4096);
+  ASSERT_EQ(strncmp(result.data(), content.substr(15000, 4096).c_str(), 4096),
+            0);
+
+  ASSERT_TRUE(fpb.TryReadFromCache(IOOptions(), r.get(), 40000 /* offset */,
+                                   20000 /* n */, &result, &s, true));
+  ASSERT_EQ(s, Status::OK());
+  ASSERT_EQ(result.size(), 20000);
+  ASSERT_EQ(strncmp(result.data(), content.substr(40000, 20000).c_str(), 20000),
+            0);
+
+  // Try reading past end of file
+  ASSERT_TRUE(fpb.TryReadFromCache(IOOptions(), r.get(), 60000 /* offset */,
+                                   10000 /* n */, &result, &s, true));
+  ASSERT_EQ(s, Status::OK());
+  ASSERT_EQ(result.size(), 64 * 1024 - 60000);
+  ASSERT_EQ(
+      strncmp(result.data(), content.substr(60000, 64 * 1024 - 60000).c_str(),
+              64 * 1024 - 60000),
+      0);
+}
+
+class FSBufferPrefetchTest
+    : public testing::Test,
+      public ::testing::WithParamInterface<std::tuple<bool, bool>> {
  public:
   // Mock file system supporting the kFSBuffer buffer reuse operation
   class BufferReuseFS : public FileSystemWrapper {
@@ -3316,12 +3404,24 @@ class FSBufferPrefetchTest : public testing::Test,
                            IODebugContext* dbg) override {
           for (size_t i = 0; i < num_reqs; ++i) {
             FSReadRequest& req = reqs[i];
-            FSAllocationPtr buffer(new char[req.len], [](void* ptr) {
-              delete[] static_cast<char*>(ptr);
-            });
-            req.fs_scratch = std::move(buffer);
+
+            // We cannot assume that fs_scratch points to the start of
+            // the read data. We can have the FSAllocationPtr point to a
+            // wrapper around the result buffer in our test implementation so
+            // that we can catch whenever we incorrectly make this assumption.
+            // See https://github.com/facebook/rocksdb/pull/13189 for more
+            // context.
+            char* internalData = new char[req.len];
             req.status = Read(req.offset, req.len, options, &req.result,
-                              static_cast<char*>(req.fs_scratch.get()), dbg);
+                              internalData, dbg);
+
+            Slice* internalSlice = new Slice(internalData, req.len);
+            FSAllocationPtr internalPtr(internalSlice, [](void* ptr) {
+              delete[] static_cast<const char*>(
+                  static_cast<Slice*>(ptr)->data_);
+              delete static_cast<Slice*>(ptr);
+            });
+            req.fs_scratch = std::move(internalPtr);
           }
           return IOStatus::OK();
         }
@@ -3343,7 +3443,7 @@ class FSBufferPrefetchTest : public testing::Test,
   void SetUp() override {
     SetupSyncPointsToMockDirectIO();
     env_ = Env::Default();
-    bool use_async_prefetch = GetParam();
+    bool use_async_prefetch = std::get<0>(GetParam());
     if (use_async_prefetch) {
       fs_ = FileSystem::Default();
     } else {
@@ -3387,8 +3487,13 @@ class FSBufferPrefetchTest : public testing::Test,
   std::string Path(const std::string& fname) { return test_dir_ + "/" + fname; }
 };
 
+// param 1: whether async IO is enabled (num_buffers_ > 1)
+// param 2: whether for_compaction is set to true for TryReadFromCache requests
+// 3 out of these 4 combinations are tested (async IO is not allowed for
+// compaction reads)
 INSTANTIATE_TEST_CASE_P(FSBufferPrefetchTest, FSBufferPrefetchTest,
-                        ::testing::Bool());
+                        ::testing::Combine(::testing::Bool(),
+                                           ::testing::Bool()));
 
 TEST_P(FSBufferPrefetchTest, FSBufferPrefetchStatsInternals) {
   // Check that the main buffer, the overlap_buf_, and the secondary buffer (in
@@ -3407,12 +3512,20 @@ TEST_P(FSBufferPrefetchTest, FSBufferPrefetchStatsInternals) {
   ReadaheadParams readahead_params;
   readahead_params.initial_readahead_size = 8192;
   readahead_params.max_readahead_size = 8192;
-  bool use_async_prefetch = GetParam();
+  bool use_async_prefetch = std::get<0>(GetParam());
+  bool for_compaction = std::get<1>(GetParam());
+  // We disallow async IO for compaction reads since they are background
+  // operations anyways and not as latency sensitive as user-initiated reads
+  if (use_async_prefetch && for_compaction) {
+    return;
+  }
   size_t num_buffers = use_async_prefetch ? 2 : 1;
   readahead_params.num_buffers = num_buffers;
 
-  FilePrefetchBuffer fpb(readahead_params, true, false, fs(), clock(),
-                         stats.get());
+  FilePrefetchBuffer fpb(
+      readahead_params, true /* enable */, false /* track_min_offset */, fs(),
+      clock(), stats.get(), nullptr /* cb */,
+      FilePrefetchBufferUsage::kUserScanPrefetch /* usage */);
 
   int overlap_buffer_write_ct = 0;
   ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
@@ -3426,15 +3539,18 @@ TEST_P(FSBufferPrefetchTest, FSBufferPrefetchStatsInternals) {
   std::vector<std::tuple<uint64_t, size_t, bool>> buffer_info(num_buffers);
   std::pair<uint64_t, size_t> overlap_buffer_info;
   bool could_read_from_cache =
-      fpb.TryReadFromCache(IOOptions(), r.get(), 0, 4096, &result, &s);
+      fpb.TryReadFromCache(IOOptions(), r.get(), 0 /* offset */, 4096 /* n */,
+                           &result, &s, for_compaction);
   // Platforms that don't have IO uring may not support async IO.
   if (use_async_prefetch && s.IsNotSupported()) {
     return;
   }
   ASSERT_TRUE(could_read_from_cache);
   ASSERT_EQ(s, Status::OK());
+
   ASSERT_EQ(stats->getAndResetTickerCount(PREFETCH_HITS), 0);
   ASSERT_EQ(stats->getAndResetTickerCount(PREFETCH_BYTES_USEFUL), 0);
+
   ASSERT_EQ(strncmp(result.data(), content.substr(0, 4096).c_str(), 4096), 0);
   fpb.TEST_GetOverlapBufferOffsetandSize(overlap_buffer_info);
   fpb.TEST_GetBufferOffsetandSize(buffer_info);
@@ -3460,12 +3576,15 @@ TEST_P(FSBufferPrefetchTest, FSBufferPrefetchStatsInternals) {
 
   // Simulate a block cache hit
   fpb.UpdateReadPattern(4096, 4096, false);
-  ASSERT_TRUE(
-      fpb.TryReadFromCache(IOOptions(), r.get(), 8192, 8192, &result, &s));
+  ASSERT_TRUE(fpb.TryReadFromCache(IOOptions(), r.get(), 8192 /* offset */,
+                                   8192 /* n */, &result, &s, for_compaction));
   ASSERT_EQ(s, Status::OK());
-  ASSERT_EQ(stats->getAndResetTickerCount(PREFETCH_HITS), 0);
-  ASSERT_EQ(stats->getAndResetTickerCount(PREFETCH_BYTES_USEFUL),
-            4096);  // 8192-12288
+  if (!for_compaction) {
+    ASSERT_EQ(stats->getAndResetTickerCount(PREFETCH_HITS), 0);
+    ASSERT_EQ(stats->getAndResetTickerCount(PREFETCH_BYTES_USEFUL),
+              4096);  // 8192-12288
+  }
+
   ASSERT_EQ(strncmp(result.data(), content.substr(8192, 8192).c_str(), 8192),
             0);
   fpb.TEST_GetOverlapBufferOffsetandSize(overlap_buffer_info);
@@ -3496,12 +3615,16 @@ TEST_P(FSBufferPrefetchTest, FSBufferPrefetchStatsInternals) {
     ASSERT_EQ(std::get<1>(buffer_info[0]), 12288);
   }
 
-  ASSERT_TRUE(
-      fpb.TryReadFromCache(IOOptions(), r.get(), 12288, 4096, &result, &s));
+  ASSERT_TRUE(fpb.TryReadFromCache(IOOptions(), r.get(), 12288 /* offset */,
+                                   4096 /* n */, &result, &s, for_compaction));
   ASSERT_EQ(s, Status::OK());
-  ASSERT_EQ(stats->getAndResetTickerCount(PREFETCH_HITS), 1);
-  ASSERT_EQ(stats->getAndResetTickerCount(PREFETCH_BYTES_USEFUL),
-            4096);  // 12288-16384
+
+  if (!for_compaction) {
+    ASSERT_EQ(stats->getAndResetTickerCount(PREFETCH_HITS), 1);
+    ASSERT_EQ(stats->getAndResetTickerCount(PREFETCH_BYTES_USEFUL),
+              4096);  // 12288-16384
+  }
+
   ASSERT_EQ(strncmp(result.data(), content.substr(12288, 4096).c_str(), 4096),
             0);
   fpb.TEST_GetOverlapBufferOffsetandSize(overlap_buffer_info);
@@ -3528,13 +3651,17 @@ TEST_P(FSBufferPrefetchTest, FSBufferPrefetchStatsInternals) {
   }
 
   // Read from 16000-26000 (start and end do not meet normal alignment)
-  ASSERT_TRUE(
-      fpb.TryReadFromCache(IOOptions(), r.get(), 16000, 10000, &result, &s));
+  ASSERT_TRUE(fpb.TryReadFromCache(IOOptions(), r.get(), 16000 /* offset */,
+                                   10000 /* n */, &result, &s, for_compaction));
   ASSERT_EQ(s, Status::OK());
-  ASSERT_EQ(stats->getAndResetTickerCount(PREFETCH_HITS), 0);
-  ASSERT_EQ(
-      stats->getAndResetTickerCount(PREFETCH_BYTES_USEFUL),
-      /* 24576(end offset of the buffer) - 16000(requested offset) =*/8576);
+
+  if (!for_compaction) {
+    ASSERT_EQ(stats->getAndResetTickerCount(PREFETCH_HITS), 0);
+    ASSERT_EQ(
+        stats->getAndResetTickerCount(PREFETCH_BYTES_USEFUL),
+        /* 24576(end offset of the buffer) - 16000(requested offset) =*/8576);
+  }
+
   ASSERT_EQ(strncmp(result.data(), content.substr(16000, 10000).c_str(), 10000),
             0);
   fpb.TEST_GetOverlapBufferOffsetandSize(overlap_buffer_info);
@@ -3583,10 +3710,17 @@ TEST_P(FSBufferPrefetchTest, FSBufferPrefetchUnalignedReads) {
   // Readahead size will double each time
   readahead_params.initial_readahead_size = 5;
   readahead_params.max_readahead_size = 100;
-  bool use_async_prefetch = GetParam();
+  bool use_async_prefetch = std::get<0>(GetParam());
+  bool for_compaction = std::get<1>(GetParam());
+  // We disallow async IO for compaction reads since they are background
+  // operations anyways and their latencies are not visible to the end user
+  if (use_async_prefetch && for_compaction) {
+    return;
+  }
   size_t num_buffers = use_async_prefetch ? 2 : 1;
   readahead_params.num_buffers = num_buffers;
-  FilePrefetchBuffer fpb(readahead_params, true, false, fs(), clock(),
+  FilePrefetchBuffer fpb(readahead_params, true /* enable */,
+                         false /* track_min_offset */, fs(), clock(),
                          stats.get());
 
   int overlap_buffer_write_ct = 0;
@@ -3601,7 +3735,8 @@ TEST_P(FSBufferPrefetchTest, FSBufferPrefetchUnalignedReads) {
   std::vector<std::tuple<uint64_t, size_t, bool>> buffer_info(num_buffers);
   std::pair<uint64_t, size_t> overlap_buffer_info;
   bool could_read_from_cache =
-      fpb.TryReadFromCache(IOOptions(), r.get(), 5, 3, &result, &s);
+      fpb.TryReadFromCache(IOOptions(), r.get(), 5 /* offset */, 3 /* n */,
+                           &result, &s, for_compaction);
   // Platforms that don't have IO uring may not support async IO.
   if (use_async_prefetch && s.IsNotSupported()) {
     return;
@@ -3633,7 +3768,8 @@ TEST_P(FSBufferPrefetchTest, FSBufferPrefetchUnalignedReads) {
     ASSERT_EQ(std::get<1>(buffer_info[0]), 3 + 5);
   }
 
-  ASSERT_TRUE(fpb.TryReadFromCache(IOOptions(), r.get(), 16, 7, &result, &s));
+  ASSERT_TRUE(fpb.TryReadFromCache(IOOptions(), r.get(), 16 /* offset */,
+                                   7 /* n */, &result, &s, for_compaction));
   ASSERT_EQ(s, Status::OK());
   ASSERT_EQ(strncmp(result.data(), content.substr(16, 7).c_str(), 7), 0);
   fpb.TEST_GetOverlapBufferOffsetandSize(overlap_buffer_info);
@@ -3657,16 +3793,18 @@ TEST_P(FSBufferPrefetchTest, FSBufferPrefetchUnalignedReads) {
 
   // Go backwards
   if (use_async_prefetch) {
-    ASSERT_TRUE(fpb.TryReadFromCache(IOOptions(), r.get(), 10, 8, &result, &s));
+    ASSERT_TRUE(fpb.TryReadFromCache(IOOptions(), r.get(), 10 /* offset */,
+                                     8 /* n */, &result, &s, for_compaction));
   } else {
     // TryReadFromCacheUntracked returns false since the offset
     // requested is less than the start of our buffer
-    ASSERT_FALSE(
-        fpb.TryReadFromCache(IOOptions(), r.get(), 10, 8, &result, &s));
+    ASSERT_FALSE(fpb.TryReadFromCache(IOOptions(), r.get(), 10 /* offset */,
+                                      8 /* n */, &result, &s, for_compaction));
   }
   ASSERT_EQ(s, Status::OK());
 
-  ASSERT_TRUE(fpb.TryReadFromCache(IOOptions(), r.get(), 27, 6, &result, &s));
+  ASSERT_TRUE(fpb.TryReadFromCache(IOOptions(), r.get(), 27 /* offset */,
+                                   6 /* n */, &result, &s, for_compaction));
   ASSERT_EQ(s, Status::OK());
   ASSERT_EQ(strncmp(result.data(), content.substr(27, 6).c_str(), 6), 0);
   fpb.TEST_GetOverlapBufferOffsetandSize(overlap_buffer_info);
@@ -3687,7 +3825,8 @@ TEST_P(FSBufferPrefetchTest, FSBufferPrefetchUnalignedReads) {
     ASSERT_EQ(std::get<1>(buffer_info[0]), 7 + 10);
   }
 
-  ASSERT_TRUE(fpb.TryReadFromCache(IOOptions(), r.get(), 30, 20, &result, &s));
+  ASSERT_TRUE(fpb.TryReadFromCache(IOOptions(), r.get(), 30 /* offset */,
+                                   20 /* n */, &result, &s, for_compaction));
   ASSERT_EQ(s, Status::OK());
   ASSERT_EQ(strncmp(result.data(), content.substr(30, 20).c_str(), 20), 0);
   fpb.TEST_GetOverlapBufferOffsetandSize(overlap_buffer_info);
@@ -3710,13 +3849,13 @@ TEST_P(FSBufferPrefetchTest, FSBufferPrefetchUnalignedReads) {
   }
 }
 
-TEST_P(FSBufferPrefetchTest, FSBufferPrefetchForCompaction) {
-  // Quick test to make sure file system buffer reuse is disabled for compaction
-  // reads. Will update once it is re-enabled
-  // Primarily making sure we do not hit unsigned integer overflow issues
-  std::string fname = "fs-buffer-prefetch-for-compaction";
+TEST_P(FSBufferPrefetchTest, FSBufferPrefetchRandomized) {
+  // This test is meant to find untested code paths. It does very simple
+  // verifications and relies on debug assertions to catch invariant violations
+  // We scan through a file reading between 0 and 16 KiB at a time
+  std::string fname = "fs-buffer-prefetch-randomized";
   Random rand(0);
-  std::string content = rand.RandomString(32768);
+  std::string content = rand.RandomString(16 * 1024 * 1024);
   Write(fname, content);
 
   FileOptions opts;
@@ -3725,45 +3864,59 @@ TEST_P(FSBufferPrefetchTest, FSBufferPrefetchForCompaction) {
 
   std::shared_ptr<Statistics> stats = CreateDBStatistics();
   ReadaheadParams readahead_params;
-  readahead_params.initial_readahead_size = 8192;
-  readahead_params.max_readahead_size = 8192;
-  bool use_async_prefetch = GetParam();
+  readahead_params.initial_readahead_size = 512;
+  readahead_params.max_readahead_size = 2048;
+  bool use_async_prefetch = std::get<0>(GetParam());
+  bool for_compaction = std::get<1>(GetParam());
   // Async IO is not enabled for compaction prefetching
-  if (use_async_prefetch) {
+  if (use_async_prefetch && for_compaction) {
     return;
   }
-  readahead_params.num_buffers = 1;
+  size_t num_buffers = use_async_prefetch ? 2 : 1;
+  readahead_params.num_buffers = num_buffers;
 
-  FilePrefetchBuffer fpb(readahead_params, true, false, fs(), clock(),
+  FilePrefetchBuffer fpb(readahead_params, true /* enable */,
+                         false /* track_min_offset */, fs(), clock(),
                          stats.get());
 
   Slice result;
   Status s;
-  ASSERT_TRUE(
-      fpb.TryReadFromCache(IOOptions(), r.get(), 0, 4096, &result, &s, true));
-  ASSERT_EQ(s, Status::OK());
-  ASSERT_EQ(strncmp(result.data(), content.substr(0, 4096).c_str(), 4096), 0);
 
-  fpb.UpdateReadPattern(4096, 4096, false);
-
-  ASSERT_TRUE(fpb.TryReadFromCache(IOOptions(), r.get(), 8192, 8192, &result,
-                                   &s, true));
-  ASSERT_EQ(s, Status::OK());
-  ASSERT_EQ(strncmp(result.data(), content.substr(8192, 8192).c_str(), 8192),
-            0);
-
-  ASSERT_TRUE(fpb.TryReadFromCache(IOOptions(), r.get(), 12288, 4096, &result,
-                                   &s, true));
-  ASSERT_EQ(s, Status::OK());
-  ASSERT_EQ(strncmp(result.data(), content.substr(12288, 4096).c_str(), 4096),
-            0);
-
-  // Read from 16000-26000 (start and end do not meet normal alignment)
-  ASSERT_TRUE(fpb.TryReadFromCache(IOOptions(), r.get(), 16000, 10000, &result,
-                                   &s, true));
-  ASSERT_EQ(s, Status::OK());
-  ASSERT_EQ(strncmp(result.data(), content.substr(16000, 10000).c_str(), 10000),
-            0);
+  uint64_t offset = 0;
+  Random rnd(987654);
+  for (int i = 0; i < 1000; i++) {
+    size_t len = rnd.Uniform(16 * 1024);
+    if (offset >= content.size()) {
+      std::cout << "Stopped early after " << i << " iterations" << std::endl;
+      break;
+    }
+    bool could_read_from_cache = fpb.TryReadFromCache(
+        IOOptions(), r.get(), offset, len, &result, &s, for_compaction);
+    // Platforms that don't have IO uring may not support async IO.
+    if (use_async_prefetch && s.IsNotSupported()) {
+      return;
+    }
+    ASSERT_TRUE(could_read_from_cache);
+    ASSERT_EQ(s, Status::OK());
+    ASSERT_EQ(result.size(),
+              std::min(len, content.size() - static_cast<size_t>(offset)));
+    ASSERT_EQ(strncmp(result.data(),
+                      content.substr(offset, offset + len).c_str(), len),
+              0);
+    if (i % 4 == 0) {
+      // Test reads where we "skip forward" in the file more than we could read
+      // ahead
+      offset += len + 2 * readahead_params.max_readahead_size;
+    } else if (i % 4 == 1) {
+      // Test reads where we "skip forward" in the file but should have some
+      // overlap with the read ahead data
+      offset += len + readahead_params.max_readahead_size / 2;
+    } else {
+      // Test "back to back" reads (next read starts right at end of previous
+      // one)
+      offset += len;
+    }
+  }
 }
 
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/file/random_access_file_reader.cc

@@ -106,11 +106,14 @@ IOStatus RandomAccessFileReader::Create(
 
 IOStatus RandomAccessFileReader::Read(const IOOptions& opts, uint64_t offset,
                                       size_t n, Slice* result, char* scratch,
-                                      AlignedBuf* aligned_buf) const {
+                                      AlignedBuf* aligned_buf,
+                                      IODebugContext* dbg) const {
   (void)aligned_buf;
   const Env::IOPriority rate_limiter_priority = opts.rate_limiter_priority;
 
   TEST_SYNC_POINT_CALLBACK("RandomAccessFileReader::Read", nullptr);
+  TEST_SYNC_POINT_CALLBACK("RandomAccessFileReader::Read:IODebugContext",
+                           const_cast<void*>(static_cast<void*>(dbg)));
 
   // To be paranoid: modify scratch a little bit, so in case underlying
   // FileSystem doesn't fill the buffer but return success and `scratch` returns
@@ -175,7 +178,7 @@ IOStatus RandomAccessFileReader::Read(const IOOptions& opts, uint64_t offset,
           // the opts.timeout before calling file_->Read
           assert(!opts.timeout.count() || allowed == read_size);
           io_s = file_->Read(aligned_offset + buf.CurrentSize(), allowed, opts,
-                             &tmp, buf.Destination(), nullptr);
+                             &tmp, buf.Destination(), dbg);
         }
         if (ShouldNotifyListeners()) {
           auto finish_ts = FileOperationInfo::FinishNow();
@@ -237,7 +240,7 @@ IOStatus RandomAccessFileReader::Read(const IOOptions& opts, uint64_t offset,
           // the opts.timeout before calling file_->Read
           assert(!opts.timeout.count() || allowed == n);
           io_s = file_->Read(offset + pos, allowed, opts, &tmp_result,
-                             scratch + pos, nullptr);
+                             scratch + pos, dbg);
         }
         if (ShouldNotifyListeners()) {
           auto finish_ts = FileOperationInfo::FinishNow();
@@ -311,7 +314,8 @@ bool TryMerge(FSReadRequest* dest, const FSReadRequest& src) {
 IOStatus RandomAccessFileReader::MultiRead(const IOOptions& opts,
                                            FSReadRequest* read_reqs,
                                            size_t num_reqs,
-                                           AlignedBuf* aligned_buf) const {
+                                           AlignedBuf* aligned_buf,
+                                           IODebugContext* dbg) const {
   (void)aligned_buf;  // suppress warning of unused variable in LITE mode
   assert(num_reqs > 0);
 
@@ -420,8 +424,10 @@ IOStatus RandomAccessFileReader::MultiRead(const IOOptions& opts,
           remaining_bytes -= request_bytes;
         }
       }
-      io_s = file_->MultiRead(fs_reqs, num_fs_reqs, opts,
-                              /*IODebugContext*=*/nullptr);
+      TEST_SYNC_POINT_CALLBACK(
+          "RandomAccessFileReader::MultiRead:IODebugContext",
+          const_cast<void*>(static_cast<void*>(dbg)));
+      io_s = file_->MultiRead(fs_reqs, num_fs_reqs, opts, dbg);
       RecordInHistogram(stats_, MULTIGET_IO_BATCH_SIZE, num_fs_reqs);
     }
 
@@ -475,18 +481,21 @@ IOStatus RandomAccessFileReader::MultiRead(const IOOptions& opts,
 }
 
 IOStatus RandomAccessFileReader::PrepareIOOptions(const ReadOptions& ro,
-                                                  IOOptions& opts) const {
+                                                  IOOptions& opts,
+                                                  IODebugContext* dbg) const {
   if (clock_ != nullptr) {
-    return PrepareIOFromReadOptions(ro, clock_, opts);
+    return PrepareIOFromReadOptions(ro, clock_, opts, dbg);
   } else {
-    return PrepareIOFromReadOptions(ro, SystemClock::Default().get(), opts);
+    return PrepareIOFromReadOptions(ro, SystemClock::Default().get(), opts,
+                                    dbg);
   }
 }
 
 IOStatus RandomAccessFileReader::ReadAsync(
     FSReadRequest& req, const IOOptions& opts,
     std::function<void(FSReadRequest&, void*)> cb, void* cb_arg,
-    void** io_handle, IOHandleDeleter* del_fn, AlignedBuf* aligned_buf) {
+    void** io_handle, IOHandleDeleter* del_fn, AlignedBuf* aligned_buf,
+    IODebugContext* dbg) {
   IOStatus s;
   // Create a callback and populate info.
   auto read_async_callback =
@@ -532,14 +541,14 @@ IOStatus RandomAccessFileReader::ReadAsync(
                  (stats_ != nullptr) ? &elapsed : nullptr, true /*overwrite*/,
                  true /*delay_enabled*/);
     s = file_->ReadAsync(aligned_req, opts, read_async_callback,
-                         read_async_info, io_handle, del_fn, nullptr /*dbg*/);
+                         read_async_info, io_handle, del_fn, dbg);
   } else {
     StopWatch sw(clock_, stats_, hist_type_,
                  GetFileReadHistograms(stats_, opts.io_activity),
                  (stats_ != nullptr) ? &elapsed : nullptr, true /*overwrite*/,
                  true /*delay_enabled*/);
     s = file_->ReadAsync(req, opts, read_async_callback, read_async_info,
-                         io_handle, del_fn, nullptr /*dbg*/);
+                         io_handle, del_fn, dbg);
   }
   RecordTick(stats_, READ_ASYNC_MICROS, elapsed);
 

package/deps/rocksdb/rocksdb/file/random_access_file_reader.h

@@ -76,7 +76,6 @@ class RandomAccessFileReader {
     io_status.PermitUncheckedError();
   }
 
-
   bool ShouldNotifyListeners() const { return !listeners_.empty(); }
 
   FSRandomAccessFilePtr file_;
@@ -165,7 +164,8 @@ class RandomAccessFileReader {
   // the internally allocated buffer on return, and the result refers to a
   // region in aligned_buf.
   IOStatus Read(const IOOptions& opts, uint64_t offset, size_t n, Slice* result,
-                char* scratch, AlignedBuf* aligned_buf) const;
+                char* scratch, AlignedBuf* aligned_buf,
+                IODebugContext* dbg = nullptr) const;
 
   // REQUIRES:
   // num_reqs > 0, reqs do not overlap, and offsets in reqs are increasing.
@@ -173,10 +173,12 @@ class RandomAccessFileReader {
   // In direct IO mode, aligned_buf stores the aligned buffer allocated inside
   // MultiRead, the result Slices in reqs refer to aligned_buf.
   IOStatus MultiRead(const IOOptions& opts, FSReadRequest* reqs,
-                     size_t num_reqs, AlignedBuf* aligned_buf) const;
+                     size_t num_reqs, AlignedBuf* aligned_buf,
+                     IODebugContext* dbg = nullptr) const;
 
-  IOStatus Prefetch(const IOOptions& opts, uint64_t offset, size_t n) const {
-    return file_->Prefetch(offset, n, opts, nullptr);
+  IOStatus Prefetch(const IOOptions& opts, uint64_t offset, size_t n,
+                    IODebugContext* dbg = nullptr) const {
+    return file_->Prefetch(offset, n, opts, dbg);
   }
 
   FSRandomAccessFile* file() { return file_.get(); }
@@ -185,12 +187,13 @@ class RandomAccessFileReader {
 
   bool use_direct_io() const { return file_->use_direct_io(); }
 
-  IOStatus PrepareIOOptions(const ReadOptions& ro, IOOptions& opts) const;
+  IOStatus PrepareIOOptions(const ReadOptions& ro, IOOptions& opts,
+                            IODebugContext* dbg = nullptr) const;
 
   IOStatus ReadAsync(FSReadRequest& req, const IOOptions& opts,
                      std::function<void(FSReadRequest&, void*)> cb,
                      void* cb_arg, void** io_handle, IOHandleDeleter* del_fn,
-                     AlignedBuf* aligned_buf);
+                     AlignedBuf* aligned_buf, IODebugContext* dbg = nullptr);
 
   void ReadAsyncCallback(FSReadRequest& req, void* cb_arg);
 };