@nxtedition/rocksdb 6.0.1 → 6.0.2

package/deps/rocksdb/rocksdb/monitoring/perf_level.cc

@@ -9,11 +9,7 @@
 
 namespace ROCKSDB_NAMESPACE {
 
-#ifdef ROCKSDB_SUPPORT_THREAD_LOCAL
-__thread PerfLevel perf_level = kEnableCount;
-#else
-PerfLevel perf_level = kEnableCount;
-#endif
+thread_local PerfLevel perf_level = kEnableCount;
 
 void SetPerfLevel(PerfLevel level) {
   assert(level > kUninitialized);

package/deps/rocksdb/rocksdb/monitoring/perf_level_imp.h

@@ -9,10 +9,6 @@
 
 namespace ROCKSDB_NAMESPACE {
 
-#ifdef ROCKSDB_SUPPORT_THREAD_LOCAL
-extern __thread PerfLevel perf_level;
-#else
-extern PerfLevel perf_level;
-#endif
+extern thread_local PerfLevel perf_level;
 
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/monitoring/persistent_stats_history.cc

@@ -98,13 +98,13 @@ std::pair<uint64_t, std::string> parseKey(const Slice& key,
   std::string::size_type pos = key_str.find("#");
   // TODO(Zhongyi): add counters to track parse failures?
   if (pos == std::string::npos) {
-    result.first = port::kMaxUint64;
+    result.first = std::numeric_limits<uint64_t>::max();
     result.second.clear();
   } else {
     uint64_t parsed_time = ParseUint64(key_str.substr(0, pos));
     // skip entries with timestamp smaller than start_time
     if (parsed_time < start_time) {
-      result.first = port::kMaxUint64;
+      result.first = std::numeric_limits<uint64_t>::max();
       result.second = "";
     } else {
       result.first = parsed_time;

package/deps/rocksdb/rocksdb/monitoring/thread_status_updater.cc

@@ -16,7 +16,8 @@ namespace ROCKSDB_NAMESPACE {
 
 #ifdef ROCKSDB_USING_THREAD_STATUS
 
-__thread ThreadStatusData* ThreadStatusUpdater::thread_status_data_ = nullptr;
+thread_local ThreadStatusData* ThreadStatusUpdater::thread_status_data_ =
+    nullptr;
 
 void ThreadStatusUpdater::RegisterThread(ThreadStatus::ThreadType ttype,
                                          uint64_t thread_id) {

package/deps/rocksdb/rocksdb/monitoring/thread_status_updater.h

@@ -196,7 +196,7 @@ class ThreadStatusUpdater {
  protected:
 #ifdef ROCKSDB_USING_THREAD_STATUS
   // The thread-local variable for storing thread status.
-  static __thread ThreadStatusData* thread_status_data_;
+  static thread_local ThreadStatusData* thread_status_data_;
 
   // Returns the pointer to the thread status data only when the
   // thread status data is non-null and has enable_tracking == true.

package/deps/rocksdb/rocksdb/monitoring/thread_status_util.cc

@@ -12,9 +12,9 @@
 namespace ROCKSDB_NAMESPACE {
 
 #ifdef ROCKSDB_USING_THREAD_STATUS
-__thread ThreadStatusUpdater* ThreadStatusUtil::thread_updater_local_cache_ =
-    nullptr;
-__thread bool ThreadStatusUtil::thread_updater_initialized_ = false;
+thread_local ThreadStatusUpdater*
+    ThreadStatusUtil::thread_updater_local_cache_ = nullptr;
+thread_local bool ThreadStatusUtil::thread_updater_initialized_ = false;
 
 void ThreadStatusUtil::RegisterThread(const Env* env,
                                       ThreadStatus::ThreadType thread_type) {

package/deps/rocksdb/rocksdb/monitoring/thread_status_util.h

@@ -94,7 +94,7 @@ class ThreadStatusUtil {
   // When this variable is set to true, thread_updater_local_cache_
   // will not be updated until this variable is again set to false
   // in UnregisterThread().
-  static  __thread bool thread_updater_initialized_;
+  static thread_local bool thread_updater_initialized_;
 
   // The thread-local cached ThreadStatusUpdater that caches the
   // thread_status_updater_ of the first Env that uses any ThreadStatusUtil
@@ -109,7 +109,7 @@ class ThreadStatusUtil {
   // When thread_updater_initialized_ is set to true, this variable
   // will not be updated until this thread_updater_initialized_ is
   // again set to false in UnregisterThread().
-  static __thread ThreadStatusUpdater* thread_updater_local_cache_;
+  static thread_local ThreadStatusUpdater* thread_updater_local_cache_;
 #else
   static bool thread_updater_initialized_;
   static ThreadStatusUpdater* thread_updater_local_cache_;

package/deps/rocksdb/rocksdb/options/cf_options.cc

@@ -364,9 +364,10 @@ static std::unordered_map<std::string, OptionTypeInfo>
          OptionTypeInfo::Struct(
              "compaction_options_fifo", &fifo_compaction_options_type_info,
              offsetof(struct MutableCFOptions, compaction_options_fifo),
-             OptionVerificationType::kNormal, OptionTypeFlags::kMutable,
-             [](const ConfigOptions& opts, const std::string& name,
-                const std::string& value, void* addr) {
+             OptionVerificationType::kNormal, OptionTypeFlags::kMutable)
+             .SetParseFunc([](const ConfigOptions& opts,
+                              const std::string& name, const std::string& value,
+                              void* addr) {
                // This is to handle backward compatibility, where
                // compaction_options_fifo could be assigned a single scalar
                // value, say, like "23", which would be assigned to
@@ -556,30 +557,30 @@ static std::unordered_map<std::string, OptionTypeInfo>
         {"comparator",
          OptionTypeInfo::AsCustomRawPtr<const Comparator>(
              offsetof(struct ImmutableCFOptions, user_comparator),
-             OptionVerificationType::kByName, OptionTypeFlags::kCompareLoose,
-             // Serializes a Comparator
-             [](const ConfigOptions& opts, const std::string&, const void* addr,
-                std::string* value) {
-               // it's a const pointer of const Comparator*
-               const auto* ptr = static_cast<const Comparator* const*>(addr);
-
-               // Since the user-specified comparator will be wrapped by
-               // InternalKeyComparator, we should persist the user-specified
-               // one instead of InternalKeyComparator.
-               if (*ptr == nullptr) {
-                 *value = kNullptrString;
-               } else if (opts.mutable_options_only) {
-                 *value = "";
-               } else {
-                 const Comparator* root_comp = (*ptr)->GetRootComparator();
-                 if (root_comp == nullptr) {
-                   root_comp = (*ptr);
-                 }
-                 *value = root_comp->ToString(opts);
-               }
-               return Status::OK();
-             },
-             /* Use the default match function*/ nullptr)},
+             OptionVerificationType::kByName, OptionTypeFlags::kCompareLoose)
+             .SetSerializeFunc(
+                 // Serializes a Comparator
+                 [](const ConfigOptions& opts, const std::string&,
+                    const void* addr, std::string* value) {
+                   // it's a const pointer of const Comparator*
+                   const auto* ptr =
+                       static_cast<const Comparator* const*>(addr);
+                   // Since the user-specified comparator will be wrapped by
+                   // InternalKeyComparator, we should persist the
+                   // user-specified one instead of InternalKeyComparator.
+                   if (*ptr == nullptr) {
+                     *value = kNullptrString;
+                   } else if (opts.mutable_options_only) {
+                     *value = "";
+                   } else {
+                     const Comparator* root_comp = (*ptr)->GetRootComparator();
+                     if (root_comp == nullptr) {
+                       root_comp = (*ptr);
+                     }
+                     *value = root_comp->ToString(opts);
+                   }
+                   return Status::OK();
+                 })},
         {"memtable_insert_with_hint_prefix_extractor",
          OptionTypeInfo::AsCustomSharedPtr<const SliceTransform>(
              offsetof(struct ImmutableCFOptions,
@@ -595,10 +596,7 @@ static std::unordered_map<std::string, OptionTypeInfo>
             auto* shared =
                 static_cast<std::shared_ptr<MemTableRepFactory>*>(addr);
             Status s =
-                MemTableRepFactory::CreateFromString(opts, value, &factory);
-            if (factory && s.ok()) {
-              shared->reset(factory.release());
-            }
+                MemTableRepFactory::CreateFromString(opts, value, shared);
             return s;
           }}},
         {"memtable",
@@ -611,10 +609,7 @@ static std::unordered_map<std::string, OptionTypeInfo>
             auto* shared =
                 static_cast<std::shared_ptr<MemTableRepFactory>*>(addr);
             Status s =
-                MemTableRepFactory::CreateFromString(opts, value, &factory);
-            if (factory && s.ok()) {
-              shared->reset(factory.release());
-            }
+                MemTableRepFactory::CreateFromString(opts, value, shared);
             return s;
           }}},
         {"table_factory",
@@ -886,7 +881,7 @@ uint64_t MultiplyCheckOverflow(uint64_t op1, double op2) {
   if (op1 == 0 || op2 <= 0) {
     return 0;
   }
-  if (port::kMaxUint64 / op1 < op2) {
+  if (std::numeric_limits<uint64_t>::max() / op1 < op2) {
     return op1;
   }
   return static_cast<uint64_t>(op1 * op2);
@@ -915,8 +910,9 @@ size_t MaxFileSizeForL0MetaPin(const MutableCFOptions& cf_options) {
   // or a former larger `write_buffer_size` value to avoid surprising users with
   // pinned memory usage. We use a factor of 1.5 to account for overhead
   // introduced during flush in most cases.
-  if (port::kMaxSizet / 3 < cf_options.write_buffer_size / 2) {
-    return port::kMaxSizet;
+  if (std::numeric_limits<size_t>::max() / 3 <
+      cf_options.write_buffer_size / 2) {
+    return std::numeric_limits<size_t>::max();
   }
   return cf_options.write_buffer_size / 2 * 3;
 }

package/deps/rocksdb/rocksdb/options/configurable.cc

@@ -46,20 +46,10 @@ Status Configurable::PrepareOptions(const ConfigOptions& opts) {
     if (opt_iter.type_map != nullptr) {
       for (auto map_iter : *(opt_iter.type_map)) {
         auto& opt_info = map_iter.second;
-        if (!opt_info.IsDeprecated() && !opt_info.IsAlias() &&
-            opt_info.IsConfigurable()) {
-          if (!opt_info.IsEnabled(OptionTypeFlags::kDontPrepare)) {
-            Configurable* config =
-                opt_info.AsRawPointer<Configurable>(opt_iter.opt_ptr);
-            if (config != nullptr) {
-              status = config->PrepareOptions(opts);
-            } else if (!opt_info.CanBeNull()) {
-              status = Status::NotFound("Missing configurable object",
-                                        map_iter.first);
-            }
-            if (!status.ok()) {
-              return status;
-            }
+        if (opt_info.ShouldPrepare()) {
+          status = opt_info.Prepare(opts, map_iter.first, opt_iter.opt_ptr);
+          if (!status.ok()) {
+            return status;
           }
         }
       }
@@ -79,19 +69,11 @@ Status Configurable::ValidateOptions(const DBOptions& db_opts,
     if (opt_iter.type_map != nullptr) {
       for (auto map_iter : *(opt_iter.type_map)) {
         auto& opt_info = map_iter.second;
-        if (!opt_info.IsDeprecated() && !opt_info.IsAlias()) {
-          if (opt_info.IsConfigurable()) {
-            const Configurable* config =
-                opt_info.AsRawPointer<Configurable>(opt_iter.opt_ptr);
-            if (config != nullptr) {
-              status = config->ValidateOptions(db_opts, cf_opts);
-            } else if (!opt_info.CanBeNull()) {
-              status = Status::NotFound("Missing configurable object",
-                                        map_iter.first);
-            }
-            if (!status.ok()) {
-              return status;
-            }
+        if (opt_info.ShouldValidate()) {
+          status = opt_info.Validate(db_opts, cf_opts, map_iter.first,
+                                     opt_iter.opt_ptr);
+          if (!status.ok()) {
+            return status;
           }
         }
       }

package/deps/rocksdb/rocksdb/options/configurable_test.cc

@@ -173,7 +173,7 @@ TEST_F(ConfigurableTest, GetOptionsTest) {
   int i = 11;
   for (auto opt : {"", "shared.", "unique.", "pointer."}) {
     std::string value;
-    std::string expected = ToString(i);
+    std::string expected = std::to_string(i);
     std::string opt_name = opt;
     ASSERT_OK(
         simple->ConfigureOption(config_options_, opt_name + "int", expected));

package/deps/rocksdb/rocksdb/options/customizable.cc

@@ -76,7 +76,9 @@ bool Customizable::AreEquivalent(const ConfigOptions& config_options,
   if (config_options.sanity_level > ConfigOptions::kSanityLevelNone &&
       this != other) {
     const Customizable* custom = reinterpret_cast<const Customizable*>(other);
-    if (GetId() != custom->GetId()) {
+    if (custom == nullptr) {  // Cast failed
+      return false;
+    } else if (GetId() != custom->GetId()) {
       *mismatch = OptionTypeInfo::kIdPropName();
       return false;
     } else if (config_options.sanity_level >