@nxtedition/rocksdb 9.0.0 → 9.0.1

package/deps/rocksdb/rocksdb/db_stress_tool/db_stress_tool.cc

@@ -88,11 +88,11 @@ int db_stress_tool(int argc, char** argv) {
     FaultInjectionTestFS* fs =
         new FaultInjectionTestFS(raw_env->GetFileSystem());
     fault_fs_guard.reset(fs);
-    if (FLAGS_write_fault_one_in) {
-      fault_fs_guard->SetFilesystemDirectWritable(false);
-    } else {
-      fault_fs_guard->SetFilesystemDirectWritable(true);
-    }
+    // Set it to direct writable here to not lose files created during DB open
+    // when no open fault injection is not enabled.
+    // This will be overwritten in StressTest::Open() for open fault injection
+    // and in RunStressTestImpl() for proper write fault injection setup.
+    fault_fs_guard->SetFilesystemDirectWritable(true);
     fault_env_guard =
         std::make_shared<CompositeEnvWrapper>(raw_env, fault_fs_guard);
     raw_env = fault_env_guard.get();
@@ -240,10 +240,10 @@ int db_stress_tool(int argc, char** argv) {
     FLAGS_secondaries_base = default_secondaries_path;
   }
 
-  if (FLAGS_best_efforts_recovery && !FLAGS_skip_verifydb &&
-      !FLAGS_disable_wal) {
+  if (FLAGS_best_efforts_recovery &&
+      !(FLAGS_skip_verifydb && FLAGS_disable_wal)) {
     fprintf(stderr,
-            "With best-efforts recovery, either skip_verifydb or disable_wal "
+            "With best-efforts recovery, skip_verifydb and disable_wal "
             "should be set to true.\n");
     exit(1);
   }
@@ -308,11 +308,11 @@ int db_stress_tool(int argc, char** argv) {
   }
 
   if (FLAGS_use_put_entity_one_in > 0 &&
-      (FLAGS_use_merge || FLAGS_use_full_merge_v1 || FLAGS_use_txn ||
-       FLAGS_test_multi_ops_txns || FLAGS_user_timestamp_size > 0)) {
+      (FLAGS_use_full_merge_v1 || FLAGS_use_txn || FLAGS_test_multi_ops_txns ||
+       FLAGS_user_timestamp_size > 0)) {
     fprintf(stderr,
-            "PutEntity is currently incompatible with Merge,"
-            " transactions, and user-defined timestamps\n");
+            "Wide columns are incompatible with V1 Merge, transactions, and "
+            "user-defined timestamps\n");
     exit(1);
   }
 

package/deps/rocksdb/rocksdb/db_stress_tool/db_stress_wide_merge_operator.cc

@@ -0,0 +1,51 @@
+//  Copyright (c) Meta Platforms, Inc. and affiliates.
+//  This source code is licensed under both the GPLv2 (found in the
+//  COPYING file in the root directory) and Apache 2.0 License
+//  (found in the LICENSE.Apache file in the root directory).
+
+#ifdef GFLAGS
+
+#include "db_stress_tool/db_stress_wide_merge_operator.h"
+
+#include "db_stress_tool/db_stress_common.h"
+
+namespace ROCKSDB_NAMESPACE {
+
+bool DBStressWideMergeOperator::FullMergeV3(
+    const MergeOperationInputV3& merge_in,
+    MergeOperationOutputV3* merge_out) const {
+  assert(!merge_in.operand_list.empty());
+  assert(merge_out);
+
+  const Slice& latest = merge_in.operand_list.back();
+
+  if (latest.size() < sizeof(uint32_t)) {
+    return false;
+  }
+
+  const uint32_t value_base = GetValueBase(latest);
+
+  if (FLAGS_use_put_entity_one_in == 0 ||
+      (value_base % FLAGS_use_put_entity_one_in) != 0) {
+    merge_out->new_value = latest;
+    return true;
+  }
+
+  const auto columns = GenerateWideColumns(value_base, latest);
+
+  merge_out->new_value = MergeOperationOutputV3::NewColumns();
+  auto& new_columns =
+      std::get<MergeOperationOutputV3::NewColumns>(merge_out->new_value);
+  new_columns.reserve(columns.size());
+
+  for (const auto& column : columns) {
+    new_columns.emplace_back(column.name().ToString(),
+                             column.value().ToString());
+  }
+
+  return true;
+}
+
+}  // namespace ROCKSDB_NAMESPACE
+
+#endif  // GFLAGS

package/deps/rocksdb/rocksdb/db_stress_tool/db_stress_wide_merge_operator.h

@@ -0,0 +1,27 @@
+//  Copyright (c) Meta Platforms, Inc. and affiliates.
+//  This source code is licensed under both the GPLv2 (found in the
+//  COPYING file in the root directory) and Apache 2.0 License
+//  (found in the LICENSE.Apache file in the root directory).
+
+#pragma once
+
+#include "rocksdb/merge_operator.h"
+
+namespace ROCKSDB_NAMESPACE {
+
+// A test merge operator that implements the wide-column aware FullMergeV3
+// interface. Similarly to the simple "put" type merge operators, the merge
+// result is based on the last merge operand; however, the merge result can
+// potentially be a wide-column entity, depending on the value base encoded into
+// the merge operand and the value of the "use_put_entity_one_in" stress test
+// option. Following the same rule as for writes ensures that the queries
+// issued by the validation logic receive the expected results.
+class DBStressWideMergeOperator : public MergeOperator {
+ public:
+  bool FullMergeV3(const MergeOperationInputV3& merge_in,
+                   MergeOperationOutputV3* merge_out) const override;
+
+  const char* Name() const override { return "DBStressWideMergeOperator"; }
+};
+
+}  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/db_stress_tool/expected_state.cc

@@ -6,8 +6,8 @@
 #include <atomic>
 #ifdef GFLAGS
 
-
 #include "db/wide/wide_column_serialization.h"
+#include "db/wide/wide_columns_helper.h"
 #include "db_stress_tool/db_stress_common.h"
 #include "db_stress_tool/db_stress_shared_state.h"
 #include "db_stress_tool/expected_state.h"
@@ -363,7 +363,6 @@ bool FileExpectedStateManager::HasHistory() {
   return saved_seqno_ != kMaxSequenceNumber;
 }
 
-
 namespace {
 
 // An `ExpectedStateTraceRecordHandler` applies a configurable number of
@@ -462,10 +461,8 @@ class ExpectedStateTraceRecordHandler : public TraceRecord::Handler,
                                            column_family_id, key, columns);
     }
 
-    assert(!columns.empty());
-    assert(columns.front().name() == kDefaultWideColumnName);
-
-    const uint32_t value_base = GetValueBase(columns.front().value());
+    const uint32_t value_base =
+        GetValueBase(WideColumnsHelper::GetDefaultColumn(columns));
 
     state_->SyncPut(column_family_id, static_cast<int64_t>(key_id), value_base);
 

package/deps/rocksdb/rocksdb/db_stress_tool/multi_ops_txns_stress.cc

@@ -1104,8 +1104,9 @@ void MultiOpsTxnsStressTest::VerifyDb(ThreadState* thread) const {
       Status s = record.DecodePrimaryIndexEntry(it->key(), it->value());
       if (!s.ok()) {
         oss << "Cannot decode primary index entry " << it->key().ToString(true)
-            << "=>" << it->value().ToString(true);
-        VerificationAbort(thread->shared, oss.str(), s);
+            << "=>" << it->value().ToString(true) << ". Status is "
+            << s.ToString();
+        VerificationAbort(thread->shared, oss.str());
         assert(false);
         return;
       }
@@ -1125,8 +1126,9 @@ void MultiOpsTxnsStressTest::VerifyDb(ThreadState* thread) const {
       std::string value;
       s = db_->Get(ropts, sk, &value);
       if (!s.ok()) {
-        oss << "Cannot find secondary index entry " << sk.ToString(true);
-        VerificationAbort(thread->shared, oss.str(), s);
+        oss << "Cannot find secondary index entry " << sk.ToString(true)
+            << ". Status is " << s.ToString();
+        VerificationAbort(thread->shared, oss.str());
         assert(false);
         return;
       }
@@ -1153,8 +1155,9 @@ void MultiOpsTxnsStressTest::VerifyDb(ThreadState* thread) const {
       Status s = record.DecodeSecondaryIndexEntry(it->key(), it->value());
       if (!s.ok()) {
         oss << "Cannot decode secondary index entry "
-            << it->key().ToString(true) << "=>" << it->value().ToString(true);
-        VerificationAbort(thread->shared, oss.str(), s);
+            << it->key().ToString(true) << "=>" << it->value().ToString(true)
+            << ". Status is " << s.ToString();
+        VerificationAbort(thread->shared, oss.str());
         assert(false);
         return;
       }
@@ -1168,7 +1171,7 @@ void MultiOpsTxnsStressTest::VerifyDb(ThreadState* thread) const {
       if (!s.ok()) {
         oss << "Error searching pk " << Slice(pk).ToString(true) << ". "
             << s.ToString() << ". sk " << it->key().ToString(true);
-        VerificationAbort(thread->shared, oss.str(), s);
+        VerificationAbort(thread->shared, oss.str());
         assert(false);
         return;
       }
@@ -1176,8 +1179,8 @@ void MultiOpsTxnsStressTest::VerifyDb(ThreadState* thread) const {
       s = std::get<0>(result);
       if (!s.ok()) {
         oss << "Error decoding primary index value "
-            << Slice(value).ToString(true) << ". " << s.ToString();
-        VerificationAbort(thread->shared, oss.str(), s);
+            << Slice(value).ToString(true) << ". Status is " << s.ToString();
+        VerificationAbort(thread->shared, oss.str());
         assert(false);
         return;
       }
@@ -1187,7 +1190,7 @@ void MultiOpsTxnsStressTest::VerifyDb(ThreadState* thread) const {
             << Slice(value).ToString(true) << " (a=" << record.a_value()
             << ", c=" << c_in_primary << "), sk: " << it->key().ToString(true)
             << " (c=" << record.c_value() << ")";
-        VerificationAbort(thread->shared, oss.str(), s);
+        VerificationAbort(thread->shared, oss.str());
         assert(false);
         return;
       }
@@ -1198,7 +1201,7 @@ void MultiOpsTxnsStressTest::VerifyDb(ThreadState* thread) const {
     oss << "Pk/sk mismatch: primary index has " << primary_index_entries_count
         << " entries. Secondary index has " << secondary_index_entries_count
         << " entries.";
-    VerificationAbort(thread->shared, oss.str(), Status::OK());
+    VerificationAbort(thread->shared, oss.str());
     assert(false);
     return;
   }

package/deps/rocksdb/rocksdb/db_stress_tool/no_batched_ops_stress.cc

@@ -9,6 +9,7 @@
 
 #include "db_stress_tool/expected_state.h"
 #ifdef GFLAGS
+#include "db/wide/wide_columns_helper.h"
 #include "db_stress_tool/db_stress_common.h"
 #include "rocksdb/utilities/transaction_db.h"
 #include "utilities/fault_injection_fs.h"
@@ -165,9 +166,8 @@ class NonBatchedOpsStressTest : public StressTest {
           if (s.ok()) {
             const WideColumns& columns = result.columns();
 
-            if (!columns.empty() &&
-                columns.front().name() == kDefaultWideColumnName) {
-              from_db = columns.front().value().ToString();
+            if (WideColumnsHelper::HasDefaultColumn(columns)) {
+              from_db = WideColumnsHelper::GetDefaultColumn(columns).ToString();
             }
 
             if (!VerifyWideColumns(columns)) {
@@ -251,9 +251,9 @@ class NonBatchedOpsStressTest : public StressTest {
             if (statuses[j].ok()) {
               const WideColumns& columns = results[j].columns();
 
-              if (!columns.empty() &&
-                  columns.front().name() == kDefaultWideColumnName) {
-                from_db = columns.front().value().ToString();
+              if (WideColumnsHelper::HasDefaultColumn(columns)) {
+                from_db =
+                    WideColumnsHelper::GetDefaultColumn(columns).ToString();
               }
 
               if (!VerifyWideColumns(columns)) {
@@ -1067,7 +1067,8 @@ class NonBatchedOpsStressTest : public StressTest {
         is_consistent = false;
       } else if (check_get_entity && (s.ok() || s.IsNotFound())) {
         PinnableWideColumns cmp_result;
-
+        ThreadStatusUtil::SetThreadOperation(
+            ThreadStatus::OperationType::OP_GETENTITY);
         const Status cmp_s =
             db_->GetEntity(read_opts_copy, cfh, key_slices[i], &cmp_result);
 
@@ -1276,10 +1277,13 @@ class NonBatchedOpsStressTest : public StressTest {
     const size_t sz = GenerateValue(value_base, value, sizeof(value));
     const Slice v(value, sz);
 
-
     Status s;
 
-    if (FLAGS_use_merge) {
+    if (FLAGS_use_put_entity_one_in > 0 &&
+        (value_base % FLAGS_use_put_entity_one_in) == 0) {
+      s = db_->PutEntity(write_opts, cfh, k,
+                         GenerateWideColumns(value_base, v));
+    } else if (FLAGS_use_merge) {
       if (!FLAGS_use_txn) {
         if (FLAGS_user_timestamp_size == 0) {
           s = db_->Merge(write_opts, cfh, k, v);
@@ -1291,10 +1295,6 @@ class NonBatchedOpsStressTest : public StressTest {
           return txn.Merge(cfh, k, v);
         });
       }
-    } else if (FLAGS_use_put_entity_one_in > 0 &&
-               (value_base % FLAGS_use_put_entity_one_in) == 0) {
-      s = db_->PutEntity(write_opts, cfh, k,
-                         GenerateWideColumns(value_base, v));
     } else {
       if (!FLAGS_use_txn) {
         if (FLAGS_user_timestamp_size == 0) {
@@ -1309,10 +1309,8 @@ class NonBatchedOpsStressTest : public StressTest {
       }
     }
 
-    pending_expected_value.Commit();
-
     if (!s.ok()) {
-      if (FLAGS_injest_error_severity >= 2) {
+      if (FLAGS_inject_error_severity >= 2) {
         if (!is_db_stopped_ && s.severity() >= Status::Severity::kFatalError) {
           is_db_stopped_ = true;
         } else if (!is_db_stopped_ ||
@@ -1325,7 +1323,7 @@ class NonBatchedOpsStressTest : public StressTest {
         thread->shared->SafeTerminate();
       }
     }
-
+    pending_expected_value.Commit();
     thread->stats.AddBytesForWrites(1, sz);
     PrintKeyValue(rand_column_family, static_cast<uint32_t>(rand_key), value,
                   sz);
@@ -1367,11 +1365,9 @@ class NonBatchedOpsStressTest : public StressTest {
           return txn.Delete(cfh, key);
         });
       }
-      pending_expected_value.Commit();
 
-      thread->stats.AddDeletes(1);
       if (!s.ok()) {
-        if (FLAGS_injest_error_severity >= 2) {
+        if (FLAGS_inject_error_severity >= 2) {
           if (!is_db_stopped_ &&
               s.severity() >= Status::Severity::kFatalError) {
             is_db_stopped_ = true;
@@ -1385,6 +1381,8 @@ class NonBatchedOpsStressTest : public StressTest {
           thread->shared->SafeTerminate();
         }
       }
+      pending_expected_value.Commit();
+      thread->stats.AddDeletes(1);
     } else {
       PendingExpectedValue pending_expected_value =
           shared->PrepareSingleDelete(rand_column_family, rand_key);
@@ -1399,10 +1397,9 @@ class NonBatchedOpsStressTest : public StressTest {
           return txn.SingleDelete(cfh, key);
         });
       }
-      pending_expected_value.Commit();
-      thread->stats.AddSingleDeletes(1);
+
       if (!s.ok()) {
-        if (FLAGS_injest_error_severity >= 2) {
+        if (FLAGS_inject_error_severity >= 2) {
           if (!is_db_stopped_ &&
               s.severity() >= Status::Severity::kFatalError) {
             is_db_stopped_ = true;
@@ -1416,6 +1413,8 @@ class NonBatchedOpsStressTest : public StressTest {
           thread->shared->SafeTerminate();
         }
       }
+      pending_expected_value.Commit();
+      thread->stats.AddSingleDeletes(1);
     }
     return s;
   }
@@ -1464,7 +1463,7 @@ class NonBatchedOpsStressTest : public StressTest {
       s = db_->DeleteRange(write_opts, cfh, key, end_key);
     }
     if (!s.ok()) {
-      if (FLAGS_injest_error_severity >= 2) {
+      if (FLAGS_inject_error_severity >= 2) {
         if (!is_db_stopped_ && s.severity() >= Status::Severity::kFatalError) {
           is_db_stopped_ = true;
         } else if (!is_db_stopped_ ||
@@ -1543,11 +1542,8 @@ class NonBatchedOpsStressTest : public StressTest {
       const Slice k(key_str);
       const Slice v(value, value_len);
 
-      const bool use_put_entity =
-          !FLAGS_use_merge && FLAGS_use_put_entity_one_in > 0 &&
-          (value_base % FLAGS_use_put_entity_one_in) == 0;
-
-      if (use_put_entity) {
+      if (FLAGS_use_put_entity_one_in > 0 &&
+          (value_base % FLAGS_use_put_entity_one_in) == 0) {
         WideColumns columns = GenerateWideColumns(value_base, v);
         s = sst_file_writer.PutEntity(k, columns);
       } else {
@@ -1567,12 +1563,16 @@ class NonBatchedOpsStressTest : public StressTest {
                                   {sst_filename}, IngestExternalFileOptions());
     }
     if (!s.ok()) {
-      fprintf(stderr, "file ingestion error: %s\n", s.ToString().c_str());
-      thread->shared->SafeTerminate();
-    }
-
-    for (size_t i = 0; i < pending_expected_values.size(); ++i) {
-      pending_expected_values[i].Commit();
+      if (!s.IsIOError() || !std::strstr(s.getState(), "injected")) {
+        fprintf(stderr, "file ingestion error: %s\n", s.ToString().c_str());
+        thread->shared->SafeTerminate();
+      } else {
+        fprintf(stdout, "file ingestion error: %s\n", s.ToString().c_str());
+      }
+    } else {
+      for (size_t i = 0; i < pending_expected_values.size(); ++i) {
+        pending_expected_values[i].Commit();
+      }
     }
   }
 
@@ -2035,9 +2035,7 @@ class NonBatchedOpsStressTest : public StressTest {
       const Slice slice(value_from_db);
       const uint32_t value_base_from_db = GetValueBase(slice);
       if (ExpectedValueHelper::MustHaveNotExisted(expected_value,
-                                                  expected_value) ||
-          !ExpectedValueHelper::InExpectedValueBaseRange(
-              value_base_from_db, expected_value, expected_value)) {
+                                                  expected_value)) {
         VerificationAbort(shared, msg_prefix + ": Unexpected value found", cf,
                           key, value_from_db, "");
         return false;
@@ -2046,6 +2044,14 @@ class NonBatchedOpsStressTest : public StressTest {
       size_t expected_value_data_size =
           GenerateValue(expected_value.GetValueBase(), expected_value_data,
                         sizeof(expected_value_data));
+      if (!ExpectedValueHelper::InExpectedValueBaseRange(
+              value_base_from_db, expected_value, expected_value)) {
+        VerificationAbort(shared, msg_prefix + ": Unexpected value found", cf,
+                          key, value_from_db,
+                          Slice(expected_value_data, expected_value_data_size));
+        return false;
+      }
+      // TODO: are the length/memcmp() checks repetitive?
       if (value_from_db.length() != expected_value_data_size) {
         VerificationAbort(shared,
                           msg_prefix + ": Length of value read is not equal",

package/deps/rocksdb/rocksdb/env/env.cc

@@ -1229,4 +1229,9 @@ Status SystemClock::CreateFromString(const ConfigOptions& config_options,
     return LoadSharedObject<SystemClock>(config_options, value, result);
   }
 }
+
+bool SystemClock::TimedWait(port::CondVar* cv,
+                            std::chrono::microseconds deadline) {
+  return cv->TimedWait(deadline.count());
+}
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/env/unique_id_gen.cc

@@ -21,6 +21,7 @@
 #ifdef __SSE4_2__
 #ifdef _WIN32
 #include <intrin.h>
+#define _rdtsc() __rdtsc()
 #else
 #include <x86intrin.h>
 #endif

package/deps/rocksdb/rocksdb/file/file_prefetch_buffer.cc

@@ -98,6 +98,9 @@ Status FilePrefetchBuffer::Read(const IOOptions& opts,
     return s;
   }
 
+  if (usage_ == FilePrefetchBufferUsage::kUserScanPrefetch) {
+    RecordTick(stats_, PREFETCH_BYTES, read_len);
+  }
   // Update the buffer offset and size.
   bufs_[index].offset_ = rounddown_start;
   bufs_[index].buffer_.Size(static_cast<size_t>(chunk_len) + result.size());
@@ -364,8 +367,11 @@ Status FilePrefetchBuffer::HandleOverlappingData(
     size_t second_size = bufs_[second].async_read_in_progress_
                              ? bufs_[second].async_req_len_
                              : bufs_[second].buffer_.CurrentSize();
-    if (tmp_offset + tmp_length <= bufs_[second].offset_ + second_size) {
-      uint64_t rounddown_start = bufs_[second].offset_ + second_size;
+    uint64_t rounddown_start = bufs_[second].offset_ + second_size;
+    // Second buffer might be out of bound if first buffer already prefetched
+    // that data.
+    if (tmp_offset + tmp_length <= bufs_[second].offset_ + second_size &&
+        !IsOffsetOutOfBound(rounddown_start)) {
       uint64_t roundup_end =
           Roundup(rounddown_start + readahead_size, alignment);
       uint64_t roundup_len = roundup_end - rounddown_start;
@@ -562,20 +568,24 @@ Status FilePrefetchBuffer::PrefetchAsyncInternal(const IOOptions& opts,
       roundup_end2 = Roundup(rounddown_start2 + prefetch_size, alignment);
     }
 
-    uint64_t roundup_len2 = roundup_end2 - rounddown_start2;
-    uint64_t chunk_len2 = 0;
-    CalculateOffsetAndLen(alignment, rounddown_start2, roundup_len2, second,
-                          false /*refit_tail*/, chunk_len2);
-    assert(chunk_len2 == 0);
-    // Update the buffer offset.
-    bufs_[second].offset_ = rounddown_start2;
-    assert(roundup_len2 >= chunk_len2);
-    uint64_t read_len2 = static_cast<size_t>(roundup_len2 - chunk_len2);
-    s = ReadAsync(opts, reader, read_len2, rounddown_start2, second);
-    if (!s.ok()) {
-      DestroyAndClearIOHandle(second);
-      bufs_[second].buffer_.Clear();
-      return s;
+    // Second buffer might be out of bound if first buffer already prefetched
+    // that data.
+    if (!IsOffsetOutOfBound(rounddown_start2)) {
+      uint64_t roundup_len2 = roundup_end2 - rounddown_start2;
+      uint64_t chunk_len2 = 0;
+      CalculateOffsetAndLen(alignment, rounddown_start2, roundup_len2, second,
+                            false /*refit_tail*/, chunk_len2);
+      assert(chunk_len2 == 0);
+      // Update the buffer offset.
+      bufs_[second].offset_ = rounddown_start2;
+      assert(roundup_len2 >= chunk_len2);
+      uint64_t read_len2 = static_cast<size_t>(roundup_len2 - chunk_len2);
+      s = ReadAsync(opts, reader, read_len2, rounddown_start2, second);
+      if (!s.ok()) {
+        DestroyAndClearIOHandle(second);
+        bufs_[second].buffer_.Clear();
+        return s;
+      }
     }
   }
 
@@ -646,6 +656,11 @@ bool FilePrefetchBuffer::TryReadFromCacheUntracked(
       if (for_compaction) {
         s = Prefetch(opts, reader, offset, std::max(n, readahead_size_));
       } else {
+        if (IsOffsetInBuffer(offset, curr_)) {
+          RecordTick(stats_, PREFETCH_BYTES_USEFUL,
+                     bufs_[curr_].offset_ + bufs_[curr_].buffer_.CurrentSize() -
+                         offset);
+        }
         if (implicit_auto_readahead_) {
           if (!IsEligibleForPrefetch(offset, n)) {
             // Ignore status as Prefetch is not called.
@@ -653,8 +668,8 @@ bool FilePrefetchBuffer::TryReadFromCacheUntracked(
             return false;
           }
         }
-        UpdateReadAheadSizeForUpperBound(offset, n);
-        s = Prefetch(opts, reader, offset, n + readahead_size_);
+        size_t current_readahead_size = ReadAheadSizeTuning(offset, n);
+        s = Prefetch(opts, reader, offset, n + current_readahead_size);
       }
       if (!s.ok()) {
         if (status) {
@@ -669,6 +684,9 @@ bool FilePrefetchBuffer::TryReadFromCacheUntracked(
     } else {
       return false;
     }
+  } else if (!for_compaction) {
+    RecordTick(stats_, PREFETCH_HITS);
+    RecordTick(stats_, PREFETCH_BYTES_USEFUL, n);
   }
   UpdateReadPattern(offset, n, false /*decrease_readaheadsize*/);
 
@@ -925,17 +943,20 @@ Status FilePrefetchBuffer::PrefetchAsync(const IOOptions& opts,
       rounddown_start2 = roundup_end1;
     }
 
-    roundup_end2 = Roundup(rounddown_start2 + prefetch_size, alignment);
-    uint64_t roundup_len2 = roundup_end2 - rounddown_start2;
-
-    assert(roundup_len2 >= alignment);
-    CalculateOffsetAndLen(alignment, rounddown_start2, roundup_len2, second,
-                          false, chunk_len2);
-    assert(chunk_len2 == 0);
-    assert(roundup_len2 >= chunk_len2);
-    read_len2 = static_cast<size_t>(roundup_len2 - chunk_len2);
-    // Update the buffer offset.
-    bufs_[second].offset_ = rounddown_start2;
+    // Second buffer might be out of bound if first buffer already prefetched
+    // that data.
+    if (!IsOffsetOutOfBound(rounddown_start2)) {
+      roundup_end2 = Roundup(rounddown_start2 + prefetch_size, alignment);
+      uint64_t roundup_len2 = roundup_end2 - rounddown_start2;
+
+      CalculateOffsetAndLen(alignment, rounddown_start2, roundup_len2, second,
+                            false, chunk_len2);
+      assert(chunk_len2 == 0);
+      assert(roundup_len2 >= chunk_len2);
+      read_len2 = static_cast<size_t>(roundup_len2 - chunk_len2);
+      // Update the buffer offset.
+      bufs_[second].offset_ = rounddown_start2;
+    }
   }
 
   if (read_len1) {

package/deps/rocksdb/rocksdb/file/file_prefetch_buffer.h

@@ -56,6 +56,7 @@ struct BufferInfo {
 
 enum class FilePrefetchBufferUsage {
   kTableOpenPrefetchTail,
+  kUserScanPrefetch,
   kUnknown,
 };
 
@@ -90,6 +91,7 @@ class FilePrefetchBuffer {
       uint64_t num_file_reads_for_auto_readahead = 0,
       uint64_t upper_bound_offset = 0, FileSystem* fs = nullptr,
       SystemClock* clock = nullptr, Statistics* stats = nullptr,
+      const std::function<void(uint64_t, size_t, size_t&)>& cb = nullptr,
       FilePrefetchBufferUsage usage = FilePrefetchBufferUsage::kUnknown)
       : curr_(0),
         readahead_size_(readahead_size),
@@ -108,7 +110,8 @@ class FilePrefetchBuffer {
         clock_(clock),
         stats_(stats),
         usage_(usage),
-        upper_bound_offset_(upper_bound_offset) {
+        upper_bound_offset_(upper_bound_offset),
+        readaheadsize_cb_(cb) {
     assert((num_file_reads_ >= num_file_reads_for_auto_readahead_ + 1) ||
            (num_file_reads_ == 0));
     // If ReadOptions.async_io is enabled, data is asynchronously filled in
@@ -279,6 +282,11 @@ class FilePrefetchBuffer {
   // Callback function passed to underlying FS in case of asynchronous reads.
   void PrefetchAsyncCallback(const FSReadRequest& req, void* cb_arg);
 
+  void ResetUpperBoundOffset(uint64_t upper_bound_offset) {
+    upper_bound_offset_ = upper_bound_offset;
+    readahead_size_ = initial_auto_readahead_size_;
+  }
+
  private:
   // Calculates roundoff offset and length to be prefetched based on alignment
   // and data present in buffer_. It also allocates new buffer or refit tail if
@@ -321,7 +329,6 @@ class FilePrefetchBuffer {
   void ResetValues() {
     num_file_reads_ = 1;
     readahead_size_ = initial_auto_readahead_size_;
-    upper_bound_offset_ = 0;
   }
 
   // Called in case of implicit auto prefetching.
@@ -437,6 +444,28 @@ class FilePrefetchBuffer {
     }
   }
 
+  inline bool IsOffsetOutOfBound(uint64_t offset) {
+    if (upper_bound_offset_ > 0) {
+      return (offset >= upper_bound_offset_);
+    }
+    return false;
+  }
+
+  // Performs tuning to calculate readahead_size.
+  size_t ReadAheadSizeTuning(uint64_t offset, size_t n) {
+    UpdateReadAheadSizeForUpperBound(offset, n);
+
+    if (readaheadsize_cb_ != nullptr && readahead_size_ > 0) {
+      size_t updated_readahead_size = 0;
+      readaheadsize_cb_(offset, readahead_size_, updated_readahead_size);
+      if (readahead_size_ != updated_readahead_size) {
+        RecordTick(stats_, READAHEAD_TRIMMED);
+      }
+      return updated_readahead_size;
+    }
+    return readahead_size_;
+  }
+
   std::vector<BufferInfo> bufs_;
   // curr_ represents the index for bufs_ indicating which buffer is being
   // consumed currently.
@@ -483,5 +512,6 @@ class FilePrefetchBuffer {
   // ReadOptions.auto_readahead_size are set to trim readahead_size upto
   // upper_bound_offset_ during prefetching.
   uint64_t upper_bound_offset_ = 0;
+  std::function<void(uint64_t, size_t, size_t&)> readaheadsize_cb_;
 };
 }  // namespace ROCKSDB_NAMESPACE