@nxtedition/rocksdb 15.4.1 → 15.5.0

package/deps/rocksdb/rocksdb/util/math.h

@@ -41,7 +41,9 @@ inline T BottomNBits(T v, int nbits) {
 #endif
   // Newer compilers compile this down to bzhi on x86, but some older
   // ones don't, thus the need for the intrinsic above.
-  return static_cast<T>(v & ((T{1} << nbits) - 1));
+  using UnsignedT = std::make_unsigned_t<T>;
+  UnsignedT mask = (static_cast<UnsignedT>(1) << nbits) - 1;
+  return static_cast<T>(static_cast<UnsignedT>(v) & mask);
 }
 
 // Fast implementation of floor(log2(v)). Undefined for 0 or negative

package/deps/rocksdb/rocksdb/util/mutexlock.h

@@ -34,15 +34,15 @@ namespace ROCKSDB_NAMESPACE {
 
 class MutexLock {
  public:
-  explicit MutexLock(port::Mutex *mu) : mu_(mu) { this->mu_->Lock(); }
+  explicit MutexLock(port::Mutex* mu) : mu_(mu) { this->mu_->Lock(); }
   // No copying allowed
-  MutexLock(const MutexLock &) = delete;
-  void operator=(const MutexLock &) = delete;
+  MutexLock(const MutexLock&) = delete;
+  void operator=(const MutexLock&) = delete;
 
   ~MutexLock() { this->mu_->Unlock(); }
 
  private:
-  port::Mutex *const mu_;
+  port::Mutex* const mu_;
 };
 
 //
@@ -52,15 +52,15 @@ class MutexLock {
 //
 class ReadLock {
  public:
-  explicit ReadLock(port::RWMutex *mu) : mu_(mu) { this->mu_->ReadLock(); }
+  explicit ReadLock(port::RWMutex* mu) : mu_(mu) { this->mu_->ReadLock(); }
   // No copying allowed
-  ReadLock(const ReadLock &) = delete;
-  void operator=(const ReadLock &) = delete;
+  ReadLock(const ReadLock&) = delete;
+  void operator=(const ReadLock&) = delete;
 
   ~ReadLock() { this->mu_->ReadUnlock(); }
 
  private:
-  port::RWMutex *const mu_;
+  port::RWMutex* const mu_;
 };
 
 //
@@ -68,15 +68,15 @@ class ReadLock {
 //
 class ReadUnlock {
  public:
-  explicit ReadUnlock(port::RWMutex *mu) : mu_(mu) { mu->AssertHeld(); }
+  explicit ReadUnlock(port::RWMutex* mu) : mu_(mu) { mu->AssertHeld(); }
   // No copying allowed
-  ReadUnlock(const ReadUnlock &) = delete;
-  ReadUnlock &operator=(const ReadUnlock &) = delete;
+  ReadUnlock(const ReadUnlock&) = delete;
+  ReadUnlock& operator=(const ReadUnlock&) = delete;
 
   ~ReadUnlock() { mu_->ReadUnlock(); }
 
  private:
-  port::RWMutex *const mu_;
+  port::RWMutex* const mu_;
 };
 
 //
@@ -86,15 +86,15 @@ class ReadUnlock {
 //
 class WriteLock {
  public:
-  explicit WriteLock(port::RWMutex *mu) : mu_(mu) { this->mu_->WriteLock(); }
+  explicit WriteLock(port::RWMutex* mu) : mu_(mu) { this->mu_->WriteLock(); }
   // No copying allowed
-  WriteLock(const WriteLock &) = delete;
-  void operator=(const WriteLock &) = delete;
+  WriteLock(const WriteLock&) = delete;
+  void operator=(const WriteLock&) = delete;
 
   ~WriteLock() { this->mu_->WriteUnlock(); }
 
  private:
-  port::RWMutex *const mu_;
+  port::RWMutex* const mu_;
 };
 
 //
@@ -145,12 +145,12 @@ struct ALIGN_AS(CACHE_LINE_SIZE) CacheAlignedWrapper {
 template <class T>
 struct Unwrap {
   using type = T;
-  static type &Go(T &t) { return t; }
+  static type& Go(T& t) { return t; }
 };
 template <class T>
 struct Unwrap<CacheAlignedWrapper<T>> {
   using type = T;
-  static type &Go(CacheAlignedWrapper<T> &t) { return t.obj_; }
+  static type& Go(CacheAlignedWrapper<T>& t) { return t.obj_; }
 };
 
 //
@@ -169,7 +169,7 @@ class Striped {
       : stripe_count_(stripe_count), data_(new T[stripe_count]) {}
 
   using Unwrapped = typename Unwrap<T>::type;
-  Unwrapped &Get(const Key &key, uint64_t seed = 0) {
+  Unwrapped& Get(const Key& key, uint64_t seed = 0) {
     size_t index = FastRangeGeneric(hash_(key, seed), stripe_count_);
     return Unwrap<T>::Go(data_[index]);
   }

package/deps/rocksdb/rocksdb/util/ribbon_alg.h

@@ -545,10 +545,10 @@ namespace ribbon {
 // solution satisfying all the cr@start -> rr entries added.
 template <bool kFirstCoeffAlwaysOne, typename BandingStorage,
           typename BacktrackStorage>
-bool BandingAdd(BandingStorage *bs, typename BandingStorage::Index start,
+bool BandingAdd(BandingStorage* bs, typename BandingStorage::Index start,
                 typename BandingStorage::ResultRow rr,
-                typename BandingStorage::CoeffRow cr, BacktrackStorage *bts,
-                typename BandingStorage::Index *backtrack_pos) {
+                typename BandingStorage::CoeffRow cr, BacktrackStorage* bts,
+                typename BandingStorage::Index* backtrack_pos) {
   using CoeffRow = typename BandingStorage::CoeffRow;
   using ResultRow = typename BandingStorage::ResultRow;
   using Index = typename BandingStorage::Index;
@@ -608,8 +608,8 @@ bool BandingAdd(BandingStorage *bs, typename BandingStorage::Index start,
 //
 template <typename BandingStorage, typename BacktrackStorage,
           typename BandingHasher, typename InputIterator>
-bool BandingAddRange(BandingStorage *bs, BacktrackStorage *bts,
-                     const BandingHasher &bh, InputIterator begin,
+bool BandingAddRange(BandingStorage* bs, BacktrackStorage* bts,
+                     const BandingHasher& bh, InputIterator begin,
                      InputIterator end) {
   using CoeffRow = typename BandingStorage::CoeffRow;
   using Index = typename BandingStorage::Index;
@@ -703,7 +703,7 @@ bool BandingAddRange(BandingStorage *bs, BacktrackStorage *bts,
 //
 template <typename BandingStorage, typename BandingHasher,
           typename InputIterator>
-bool BandingAddRange(BandingStorage *bs, const BandingHasher &bh,
+bool BandingAddRange(BandingStorage* bs, const BandingHasher& bh,
                      InputIterator begin, InputIterator end) {
   using Index = typename BandingStorage::Index;
   struct NoopBacktrackStorage {
@@ -754,7 +754,7 @@ bool BandingAddRange(BandingStorage *bs, const BandingHasher &bh,
 // Back-substitution for generating a solution from BandingStorage to
 // SimpleSolutionStorage.
 template <typename SimpleSolutionStorage, typename BandingStorage>
-void SimpleBackSubst(SimpleSolutionStorage *sss, const BandingStorage &bs) {
+void SimpleBackSubst(SimpleSolutionStorage* sss, const BandingStorage& bs) {
   using CoeffRow = typename BandingStorage::CoeffRow;
   using Index = typename BandingStorage::Index;
   using ResultRow = typename BandingStorage::ResultRow;
@@ -815,7 +815,7 @@ template <typename SimpleSolutionStorage>
 typename SimpleSolutionStorage::ResultRow SimpleQueryHelper(
     typename SimpleSolutionStorage::Index start_slot,
     typename SimpleSolutionStorage::CoeffRow cr,
-    const SimpleSolutionStorage &sss) {
+    const SimpleSolutionStorage& sss) {
   using CoeffRow = typename SimpleSolutionStorage::CoeffRow;
   using ResultRow = typename SimpleSolutionStorage::ResultRow;
 
@@ -833,8 +833,8 @@ typename SimpleSolutionStorage::ResultRow SimpleQueryHelper(
 // General PHSF query a key from SimpleSolutionStorage.
 template <typename SimpleSolutionStorage, typename PhsfQueryHasher>
 typename SimpleSolutionStorage::ResultRow SimplePhsfQuery(
-    const typename PhsfQueryHasher::Key &key, const PhsfQueryHasher &hasher,
-    const SimpleSolutionStorage &sss) {
+    const typename PhsfQueryHasher::Key& key, const PhsfQueryHasher& hasher,
+    const SimpleSolutionStorage& sss) {
   const typename PhsfQueryHasher::Hash hash = hasher.GetHash(key);
 
   static_assert(sizeof(typename SimpleSolutionStorage::Index) ==
@@ -850,9 +850,9 @@ typename SimpleSolutionStorage::ResultRow SimplePhsfQuery(
 
 // Filter query a key from SimpleSolutionStorage.
 template <typename SimpleSolutionStorage, typename FilterQueryHasher>
-bool SimpleFilterQuery(const typename FilterQueryHasher::Key &key,
-                       const FilterQueryHasher &hasher,
-                       const SimpleSolutionStorage &sss) {
+bool SimpleFilterQuery(const typename FilterQueryHasher::Key& key,
+                       const FilterQueryHasher& hasher,
+                       const SimpleSolutionStorage& sss) {
   const typename FilterQueryHasher::Hash hash = hasher.GetHash(key);
   const typename SimpleSolutionStorage::ResultRow expected =
       hasher.GetResultRowFromHash(hash);
@@ -968,9 +968,9 @@ bool SimpleFilterQuery(const typename FilterQueryHasher::Key &key,
 
 // A helper for InterleavedBackSubst.
 template <typename BandingStorage>
-inline void BackSubstBlock(typename BandingStorage::CoeffRow *state,
+inline void BackSubstBlock(typename BandingStorage::CoeffRow* state,
                            typename BandingStorage::Index num_columns,
-                           const BandingStorage &bs,
+                           const BandingStorage& bs,
                            typename BandingStorage::Index start_slot) {
   using CoeffRow = typename BandingStorage::CoeffRow;
   using Index = typename BandingStorage::Index;
@@ -1004,8 +1004,8 @@ inline void BackSubstBlock(typename BandingStorage::CoeffRow *state,
 // Back-substitution for generating a solution from BandingStorage to
 // InterleavedSolutionStorage.
 template <typename InterleavedSolutionStorage, typename BandingStorage>
-void InterleavedBackSubst(InterleavedSolutionStorage *iss,
-                          const BandingStorage &bs) {
+void InterleavedBackSubst(InterleavedSolutionStorage* iss,
+                          const BandingStorage& bs) {
   using CoeffRow = typename BandingStorage::CoeffRow;
   using Index = typename BandingStorage::Index;
 
@@ -1084,12 +1084,12 @@ void InterleavedBackSubst(InterleavedSolutionStorage *iss,
 // Prefetch memory for a key in InterleavedSolutionStorage.
 template <typename InterleavedSolutionStorage, typename PhsfQueryHasher>
 inline void InterleavedPrepareQuery(
-    const typename PhsfQueryHasher::Key &key, const PhsfQueryHasher &hasher,
-    const InterleavedSolutionStorage &iss,
-    typename PhsfQueryHasher::Hash *saved_hash,
-    typename InterleavedSolutionStorage::Index *saved_segment_num,
-    typename InterleavedSolutionStorage::Index *saved_num_columns,
-    typename InterleavedSolutionStorage::Index *saved_start_bit) {
+    const typename PhsfQueryHasher::Key& key, const PhsfQueryHasher& hasher,
+    const InterleavedSolutionStorage& iss,
+    typename PhsfQueryHasher::Hash* saved_hash,
+    typename InterleavedSolutionStorage::Index* saved_segment_num,
+    typename InterleavedSolutionStorage::Index* saved_num_columns,
+    typename InterleavedSolutionStorage::Index* saved_start_bit) {
   using Hash = typename PhsfQueryHasher::Hash;
   using CoeffRow = typename InterleavedSolutionStorage::CoeffRow;
   using Index = typename InterleavedSolutionStorage::Index;
@@ -1131,7 +1131,7 @@ inline typename InterleavedSolutionStorage::ResultRow InterleavedPhsfQuery(
     typename InterleavedSolutionStorage::Index segment_num,
     typename InterleavedSolutionStorage::Index num_columns,
     typename InterleavedSolutionStorage::Index start_bit,
-    const PhsfQueryHasher &hasher, const InterleavedSolutionStorage &iss) {
+    const PhsfQueryHasher& hasher, const InterleavedSolutionStorage& iss) {
   using CoeffRow = typename InterleavedSolutionStorage::CoeffRow;
   using Index = typename InterleavedSolutionStorage::Index;
   using ResultRow = typename InterleavedSolutionStorage::ResultRow;
@@ -1170,7 +1170,7 @@ inline bool InterleavedFilterQuery(
     typename InterleavedSolutionStorage::Index segment_num,
     typename InterleavedSolutionStorage::Index num_columns,
     typename InterleavedSolutionStorage::Index start_bit,
-    const FilterQueryHasher &hasher, const InterleavedSolutionStorage &iss) {
+    const FilterQueryHasher& hasher, const InterleavedSolutionStorage& iss) {
   using CoeffRow = typename InterleavedSolutionStorage::CoeffRow;
   using Index = typename InterleavedSolutionStorage::Index;
   using ResultRow = typename InterleavedSolutionStorage::ResultRow;

package/deps/rocksdb/rocksdb/util/simple_mixed_compressor.cc

@@ -15,8 +15,7 @@
 namespace ROCKSDB_NAMESPACE {
 
 // MultiCompressorWrapper implementation
-MultiCompressorWrapper::MultiCompressorWrapper(const CompressionOptions& opts,
-                                               CompressionDict&& dict)
+MultiCompressorWrapper::MultiCompressorWrapper(const CompressionOptions& opts)
     : opts_(opts) {
   // TODO: make the compression manager a field
   auto builtInManager = GetBuiltinV2CompressionManager();
@@ -27,12 +26,11 @@ MultiCompressorWrapper::MultiCompressorWrapper(const CompressionOptions& opts,
     }
     compressors_.push_back(builtInManager->GetCompressor(opts, type));
   }
-  (void)dict;
 }
 
-size_t MultiCompressorWrapper::GetMaxSampleSizeIfWantDict(
+Compressor::DictConfig MultiCompressorWrapper::GetDictGuidance(
     CacheEntryRole block_type) const {
-  return compressors_.back()->GetMaxSampleSizeIfWantDict(block_type);
+  return compressors_.back()->GetDictGuidance(block_type);
 }
 
 Slice MultiCompressorWrapper::GetSerializedDict() const {
@@ -48,11 +46,11 @@ Compressor::ManagedWorkingArea MultiCompressorWrapper::ObtainWorkingArea() {
 }
 
 std::unique_ptr<Compressor> MultiCompressorWrapper::MaybeCloneSpecialized(
-    CacheEntryRole block_type, DictSampleArgs&& dict_samples) const {
+    CacheEntryRole block_type, DictConfigArgs&& dict_config) const {
   // TODO: full dictionary compression support. Currently this just falls
   // back on a non-multi compressor when asked to use a dictionary.
   return compressors_.back()->MaybeCloneSpecialized(block_type,
-                                                    std::move(dict_samples));
+                                                    std::move(dict_config));
 }
 
 // RandomMixedCompressor implementation

package/deps/rocksdb/rocksdb/util/simple_mixed_compressor.h

@@ -10,22 +10,21 @@
 #include <memory>
 #include <vector>
 
-#include "compression.h"
 #include "rocksdb/advanced_compression.h"
+#include "util/atomic.h"
 
 namespace ROCKSDB_NAMESPACE {
 
 class MultiCompressorWrapper : public Compressor {
  public:
-  explicit MultiCompressorWrapper(const CompressionOptions& opts,
-                                  CompressionDict&& dict = {});
+  explicit MultiCompressorWrapper(const CompressionOptions& opts);
 
-  size_t GetMaxSampleSizeIfWantDict(CacheEntryRole block_type) const override;
+  DictConfig GetDictGuidance(CacheEntryRole block_type) const override;
   Slice GetSerializedDict() const override;
   CompressionType GetPreferredCompressionType() const override;
   ManagedWorkingArea ObtainWorkingArea() override;
   std::unique_ptr<Compressor> MaybeCloneSpecialized(
-      CacheEntryRole block_type, DictSampleArgs&& dict_samples) const override;
+      CacheEntryRole block_type, DictConfigArgs&& dict_config) const override;
 
  protected:
   const CompressionOptions opts_;

package/deps/rocksdb/rocksdb/util/slice.cc

@@ -61,10 +61,6 @@ class FixedPrefixTransform : public SliceTransform {
     return (src.size() >= prefix_len_);
   }
 
-  bool InRange(const Slice& dst) const override {
-    return (dst.size() == prefix_len_);
-  }
-
   bool FullLengthEnabled(size_t* len) const override {
     *len = prefix_len_;
     return true;
@@ -111,10 +107,6 @@ class CappedPrefixTransform : public SliceTransform {
 
   bool InDomain(const Slice& /*src*/) const override { return true; }
 
-  bool InRange(const Slice& dst) const override {
-    return (dst.size() <= cap_len_);
-  }
-
   bool FullLengthEnabled(size_t* len) const override {
     *len = cap_len_;
     return true;
@@ -136,8 +128,6 @@ class NoopTransform : public SliceTransform {
 
   bool InDomain(const Slice& /*src*/) const override { return true; }
 
-  bool InRange(const Slice& /*dst*/) const override { return true; }
-
   bool SameResultWhenAppended(const Slice& /*prefix*/) const override {
     return false;
   }

package/deps/rocksdb/rocksdb/util/slice_test.cc

@@ -590,7 +590,7 @@ TEST(BitFieldsTest, BitFields) {
     ASSERT_EQ(after.Get<Field5>(), 0U);
   }
   {
-    AcqRelBitFieldsAtomic<MyState> acqrel{state};
+    BitFieldsAtomic<MyState> acqrel{state};
     ASSERT_EQ(state, acqrel.Load());
     acqrel.Store(state2);
     ASSERT_EQ(state2, acqrel.Load());
@@ -622,6 +622,29 @@ TEST(BitFieldsTest, BitFields) {
     ASSERT_EQ(after.Get<Field3>(), true);
     ASSERT_EQ(state.Get<Field4>(), 3U);
 
+    auto transform2a = Field2::And(true) + Field3::And(false);
+    acqrel.Apply(transform2a, &before, &after);
+    ASSERT_EQ(after.Get<Field2>(), true);
+    ASSERT_EQ(after.Get<Field3>(), false);
+
+    auto transform2b = Field2::And(false) + Field3::And(true);
+    acqrel.Apply(transform2b, &before, &after);
+    ASSERT_EQ(after.Get<Field2>(), false);
+    ASSERT_EQ(after.Get<Field3>(), false);
+
+    auto transform2c = Field2::Or(true) + Field3::Or(false);
+    acqrel.Apply(transform2c, &before, &after);
+    ASSERT_EQ(after.Get<Field2>(), true);
+    ASSERT_EQ(after.Get<Field3>(), false);
+
+    auto transform2d = Field2::Or(false) + Field3::Or(true);
+    acqrel.Apply(transform2d, &before, &after);
+    ASSERT_EQ(after.Get<Field2>(), true);
+    ASSERT_EQ(after.Get<Field3>(), true);
+
+    ASSERT_EQ(state.Get<Field1>(), 45U);
+    ASSERT_EQ(state.Get<Field4>(), 3U);
+
     auto transform3 = Field1::PlusTransformPromiseNoOverflow(10000U) +
                       Field4::MinusTransformPromiseNoUnderflow(3U);
     acqrel.Apply(transform3, &before, &after);
@@ -636,6 +659,17 @@ TEST(BitFieldsTest, BitFields) {
     ASSERT_EQ(after.Get<Field1>(), 9046U);
     ASSERT_EQ(after.Get<Field4>(), 31U);
 
+    auto transform4a =
+        Field1::AndTransform(8192U + 4096U) + Field4::AndTransform(15U);
+    acqrel.Apply(transform4a, &before, &after);
+    ASSERT_EQ(after.Get<Field1>(), 8192U);
+    ASSERT_EQ(after.Get<Field4>(), 15U);
+
+    auto transform4b = Field1::OrTransform(127U) + Field4::OrTransform(16U);
+    acqrel.Apply(transform4b, &before, &after);
+    ASSERT_EQ(after.Get<Field1>(), 8192U + 127U);
+    ASSERT_EQ(after.Get<Field4>(), 31U);
+
     // Unmodified
     ASSERT_EQ(after.Get<Field2>(), true);
     ASSERT_EQ(after.Get<Field3>(), true);

package/deps/rocksdb/rocksdb/util/slice_transform_test.cc

@@ -49,7 +49,7 @@ class SliceTransformDBTest : public testing::Test {
  private:
   std::string dbname_;
   Env* env_;
-  DB* db_;
+  std::unique_ptr<DB> db_;
 
  public:
   SliceTransformDBTest() : env_(Env::Default()), db_(nullptr) {
@@ -58,11 +58,11 @@ class SliceTransformDBTest : public testing::Test {
   }
 
   ~SliceTransformDBTest() override {
-    delete db_;
+    db_.reset();
     EXPECT_OK(DestroyDB(dbname_, last_options_));
   }
 
-  DB* db() { return db_; }
+  DB* db() { return db_.get(); }
 
   // Return the current option configuration.
   Options* GetOptions() { return &last_options_; }
@@ -74,14 +74,12 @@ class SliceTransformDBTest : public testing::Test {
   }
 
   void Destroy() {
-    delete db_;
-    db_ = nullptr;
+    db_.reset();
     ASSERT_OK(DestroyDB(dbname_, last_options_));
   }
 
   Status TryReopen() {
-    delete db_;
-    db_ = nullptr;
+    db_.reset();
     last_options_.create_if_missing = true;
 
     return DB::Open(last_options_, dbname_, &db_);

package/deps/rocksdb/rocksdb/util/status.cc

@@ -46,7 +46,9 @@ static const char* msgs[static_cast<int>(Status::kMaxSubCode)] = {
     "IO fenced off",          // kIOFenced
     "Merge operator failed",  // kMergeOperatorFailed
     "Number of operands merged exceeded threshold",  // kMergeOperandThresholdExceeded
-    "MultiScan reached file prefetch limit",         // kMultiScanPrefetchLimit
+    "MultiScan reached file prefetch limit",         // kPrefetchLimitReached
+    "Not expected code path",                        // kNotExpectedCodePath
+    "All compactions aborted",                       // kCompactionAborted
 };
 
 Status::Status(Code _code, SubCode _subcode, const Slice& msg,

package/deps/rocksdb/rocksdb/util/stop_watch.h

@@ -112,6 +112,7 @@ class StopWatchNano {
     }
   }
   void Start() {
+    assert(clock_);
     if constexpr (use_cpu_time) {
       start_ = clock_->CPUNanos();
     } else {
@@ -119,6 +120,7 @@ class StopWatchNano {
     }
   }
   uint64_t ElapsedNanos(bool reset = false) {
+    assert(clock_);
     uint64_t now = 0;
     if constexpr (use_cpu_time) {
       now = clock_->CPUNanos();

package/deps/rocksdb/rocksdb/utilities/backup/backup_engine.cc

@@ -1886,7 +1886,10 @@ void BackupEngineImpl::SetBackupInfoFromBackupMeta(
       finfo.directory = dir;
       uint64_t number;
       FileType type;
-      bool ok = ParseFileName(file_ptr->filename, &number, &type);
+      // file_ptr->filename may contain directory components (e.g.
+      // "private/1/000008.log"). ParseFileName expects a bare filename,
+      // so use GetDbFileName() to extract it.
+      bool ok = ParseFileName(file_ptr->GetDbFileName(), &number, &type);
       if (ok) {
         finfo.file_number = number;
         finfo.file_type = type;