@nxtedition/rocksdb 10.0.13 → 10.0.15

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

@@ -46,6 +46,7 @@
 #include "monitoring/histogram.h"
 #include "options/options_helper.h"
 #include "port/port.h"
+#include "rocksdb/advanced_options.h"
 #include "rocksdb/cache.h"
 #include "rocksdb/env.h"
 #include "rocksdb/slice.h"
@@ -136,7 +137,8 @@ DECLARE_int32(universal_min_merge_width);
 DECLARE_int32(universal_max_merge_width);
 DECLARE_int32(universal_max_size_amplification_percent);
 DECLARE_int32(clear_column_family_one_in);
-DECLARE_int32(get_live_files_one_in);
+DECLARE_int32(get_live_files_apis_one_in);
+DECLARE_int32(get_all_column_family_metadata_one_in);
 DECLARE_int32(get_sorted_wal_files_one_in);
 DECLARE_int32(get_current_wal_file_one_in);
 DECLARE_int32(set_options_one_in);
@@ -155,6 +157,7 @@ DECLARE_int32(unpartitioned_pinning);
 DECLARE_string(cache_type);
 DECLARE_uint64(subcompactions);
 DECLARE_uint64(periodic_compaction_seconds);
+DECLARE_string(daily_offpeak_time_utc);
 DECLARE_uint64(compaction_ttl);
 DECLARE_bool(fifo_allow_compaction);
 DECLARE_bool(allow_concurrent_memtable_write);
@@ -206,9 +209,14 @@ DECLARE_int32(ingest_external_file_one_in);
 DECLARE_int32(ingest_external_file_width);
 DECLARE_int32(compact_files_one_in);
 DECLARE_int32(compact_range_one_in);
+DECLARE_int32(promote_l0_one_in);
 DECLARE_int32(mark_for_compaction_one_file_in);
 DECLARE_int32(flush_one_in);
+DECLARE_int32(key_may_exist_one_in);
+DECLARE_int32(reset_stats_one_in);
 DECLARE_int32(pause_background_one_in);
+DECLARE_int32(disable_file_deletions_one_in);
+DECLARE_int32(disable_manual_compaction_one_in);
 DECLARE_int32(compact_range_width);
 DECLARE_int32(acquire_snapshot_one_in);
 DECLARE_bool(compare_full_db_state_snapshot);
@@ -245,6 +253,7 @@ DECLARE_string(memtablerep);
 DECLARE_int32(prefix_size);
 DECLARE_bool(use_merge);
 DECLARE_uint32(use_put_entity_one_in);
+DECLARE_bool(use_attribute_group);
 DECLARE_bool(use_full_merge_v1);
 DECLARE_int32(sync_wal_one_in);
 DECLARE_bool(avoid_unnecessary_blocking_io);
@@ -257,8 +266,12 @@ DECLARE_int32(verify_file_checksums_one_in);
 DECLARE_int32(verify_db_one_in);
 DECLARE_int32(continuous_verification_interval);
 DECLARE_int32(get_property_one_in);
+DECLARE_int32(get_properties_of_all_tables_one_in);
 DECLARE_string(file_checksum_impl);
 DECLARE_bool(verification_only);
+DECLARE_string(last_level_temperature);
+DECLARE_string(default_write_temperature);
+DECLARE_string(default_temperature);
 
 // Options for transaction dbs.
 // Use TransactionDB (a.k.a. Pessimistic Transaction DB)
@@ -313,6 +326,7 @@ DECLARE_uint32(memtable_protection_bytes_per_key);
 DECLARE_uint32(block_protection_bytes_per_key);
 
 DECLARE_uint64(user_timestamp_size);
+DECLARE_bool(persist_user_defined_timestamps);
 DECLARE_string(secondary_cache_uri);
 DECLARE_int32(secondary_cache_fault_one_in);
 
@@ -339,9 +353,9 @@ DECLARE_uint32(memtable_max_range_deletions);
 DECLARE_uint32(bottommost_file_compaction_delay);
 
 // 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_uint32(use_timed_put_one_in);
 
 DECLARE_int32(verify_iterator_with_expected_state_one_in);
 DECLARE_bool(preserve_unverified_changes);
@@ -350,12 +364,62 @@ DECLARE_uint64(readahead_size);
 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);
+DECLARE_bool(allow_fallocate);
+DECLARE_int32(table_cache_numshardbits);
+DECLARE_bool(enable_write_thread_adaptive_yield);
+DECLARE_uint64(log_readahead_size);
+DECLARE_uint64(bgerror_resume_retry_interval);
+DECLARE_uint64(delete_obsolete_files_period_micros);
+DECLARE_uint64(max_log_file_size);
+DECLARE_uint64(log_file_time_to_roll);
+DECLARE_bool(use_adaptive_mutex);
+DECLARE_bool(advise_random_on_open);
+DECLARE_uint64(WAL_ttl_seconds);
+DECLARE_uint64(WAL_size_limit_MB);
+DECLARE_bool(strict_bytes_per_sync);
+DECLARE_bool(avoid_flush_during_shutdown);
+DECLARE_bool(fill_cache);
+DECLARE_bool(optimize_multiget_for_io);
+DECLARE_bool(memtable_insert_hint_per_batch);
+DECLARE_bool(dump_malloc_stats);
+DECLARE_uint64(stats_history_buffer_size);
+DECLARE_bool(skip_stats_update_on_db_open);
+DECLARE_bool(optimize_filters_for_hits);
+DECLARE_uint64(sample_for_compression);
+DECLARE_bool(report_bg_io_stats);
+DECLARE_bool(cache_index_and_filter_blocks_with_high_priority);
+DECLARE_bool(use_delta_encoding);
+DECLARE_bool(verify_compression);
+DECLARE_uint32(read_amp_bytes_per_bit);
+DECLARE_bool(enable_index_compression);
+DECLARE_uint32(index_shortening);
+DECLARE_uint32(metadata_charge_policy);
+DECLARE_bool(use_adaptive_mutex_lru);
+DECLARE_uint32(compress_format_version);
+DECLARE_uint64(manifest_preallocation_size);
+DECLARE_bool(enable_checksum_handoff);
+DECLARE_uint64(max_total_wal_size);
+DECLARE_double(high_pri_pool_ratio);
+DECLARE_double(low_pri_pool_ratio);
+DECLARE_uint64(soft_pending_compaction_bytes_limit);
+DECLARE_uint64(hard_pending_compaction_bytes_limit);
+DECLARE_uint64(max_sequential_skip_in_iterations);
+DECLARE_bool(enable_sst_partitioner_factory);
+DECLARE_bool(enable_do_not_compress_roles);
+DECLARE_bool(block_align);
+DECLARE_uint32(lowest_used_cache_tier);
+DECLARE_bool(enable_custom_split_merge);
+DECLARE_uint32(adm_policy);
+DECLARE_bool(enable_memtable_insert_with_hint_prefix_extractor);
+DECLARE_bool(check_multiget_consistency);
+DECLARE_bool(check_multiget_entity_consistency);
+DECLARE_bool(inplace_update_support);
 
 constexpr long KB = 1024;
 constexpr int kRandomValueMaxFactor = 3;
 constexpr int kValueMaxLen = 100;
+constexpr uint32_t kLargePrimeForCommonFactorSkew = 1872439133;
 
 // wrapped posix environment
 extern ROCKSDB_NAMESPACE::Env* db_stress_env;
@@ -447,6 +511,28 @@ inline std::string ChecksumTypeToString(ROCKSDB_NAMESPACE::ChecksumType ctype) {
   return iter->first;
 }
 
+inline enum ROCKSDB_NAMESPACE::Temperature StringToTemperature(
+    const char* ctype) {
+  assert(ctype);
+  auto iter = std::find_if(
+      ROCKSDB_NAMESPACE::temperature_to_string.begin(),
+      ROCKSDB_NAMESPACE::temperature_to_string.end(),
+      [&](const std::pair<ROCKSDB_NAMESPACE::Temperature, std::string>&
+              temp_and_string_val) {
+        return ctype == temp_and_string_val.second;
+      });
+  assert(iter != ROCKSDB_NAMESPACE::temperature_to_string.end());
+  return iter->first;
+}
+
+inline std::string TemperatureToString(
+    ROCKSDB_NAMESPACE::Temperature temperature) {
+  auto iter =
+      ROCKSDB_NAMESPACE::OptionsHelper::temperature_to_string.find(temperature);
+  assert(iter != ROCKSDB_NAMESPACE::OptionsHelper::temperature_to_string.end());
+  return iter->second;
+}
+
 inline std::vector<std::string> SplitString(std::string src) {
   std::vector<std::string> ret;
   if (src.empty()) {
@@ -488,7 +574,7 @@ inline bool GetNextPrefix(const ROCKSDB_NAMESPACE::Slice& src, std::string* v) {
 #endif
 
 // Append `val` to `*key` in fixed-width big-endian format
-extern inline void AppendIntToString(uint64_t val, std::string* key) {
+inline void AppendIntToString(uint64_t val, std::string* key) {
   // PutFixed64 uses little endian
   PutFixed64(key, val);
   // Reverse to get big endian
@@ -517,7 +603,7 @@ extern KeyGenContext key_gen_ctx;
 // - {0}...{x-1}
 // {(x-1),0}..{(x-1),(y-1)},{(x-1),(y-1),0}..{(x-1),(y-1),(z-1)} and so on.
 // Additionally, a trailer of 0-7 bytes could be appended.
-extern inline std::string Key(int64_t val) {
+inline std::string Key(int64_t val) {
   uint64_t window = key_gen_ctx.window;
   size_t levels = key_gen_ctx.weights.size();
   std::string key;
@@ -555,7 +641,7 @@ extern inline std::string Key(int64_t val) {
 }
 
 // Given a string key, map it to an index into the expected values buffer
-extern inline bool GetIntVal(std::string big_endian_key, uint64_t* key_p) {
+inline bool GetIntVal(std::string big_endian_key, uint64_t* key_p) {
   size_t size_key = big_endian_key.size();
   std::vector<uint64_t> prefixes;
 
@@ -610,8 +696,8 @@ inline bool GetFirstIntValInPrefix(std::string big_endian_prefix,
   return GetIntVal(std::move(big_endian_prefix), key_p);
 }
 
-extern inline uint64_t GetPrefixKeyCount(const std::string& prefix,
-                                         const std::string& ub) {
+inline uint64_t GetPrefixKeyCount(const std::string& prefix,
+                                  const std::string& ub) {
   uint64_t start = 0;
   uint64_t end = 0;
 
@@ -623,7 +709,7 @@ extern inline uint64_t GetPrefixKeyCount(const std::string& prefix,
   return end - start;
 }
 
-extern inline std::string StringToHex(const std::string& str) {
+inline std::string StringToHex(const std::string& str) {
   std::string result = "0x";
   result.append(Slice(str).ToString(true));
   return result;
@@ -642,49 +728,55 @@ inline std::string WideColumnsToHex(const WideColumns& columns) {
 }
 
 // Unified output format for double parameters
-extern inline std::string FormatDoubleParam(double param) {
+inline std::string FormatDoubleParam(double param) {
   return std::to_string(param);
 }
 
 // Make sure that double parameter is a value we can reproduce by
 // re-inputting the value printed.
-extern inline void SanitizeDoubleParam(double* param) {
+inline void SanitizeDoubleParam(double* param) {
   *param = std::atof(FormatDoubleParam(*param).c_str());
 }
 
-extern void PoolSizeChangeThread(void* v);
+void PoolSizeChangeThread(void* v);
+
+void DbVerificationThread(void* v);
+
+void CompressedCacheSetCapacityThread(void* v);
 
-extern void DbVerificationThread(void* v);
+void TimestampedSnapshotsThread(void* v);
 
-extern void CompressedCacheSetCapacityThread(void* v);
+void PrintKeyValue(int cf, uint64_t key, const char* value, size_t sz);
 
-extern void TimestampedSnapshotsThread(void* v);
+int64_t GenerateOneKey(ThreadState* thread, uint64_t iteration);
 
-extern void PrintKeyValue(int cf, uint64_t key, const char* value, size_t sz);
+std::vector<int64_t> GenerateNKeys(ThreadState* thread, int num_keys,
+                                   uint64_t iteration);
 
-extern int64_t GenerateOneKey(ThreadState* thread, uint64_t iteration);
+size_t GenerateValue(uint32_t rand, char* v, size_t max_sz);
+uint32_t GetValueBase(Slice s);
 
-extern std::vector<int64_t> GenerateNKeys(ThreadState* thread, int num_keys,
-                                          uint64_t iteration);
+WideColumns GenerateWideColumns(uint32_t value_base, const Slice& slice);
+WideColumns GenerateExpectedWideColumns(uint32_t value_base,
+                                        const Slice& slice);
+bool VerifyWideColumns(const Slice& value, const WideColumns& columns);
+bool VerifyWideColumns(const WideColumns& columns);
 
-extern size_t GenerateValue(uint32_t rand, char* v, size_t max_sz);
-extern uint32_t GetValueBase(Slice s);
+AttributeGroups GenerateAttributeGroups(
+    const std::vector<ColumnFamilyHandle*>& cfhs, uint32_t value_base,
+    const Slice& slice);
 
-extern WideColumns GenerateWideColumns(uint32_t value_base, const Slice& slice);
-extern WideColumns GenerateExpectedWideColumns(uint32_t value_base,
-                                               const Slice& slice);
-extern bool VerifyWideColumns(const Slice& value, const WideColumns& columns);
-extern bool VerifyWideColumns(const WideColumns& columns);
+StressTest* CreateCfConsistencyStressTest();
+StressTest* CreateBatchedOpsStressTest();
+StressTest* CreateNonBatchedOpsStressTest();
+StressTest* CreateMultiOpsTxnsStressTest();
+void CheckAndSetOptionsForMultiOpsTxnStressTest();
+void InitializeHotKeyGenerator(double alpha);
+int64_t GetOneHotKeyID(double rand_seed, int64_t max_key);
 
-extern StressTest* CreateCfConsistencyStressTest();
-extern StressTest* CreateBatchedOpsStressTest();
-extern StressTest* CreateNonBatchedOpsStressTest();
-extern StressTest* CreateMultiOpsTxnsStressTest();
-extern void CheckAndSetOptionsForMultiOpsTxnStressTest();
-extern void InitializeHotKeyGenerator(double alpha);
-extern int64_t GetOneHotKeyID(double rand_seed, int64_t max_key);
+std::string GetNowNanos();
 
-extern std::string GetNowNanos();
+uint64_t GetWriteUnixTime(ThreadState* thread);
 
 std::shared_ptr<FileChecksumGenFactory> GetFileChecksumImpl(
     const std::string& name);

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

@@ -15,7 +15,7 @@
 namespace ROCKSDB_NAMESPACE {
 void ThreadBody(void* v) {
   ThreadStatusUtil::RegisterThread(db_stress_env, ThreadStatus::USER);
-  ThreadState* thread = reinterpret_cast<ThreadState*>(v);
+  ThreadState* thread = static_cast<ThreadState*>(v);
   SharedState* shared = thread->shared;
 
   if (!FLAGS_skip_verifydb && shared->ShouldVerifyAtBeginning()) {

package/deps/rocksdb/rocksdb/db_stress_tool/db_stress_driver.h

@@ -12,7 +12,7 @@
 #pragma once
 #include "db_stress_tool/db_stress_test_base.h"
 namespace ROCKSDB_NAMESPACE {
-extern void ThreadBody(void* /*thread_state*/);
-extern bool RunStressTest(SharedState*);
+void ThreadBody(void* /*thread_state*/);
+bool RunStressTest(SharedState*);
 }  // namespace ROCKSDB_NAMESPACE
 #endif  // GFLAGS

package/deps/rocksdb/rocksdb/db_stress_tool/db_stress_env_wrapper.h

@@ -60,7 +60,7 @@ class DbStressRandomAccessFileWrapper : public FSRandomAccessFileOwnerWrapper {
   }
 
   IOStatus ReadAsync(FSReadRequest& req, const IOOptions& options,
-                     std::function<void(const FSReadRequest&, void*)> cb,
+                     std::function<void(FSReadRequest&, void*)> cb,
                      void* cb_arg, void** io_handle, IOHandleDeleter* del_fn,
                      IODebugContext* dbg) override {
 #ifndef NDEBUG
@@ -76,6 +76,155 @@ class DbStressRandomAccessFileWrapper : public FSRandomAccessFileOwnerWrapper {
   }
 };
 
+class DbStressWritableFileWrapper : public FSWritableFileOwnerWrapper {
+ public:
+  explicit DbStressWritableFileWrapper(std::unique_ptr<FSWritableFile>&& target)
+      : FSWritableFileOwnerWrapper(std::move(target)) {}
+
+  IOStatus Append(const Slice& data, const IOOptions& options,
+                  IODebugContext* dbg) override {
+#ifndef NDEBUG
+    const ThreadStatus::OperationType thread_op =
+        ThreadStatusUtil::GetThreadOperation();
+    Env::IOActivity io_activity =
+        ThreadStatusUtil::TEST_GetExpectedIOActivity(thread_op);
+    assert(io_activity == Env::IOActivity::kUnknown ||
+           io_activity == options.io_activity);
+#endif
+    return target()->Append(data, options, dbg);
+  }
+  IOStatus Append(const Slice& data, const IOOptions& options,
+                  const DataVerificationInfo& verification_info,
+                  IODebugContext* dbg) override {
+#ifndef NDEBUG
+    const ThreadStatus::OperationType thread_op =
+        ThreadStatusUtil::GetThreadOperation();
+    Env::IOActivity io_activity =
+        ThreadStatusUtil::TEST_GetExpectedIOActivity(thread_op);
+    assert(io_activity == Env::IOActivity::kUnknown ||
+           io_activity == options.io_activity);
+#endif
+    return target()->Append(data, options, verification_info, dbg);
+  }
+  IOStatus PositionedAppend(const Slice& data, uint64_t offset,
+                            const IOOptions& options,
+                            IODebugContext* dbg) override {
+#ifndef NDEBUG
+    const ThreadStatus::OperationType thread_op =
+        ThreadStatusUtil::GetThreadOperation();
+    Env::IOActivity io_activity =
+        ThreadStatusUtil::TEST_GetExpectedIOActivity(thread_op);
+    assert(io_activity == Env::IOActivity::kUnknown ||
+           io_activity == options.io_activity);
+#endif
+    return target()->PositionedAppend(data, offset, options, dbg);
+  }
+  IOStatus PositionedAppend(const Slice& data, uint64_t offset,
+                            const IOOptions& options,
+                            const DataVerificationInfo& verification_info,
+                            IODebugContext* dbg) override {
+#ifndef NDEBUG
+    const ThreadStatus::OperationType thread_op =
+        ThreadStatusUtil::GetThreadOperation();
+    Env::IOActivity io_activity =
+        ThreadStatusUtil::TEST_GetExpectedIOActivity(thread_op);
+    assert(io_activity == Env::IOActivity::kUnknown ||
+           io_activity == options.io_activity);
+#endif
+    return target()->PositionedAppend(data, offset, options, verification_info,
+                                      dbg);
+  }
+
+  IOStatus Truncate(uint64_t size, const IOOptions& options,
+                    IODebugContext* dbg) override {
+#ifndef NDEBUG
+    const ThreadStatus::OperationType thread_op =
+        ThreadStatusUtil::GetThreadOperation();
+    Env::IOActivity io_activity =
+        ThreadStatusUtil::TEST_GetExpectedIOActivity(thread_op);
+    assert(io_activity == Env::IOActivity::kUnknown ||
+           io_activity == options.io_activity);
+#endif
+    return target()->Truncate(size, options, dbg);
+  }
+
+  IOStatus Close(const IOOptions& options, IODebugContext* dbg) override {
+#ifndef NDEBUG
+    const ThreadStatus::OperationType thread_op =
+        ThreadStatusUtil::GetThreadOperation();
+    Env::IOActivity io_activity =
+        ThreadStatusUtil::TEST_GetExpectedIOActivity(thread_op);
+    assert(io_activity == Env::IOActivity::kUnknown ||
+           io_activity == options.io_activity);
+#endif
+    return target()->Close(options, dbg);
+  }
+
+  IOStatus Flush(const IOOptions& options, IODebugContext* dbg) override {
+#ifndef NDEBUG
+    const ThreadStatus::OperationType thread_op =
+        ThreadStatusUtil::GetThreadOperation();
+    Env::IOActivity io_activity =
+        ThreadStatusUtil::TEST_GetExpectedIOActivity(thread_op);
+    assert(io_activity == Env::IOActivity::kUnknown ||
+           io_activity == options.io_activity);
+#endif
+    return target()->Flush(options, dbg);
+  }
+
+  IOStatus Sync(const IOOptions& options, IODebugContext* dbg) override {
+#ifndef NDEBUG
+    const ThreadStatus::OperationType thread_op =
+        ThreadStatusUtil::GetThreadOperation();
+    Env::IOActivity io_activity =
+        ThreadStatusUtil::TEST_GetExpectedIOActivity(thread_op);
+    assert(io_activity == Env::IOActivity::kUnknown ||
+           io_activity == options.io_activity);
+#endif
+    return target()->Sync(options, dbg);
+  }
+
+  IOStatus Fsync(const IOOptions& options, IODebugContext* dbg) override {
+#ifndef NDEBUG
+    const ThreadStatus::OperationType thread_op =
+        ThreadStatusUtil::GetThreadOperation();
+    Env::IOActivity io_activity =
+        ThreadStatusUtil::TEST_GetExpectedIOActivity(thread_op);
+    assert(io_activity == Env::IOActivity::kUnknown ||
+           io_activity == options.io_activity);
+#endif
+    return target()->Fsync(options, dbg);
+  }
+
+#ifdef ROCKSDB_FALLOCATE_PRESENT
+  IOStatus Allocate(uint64_t offset, uint64_t len, const IOOptions& options,
+                    IODebugContext* dbg) override {
+#ifndef NDEBUG
+    const ThreadStatus::OperationType thread_op =
+        ThreadStatusUtil::GetThreadOperation();
+    Env::IOActivity io_activity =
+        ThreadStatusUtil::TEST_GetExpectedIOActivity(thread_op);
+    assert(io_activity == Env::IOActivity::kUnknown ||
+           io_activity == options.io_activity);
+#endif
+    return target()->Allocate(offset, len, options, dbg);
+  }
+#endif
+
+  IOStatus RangeSync(uint64_t offset, uint64_t nbytes, const IOOptions& options,
+                     IODebugContext* dbg) override {
+#ifndef NDEBUG
+    const ThreadStatus::OperationType thread_op =
+        ThreadStatusUtil::GetThreadOperation();
+    Env::IOActivity io_activity =
+        ThreadStatusUtil::TEST_GetExpectedIOActivity(thread_op);
+    assert(io_activity == Env::IOActivity::kUnknown ||
+           io_activity == options.io_activity);
+#endif
+    return target()->RangeSync(offset, nbytes, options, dbg);
+  }
+};
+
 class DbStressFSWrapper : public FileSystemWrapper {
  public:
   explicit DbStressFSWrapper(const std::shared_ptr<FileSystem>& t)
@@ -95,6 +244,17 @@ class DbStressFSWrapper : public FileSystemWrapper {
     return s;
   }
 
+  IOStatus NewWritableFile(const std::string& f, const FileOptions& file_opts,
+                           std::unique_ptr<FSWritableFile>* r,
+                           IODebugContext* dbg) override {
+    std::unique_ptr<FSWritableFile> file;
+    IOStatus s = target()->NewWritableFile(f, file_opts, &file, dbg);
+    if (s.ok()) {
+      r->reset(new DbStressWritableFileWrapper(std::move(file)));
+    }
+    return s;
+  }
+
   IOStatus DeleteFile(const std::string& f, const IOOptions& opts,
                       IODebugContext* dbg) override {
     // We determine whether it is a manifest file by searching a strong,