@nxtedition/rocksdb 10.0.13 → 10.0.15

package/deps/rocksdb/rocksdb/db_stress_tool/db_stress_test_base.h

@@ -89,6 +89,10 @@ class StressTest {
     return {rand_key};
   }
 
+  virtual void TestKeyMayExist(ThreadState*, const ReadOptions&,
+                               const std::vector<int>&,
+                               const std::vector<int64_t>&) {}
+
   virtual Status TestGet(ThreadState* thread, const ReadOptions& read_opts,
                          const std::vector<int>& rand_column_families,
                          const std::vector<int64_t>& rand_keys) = 0;
@@ -136,6 +140,9 @@ class StressTest {
                                 const Slice& start_key,
                                 ColumnFamilyHandle* column_family);
 
+  virtual void TestPromoteL0(ThreadState* thread,
+                             ColumnFamilyHandle* column_family);
+
   // Calculate a hash value for all keys in range [start_key, end_key]
   // at a certain snapshot.
   uint32_t GetRangeHash(ThreadState* thread, const Snapshot* snapshot,
@@ -194,6 +201,8 @@ class StressTest {
                                    const std::vector<int>& rand_column_families,
                                    const std::vector<int64_t>& rand_keys);
 
+  virtual Status PrepareOptionsForRestoredDB(Options* options);
+
   virtual Status TestCheckpoint(ThreadState* thread,
                                 const std::vector<int>& rand_column_families,
                                 const std::vector<int64_t>& rand_keys);
@@ -202,16 +211,28 @@ class StressTest {
 
   Status TestFlush(const std::vector<int>& rand_column_families);
 
+  Status TestResetStats();
+
   Status TestPauseBackground(ThreadState* thread);
 
+  Status TestDisableFileDeletions(ThreadState* thread);
+
+  Status TestDisableManualCompaction(ThreadState* thread);
+
   void TestAcquireSnapshot(ThreadState* thread, int rand_column_family,
                            const std::string& keystr, uint64_t i);
 
   Status MaybeReleaseSnapshots(ThreadState* thread, uint64_t i);
+
   Status VerifyGetLiveFiles() const;
+  Status VerifyGetLiveFilesMetaData() const;
+  Status VerifyGetLiveFilesStorageInfo() const;
+  Status VerifyGetAllColumnFamilyMetaData() const;
+
   Status VerifyGetSortedWalFiles() const;
   Status VerifyGetCurrentWalFile() const;
   void TestGetProperty(ThreadState* thread) const;
+  Status TestGetPropertiesOfAllTables() const;
 
   virtual Status TestApproximateSize(
       ThreadState* thread, uint64_t iteration,
@@ -224,7 +245,8 @@ class StressTest {
     return Status::NotSupported("TestCustomOperations() must be overridden");
   }
 
-  void ProcessStatus(SharedState* shared, std::string msg, Status s) const;
+  void ProcessStatus(SharedState* shared, std::string msg, const Status& s,
+                     bool ignore_injected_error = true) const;
 
   void VerificationAbort(SharedState* shared, std::string msg) const;
 
@@ -289,13 +311,13 @@ class StressTest {
 };
 
 // Load options from OPTIONS file and populate `options`.
-extern bool InitializeOptionsFromFile(Options& options);
+bool InitializeOptionsFromFile(Options& options);
 
 // Initialize `options` using command line arguments.
 // When this function is called, `cache`, `block_cache_compressed`,
 // `filter_policy` have all been initialized. Therefore, we just pass them as
 // input arguments.
-extern void InitializeOptionsFromFlags(
+void InitializeOptionsFromFlags(
     const std::shared_ptr<Cache>& cache,
     const std::shared_ptr<const FilterPolicy>& filter_policy, Options& options);
 
@@ -320,7 +342,7 @@ extern void InitializeOptionsFromFlags(
 //
 // InitializeOptionsGeneral() must not overwrite fields of `options` loaded
 // from OPTIONS file.
-extern void InitializeOptionsGeneral(
+void InitializeOptionsGeneral(
     const std::shared_ptr<Cache>& cache,
     const std::shared_ptr<const FilterPolicy>& filter_policy, Options& options);
 
@@ -328,7 +350,7 @@ extern void InitializeOptionsGeneral(
 // user-defined timestamp which requires `-user_timestamp_size=8`.
 // This function also checks for known (currently) incompatible features with
 // user-defined timestamp.
-extern void CheckAndSetOptionsForUserTimestamp(Options& options);
+void CheckAndSetOptionsForUserTimestamp(Options& options);
 
 }  // namespace ROCKSDB_NAMESPACE
 #endif  // GFLAGS

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

@@ -100,17 +100,6 @@ int db_stress_tool(int argc, char** argv) {
 
   env_wrapper_guard = std::make_shared<CompositeEnvWrapper>(
       raw_env, std::make_shared<DbStressFSWrapper>(raw_env->GetFileSystem()));
-  if (!env_opts && !FLAGS_use_io_uring) {
-    // If using the default Env (Posix), wrap DbStressEnvWrapper with the
-    // legacy EnvWrapper. This is a workaround to prevent MultiGet and scans
-    // from failing when IO uring is disabled. The EnvWrapper
-    // has a default implementation of ReadAsync that redirects to Read.
-    legacy_env_wrapper_guard = std::make_shared<EnvWrapper>(raw_env);
-    env_wrapper_guard = std::make_shared<CompositeEnvWrapper>(
-        legacy_env_wrapper_guard,
-        std::make_shared<DbStressFSWrapper>(
-            legacy_env_wrapper_guard->GetFileSystem()));
-  }
   db_stress_env = env_wrapper_guard.get();
 
   FLAGS_rep_factory = StringToRepFactory(FLAGS_memtablerep.c_str());
@@ -260,14 +249,18 @@ int db_stress_tool(int argc, char** argv) {
       exit(1);
     }
   }
-  if (FLAGS_enable_compaction_filter &&
+  if ((FLAGS_enable_compaction_filter || FLAGS_inplace_update_support) &&
       (FLAGS_acquire_snapshot_one_in > 0 || FLAGS_compact_range_one_in > 0 ||
-       FLAGS_iterpercent > 0 || FLAGS_test_batches_snapshots ||
-       FLAGS_test_cf_consistency)) {
+       FLAGS_iterpercent > 0 || FLAGS_prefixpercent > 0 ||
+       FLAGS_test_batches_snapshots || FLAGS_test_cf_consistency ||
+       FLAGS_check_multiget_consistency ||
+       FLAGS_check_multiget_entity_consistency)) {
     fprintf(
         stderr,
         "Error: acquire_snapshot_one_in, compact_range_one_in, iterpercent, "
-        "test_batches_snapshots  must all be 0 when using compaction filter\n");
+        "prefixpercent, test_batches_snapshots, test_cf_consistency, "
+        "check_multiget_consistency, check_multiget_entity_consistency must "
+        "all be 0 when using compaction filter or inplace update support\n");
     exit(1);
   }
   if (FLAGS_test_multi_ops_txns) {

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

@@ -79,6 +79,8 @@ std::vector<PendingExpectedValue> ExpectedState::PrepareDeleteRange(
         PrepareDelete(cf, key, &prepared);
     if (prepared) {
       pending_expected_values.push_back(pending_expected_value);
+    } else {
+      pending_expected_value.PermitUnclosedPendingState();
     }
   }
   return pending_expected_values;
@@ -185,7 +187,7 @@ ExpectedStateManager::ExpectedStateManager(size_t max_key,
       num_column_families_(num_column_families),
       latest_(nullptr) {}
 
-ExpectedStateManager::~ExpectedStateManager() {}
+ExpectedStateManager::~ExpectedStateManager() = default;
 
 const std::string FileExpectedStateManager::kLatestBasename = "LATEST";
 const std::string FileExpectedStateManager::kStateFilenameSuffix = ".state";
@@ -306,9 +308,10 @@ Status FileExpectedStateManager::SaveAtAndAfter(DB* db) {
 
   // Populate a tempfile and then rename it to atomically create "<seqno>.state"
   // with contents from "LATEST.state"
-  Status s = CopyFile(FileSystem::Default(), latest_file_path,
-                      state_file_temp_path, 0 /* size */, false /* use_fsync */,
-                      nullptr /* io_tracer */, Temperature::kUnknown);
+  Status s =
+      CopyFile(FileSystem::Default(), latest_file_path, Temperature::kUnknown,
+               state_file_temp_path, Temperature::kUnknown, 0 /* size */,
+               false /* use_fsync */, nullptr /* io_tracer */);
   if (s.ok()) {
     s = FileSystem::Default()->RenameFile(state_file_temp_path, state_file_path,
                                           IOOptions(), nullptr /* dbg */);
@@ -434,6 +437,28 @@ class ExpectedStateTraceRecordHandler : public TraceRecord::Handler,
     return Status::OK();
   }
 
+  Status TimedPutCF(uint32_t column_family_id, const Slice& key_with_ts,
+                    const Slice& value, uint64_t write_unix_time) override {
+    Slice key =
+        StripTimestampFromUserKey(key_with_ts, FLAGS_user_timestamp_size);
+    uint64_t key_id;
+    if (!GetIntVal(key.ToString(), &key_id)) {
+      return Status::Corruption("unable to parse key", key.ToString());
+    }
+    uint32_t value_base = GetValueBase(value);
+
+    bool should_buffer_write = !(buffered_writes_ == nullptr);
+    if (should_buffer_write) {
+      return WriteBatchInternal::TimedPut(buffered_writes_.get(),
+                                          column_family_id, key, value,
+                                          write_unix_time);
+    }
+
+    state_->SyncPut(column_family_id, static_cast<int64_t>(key_id), value_base);
+    ++num_write_ops_;
+    return Status::OK();
+  }
+
   Status PutEntityCF(uint32_t column_family_id, const Slice& key_with_ts,
                      const Slice& entity) override {
     Slice key =
@@ -631,9 +656,9 @@ Status FileExpectedStateManager::Restore(DB* db) {
     // We are going to replay on top of "`seqno`.state" to create a new
     // "LATEST.state". Start off by creating a tempfile so we can later make the
     // new "LATEST.state" appear atomically using `RenameFile()`.
-    s = CopyFile(FileSystem::Default(), state_file_path, latest_file_temp_path,
-                 0 /* size */, false /* use_fsync */, nullptr /* io_tracer */,
-                 Temperature::kUnknown);
+    s = CopyFile(FileSystem::Default(), state_file_path, Temperature::kUnknown,
+                 latest_file_temp_path, Temperature::kUnknown, 0 /* size */,
+                 false /* use_fsync */, nullptr /* io_tracer */);
   }
 
   {
@@ -658,26 +683,26 @@ Status FileExpectedStateManager::Restore(DB* db) {
     if (s.ok()) {
       s = replayer->Prepare();
     }
-    for (;;) {
+    for (; s.ok();) {
       std::unique_ptr<TraceRecord> record;
       s = replayer->Next(&record);
       if (!s.ok()) {
+        if (s.IsCorruption() && handler->IsDone()) {
+          // There could be a corruption reading the tail record of the trace
+          // due to `db_stress` crashing while writing it. It shouldn't matter
+          // as long as we already found all the write ops we need to catch up
+          // the expected state.
+          s = Status::OK();
+        }
+        if (s.IsIncomplete()) {
+          // OK because `Status::Incomplete` is expected upon finishing all the
+          // trace records.
+          s = Status::OK();
+        }
         break;
       }
       std::unique_ptr<TraceRecordResult> res;
-      record->Accept(handler.get(), &res);
-    }
-    if (s.IsCorruption() && handler->IsDone()) {
-      // There could be a corruption reading the tail record of the trace due to
-      // `db_stress` crashing while writing it. It shouldn't matter as long as
-      // we already found all the write ops we need to catch up the expected
-      // state.
-      s = Status::OK();
-    }
-    if (s.IsIncomplete()) {
-      // OK because `Status::Incomplete` is expected upon finishing all the
-      // trace records.
-      s = Status::OK();
+      s = record->Accept(handler.get(), &res);
     }
   }
 

package/deps/rocksdb/rocksdb/db_stress_tool/expected_value.h

@@ -8,6 +8,7 @@
 #pragma once
 
 #include <stdint.h>
+#include <stdio.h>
 
 #include <atomic>
 #include <cassert>
@@ -150,6 +151,11 @@ class ExpectedValue {
 // `PendingExpectedValue` represents the expected value of a key undergoing a
 // pending operation in db stress.
 //
+// After a `PendingExpectedValue` object is created, either `Rollback` or
+// `Commit` should be called to close its pending state before it's destructed.
+// In case no pending state was introduced while creating this
+// `PendingExpectedValue` and user want to ignore the unclosed pending state,
+// `PermitUnclosedPendingState` should be called explicitly.
 // This class is not thread-safe.
 class PendingExpectedValue {
  public:
@@ -158,21 +164,85 @@ class PendingExpectedValue {
                                 ExpectedValue final_value)
       : value_ptr_(value_ptr),
         orig_value_(orig_value),
-        final_value_(final_value) {}
+        final_value_(final_value),
+        pending_state_closed_(false) {}
+
+  PendingExpectedValue(const PendingExpectedValue& other)
+      : value_ptr_(other.value_ptr_),
+        orig_value_(other.orig_value_),
+        final_value_(other.final_value_),
+        pending_state_closed_(false) {
+    other.ClosePendingState();
+  }
+
+  PendingExpectedValue(PendingExpectedValue&& other) noexcept
+      : value_ptr_(std::move(other.value_ptr_)),
+        orig_value_(std::move(other.orig_value_)),
+        final_value_(std::move(other.final_value_)),
+        pending_state_closed_(false) {
+    other.ClosePendingState();
+  }
+
+  PendingExpectedValue& operator=(const PendingExpectedValue& other) {
+    if (this != &other) {
+      other.ClosePendingState();
+      value_ptr_ = other.value_ptr_;
+      orig_value_ = other.orig_value_;
+      final_value_ = other.final_value_;
+      pending_state_closed_ = false;
+    }
+    return *this;
+  }
+
+  PendingExpectedValue& operator=(PendingExpectedValue&& other) {
+    if (this != &other) {
+      other.ClosePendingState();
+      value_ptr_ = std::move(other.value_ptr_);
+      orig_value_ = std::move(other.orig_value_);
+      final_value_ = std::move(other.final_value_);
+      pending_state_closed_ = false;
+    }
+    return *this;
+  }
+
+  ~PendingExpectedValue() { assert(pending_state_closed_); }
 
   void Commit() {
+    assert(!pending_state_closed_);
+    ClosePendingState();
     // To prevent low-level instruction reordering that results
     // in setting expected value happens before db write
     std::atomic_thread_fence(std::memory_order_release);
     value_ptr_->store(final_value_.Read());
   }
 
+  // Rollbacks the key to its original state.
+  // This rollbacks the pending state created in `ExpectedState::Precommit`,
+  // such as pending delete, pending put. If `ExpectedState::Precommit()` is not
+  // called before creating this `PendingExpectedValue`, this is a no-op.
+  void Rollback() {
+    assert(!pending_state_closed_);
+    ClosePendingState();
+    // To prevent low-level instruction reordering that results
+    // in setting expected value happens before db write
+    std::atomic_thread_fence(std::memory_order_release);
+    value_ptr_->store(orig_value_.Read());
+  }
+
+  void PermitUnclosedPendingState() const {
+    assert(!pending_state_closed_);
+    ClosePendingState();
+  }
+
   uint32_t GetFinalValueBase() { return final_value_.GetValueBase(); }
 
  private:
-  std::atomic<uint32_t>* const value_ptr_;
-  const ExpectedValue orig_value_;
-  const ExpectedValue final_value_;
+  inline void ClosePendingState() const { pending_state_closed_ = true; }
+
+  std::atomic<uint32_t>* value_ptr_;
+  ExpectedValue orig_value_;
+  ExpectedValue final_value_;
+  mutable bool pending_state_closed_;
 };
 
 // `ExpectedValueHelper` provides utils to parse `ExpectedValue` to obtain

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

@@ -150,7 +150,7 @@ std::string MultiOpsTxnsStressTest::Record::EncodePrimaryKey(uint32_t a) {
   PutFixed32(&ret, kPrimaryIndexId);
   PutFixed32(&ret, a);
 
-  char* const buf = &ret[0];
+  char* const buf = ret.data();
   std::reverse(buf, buf + sizeof(kPrimaryIndexId));
   std::reverse(buf + sizeof(kPrimaryIndexId),
                buf + sizeof(kPrimaryIndexId) + sizeof(a));
@@ -162,7 +162,7 @@ std::string MultiOpsTxnsStressTest::Record::EncodeSecondaryKey(uint32_t c) {
   PutFixed32(&ret, kSecondaryIndexId);
   PutFixed32(&ret, c);
 
-  char* const buf = &ret[0];
+  char* const buf = ret.data();
   std::reverse(buf, buf + sizeof(kSecondaryIndexId));
   std::reverse(buf + sizeof(kSecondaryIndexId),
                buf + sizeof(kSecondaryIndexId) + sizeof(c));
@@ -176,7 +176,7 @@ std::string MultiOpsTxnsStressTest::Record::EncodeSecondaryKey(uint32_t c,
   PutFixed32(&ret, c);
   PutFixed32(&ret, a);
 
-  char* const buf = &ret[0];
+  char* const buf = ret.data();
   std::reverse(buf, buf + sizeof(kSecondaryIndexId));
   std::reverse(buf + sizeof(kSecondaryIndexId),
                buf + sizeof(kSecondaryIndexId) + sizeof(c));
@@ -373,10 +373,15 @@ Status MultiOpsTxnsStressTest::TestGet(
     ThreadState* thread, const ReadOptions& read_opts,
     const std::vector<int>& /*rand_column_families*/,
     const std::vector<int64_t>& /*rand_keys*/) {
+  ThreadStatus::OperationType cur_op_type =
+      ThreadStatusUtil::GetThreadOperation();
+  ThreadStatusUtil::SetThreadOperation(ThreadStatus::OperationType::OP_UNKNOWN);
   uint32_t a = 0;
   uint32_t pos = 0;
   std::tie(a, pos) = ChooseExistingA(thread);
-  return PointLookupTxn(thread, read_opts, a);
+  Status s = PointLookupTxn(thread, read_opts, a);
+  ThreadStatusUtil::SetThreadOperation(cur_op_type);
+  return s;
 }
 
 // Not used.
@@ -416,10 +421,15 @@ Status MultiOpsTxnsStressTest::TestIterate(
     ThreadState* thread, const ReadOptions& read_opts,
     const std::vector<int>& /*rand_column_families*/,
     const std::vector<int64_t>& /*rand_keys*/) {
+  ThreadStatus::OperationType cur_op_type =
+      ThreadStatusUtil::GetThreadOperation();
+  ThreadStatusUtil::SetThreadOperation(ThreadStatus::OperationType::OP_UNKNOWN);
   uint32_t c = 0;
   uint32_t pos = 0;
   std::tie(c, pos) = ChooseExistingC(thread);
-  return RangeScanTxn(thread, read_opts, c);
+  Status s = RangeScanTxn(thread, read_opts, c);
+  ThreadStatusUtil::SetThreadOperation(cur_op_type);
+  return s;
 }
 
 // Not intended for use.
@@ -1221,7 +1231,11 @@ void MultiOpsTxnsStressTest::VerifyPkSkFast(const ReadOptions& read_options,
   assert(db_ == db);
   assert(db_ != nullptr);
 
+  ThreadStatus::OperationType cur_op_type =
+      ThreadStatusUtil::GetThreadOperation();
+  ThreadStatusUtil::SetThreadOperation(ThreadStatus::OperationType::OP_UNKNOWN);
   const Snapshot* const snapshot = db_->GetSnapshot();
+  ThreadStatusUtil::SetThreadOperation(cur_op_type);
   assert(snapshot);
   ManagedSnapshot snapshot_guard(db_, snapshot);
 
@@ -1317,14 +1331,16 @@ uint32_t MultiOpsTxnsStressTest::GenerateNextC(ThreadState* thread) {
 }
 
 void MultiOpsTxnsStressTest::ProcessRecoveredPreparedTxnsHelper(
-    Transaction* txn, SharedState*) {
+    Transaction* txn, SharedState* shared) {
   thread_local Random rand(static_cast<uint32_t>(FLAGS_seed));
   if (rand.OneIn(2)) {
     Status s = txn->Commit();
-    assert(s.ok());
+    ProcessStatus(shared, "ProcessRecoveredPreparedTxnsHelper", s,
+                  /*ignore_injected_error=*/false);
   } else {
     Status s = txn->Rollback();
-    assert(s.ok());
+    ProcessStatus(shared, "ProcessRecoveredPreparedTxnsHelper", s,
+                  /*ignore_injected_error=*/false);
   }
 }
 
@@ -1503,14 +1519,15 @@ void MultiOpsTxnsStressTest::PreloadDb(SharedState* shared, int threads,
     WriteBatch wb;
     const auto primary_index_entry = record.EncodePrimaryIndexEntry();
     Status s = wb.Put(primary_index_entry.first, primary_index_entry.second);
-    assert(s.ok());
+    ProcessStatus(shared, "PreloadDB", s, /*ignore_injected_error=*/false);
 
     const auto secondary_index_entry = record.EncodeSecondaryIndexEntry();
     s = wb.Put(secondary_index_entry.first, secondary_index_entry.second);
-    assert(s.ok());
+    ProcessStatus(shared, "PreloadDB", s, /*ignore_injected_error=*/false);
 
     s = txn_db_->Write(wopts, &wb);
     assert(s.ok());
+    ProcessStatus(shared, "PreloadDB", s, /*ignore_injected_error=*/false);
 
     // TODO (yanqin): make the following check optional, especially when data
     // size is large.
@@ -1518,7 +1535,7 @@ void MultiOpsTxnsStressTest::PreloadDb(SharedState* shared, int threads,
     tmp_rec.SetB(record.b_value());
     s = tmp_rec.DecodeSecondaryIndexEntry(secondary_index_entry.first,
                                           secondary_index_entry.second);
-    assert(s.ok());
+    ProcessStatus(shared, "PreloadDB", s, /*ignore_injected_error=*/false);
     assert(tmp_rec == record);
 
     existing_a_uniqs[tid].insert(a);