@nxtedition/rocksdb 8.2.0 → 8.2.2

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

@@ -31,6 +31,7 @@ namespace ROCKSDB_NAMESPACE {
 namespace {
 static std::shared_ptr<ROCKSDB_NAMESPACE::Env> env_guard;
 static std::shared_ptr<ROCKSDB_NAMESPACE::Env> env_wrapper_guard;
+static std::shared_ptr<ROCKSDB_NAMESPACE::Env> legacy_env_wrapper_guard;
 static std::shared_ptr<ROCKSDB_NAMESPACE::CompositeEnvWrapper>
     dbsl_env_wrapper_guard;
 static std::shared_ptr<CompositeEnvWrapper> fault_env_guard;
@@ -104,7 +105,11 @@ int db_stress_tool(int argc, char** argv) {
     // 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.
-    env_wrapper_guard = std::make_shared<EnvWrapper>(env_wrapper_guard);
+    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();
 

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

@@ -3,88 +3,125 @@
 //  COPYING file in the root directory) and Apache 2.0 License
 //  (found in the LICENSE.Apache file in the root directory).
 
+#include <atomic>
 #ifdef GFLAGS
 
-#include "db_stress_tool/expected_state.h"
 
 #include "db/wide/wide_column_serialization.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"
 #include "rocksdb/trace_reader_writer.h"
 #include "rocksdb/trace_record_result.h"
 
 namespace ROCKSDB_NAMESPACE {
-
 ExpectedState::ExpectedState(size_t max_key, size_t num_column_families)
     : max_key_(max_key),
       num_column_families_(num_column_families),
       values_(nullptr) {}
 
 void ExpectedState::ClearColumnFamily(int cf) {
-  std::fill(&Value(cf, 0 /* key */), &Value(cf + 1, 0 /* key */),
-            SharedState::DELETION_SENTINEL);
+  const uint32_t del_mask = ExpectedValue::GetDelMask();
+  std::fill(&Value(cf, 0 /* key */), &Value(cf + 1, 0 /* key */), del_mask);
 }
 
-void ExpectedState::Put(int cf, int64_t key, uint32_t value_base,
-                        bool pending) {
-  if (!pending) {
-    // prevent expected-value update from reordering before Write
-    std::atomic_thread_fence(std::memory_order_release);
-  }
-  Value(cf, key).store(pending ? SharedState::UNKNOWN_SENTINEL : value_base,
-                       std::memory_order_relaxed);
-  if (pending) {
-    // prevent Write from reordering before expected-value update
-    std::atomic_thread_fence(std::memory_order_release);
-  }
+void ExpectedState::Precommit(int cf, int64_t key, const ExpectedValue& value) {
+  Value(cf, key).store(value.Read());
+  // To prevent low-level instruction reordering that results
+  // in db write happens before setting pending state in expected value
+  std::atomic_thread_fence(std::memory_order_release);
 }
 
-uint32_t ExpectedState::Get(int cf, int64_t key) const {
-  return Value(cf, key);
+PendingExpectedValue ExpectedState::PreparePut(int cf, int64_t key) {
+  ExpectedValue expected_value = Load(cf, key);
+  const ExpectedValue orig_expected_value = expected_value;
+  expected_value.Put(true /* pending */);
+  const ExpectedValue pending_expected_value = expected_value;
+  expected_value.Put(false /* pending */);
+  const ExpectedValue final_expected_value = expected_value;
+  Precommit(cf, key, pending_expected_value);
+  return PendingExpectedValue(&Value(cf, key), orig_expected_value,
+                              final_expected_value);
 }
 
-bool ExpectedState::Delete(int cf, int64_t key, bool pending) {
-  if (Value(cf, key) == SharedState::DELETION_SENTINEL) {
-    return false;
-  }
-  Put(cf, key, SharedState::DELETION_SENTINEL, pending);
-  return true;
+ExpectedValue ExpectedState::Get(int cf, int64_t key) { return Load(cf, key); }
+
+PendingExpectedValue ExpectedState::PrepareDelete(int cf, int64_t key,
+                                                  bool* prepared) {
+  ExpectedValue expected_value = Load(cf, key);
+  const ExpectedValue orig_expected_value = expected_value;
+  bool res = expected_value.Delete(true /* pending */);
+  if (prepared) {
+    *prepared = res;
+  }
+  if (!res) {
+    return PendingExpectedValue(&Value(cf, key), orig_expected_value,
+                                orig_expected_value);
+  }
+  const ExpectedValue pending_expected_value = expected_value;
+  expected_value.Delete(false /* pending */);
+  const ExpectedValue final_expected_value = expected_value;
+  Precommit(cf, key, pending_expected_value);
+  return PendingExpectedValue(&Value(cf, key), orig_expected_value,
+                              final_expected_value);
 }
 
-bool ExpectedState::SingleDelete(int cf, int64_t key, bool pending) {
-  return Delete(cf, key, pending);
+PendingExpectedValue ExpectedState::PrepareSingleDelete(int cf, int64_t key) {
+  return PrepareDelete(cf, key);
 }
 
-int ExpectedState::DeleteRange(int cf, int64_t begin_key, int64_t end_key,
-                               bool pending) {
-  int covered = 0;
+std::vector<PendingExpectedValue> ExpectedState::PrepareDeleteRange(
+    int cf, int64_t begin_key, int64_t end_key) {
+  std::vector<PendingExpectedValue> pending_expected_values;
   for (int64_t key = begin_key; key < end_key; ++key) {
-    if (Delete(cf, key, pending)) {
-      ++covered;
+    bool prepared = false;
+    PendingExpectedValue pending_expected_value =
+        PrepareDelete(cf, key, &prepared);
+    if (prepared) {
+      pending_expected_values.push_back(pending_expected_value);
     }
   }
-  return covered;
+  return pending_expected_values;
 }
 
 bool ExpectedState::Exists(int cf, int64_t key) {
-  // UNKNOWN_SENTINEL counts as exists. That assures a key for which overwrite
-  // is disallowed can't be accidentally added a second time, in which case
-  // SingleDelete wouldn't be able to properly delete the key. It does allow
-  // the case where a SingleDelete might be added which covers nothing, but
-  // that's not a correctness issue.
-  uint32_t expected_value = Value(cf, key).load();
-  return expected_value != SharedState::DELETION_SENTINEL;
+  return Load(cf, key).Exists();
 }
 
 void ExpectedState::Reset() {
+  const uint32_t del_mask = ExpectedValue::GetDelMask();
   for (size_t i = 0; i < num_column_families_; ++i) {
     for (size_t j = 0; j < max_key_; ++j) {
-      Value(static_cast<int>(i), j)
-          .store(SharedState::DELETION_SENTINEL, std::memory_order_relaxed);
+      Value(static_cast<int>(i), j).store(del_mask, std::memory_order_relaxed);
     }
   }
 }
 
+void ExpectedState::SyncPut(int cf, int64_t key, uint32_t value_base) {
+  ExpectedValue expected_value = Load(cf, key);
+  expected_value.SyncPut(value_base);
+  Value(cf, key).store(expected_value.Read());
+}
+
+void ExpectedState::SyncPendingPut(int cf, int64_t key) {
+  ExpectedValue expected_value = Load(cf, key);
+  expected_value.SyncPendingPut();
+  Value(cf, key).store(expected_value.Read());
+}
+
+void ExpectedState::SyncDelete(int cf, int64_t key) {
+  ExpectedValue expected_value = Load(cf, key);
+  expected_value.SyncDelete();
+  Value(cf, key).store(expected_value.Read());
+}
+
+void ExpectedState::SyncDeleteRange(int cf, int64_t begin_key,
+                                    int64_t end_key) {
+  for (int64_t key = begin_key; key < end_key; ++key) {
+    SyncDelete(cf, key);
+  }
+}
+
 FileExpectedState::FileExpectedState(std::string expected_state_file_path,
                                      size_t max_key, size_t num_column_families)
     : ExpectedState(max_key, num_column_families),
@@ -385,7 +422,7 @@ class ExpectedStateTraceRecordHandler : public TraceRecord::Handler,
     if (!GetIntVal(key.ToString(), &key_id)) {
       return Status::Corruption("unable to parse key", key.ToString());
     }
-    uint32_t value_id = GetValueBase(value);
+    uint32_t value_base = GetValueBase(value);
 
     bool should_buffer_write = !(buffered_writes_ == nullptr);
     if (should_buffer_write) {
@@ -393,8 +430,7 @@ class ExpectedStateTraceRecordHandler : public TraceRecord::Handler,
                                      key, value);
     }
 
-    state_->Put(column_family_id, static_cast<int64_t>(key_id), value_id,
-                false /* pending */);
+    state_->SyncPut(column_family_id, static_cast<int64_t>(key_id), value_base);
     ++num_write_ops_;
     return Status::OK();
   }
@@ -431,8 +467,7 @@ class ExpectedStateTraceRecordHandler : public TraceRecord::Handler,
 
     const uint32_t value_base = GetValueBase(columns.front().value());
 
-    state_->Put(column_family_id, static_cast<int64_t>(key_id), value_base,
-                false /* pending */);
+    state_->SyncPut(column_family_id, static_cast<int64_t>(key_id), value_base);
 
     ++num_write_ops_;
 
@@ -454,8 +489,7 @@ class ExpectedStateTraceRecordHandler : public TraceRecord::Handler,
                                         column_family_id, key);
     }
 
-    state_->Delete(column_family_id, static_cast<int64_t>(key_id),
-                   false /* pending */);
+    state_->SyncDelete(column_family_id, static_cast<int64_t>(key_id));
     ++num_write_ops_;
     return Status::OK();
   }
@@ -499,8 +533,9 @@ class ExpectedStateTraceRecordHandler : public TraceRecord::Handler,
           buffered_writes_.get(), column_family_id, begin_key, end_key);
     }
 
-    state_->DeleteRange(column_family_id, static_cast<int64_t>(begin_key_id),
-                        static_cast<int64_t>(end_key_id), false /* pending */);
+    state_->SyncDeleteRange(column_family_id,
+                            static_cast<int64_t>(begin_key_id),
+                            static_cast<int64_t>(end_key_id));
     ++num_write_ops_;
     return Status::OK();
   }

package/deps/rocksdb/rocksdb/db_stress_tool/expected_state.h

@@ -13,6 +13,7 @@
 #include <memory>
 
 #include "db/dbformat.h"
+#include "db_stress_tool/expected_value.h"
 #include "file/file_util.h"
 #include "rocksdb/db.h"
 #include "rocksdb/env.h"
@@ -22,9 +23,8 @@
 #include "util/string_util.h"
 
 namespace ROCKSDB_NAMESPACE {
-
-// An `ExpectedState` provides read/write access to expected values for every
-// key.
+// `ExpectedState` provides read/write access to expected values stored in
+// `ExpectedState` for every key.
 class ExpectedState {
  public:
   explicit ExpectedState(size_t max_key, size_t num_column_families);
@@ -38,43 +38,79 @@ class ExpectedState {
   // Requires external locking covering all keys in `cf`.
   void ClearColumnFamily(int cf);
 
-  // @param pending True if the update may have started but is not yet
-  //    guaranteed finished. This is useful for crash-recovery testing when the
-  //    process may crash before updating the expected values array.
+  // Prepare a Put that will be started but not finished yet
+  // This is useful for crash-recovery testing when the process may crash
+  // before updating the corresponding expected value
   //
-  // Requires external locking covering `key` in `cf`.
-  void Put(int cf, int64_t key, uint32_t value_base, bool pending);
+  // Requires external locking covering `key` in `cf` to prevent concurrent
+  // write or delete to the same `key`.
+  PendingExpectedValue PreparePut(int cf, int64_t key);
 
-  // Requires external locking covering `key` in `cf`.
-  uint32_t Get(int cf, int64_t key) const;
+  // Does not requires external locking.
+  ExpectedValue Get(int cf, int64_t key);
 
-  // @param pending See comment above Put()
-  // Returns true if the key was not yet deleted.
+  // Prepare a Delete that will be started but not finished yet
+  // This is useful for crash-recovery testing when the process may crash
+  // before updating the corresponding expected value
   //
-  // Requires external locking covering `key` in `cf`.
-  bool Delete(int cf, int64_t key, bool pending);
+  // Requires external locking covering `key` in `cf` to prevent concurrent
+  // write or delete to the same `key`.
+  PendingExpectedValue PrepareDelete(int cf, int64_t key,
+                                     bool* prepared = nullptr);
+
+  // Requires external locking covering `key` in `cf` to prevent concurrent
+  // write or delete to the same `key`.
+  PendingExpectedValue PrepareSingleDelete(int cf, int64_t key);
+
+  // Requires external locking covering keys in `[begin_key, end_key)` in `cf`
+  // to prevent concurrent write or delete to the same `key`.
+  std::vector<PendingExpectedValue> PrepareDeleteRange(int cf,
+                                                       int64_t begin_key,
+                                                       int64_t end_key);
+
+  // Update the expected value for start of an incomplete write or delete
+  // operation on the key assoicated with this expected value
+  void Precommit(int cf, int64_t key, const ExpectedValue& value);
+
+  // Requires external locking covering `key` in `cf` to prevent concurrent
+  // delete to the same `key`.
+  bool Exists(int cf, int64_t key);
 
-  // @param pending See comment above Put()
-  // Returns true if the key was not yet deleted.
+  // Sync the `value_base` to the corresponding expected value
   //
-  // Requires external locking covering `key` in `cf`.
-  bool SingleDelete(int cf, int64_t key, bool pending);
+  // Requires external locking covering `key` in `cf` or be in single thread
+  // to prevent concurrent write or delete to the same `key`
+  void SyncPut(int cf, int64_t key, uint32_t value_base);
 
-  // @param pending See comment above Put()
-  // Returns number of keys deleted by the call.
+  // Sync the corresponding expected value to be pending Put
   //
-  // Requires external locking covering keys in `[begin_key, end_key)` in `cf`.
-  int DeleteRange(int cf, int64_t begin_key, int64_t end_key, bool pending);
+  // Requires external locking covering `key` in `cf` or be in single thread
+  // to prevent concurrent write or delete to the same `key`
+  void SyncPendingPut(int cf, int64_t key);
 
-  // Requires external locking covering `key` in `cf`.
-  bool Exists(int cf, int64_t key);
+  // Sync the corresponding expected value to be deleted
+  //
+  // Requires external locking covering `key` in `cf` or be in single thread
+  // to prevent concurrent write or delete to the same `key`
+  void SyncDelete(int cf, int64_t key);
+
+  // Sync the corresponding expected values to be deleted
+  //
+  // Requires external locking covering keys in `[begin_key, end_key)` in `cf`
+  // to prevent concurrent write or delete to the same `key`
+  void SyncDeleteRange(int cf, int64_t begin_key, int64_t end_key);
 
  private:
-  // Requires external locking covering `key` in `cf`.
+  // Does not requires external locking.
   std::atomic<uint32_t>& Value(int cf, int64_t key) const {
     return values_[cf * max_key_ + key];
   }
 
+  // Does not requires external locking
+  ExpectedValue Load(int cf, int64_t key) const {
+    return ExpectedValue(Value(cf, key).load());
+  }
+
   const size_t max_key_;
   const size_t num_column_families_;
 
@@ -160,45 +196,52 @@ class ExpectedStateManager {
   // Requires external locking covering all keys in `cf`.
   void ClearColumnFamily(int cf) { return latest_->ClearColumnFamily(cf); }
 
-  // @param pending True if the update may have started but is not yet
-  //    guaranteed finished. This is useful for crash-recovery testing when the
-  //    process may crash before updating the expected values array.
-  //
-  // Requires external locking covering `key` in `cf`.
-  void Put(int cf, int64_t key, uint32_t value_base, bool pending) {
-    return latest_->Put(cf, key, value_base, pending);
+  // See ExpectedState::PreparePut()
+  PendingExpectedValue PreparePut(int cf, int64_t key) {
+    return latest_->PreparePut(cf, key);
   }
 
-  // Requires external locking covering `key` in `cf`.
-  uint32_t Get(int cf, int64_t key) const { return latest_->Get(cf, key); }
+  // See ExpectedState::Get()
+  ExpectedValue Get(int cf, int64_t key) { return latest_->Get(cf, key); }
 
-  // @param pending See comment above Put()
-  // Returns true if the key was not yet deleted.
-  //
-  // Requires external locking covering `key` in `cf`.
-  bool Delete(int cf, int64_t key, bool pending) {
-    return latest_->Delete(cf, key, pending);
+  // See ExpectedState::PrepareDelete()
+  PendingExpectedValue PrepareDelete(int cf, int64_t key) {
+    return latest_->PrepareDelete(cf, key);
   }
 
-  // @param pending See comment above Put()
-  // Returns true if the key was not yet deleted.
-  //
-  // Requires external locking covering `key` in `cf`.
-  bool SingleDelete(int cf, int64_t key, bool pending) {
-    return latest_->SingleDelete(cf, key, pending);
+  // See ExpectedState::PrepareSingleDelete()
+  PendingExpectedValue PrepareSingleDelete(int cf, int64_t key) {
+    return latest_->PrepareSingleDelete(cf, key);
   }
 
-  // @param pending See comment above Put()
-  // Returns number of keys deleted by the call.
-  //
-  // Requires external locking covering keys in `[begin_key, end_key)` in `cf`.
-  int DeleteRange(int cf, int64_t begin_key, int64_t end_key, bool pending) {
-    return latest_->DeleteRange(cf, begin_key, end_key, pending);
+  // See ExpectedState::PrepareDeleteRange()
+  std::vector<PendingExpectedValue> PrepareDeleteRange(int cf,
+                                                       int64_t begin_key,
+                                                       int64_t end_key) {
+    return latest_->PrepareDeleteRange(cf, begin_key, end_key);
   }
 
-  // Requires external locking covering `key` in `cf`.
+  // See ExpectedState::Exists()
   bool Exists(int cf, int64_t key) { return latest_->Exists(cf, key); }
 
+  // See ExpectedState::SyncPut()
+  void SyncPut(int cf, int64_t key, uint32_t value_base) {
+    return latest_->SyncPut(cf, key, value_base);
+  }
+
+  // See ExpectedState::SyncPendingPut()
+  void SyncPendingPut(int cf, int64_t key) {
+    return latest_->SyncPendingPut(cf, key);
+  }
+
+  // See ExpectedState::SyncDelete()
+  void SyncDelete(int cf, int64_t key) { return latest_->SyncDelete(cf, key); }
+
+  // See ExpectedState::SyncDeleteRange()
+  void SyncDeleteRange(int cf, int64_t begin_key, int64_t end_key) {
+    return latest_->SyncDeleteRange(cf, begin_key, end_key);
+  }
+
  protected:
   const size_t max_key_;
   const size_t num_column_families_;
@@ -281,7 +324,6 @@ class AnonExpectedStateManager : public ExpectedStateManager {
   // member function.
   Status Open() override;
 };
-
 }  // namespace ROCKSDB_NAMESPACE
 
 #endif  // GFLAGS

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

@@ -0,0 +1,122 @@
+//  Copyright (c) 2021-present, Facebook, Inc.  All rights reserved.
+//  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/expected_value.h"
+
+#include <atomic>
+
+namespace ROCKSDB_NAMESPACE {
+void ExpectedValue::Put(bool pending) {
+  if (pending) {
+    SetPendingWrite();
+  } else {
+    SetValueBase(NextValueBase());
+    ClearDeleted();
+    ClearPendingWrite();
+  }
+}
+
+bool ExpectedValue::Delete(bool pending) {
+  if (!Exists()) {
+    return false;
+  }
+  if (pending) {
+    SetPendingDel();
+  } else {
+    SetDelCounter(NextDelCounter());
+    SetDeleted();
+    ClearPendingDel();
+  }
+  return true;
+}
+
+void ExpectedValue::SyncPut(uint32_t value_base) {
+  assert(ExpectedValue::IsValueBaseValid(value_base));
+
+  SetValueBase(value_base);
+  ClearDeleted();
+  ClearPendingWrite();
+
+  // This is needed in case crash happens during a pending delete of the key
+  // assocated with this expected value
+  ClearPendingDel();
+}
+
+void ExpectedValue::SyncPendingPut() { Put(true /* pending */); }
+
+void ExpectedValue::SyncDelete() {
+  Delete(false /* pending */);
+  // This is needed in case crash happens during a pending write of the key
+  // assocated with this expected value
+  ClearPendingWrite();
+}
+
+uint32_t ExpectedValue::GetFinalValueBase() const {
+  return PendingWrite() ? NextValueBase() : GetValueBase();
+}
+
+uint32_t ExpectedValue::GetFinalDelCounter() const {
+  return PendingDelete() ? NextDelCounter() : GetDelCounter();
+}
+
+bool ExpectedValueHelper::MustHaveNotExisted(
+    ExpectedValue pre_read_expected_value,
+    ExpectedValue post_read_expected_value) {
+  const bool pre_read_expected_deleted = pre_read_expected_value.IsDeleted();
+
+  const uint32_t pre_read_expected_value_base =
+      pre_read_expected_value.GetValueBase();
+
+  const uint32_t post_read_expected_final_value_base =
+      post_read_expected_value.GetFinalValueBase();
+
+  const bool during_read_no_write_happened =
+      (pre_read_expected_value_base == post_read_expected_final_value_base);
+  return pre_read_expected_deleted && during_read_no_write_happened;
+}
+
+bool ExpectedValueHelper::MustHaveExisted(
+    ExpectedValue pre_read_expected_value,
+    ExpectedValue post_read_expected_value) {
+  const bool pre_read_expected_not_deleted =
+      !pre_read_expected_value.IsDeleted();
+
+  const uint32_t pre_read_expected_del_counter =
+      pre_read_expected_value.GetDelCounter();
+  const uint32_t post_read_expected_final_del_counter =
+      post_read_expected_value.GetFinalDelCounter();
+
+  const bool during_read_no_delete_happened =
+      (pre_read_expected_del_counter == post_read_expected_final_del_counter);
+
+  return pre_read_expected_not_deleted && during_read_no_delete_happened;
+}
+
+bool ExpectedValueHelper::InExpectedValueBaseRange(
+    uint32_t value_base, ExpectedValue pre_read_expected_value,
+    ExpectedValue post_read_expected_value) {
+  assert(ExpectedValue::IsValueBaseValid(value_base));
+
+  const uint32_t pre_read_expected_value_base =
+      pre_read_expected_value.GetValueBase();
+  const uint32_t post_read_expected_final_value_base =
+      post_read_expected_value.GetFinalValueBase();
+
+  if (pre_read_expected_value_base <= post_read_expected_final_value_base) {
+    const uint32_t lower_bound = pre_read_expected_value_base;
+    const uint32_t upper_bound = post_read_expected_final_value_base;
+    return lower_bound <= value_base && value_base <= upper_bound;
+  } else {
+    const uint32_t upper_bound_1 = post_read_expected_final_value_base;
+    const uint32_t lower_bound_2 = pre_read_expected_value_base;
+    const uint32_t upper_bound_2 = ExpectedValue::GetValueBaseMask();
+    return (value_base <= upper_bound_1) ||
+           (lower_bound_2 <= value_base && value_base <= upper_bound_2);
+  }
+}
+}  // namespace ROCKSDB_NAMESPACE
+#endif  // GFLAGS