@nxtedition/rocksdb 7.1.20 → 7.1.21

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

@@ -25,22 +25,36 @@ class CfConsistencyStressTest : public StressTest {
                  const std::vector<int>& rand_column_families,
                  const std::vector<int64_t>& rand_keys,
                  char (&value)[100]) override {
-    std::string key_str = Key(rand_keys[0]);
-    Slice key = key_str;
-    uint64_t value_base = batch_id_.fetch_add(1);
-    size_t sz =
-        GenerateValue(static_cast<uint32_t>(value_base), value, sizeof(value));
-    Slice v(value, sz);
+    assert(!rand_column_families.empty());
+    assert(!rand_keys.empty());
+
+    const std::string k = Key(rand_keys[0]);
+
+    const uint32_t value_base = batch_id_.fetch_add(1);
+    const size_t sz = GenerateValue(value_base, value, sizeof(value));
+    const Slice v(value, sz);
+
     WriteBatch batch;
+
+    const bool use_put_entity = !FLAGS_use_merge &&
+                                FLAGS_use_put_entity_one_in > 0 &&
+                                (value_base % FLAGS_use_put_entity_one_in) == 0;
+
     for (auto cf : rand_column_families) {
-      ColumnFamilyHandle* cfh = column_families_[cf];
+      ColumnFamilyHandle* const cfh = column_families_[cf];
+      assert(cfh);
+
       if (FLAGS_use_merge) {
-        batch.Merge(cfh, key, v);
-      } else { /* !FLAGS_use_merge */
-        batch.Put(cfh, key, v);
+        batch.Merge(cfh, k, v);
+      } else if (use_put_entity) {
+        batch.PutEntity(cfh, k, GenerateWideColumns(value_base, v));
+      } else {
+        batch.Put(cfh, k, v);
       }
     }
+
     Status s = db_->Write(write_opts, &batch);
+
     if (!s.ok()) {
       fprintf(stderr, "multi put or merge error: %s\n", s.ToString().c_str());
       thread->stats.AddErrors(1);
@@ -240,42 +254,69 @@ class CfConsistencyStressTest : public StressTest {
   Status TestPrefixScan(ThreadState* thread, const ReadOptions& readoptions,
                         const std::vector<int>& rand_column_families,
                         const std::vector<int64_t>& rand_keys) override {
-    size_t prefix_to_use =
+    assert(!rand_column_families.empty());
+    assert(!rand_keys.empty());
+
+    const std::string key = Key(rand_keys[0]);
+
+    const size_t prefix_to_use =
         (FLAGS_prefix_size < 0) ? 7 : static_cast<size_t>(FLAGS_prefix_size);
 
-    std::string key_str = Key(rand_keys[0]);
-    Slice key = key_str;
-    Slice prefix = Slice(key.data(), prefix_to_use);
+    const Slice prefix(key.data(), prefix_to_use);
 
     std::string upper_bound;
     Slice ub_slice;
+
     ReadOptions ro_copy = readoptions;
+
     // Get the next prefix first and then see if we want to set upper bound.
     // We'll use the next prefix in an assertion later on
     if (GetNextPrefix(prefix, &upper_bound) && thread->rand.OneIn(2)) {
       ub_slice = Slice(upper_bound);
       ro_copy.iterate_upper_bound = &ub_slice;
     }
-    auto cfh =
-        column_families_[rand_column_families[thread->rand.Next() %
-                                              rand_column_families.size()]];
-    Iterator* iter = db_->NewIterator(ro_copy, cfh);
-    unsigned long count = 0;
+
+    ColumnFamilyHandle* const cfh =
+        column_families_[rand_column_families[thread->rand.Uniform(
+            static_cast<int>(rand_column_families.size()))]];
+    assert(cfh);
+
+    std::unique_ptr<Iterator> iter(db_->NewIterator(ro_copy, cfh));
+
+    uint64_t count = 0;
+    Status s;
+
     for (iter->Seek(prefix); iter->Valid() && iter->key().starts_with(prefix);
          iter->Next()) {
       ++count;
+
+      const WideColumns expected_columns = GenerateExpectedWideColumns(
+          GetValueBase(iter->value()), iter->value());
+      if (iter->columns() != expected_columns) {
+        s = Status::Corruption(
+            "Value and columns inconsistent",
+            DebugString(iter->value(), iter->columns(), expected_columns));
+        break;
+      }
     }
+
     assert(prefix_to_use == 0 ||
            count <= GetPrefixKeyCount(prefix.ToString(), upper_bound));
-    Status s = iter->status();
+
     if (s.ok()) {
-      thread->stats.AddPrefixes(1, count);
-    } else {
+      s = iter->status();
+    }
+
+    if (!s.ok()) {
       fprintf(stderr, "TestPrefixScan error: %s\n", s.ToString().c_str());
       thread->stats.AddErrors(1);
+
+      return s;
     }
-    delete iter;
-    return s;
+
+    thread->stats.AddPrefixes(1, count);
+
+    return Status::OK();
   }
 
   ColumnFamilyHandle* GetControlCfh(ThreadState* thread,
@@ -289,6 +330,7 @@ class CfConsistencyStressTest : public StressTest {
     // This `ReadOptions` is for validation purposes. Ignore
     // `FLAGS_rate_limit_user_ops` to avoid slowing any validation.
     ReadOptions options(FLAGS_verify_checksum, true);
+
     // We must set total_order_seek to true because we are doing a SeekToFirst
     // on a column family whose memtables may support (by default) prefix-based
     // iterator. In this case, NewIterator with options.total_order_seek being
@@ -297,54 +339,73 @@ class CfConsistencyStressTest : public StressTest {
     // iterate the memtable using this iterator any more, although the memtable
     // contains the most up-to-date key-values.
     options.total_order_seek = true;
-    const auto ss_deleter = [this](const Snapshot* ss) {
-      db_->ReleaseSnapshot(ss);
-    };
-    std::unique_ptr<const Snapshot, decltype(ss_deleter)> snapshot_guard(
-        db_->GetSnapshot(), ss_deleter);
-    options.snapshot = snapshot_guard.get();
-    assert(thread != nullptr);
-    auto shared = thread->shared;
-    std::vector<std::unique_ptr<Iterator>> iters(column_families_.size());
-    for (size_t i = 0; i != column_families_.size(); ++i) {
-      iters[i].reset(db_->NewIterator(options, column_families_[i]));
-    }
-    for (auto& iter : iters) {
-      iter->SeekToFirst();
+
+    ManagedSnapshot snapshot_guard(db_);
+    options.snapshot = snapshot_guard.snapshot();
+
+    const size_t num = column_families_.size();
+
+    std::vector<std::unique_ptr<Iterator>> iters;
+    iters.reserve(num);
+
+    for (size_t i = 0; i < num; ++i) {
+      iters.emplace_back(db_->NewIterator(options, column_families_[i]));
+      iters.back()->SeekToFirst();
     }
-    size_t num = column_families_.size();
-    assert(num == iters.size());
+
     std::vector<Status> statuses(num, Status::OK());
+
+    assert(thread);
+
+    auto shared = thread->shared;
+    assert(shared);
+
     do {
       if (shared->HasVerificationFailedYet()) {
         break;
       }
+
       size_t valid_cnt = 0;
-      size_t idx = 0;
-      for (auto& iter : iters) {
+
+      for (size_t i = 0; i < num; ++i) {
+        const auto& iter = iters[i];
+        assert(iter);
+
         if (iter->Valid()) {
-          ++valid_cnt;
+          const WideColumns expected_columns = GenerateExpectedWideColumns(
+              GetValueBase(iter->value()), iter->value());
+          if (iter->columns() != expected_columns) {
+            statuses[i] = Status::Corruption(
+                "Value and columns inconsistent",
+                DebugString(iter->value(), iter->columns(), expected_columns));
+          } else {
+            ++valid_cnt;
+          }
         } else {
-          statuses[idx] = iter->status();
+          statuses[i] = iter->status();
         }
-        ++idx;
       }
+
       if (valid_cnt == 0) {
-        Status status;
-        for (size_t i = 0; i != num; ++i) {
+        for (size_t i = 0; i < num; ++i) {
           const auto& s = statuses[i];
           if (!s.ok()) {
-            status = s;
             fprintf(stderr, "Iterator on cf %s has error: %s\n",
                     column_families_[i]->GetName().c_str(),
                     s.ToString().c_str());
             shared->SetVerificationFailure();
           }
         }
+
         break;
-      } else if (valid_cnt != iters.size()) {
+      }
+
+      if (valid_cnt < num) {
         shared->SetVerificationFailure();
-        for (size_t i = 0; i != num; ++i) {
+
+        for (size_t i = 0; i < num; ++i) {
+          assert(iters[i]);
+
           if (!iters[i]->Valid()) {
             if (statuses[i].ok()) {
               fprintf(stderr, "Finished scanning cf %s\n",
@@ -359,83 +420,105 @@ class CfConsistencyStressTest : public StressTest {
                     column_families_[i]->GetName().c_str());
           }
         }
+
         break;
       }
+
       if (shared->HasVerificationFailedYet()) {
         break;
       }
+
       // If the program reaches here, then all column families' iterators are
       // still valid.
+      assert(valid_cnt == num);
+
       if (shared->PrintingVerificationResults()) {
         continue;
       }
-      Slice key;
-      Slice value;
+
+      assert(iters[0]);
+
+      const Slice key = iters[0]->key();
+      const Slice value = iters[0]->value();
+
       int num_mismatched_cfs = 0;
-      for (size_t i = 0; i != num; ++i) {
-        if (i == 0) {
-          key = iters[i]->key();
-          value = iters[i]->value();
-        } else {
-          int cmp = key.compare(iters[i]->key());
-          if (cmp != 0) {
-            ++num_mismatched_cfs;
-            if (1 == num_mismatched_cfs) {
-              fprintf(stderr, "Verification failed\n");
-              fprintf(stderr, "Latest Sequence Number: %" PRIu64 "\n",
-                      db_->GetLatestSequenceNumber());
-              fprintf(stderr, "[%s] %s => %s\n",
-                      column_families_[0]->GetName().c_str(),
-                      key.ToString(true /* hex */).c_str(),
-                      value.ToString(true /* hex */).c_str());
-            }
+
+      for (size_t i = 1; i < num; ++i) {
+        assert(iters[i]);
+
+        const int cmp = key.compare(iters[i]->key());
+
+        if (cmp != 0) {
+          ++num_mismatched_cfs;
+
+          if (1 == num_mismatched_cfs) {
+            fprintf(stderr, "Verification failed\n");
+            fprintf(stderr, "Latest Sequence Number: %" PRIu64 "\n",
+                    db_->GetLatestSequenceNumber());
             fprintf(stderr, "[%s] %s => %s\n",
-                    column_families_[i]->GetName().c_str(),
-                    iters[i]->key().ToString(true /* hex */).c_str(),
-                    iters[i]->value().ToString(true /* hex */).c_str());
+                    column_families_[0]->GetName().c_str(),
+                    key.ToString(true /* hex */).c_str(),
+                    value.ToString(true /* hex */).c_str());
+          }
+
+          fprintf(stderr, "[%s] %s => %s\n",
+                  column_families_[i]->GetName().c_str(),
+                  iters[i]->key().ToString(true /* hex */).c_str(),
+                  iters[i]->value().ToString(true /* hex */).c_str());
+
 #ifndef ROCKSDB_LITE
-            Slice begin_key;
-            Slice end_key;
-            if (cmp < 0) {
-              begin_key = key;
-              end_key = iters[i]->key();
-            } else {
-              begin_key = iters[i]->key();
-              end_key = key;
-            }
+          Slice begin_key;
+          Slice end_key;
+          if (cmp < 0) {
+            begin_key = key;
+            end_key = iters[i]->key();
+          } else {
+            begin_key = iters[i]->key();
+            end_key = key;
+          }
+
+          const auto print_key_versions = [&](ColumnFamilyHandle* cfh) {
+            constexpr size_t kMaxNumIKeys = 8;
+
             std::vector<KeyVersion> versions;
-            const size_t kMaxNumIKeys = 8;
-            const auto print_key_versions = [&](ColumnFamilyHandle* cfh) {
-              Status s = GetAllKeyVersions(db_, cfh, begin_key, end_key,
-                                           kMaxNumIKeys, &versions);
-              if (!s.ok()) {
-                fprintf(stderr, "%s\n", s.ToString().c_str());
-                return;
-              }
-              assert(nullptr != cfh);
-              fprintf(stderr,
-                      "Internal keys in CF '%s', [%s, %s] (max %" ROCKSDB_PRIszt
-                      ")\n",
-                      cfh->GetName().c_str(),
-                      begin_key.ToString(true /* hex */).c_str(),
-                      end_key.ToString(true /* hex */).c_str(), kMaxNumIKeys);
-              for (const KeyVersion& kv : versions) {
-                fprintf(stderr, "  key %s seq %" PRIu64 " type %d\n",
-                        Slice(kv.user_key).ToString(true).c_str(), kv.sequence,
-                        kv.type);
-              }
-            };
-            if (1 == num_mismatched_cfs) {
-              print_key_versions(column_families_[0]);
+            const Status s = GetAllKeyVersions(db_, cfh, begin_key, end_key,
+                                               kMaxNumIKeys, &versions);
+            if (!s.ok()) {
+              fprintf(stderr, "%s\n", s.ToString().c_str());
+              return;
             }
-            print_key_versions(column_families_[i]);
-#endif  // ROCKSDB_LITE
-            shared->SetVerificationFailure();
+
+            assert(cfh);
+
+            fprintf(stderr,
+                    "Internal keys in CF '%s', [%s, %s] (max %" ROCKSDB_PRIszt
+                    ")\n",
+                    cfh->GetName().c_str(),
+                    begin_key.ToString(true /* hex */).c_str(),
+                    end_key.ToString(true /* hex */).c_str(), kMaxNumIKeys);
+
+            for (const KeyVersion& kv : versions) {
+              fprintf(stderr, "  key %s seq %" PRIu64 " type %d\n",
+                      Slice(kv.user_key).ToString(true).c_str(), kv.sequence,
+                      kv.type);
+            }
+          };
+
+          if (1 == num_mismatched_cfs) {
+            print_key_versions(column_families_[0]);
           }
+
+          print_key_versions(column_families_[i]);
+#endif  // ROCKSDB_LITE
+
+          shared->SetVerificationFailure();
         }
       }
+
       shared->FinishPrintingVerificationResults();
+
       for (auto& iter : iters) {
+        assert(iter);
         iter->Next();
       }
     } while (true);
@@ -469,11 +552,19 @@ class CfConsistencyStressTest : public StressTest {
     const auto checksum_column_family = [](Iterator* iter,
                                            uint32_t* checksum) -> Status {
       assert(nullptr != checksum);
+
       uint32_t ret = 0;
       for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
         ret = crc32c::Extend(ret, iter->key().data(), iter->key().size());
         ret = crc32c::Extend(ret, iter->value().data(), iter->value().size());
+
+        for (const auto& column : iter->columns()) {
+          ret = crc32c::Extend(ret, column.name().data(), column.name().size());
+          ret =
+              crc32c::Extend(ret, column.value().data(), column.value().size());
+        }
       }
+
       *checksum = ret;
       return iter->status();
     };
@@ -538,7 +629,7 @@ class CfConsistencyStressTest : public StressTest {
   }
 
  private:
-  std::atomic<int64_t> batch_id_;
+  std::atomic<uint32_t> batch_id_;
 };
 
 StressTest* CreateCfConsistencyStressTest() {

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

@@ -239,6 +239,45 @@ uint32_t GetValueBase(Slice s) {
   return res;
 }
 
+WideColumns GenerateWideColumns(uint32_t value_base, const Slice& slice) {
+  WideColumns columns;
+
+  constexpr size_t max_columns = 4;
+  const size_t num_columns = (value_base % max_columns) + 1;
+
+  columns.reserve(num_columns);
+
+  assert(slice.size() >= num_columns);
+
+  columns.emplace_back(kDefaultWideColumnName, slice);
+
+  for (size_t i = 1; i < num_columns; ++i) {
+    const Slice name(slice.data(), i);
+    const Slice value(slice.data() + i, slice.size() - i);
+
+    columns.emplace_back(name, value);
+  }
+
+  return columns;
+}
+
+WideColumns GenerateExpectedWideColumns(uint32_t value_base,
+                                        const Slice& slice) {
+  if (FLAGS_use_put_entity_one_in == 0 ||
+      (value_base % FLAGS_use_put_entity_one_in) != 0) {
+    return WideColumns{{kDefaultWideColumnName, slice}};
+  }
+
+  WideColumns columns = GenerateWideColumns(value_base, slice);
+
+  std::sort(columns.begin(), columns.end(),
+            [](const WideColumn& lhs, const WideColumn& rhs) {
+              return lhs.name().compare(rhs.name()) < 0;
+            });
+
+  return columns;
+}
+
 std::string GetNowNanos() {
   uint64_t t = db_stress_env->NowNanos();
   std::string ret;

package/deps/rocksdb/rocksdb/db_stress_tool/db_stress_common.h

@@ -86,6 +86,7 @@ DECLARE_string(options_file);
 DECLARE_int64(active_width);
 DECLARE_bool(test_batches_snapshots);
 DECLARE_bool(atomic_flush);
+DECLARE_int32(manual_wal_flush_one_in);
 DECLARE_bool(test_cf_consistency);
 DECLARE_bool(test_multi_ops_txns);
 DECLARE_int32(threads);
@@ -173,6 +174,7 @@ DECLARE_bool(mock_direct_io);
 DECLARE_bool(statistics);
 DECLARE_bool(sync);
 DECLARE_bool(use_fsync);
+DECLARE_uint64(stats_dump_period_sec);
 DECLARE_uint64(bytes_per_sync);
 DECLARE_uint64(wal_bytes_per_sync);
 DECLARE_int32(kill_random_test);
@@ -235,6 +237,7 @@ DECLARE_bool(in_place_update);
 DECLARE_string(memtablerep);
 DECLARE_int32(prefix_size);
 DECLARE_bool(use_merge);
+DECLARE_uint32(use_put_entity_one_in);
 DECLARE_bool(use_full_merge_v1);
 DECLARE_int32(sync_wal_one_in);
 DECLARE_bool(avoid_unnecessary_blocking_io);
@@ -311,6 +314,7 @@ DECLARE_bool(allow_data_in_errors);
 // Tiered storage
 DECLARE_bool(enable_tiered_storage);  // set last_level_temperature
 DECLARE_int64(preclude_last_level_data_seconds);
+DECLARE_int64(preserve_internal_time_seconds);
 
 DECLARE_int32(verify_iterator_with_expected_state_one_in);
 DECLARE_bool(preserve_unverified_changes);
@@ -620,6 +624,10 @@ extern std::vector<int64_t> GenerateNKeys(ThreadState* thread, int num_keys,
 extern size_t GenerateValue(uint32_t rand, char* v, size_t max_sz);
 extern uint32_t GetValueBase(Slice s);
 
+extern WideColumns GenerateWideColumns(uint32_t value_base, const Slice& slice);
+extern WideColumns GenerateExpectedWideColumns(uint32_t value_base,
+                                               const Slice& slice);
+
 extern StressTest* CreateCfConsistencyStressTest();
 extern StressTest* CreateBatchedOpsStressTest();
 extern StressTest* CreateNonBatchedOpsStressTest();

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

@@ -143,7 +143,9 @@ bool RunStressTest(StressTest* stress) {
 
     // This is after the verification step to avoid making all those `Get()`s
     // and `MultiGet()`s contend on the DB-wide trace mutex.
-    stress->TrackExpectedState(&shared);
+    if (!FLAGS_expected_values_dir.empty()) {
+      stress->TrackExpectedState(&shared);
+    }
 
     now = clock->NowMicros();
     fprintf(stdout, "%s Starting database operations\n",

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

@@ -85,6 +85,13 @@ DEFINE_bool(test_batches_snapshots, false,
 DEFINE_bool(atomic_flush, false,
             "If set, enables atomic flush in the options.\n");
 
+DEFINE_int32(
+    manual_wal_flush_one_in, 0,
+    "If non-zero, then `FlushWAL(bool sync)`, where `bool sync` is randomly "
+    "decided, will be explictly called in db stress once for every N ops "
+    "on average. Setting `manual_wal_flush_one_in` to be greater than 0 "
+    "implies `Options::manual_wal_flush = true` is set.");
+
 DEFINE_bool(test_cf_consistency, false,
             "If set, runs the stress test dedicated to verifying writes to "
             "multiple column families are consistent. Setting this implies "
@@ -489,6 +496,10 @@ DEFINE_int64(preclude_last_level_data_seconds, 0,
              "Preclude data from the last level. Used with tiered storage "
              "feature to preclude new data from comacting to the last level.");
 
+DEFINE_int64(
+    preserve_internal_time_seconds, 0,
+    "Preserve internal time information which is attached to each SST.");
+
 static const bool FLAGS_subcompactions_dummy __attribute__((__unused__)) =
     RegisterFlagValidator(&FLAGS_subcompactions, &ValidateUint32Range);
 
@@ -858,6 +869,10 @@ DEFINE_bool(use_merge, false,
             "On true, replaces all writes with a Merge "
             "that behaves like a Put");
 
+DEFINE_uint32(use_put_entity_one_in, 0,
+              "If greater than zero, PutEntity will be used once per every N "
+              "write ops on average.");
+
 DEFINE_bool(use_full_merge_v1, false,
             "On true, use a merge operator that implement the deprecated "
             "version of FullMerge");
@@ -1052,4 +1067,8 @@ DEFINE_bool(
     "be preserved similarly under `FLAGS_expected_values_dir/unverified` when "
     "`--expected_values_dir` is nonempty.");
 
+DEFINE_uint64(stats_dump_period_sec,
+              ROCKSDB_NAMESPACE::Options().stats_dump_period_sec,
+              "Gap between printing stats to log in seconds");
+
 #endif  // GFLAGS

package/deps/rocksdb/rocksdb/db_stress_tool/db_stress_shared_state.h

@@ -215,6 +215,32 @@ class SharedState {
     }
   }
 
+  // Returns a collection of mutex locks covering the key range [start, end) in
+  // `cf`.
+  std::vector<std::unique_ptr<MutexLock>> GetLocksForKeyRange(int cf,
+                                                              int64_t start,
+                                                              int64_t end) {
+    std::vector<std::unique_ptr<MutexLock>> range_locks;
+
+    if (start >= end) {
+      return range_locks;
+    }
+
+    const int64_t start_idx = start >> log2_keys_per_lock_;
+
+    int64_t end_idx = end >> log2_keys_per_lock_;
+    if ((end & ((1 << log2_keys_per_lock_) - 1)) == 0) {
+      --end_idx;
+    }
+
+    for (int64_t idx = start_idx; idx <= end_idx; ++idx) {
+      range_locks.emplace_back(
+          std::make_unique<MutexLock>(&key_locks_[cf][idx]));
+    }
+
+    return range_locks;
+  }
+
   Status SaveAtAndAfter(DB* db) {
     return expected_state_manager_->SaveAtAndAfter(db);
   }