@nxtedition/rocksdb 9.0.0 → 9.0.1

package/deps/rocksdb/rocksdb/db/wide/wide_columns_helper.cc

@@ -0,0 +1,46 @@
+//  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).
+
+#include "db/wide/wide_columns_helper.h"
+
+#include <algorithm>
+
+#include "db/wide/wide_column_serialization.h"
+
+namespace ROCKSDB_NAMESPACE {
+void WideColumnsHelper::DumpWideColumns(const WideColumns& columns,
+                                        std::ostream& os, bool hex) {
+  if (columns.empty()) {
+    return;
+  }
+  if (hex) {
+    os << std::hex;
+  }
+  auto it = columns.begin();
+  os << *it;
+  for (++it; it != columns.end(); ++it) {
+    os << ' ' << *it;
+  }
+}
+
+Status WideColumnsHelper::DumpSliceAsWideColumns(const Slice& value,
+                                                 std::ostream& os, bool hex) {
+  WideColumns columns;
+  Slice value_copy = value;
+  const Status s = WideColumnSerialization::Deserialize(value_copy, columns);
+  if (s.ok()) {
+    DumpWideColumns(columns, os, hex);
+  }
+  return s;
+}
+
+void WideColumnsHelper::SortColumns(WideColumns& columns) {
+  std::sort(columns.begin(), columns.end(),
+            [](const WideColumn& lhs, const WideColumn& rhs) {
+              return lhs.name().compare(rhs.name()) < 0;
+            });
+}
+
+}  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/db/wide/wide_columns_helper.h

@@ -0,0 +1,40 @@
+//  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 <ostream>
+#include <string>
+
+#include "rocksdb/rocksdb_namespace.h"
+#include "rocksdb/wide_columns.h"
+
+namespace ROCKSDB_NAMESPACE {
+
+class WideColumnsHelper {
+ public:
+  static void DumpWideColumns(const WideColumns& columns, std::ostream& os,
+                              bool hex);
+
+  static Status DumpSliceAsWideColumns(const Slice& value, std::ostream& os,
+                                       bool hex);
+
+  static bool HasDefaultColumn(const WideColumns& columns) {
+    return !columns.empty() && columns.front().name() == kDefaultWideColumnName;
+  }
+
+  static bool HasDefaultColumnOnly(const WideColumns& columns) {
+    return columns.size() == 1 &&
+           columns.front().name() == kDefaultWideColumnName;
+  }
+
+  static const Slice& GetDefaultColumn(const WideColumns& columns) {
+    assert(HasDefaultColumn(columns));
+    return columns.front().value();
+  }
+
+  static void SortColumns(WideColumns& columns);
+};
+
+}  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/db/wide/wide_columns_helper_test.cc

@@ -0,0 +1,39 @@
+//  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).
+
+#include "db/wide/wide_columns_helper.h"
+
+#include "db/wide/wide_column_serialization.h"
+#include "test_util/testharness.h"
+#include "util/coding.h"
+
+namespace ROCKSDB_NAMESPACE {
+
+TEST(WideColumnsHelperTest, DumpWideColumns) {
+  WideColumns columns{{"foo", "bar"}, {"hello", "world"}};
+  std::ostringstream oss;
+  WideColumnsHelper::DumpWideColumns(columns, oss, false /* hex */);
+  EXPECT_EQ("foo:bar hello:world", oss.str());
+}
+
+TEST(WideColumnsHelperTest, DumpSliceAsWideColumns) {
+  WideColumns columns{{"foo", "bar"}, {"hello", "world"}};
+  std::string output;
+  ASSERT_OK(WideColumnSerialization::Serialize(columns, output));
+  Slice input(output);
+
+  std::ostringstream oss;
+  ASSERT_OK(
+      WideColumnsHelper::DumpSliceAsWideColumns(input, oss, false /* hex */));
+
+  EXPECT_EQ("foo:bar hello:world", oss.str());
+}
+}  // namespace ROCKSDB_NAMESPACE
+
+int main(int argc, char** argv) {
+  ROCKSDB_NAMESPACE::port::InstallStackTraceHandler();
+  ::testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}

package/deps/rocksdb/rocksdb/db/write_batch.cc

@@ -57,6 +57,7 @@
 #include "db/snapshot_impl.h"
 #include "db/trim_history_scheduler.h"
 #include "db/wide/wide_column_serialization.h"
+#include "db/wide/wide_columns_helper.h"
 #include "db/write_batch_internal.h"
 #include "monitoring/perf_context_imp.h"
 #include "monitoring/statistics_impl.h"
@@ -948,10 +949,7 @@ Status WriteBatchInternal::PutEntity(WriteBatch* b, uint32_t column_family_id,
   }
 
   WideColumns sorted_columns(columns);
-  std::sort(sorted_columns.begin(), sorted_columns.end(),
-            [](const WideColumn& lhs, const WideColumn& rhs) {
-              return lhs.name().compare(rhs.name()) < 0;
-            });
+  WideColumnsHelper::SortColumns(sorted_columns);
 
   std::string entity;
   const Status s = WideColumnSerialization::Serialize(sorted_columns, entity);
@@ -2485,13 +2483,15 @@ class MemTableInserter : public WriteBatch::Handler {
     }
 
     if (perform_merge) {
-      // 1) Get the existing value
-      std::string get_value;
+      // 1) Get the existing value. Use the wide column APIs to make sure we
+      // don't lose any columns in the process.
+      PinnableWideColumns existing;
 
       // Pass in the sequence number so that we also include previous merge
       // operations in the same batch.
       SnapshotImpl read_from_snapshot;
       read_from_snapshot.number_ = sequence_;
+
       // TODO: plumb Env::IOActivity
       ReadOptions read_options;
       read_options.snapshot = &read_from_snapshot;
@@ -2500,26 +2500,47 @@ class MemTableInserter : public WriteBatch::Handler {
       if (cf_handle == nullptr) {
         cf_handle = db_->DefaultColumnFamily();
       }
-      Status get_status = db_->Get(read_options, cf_handle, key, &get_value);
+
+      Status get_status =
+          db_->GetEntity(read_options, cf_handle, key, &existing);
       if (!get_status.ok()) {
         // Failed to read a key we know exists. Store the delta in memtable.
         perform_merge = false;
       } else {
-        Slice get_value_slice = Slice(get_value);
-
         // 2) Apply this merge
         auto merge_operator = moptions->merge_operator;
         assert(merge_operator);
 
+        const auto& columns = existing.columns();
+
+        Status merge_status;
         std::string new_value;
-        // `op_failure_scope` (an output parameter) is not provided (set to
-        // nullptr) since a failure must be propagated regardless of its value.
-        Status merge_status = MergeHelper::TimedFullMerge(
-            merge_operator, key, &get_value_slice, {value}, &new_value,
-            moptions->info_log, moptions->statistics,
-            SystemClock::Default().get(), /* result_operand */ nullptr,
-            /* update_num_ops_stats */ false,
-            /* op_failure_scope */ nullptr);
+        ValueType new_value_type;
+
+        if (WideColumnsHelper::HasDefaultColumnOnly(columns)) {
+          // `op_failure_scope` (an output parameter) is not provided (set to
+          // nullptr) since a failure must be propagated regardless of its
+          // value.
+          merge_status = MergeHelper::TimedFullMerge(
+              merge_operator, key, MergeHelper::kPlainBaseValue,
+              WideColumnsHelper::GetDefaultColumn(columns), {value},
+              moptions->info_log, moptions->statistics,
+              SystemClock::Default().get(),
+              /* update_num_ops_stats */ false, &new_value,
+              /* result_operand */ nullptr, &new_value_type,
+              /* op_failure_scope */ nullptr);
+        } else {
+          // `op_failure_scope` (an output parameter) is not provided (set to
+          // nullptr) since a failure must be propagated regardless of its
+          // value.
+          merge_status = MergeHelper::TimedFullMerge(
+              merge_operator, key, MergeHelper::kWideBaseValue, columns,
+              {value}, moptions->info_log, moptions->statistics,
+              SystemClock::Default().get(),
+              /* update_num_ops_stats */ false, &new_value,
+              /* result_operand */ nullptr, &new_value_type,
+              /* op_failure_scope */ nullptr);
+        }
 
         if (!merge_status.ok()) {
           // Failed to merge!
@@ -2528,15 +2549,18 @@ class MemTableInserter : public WriteBatch::Handler {
         } else {
           // 3) Add value to memtable
           assert(!concurrent_memtable_writes_);
+          assert(new_value_type == kTypeValue ||
+                 new_value_type == kTypeWideColumnEntity);
+
           if (kv_prot_info != nullptr) {
             auto merged_kv_prot_info =
                 kv_prot_info->StripC(column_family_id).ProtectS(sequence_);
             merged_kv_prot_info.UpdateV(value, new_value);
-            merged_kv_prot_info.UpdateO(kTypeMerge, kTypeValue);
-            ret_status = mem->Add(sequence_, kTypeValue, key, new_value,
+            merged_kv_prot_info.UpdateO(kTypeMerge, new_value_type);
+            ret_status = mem->Add(sequence_, new_value_type, key, new_value,
                                   &merged_kv_prot_info);
           } else {
-            ret_status = mem->Add(sequence_, kTypeValue, key, new_value,
+            ret_status = mem->Add(sequence_, new_value_type, key, new_value,
                                   nullptr /* kv_prot_info */);
           }
         }

package/deps/rocksdb/rocksdb/db_stress_tool/CMakeLists.txt

@@ -9,6 +9,7 @@ add_executable(db_stress${ARTIFACT_SUFFIX}
   db_stress_shared_state.cc
   db_stress_stat.cc
   db_stress_test_base.cc
+  db_stress_wide_merge_operator.cc
   db_stress_tool.cc
   expected_state.cc
   expected_value.cc

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

@@ -52,11 +52,11 @@ class BatchedOpsStressTest : public StressTest {
       const std::string k = num + key_body;
       const std::string v = value_body + num;
 
-      if (FLAGS_use_merge) {
-        batch.Merge(cfh, k, v);
-      } else if (FLAGS_use_put_entity_one_in > 0 &&
-                 (value_base % FLAGS_use_put_entity_one_in) == 0) {
+      if (FLAGS_use_put_entity_one_in > 0 &&
+          (value_base % FLAGS_use_put_entity_one_in) == 0) {
         batch.PutEntity(cfh, k, GenerateWideColumns(value_base, v));
+      } else if (FLAGS_use_merge) {
+        batch.Merge(cfh, k, v);
       } else {
         batch.Put(cfh, k, v);
       }

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

@@ -36,18 +36,15 @@ class CfConsistencyStressTest : public StressTest {
 
     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* const cfh = column_families_[cf];
       assert(cfh);
 
-      if (FLAGS_use_merge) {
-        batch.Merge(cfh, k, v);
-      } else if (use_put_entity) {
+      if (FLAGS_use_put_entity_one_in > 0 &&
+          (value_base % FLAGS_use_put_entity_one_in) == 0) {
         batch.PutEntity(cfh, k, GenerateWideColumns(value_base, v));
+      } else if (FLAGS_use_merge) {
+        batch.Merge(cfh, k, v);
       } else {
         batch.Put(cfh, k, v);
       }

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

@@ -13,6 +13,7 @@
 
 #include <cmath>
 
+#include "rocksdb/secondary_cache.h"
 #include "util/file_checksum_helper.h"
 #include "util/xxhash.h"
 
@@ -21,6 +22,8 @@ ROCKSDB_NAMESPACE::Env* db_stress_env = nullptr;
 // If non-null, injects read error at a rate specified by the
 // read_fault_one_in or write_fault_one_in flag
 std::shared_ptr<ROCKSDB_NAMESPACE::FaultInjectionTestFS> fault_fs_guard;
+std::shared_ptr<ROCKSDB_NAMESPACE::SecondaryCache> compressed_secondary_cache;
+std::shared_ptr<ROCKSDB_NAMESPACE::Cache> block_cache;
 enum ROCKSDB_NAMESPACE::CompressionType compression_type_e =
     ROCKSDB_NAMESPACE::kSnappyCompression;
 enum ROCKSDB_NAMESPACE::CompressionType bottommost_compression_type_e =
@@ -148,6 +151,88 @@ void DbVerificationThread(void* v) {
   }
 }
 
+void CompressedCacheSetCapacityThread(void* v) {
+  assert(FLAGS_compressed_secondary_cache_size > 0 ||
+         FLAGS_compressed_secondary_cache_ratio > 0.0);
+  auto* thread = reinterpret_cast<ThreadState*>(v);
+  SharedState* shared = thread->shared;
+  while (true) {
+    {
+      MutexLock l(shared->GetMutex());
+      if (shared->ShouldStopBgThread()) {
+        shared->IncBgThreadsFinished();
+        if (shared->BgThreadsFinished()) {
+          shared->GetCondVar()->SignalAll();
+        }
+        return;
+      }
+    }
+    db_stress_env->SleepForMicroseconds(FLAGS_secondary_cache_update_interval);
+    if (FLAGS_compressed_secondary_cache_size > 0) {
+      Status s = compressed_secondary_cache->SetCapacity(0);
+      size_t capacity;
+      if (s.ok()) {
+        s = compressed_secondary_cache->GetCapacity(capacity);
+        assert(capacity == 0);
+      }
+      db_stress_env->SleepForMicroseconds(10 * 1000 * 1000);
+      if (s.ok()) {
+        s = compressed_secondary_cache->SetCapacity(
+            FLAGS_compressed_secondary_cache_size);
+      }
+      if (s.ok()) {
+        s = compressed_secondary_cache->GetCapacity(capacity);
+        assert(capacity == FLAGS_compressed_secondary_cache_size);
+      }
+      if (!s.ok()) {
+        fprintf(stderr, "Compressed cache Set/GetCapacity returned error: %s\n",
+                s.ToString().c_str());
+      }
+    } else if (FLAGS_compressed_secondary_cache_ratio > 0.0) {
+      if (thread->rand.OneIn(2)) {
+        size_t capacity = block_cache->GetCapacity();
+        size_t adjustment;
+        if (FLAGS_use_write_buffer_manager && FLAGS_db_write_buffer_size > 0) {
+          adjustment = (capacity - FLAGS_db_write_buffer_size);
+        } else {
+          adjustment = capacity;
+        }
+        // Lower by upto 50% of usable block cache capacity
+        adjustment = (adjustment * thread->rand.Uniform(50)) / 100;
+        block_cache->SetCapacity(capacity - adjustment);
+        fprintf(stderr, "New cache capacity = %lu\n",
+                block_cache->GetCapacity());
+        db_stress_env->SleepForMicroseconds(10 * 1000 * 1000);
+        block_cache->SetCapacity(capacity);
+      } else {
+        Status s;
+        double new_comp_cache_ratio =
+            (double)thread->rand.Uniform(
+                FLAGS_compressed_secondary_cache_ratio * 100) /
+            100;
+        if (new_comp_cache_ratio == 0.0) {
+          new_comp_cache_ratio = 0.05;
+        }
+        fprintf(stderr, "New comp cache ratio = %f\n", new_comp_cache_ratio);
+
+        s = UpdateTieredCache(block_cache, /*capacity*/ -1,
+                              new_comp_cache_ratio);
+        if (s.ok()) {
+          db_stress_env->SleepForMicroseconds(10 * 1000 * 1000);
+        }
+        if (s.ok()) {
+          s = UpdateTieredCache(block_cache, /*capacity*/ -1,
+                                FLAGS_compressed_secondary_cache_ratio);
+        }
+        if (!s.ok()) {
+          fprintf(stderr, "UpdateTieredCache returned error: %s\n",
+                  s.ToString().c_str());
+        }
+      }
+    }
+  }
+}
+
 void PrintKeyValue(int cf, uint64_t key, const char* value, size_t sz) {
   if (!FLAGS_verbose) {
     return;
@@ -270,10 +355,7 @@ WideColumns GenerateExpectedWideColumns(uint32_t value_base,
 
   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;
-            });
+  WideColumnsHelper::SortColumns(columns);
 
   return columns;
 }
@@ -296,15 +378,11 @@ bool VerifyWideColumns(const Slice& value, const WideColumns& columns) {
 }
 
 bool VerifyWideColumns(const WideColumns& columns) {
-  if (columns.empty()) {
-    return false;
-  }
-
-  if (columns.front().name() != kDefaultWideColumnName) {
+  if (!WideColumnsHelper::HasDefaultColumn(columns)) {
     return false;
   }
 
-  const Slice& value_of_default = columns.front().value();
+  const Slice& value_of_default = WideColumnsHelper::GetDefaultColumn(columns);
 
   return VerifyWideColumns(value_of_default, columns);
 }

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

@@ -37,6 +37,7 @@
 
 #include "db/db_impl/db_impl.h"
 #include "db/version_set.h"
+#include "db/wide/wide_columns_helper.h"
 #include "db_stress_tool/db_stress_env_wrapper.h"
 #include "db_stress_tool/db_stress_listener.h"
 #include "db_stress_tool/db_stress_shared_state.h"
@@ -107,11 +108,14 @@ DECLARE_int32(max_write_buffer_number);
 DECLARE_int32(min_write_buffer_number_to_merge);
 DECLARE_int32(max_write_buffer_number_to_maintain);
 DECLARE_int64(max_write_buffer_size_to_maintain);
+DECLARE_bool(use_write_buffer_manager);
 DECLARE_double(memtable_prefix_bloom_size_ratio);
 DECLARE_bool(memtable_whole_key_filtering);
 DECLARE_int32(open_files);
-DECLARE_int64(compressed_cache_size);
-DECLARE_int32(compressed_cache_numshardbits);
+DECLARE_uint64(compressed_secondary_cache_size);
+DECLARE_int32(compressed_secondary_cache_numshardbits);
+DECLARE_int32(secondary_cache_update_interval);
+DECLARE_double(compressed_secondary_cache_ratio);
 DECLARE_int32(compaction_style);
 DECLARE_int32(compaction_pri);
 DECLARE_int32(num_levels);
@@ -158,7 +162,7 @@ DECLARE_double(experimental_mempurge_threshold);
 DECLARE_bool(enable_write_thread_adaptive_yield);
 DECLARE_int32(reopen);
 DECLARE_double(bloom_bits);
-DECLARE_int32(ribbon_starting_level);
+DECLARE_int32(bloom_before_level);
 DECLARE_bool(partition_filters);
 DECLARE_bool(optimize_filters_for_memory);
 DECLARE_bool(detect_filter_construct_corruption);
@@ -254,6 +258,7 @@ DECLARE_int32(verify_db_one_in);
 DECLARE_int32(continuous_verification_interval);
 DECLARE_int32(get_property_one_in);
 DECLARE_string(file_checksum_impl);
+DECLARE_bool(verification_only);
 
 // Options for transaction dbs.
 // Use TransactionDB (a.k.a. Pessimistic Transaction DB)
@@ -346,6 +351,7 @@ DECLARE_uint64(initial_auto_readahead_size);
 DECLARE_uint64(max_auto_readahead_size);
 DECLARE_uint64(num_file_reads_for_auto_readahead);
 DECLARE_bool(use_io_uring);
+DECLARE_bool(auto_readahead_size);
 
 constexpr long KB = 1024;
 constexpr int kRandomValueMaxFactor = 3;
@@ -355,6 +361,9 @@ constexpr int kValueMaxLen = 100;
 extern ROCKSDB_NAMESPACE::Env* db_stress_env;
 extern ROCKSDB_NAMESPACE::Env* db_stress_listener_env;
 extern std::shared_ptr<ROCKSDB_NAMESPACE::FaultInjectionTestFS> fault_fs_guard;
+extern std::shared_ptr<ROCKSDB_NAMESPACE::SecondaryCache>
+    compressed_secondary_cache;
+extern std::shared_ptr<ROCKSDB_NAMESPACE::Cache> block_cache;
 
 extern enum ROCKSDB_NAMESPACE::CompressionType compression_type_e;
 extern enum ROCKSDB_NAMESPACE::CompressionType bottommost_compression_type_e;
@@ -627,13 +636,7 @@ inline std::string WideColumnsToHex(const WideColumns& columns) {
 
   std::ostringstream oss;
 
-  oss << std::hex;
-
-  auto it = columns.begin();
-  oss << *it;
-  for (++it; it != columns.end(); ++it) {
-    oss << ' ' << *it;
-  }
+  WideColumnsHelper::DumpWideColumns(columns, oss, true);
 
   return oss.str();
 }
@@ -653,6 +656,8 @@ extern void PoolSizeChangeThread(void* v);
 
 extern void DbVerificationThread(void* v);
 
+extern void CompressedCacheSetCapacityThread(void* v);
+
 extern void TimestampedSnapshotsThread(void* v);
 
 extern void PrintKeyValue(int cf, uint64_t key, const char* value, size_t sz);