@nxtedition/rocksdb 13.5.13 → 15.0.1

package/deps/rocksdb/rocksdb/util/compression.h

@@ -34,6 +34,7 @@
 #include "util/string_util.h"
 
 #ifdef SNAPPY
+#include <snappy-sinksource.h>
 #include <snappy.h>
 #endif
 
@@ -48,10 +49,14 @@
 #if defined(LZ4)
 #include <lz4.h>
 #include <lz4hc.h>
+#if LZ4_VERSION_NUMBER < 10700  // < r129
+#error "LZ4 support requires version >= 1.7.0 (lz4-devel)"
+#endif
 #endif
 
 #ifdef ZSTD
 #include <zstd.h>
+#include <zstd_errors.h>
 // ZSTD_Compress2(), ZSTD_compressStream2() and frame parameters all belong to
 // advanced APIs and require v1.4.0+, which is from April 2019.
 // https://github.com/facebook/zstd/blob/eb9f881eb810f2242f1ef36b3f3e7014eecb8fa6/lib/zstd.h#L297C40-L297C45

package/deps/rocksdb/rocksdb/util/compression_test.cc

@@ -1102,8 +1102,8 @@ TEST_F(DBCompressionTest, CompressionManagerWrapper) {
     using CompressorWrapper::CompressorWrapper;
     const char* Name() const override { return "MyCompressor"; }
 
-    Status CompressBlock(Slice uncompressed_data,
-                         std::string* compressed_output,
+    Status CompressBlock(Slice uncompressed_data, char* compressed_output,
+                         size_t* compressed_output_size,
                          CompressionType* out_compression_type,
                          ManagedWorkingArea* working_area) override {
       auto begin = uncompressed_data.data();
@@ -1111,16 +1111,18 @@ TEST_F(DBCompressionTest, CompressionManagerWrapper) {
       if (std::search(begin, end, kDoNotCompress.begin(),
                       kDoNotCompress.end()) != end) {
         // Do not attempt compression
+        *compressed_output_size = 0;
         EXPECT_EQ(*out_compression_type, kNoCompression);
         return Status::OK();
       } else if (std::search(begin, end, kRejectCompression.begin(),
                              kRejectCompression.end()) != end) {
         // Simulate attempted & rejected compression
-        *compressed_output = "blah";
+        *compressed_output_size = 1;
         EXPECT_EQ(*out_compression_type, kNoCompression);
         return Status::OK();
       } else {
         return wrapped_->CompressBlock(uncompressed_data, compressed_output,
+                                       compressed_output_size,
                                        out_compression_type, working_area);
       }
     }

package/deps/rocksdb/rocksdb/util/dynamic_bloom.cc

@@ -62,9 +62,9 @@ DynamicBloom::DynamicBloom(Allocator* allocator, uint32_t total_bits,
     // Align on block_bytes boundary
     raw += block_bytes - block_offset;
   }
-  static_assert(sizeof(std::atomic<uint64_t>) == sizeof(uint64_t),
+  static_assert(sizeof(RelaxedAtomic<uint64_t>) == sizeof(uint64_t),
                 "Expecting zero-space-overhead atomic");
-  data_ = reinterpret_cast<std::atomic<uint64_t>*>(raw);
+  data_ = reinterpret_cast<RelaxedAtomic<uint64_t>*>(raw);
 }
 
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/util/dynamic_bloom.h

@@ -7,12 +7,10 @@
 
 #include <array>
 #include <atomic>
-#include <memory>
-#include <string>
 
-#include "port/port.h"
 #include "rocksdb/slice.h"
 #include "table/multiget_context.h"
+#include "util/atomic.h"
 #include "util/hash.h"
 
 namespace ROCKSDB_NAMESPACE {
@@ -50,16 +48,20 @@ class DynamicBloom {
 
   ~DynamicBloom() {}
 
-  // Assuming single threaded access to this function.
+  // Assuming single thread adding to the DynamicBloom
   void Add(const Slice& key);
 
-  // Like Add, but may be called concurrent with other functions.
+  // Like Add, but may be called concurrently with other functions. Does not
+  // establish happens-before relationship with other functions so requires some
+  // external mechanism to ensure other threads can see the change.
   void AddConcurrently(const Slice& key);
 
   // Assuming single threaded access to this function.
   void AddHash(uint32_t hash);
 
-  // Like AddHash, but may be called concurrent with other functions.
+  // Like AddHash, but may be called concurrently with other functions. Does not
+  // establish happens-before relationship with other functions so requires some
+  // external mechanism to ensure other threads can see the change.
   void AddHashConcurrently(uint32_t hash);
 
   // Multithreaded access to this function is OK
@@ -80,7 +82,7 @@ class DynamicBloom {
   // this stores k/2, the number of words to double-probe.
   const uint32_t kNumDoubleProbes;
 
-  std::atomic<uint64_t>* data_;
+  RelaxedAtomic<uint64_t>* data_;
 
   // or_func(ptr, mask) should effect *ptr |= mask with the appropriate
   // concurrency safety, working with bytes.
@@ -97,21 +99,20 @@ inline void DynamicBloom::AddConcurrently(const Slice& key) {
 }
 
 inline void DynamicBloom::AddHash(uint32_t hash) {
-  AddHash(hash, [](std::atomic<uint64_t>* ptr, uint64_t mask) {
-    ptr->store(ptr->load(std::memory_order_relaxed) | mask,
-               std::memory_order_relaxed);
+  AddHash(hash, [](RelaxedAtomic<uint64_t>* ptr, uint64_t mask) {
+    ptr->StoreRelaxed(ptr->LoadRelaxed() | mask);
   });
 }
 
 inline void DynamicBloom::AddHashConcurrently(uint32_t hash) {
-  AddHash(hash, [](std::atomic<uint64_t>* ptr, uint64_t mask) {
+  AddHash(hash, [](RelaxedAtomic<uint64_t>* ptr, uint64_t mask) {
     // Happens-before between AddHash and MaybeContains is handled by
     // access to versions_->LastSequence(), so all we have to do here is
     // avoid races (so we don't give the compiler a license to mess up
     // our code) and not lose bits.  std::memory_order_relaxed is enough
     // for that.
-    if ((mask & ptr->load(std::memory_order_relaxed)) != mask) {
-      ptr->fetch_or(mask, std::memory_order_relaxed);
+    if ((mask & ptr->LoadRelaxed()) != mask) {
+      ptr->FetchOrRelaxed(mask);
     }
   });
 }
@@ -183,7 +184,7 @@ inline bool DynamicBloom::DoubleProbe(uint32_t h32, size_t byte_offset) const {
     // Two bit probes per uint64_t probe
     uint64_t mask =
         ((uint64_t)1 << (h & 63)) | ((uint64_t)1 << ((h >> 6) & 63));
-    uint64_t val = data_[byte_offset ^ i].load(std::memory_order_relaxed);
+    uint64_t val = data_[byte_offset ^ i].LoadRelaxed();
     if (i + 1 >= kNumDoubleProbes) {
       return (val & mask) == mask;
     } else if ((val & mask) != mask) {

package/deps/rocksdb/rocksdb/util/interval_test.cc

@@ -0,0 +1,102 @@
+//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
+//  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/db_test_util.h"
+#include "rocksdb/data_structure.h"
+#include "rocksdb/slice.h"
+
+namespace ROCKSDB_NAMESPACE {
+
+class IntervalSetTest : public testing::Test {};
+
+TEST_F(IntervalSetTest, BasicTest) {
+  IntervalSet<int> set;
+  set.insert({2, 15});
+  EXPECT_EQ(set.size(), 1);
+  set.insert({5, 9});
+  EXPECT_EQ(set.size(), 1);
+  set.insert({0, 10});
+  EXPECT_EQ(set.size(), 1);
+  set.insert({25, 30});
+  EXPECT_EQ(set.size(), 2);
+  set.insert({16, 25});
+  EXPECT_EQ(set.size(), 2);
+  set.insert({45, 85});
+  ASSERT_EQ(set.size(), 3);
+  auto iter = set.begin();
+  ASSERT_EQ(*iter, Interval<int>(0, 15));
+  iter++;
+  ASSERT_EQ(*iter, Interval<int>(16, 30));
+  iter++;
+  ASSERT_EQ(*iter, Interval<int>(45, 85));
+  set.insert({31});
+  iter = set.begin();
+  ASSERT_EQ(*iter, Interval<int>(0, 15));
+  iter++;
+  ASSERT_EQ(*iter, Interval<int>(16, 30));
+  iter++;
+  ASSERT_EQ(*iter, Interval<int>(31));
+}
+
+TEST_F(IntervalSetTest, SliceTest) {
+  IntervalSet<Slice, Comparator> set(BytewiseComparator());
+  EXPECT_TRUE(set.insert("k00", "k10"));
+  // Should do nothing
+  EXPECT_TRUE(set.insert("k02", "k08"));
+  auto iter = set.begin();
+  ASSERT_EQ(iter->start().ToString(), "k00");
+  ASSERT_EQ(iter->end().ToString(), "k10");
+  ASSERT_EQ(set.size(), 1);
+  iter++;
+  ASSERT_EQ(iter, set.end());
+  EXPECT_TRUE(set.insert("k15", "k20"));
+  EXPECT_TRUE(set.insert("k16"));
+  ASSERT_EQ(set.size(), 2);
+  iter = set.begin();
+  ASSERT_EQ(iter->start().ToString(), "k00");
+  ASSERT_EQ(iter->end().ToString(), "k10");
+  iter++;
+  ASSERT_EQ(iter->start().ToString(), "k15");
+  ASSERT_EQ(iter->has_end(), false);
+  //
+}
+
+TEST_F(IntervalSetTest, PropModeTest) {
+  IntervalSet<Slice, Comparator> set(BytewiseComparator(), true);
+  EXPECT_TRUE(set.insert("k00", "k10"));
+  // Should do nothing
+  EXPECT_FALSE(set.insert("k02", "k08"));
+  EXPECT_EQ(set.size(), 1);
+  EXPECT_TRUE(set.insert("k15", "k20"));
+  EXPECT_EQ(set.size(), 2);
+  EXPECT_FALSE(set.insert("k16"));
+  ASSERT_EQ(set.size(), 2);
+  auto iter = set.begin();
+  ASSERT_EQ(iter->start().ToString(), "k00");
+  ASSERT_EQ(iter->end().ToString(), "k10");
+  iter++;
+  ASSERT_EQ(iter->start().ToString(), "k15");
+  ASSERT_EQ(iter->end().ToString(), "k20");
+  EXPECT_TRUE(set.insert("k12", "k14"));
+  iter = set.begin();
+  ASSERT_EQ(set.size(), 3);
+  ASSERT_EQ(iter->start().ToString(), "k00");
+  ASSERT_EQ(iter->end().ToString(), "k10");
+  iter++;
+  ASSERT_EQ(iter->start().ToString(), "k12");
+  ASSERT_EQ(iter->end().ToString(), "k14");
+  iter++;
+  ASSERT_EQ(iter->start().ToString(), "k15");
+  ASSERT_EQ(iter->end().ToString(), "k20");
+}
+
+}  // 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/util/semaphore.h

@@ -0,0 +1,164 @@
+//  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 <cassert>
+#include <condition_variable>
+#include <mutex>
+#ifdef ROCKSDB_USE_STD_SEMAPHORES
+#include <semaphore>
+#endif
+
+#include "port/port.h"
+#include "rocksdb/rocksdb_namespace.h"
+
+namespace ROCKSDB_NAMESPACE {
+
+// Wrapper providing a chosen counting semaphore implementation. The default
+// implementation based on a mutex and condvar unfortunately can result in
+// Release() temporarily waiting on another thread to make progress (if that
+// other thread is preempted while holding the mutex), but that should be rare.
+// However, alternative implementations may have correctness issues or even
+// worse performance. See std::counting_semaphore for general contract.
+//
+// NOTE1: std::counting_semaphore is known to be buggy on many std library
+// implementations, so be cautious about enabling it. Reportedly, an acquire()
+// can falsely block indefinitely. And we can't easily work around that with
+// try_acquire_for because another common bug has that function consistently
+// sleeping for the entire timeout duration even if a release() happens earlier.
+// Therefore, using std::counting_semaphore/binary_semaphore is strictly opt-in
+// for now.
+//
+// NOTE2: Also tried wrapping folly::fibers::Semaphore here but it was not as
+// efficient (for parallel compression) as even the mutex+condvar version.
+class ALIGN_AS(CACHE_LINE_SIZE) CountingSemaphore {
+ public:
+  explicit CountingSemaphore(std::ptrdiff_t starting_count)
+#ifdef ROCKSDB_USE_STD_SEMAPHORES
+      : sem_(starting_count)
+#else
+      : count_(static_cast<int32_t>(starting_count))
+#endif  // ROCKSDB_USE_STD_SEMAPHORES
+  {
+    assert(starting_count >= 0);
+    assert(starting_count <= INT32_MAX);
+  }
+  void Acquire() {
+#ifdef ROCKSDB_USE_STD_SEMAPHORES
+    sem_.acquire();
+#else
+    std::unique_lock<std::mutex> lock(mutex_);
+    assert(count_ >= 0);
+    cv_.wait(lock, [this] { return count_ > 0; });
+    --count_;
+#endif  // ROCKSDB_USE_STD_SEMAPHORES
+  }
+  bool TryAcquire() {
+#ifdef ROCKSDB_USE_STD_SEMAPHORES
+    return sem_.try_acquire();
+#else
+    std::unique_lock<std::mutex> lock(mutex_);
+    assert(count_ >= 0);
+    if (count_ == 0) {
+      return false;
+    } else {
+      --count_;
+      return true;
+    }
+#endif  // ROCKSDB_USE_STD_SEMAPHORES
+  }
+  void Release(std::ptrdiff_t n = 1) {
+#ifdef ROCKSDB_USE_STD_SEMAPHORES
+    sem_.release(n);
+#else
+    assert(n >= 0);
+    assert(n <= INT32_MAX);
+    if (n > 0) {
+      std::unique_lock<std::mutex> lock(mutex_);
+      assert(count_ >= 0);
+      count_ += static_cast<int32_t>(n);
+      assert(count_ >= 0);  // no overflow
+      if (n == 1) {
+        cv_.notify_one();
+      } else {
+        cv_.notify_all();
+      }
+    }
+#endif  // ROCKSDB_USE_STD_SEMAPHORES
+  }
+
+ private:
+#ifdef ROCKSDB_USE_STD_SEMAPHORES
+  std::counting_semaphore<INT32_MAX> sem_;
+#else
+  int32_t count_;
+  std::mutex mutex_;
+  std::condition_variable cv_;
+#endif  // ROCKSDB_USE_STD_SEMAPHORES
+};  // namespace ROCKSDB_NAMESPACE
+
+// Wrapper providing a chosen binary semaphore implementation. See notes on
+// CountingSemaphore above, and on Release() below.
+class BinarySemaphore {
+ public:
+  explicit BinarySemaphore(std::ptrdiff_t starting_count)
+#ifdef ROCKSDB_USE_STD_SEMAPHORES
+      : sem_(starting_count)
+#else
+      : state_(starting_count > 0)
+#endif  // ROCKSDB_USE_STD_SEMAPHORES
+  {
+    assert(starting_count >= 0);
+  }
+  void Acquire() {
+#ifdef ROCKSDB_USE_STD_SEMAPHORES
+    sem_.acquire();
+#else
+    std::unique_lock<std::mutex> lock(mutex_);
+    cv_.wait(lock, [this] { return state_; });
+    state_ = false;
+#endif  // ROCKSDB_USE_STD_SEMAPHORES
+  }
+  bool TryAcquire() {
+#ifdef ROCKSDB_USE_STD_SEMAPHORES
+    return sem_.try_acquire();
+#else
+    std::unique_lock<std::mutex> lock(mutex_);
+    if (state_) {
+      state_ = false;
+      return true;
+    } else {
+      return false;
+    }
+#endif  // ROCKSDB_USE_STD_SEMAPHORES
+  }
+  void Release() {
+    // NOTE: implementations of std::binary_semaphore::release() tend to behave
+    // like counting semaphores in the case of multiple Release() calls without
+    // Acquire() in between, though it is undefined behavior. It is also OK to
+    // cap the count at 1.
+#ifdef ROCKSDB_USE_STD_SEMAPHORES
+    sem_.release();
+#else
+    std::unique_lock<std::mutex> lock(mutex_);
+    // check precondition to avoid UB in std implementation
+    assert(state_ == false);
+    state_ = true;
+    cv_.notify_one();
+#endif  // ROCKSDB_USE_STD_SEMAPHORES
+  }
+
+ private:
+#ifdef ROCKSDB_USE_STD_SEMAPHORES
+  std::binary_semaphore sem_;
+#else
+  bool state_;
+  std::mutex mutex_;
+  std::condition_variable cv_;
+#endif  // ROCKSDB_USE_STD_SEMAPHORES
+};
+
+}  // namespace ROCKSDB_NAMESPACE

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

@@ -60,13 +60,15 @@ const char* RandomMixedCompressor::Name() const {
 }
 
 Status RandomMixedCompressor::CompressBlock(
-    Slice uncompressed_data, std::string* compressed_output,
-    CompressionType* out_compression_type, ManagedWorkingArea* wa) {
+    Slice uncompressed_data, char* compressed_output,
+    size_t* compressed_output_size, CompressionType* out_compression_type,
+    ManagedWorkingArea* wa) {
   auto selected =
       Random::GetTLSInstance()->Uniform(static_cast<int>(compressors_.size()));
   auto& compressor = compressors_[selected];
   return compressor->CompressBlock(uncompressed_data, compressed_output,
-                                   out_compression_type, wa);
+                                   compressed_output_size, out_compression_type,
+                                   wa);
 }
 
 const char* RandomMixedCompressionManager::Name() const {
@@ -85,13 +87,15 @@ const char* RoundRobinCompressor::Name() const {
 }
 
 Status RoundRobinCompressor::CompressBlock(
-    Slice uncompressed_data, std::string* compressed_output,
-    CompressionType* out_compression_type, ManagedWorkingArea* wa) {
+    Slice uncompressed_data, char* compressed_output,
+    size_t* compressed_output_size, CompressionType* out_compression_type,
+    ManagedWorkingArea* wa) {
   auto counter = block_counter.FetchAddRelaxed(1);
   auto sel_idx = counter % (compressors_.size());
   auto& compressor = compressors_[sel_idx];
   return compressor->CompressBlock(uncompressed_data, compressed_output,
-                                   out_compression_type, wa);
+                                   compressed_output_size, out_compression_type,
+                                   wa);
 }
 
 RelaxedAtomic<uint64_t> RoundRobinCompressor::block_counter{0};

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

@@ -34,7 +34,8 @@ class MultiCompressorWrapper : public Compressor {
 struct RandomMixedCompressor : public MultiCompressorWrapper {
   using MultiCompressorWrapper::MultiCompressorWrapper;
   const char* Name() const override;
-  Status CompressBlock(Slice uncompressed_data, std::string* compressed_output,
+  Status CompressBlock(Slice uncompressed_data, char* compressed_output,
+                       size_t* compressed_output_size,
                        CompressionType* out_compression_type,
                        ManagedWorkingArea* wa) override;
 };
@@ -50,7 +51,8 @@ class RandomMixedCompressionManager : public CompressionManagerWrapper {
 struct RoundRobinCompressor : public MultiCompressorWrapper {
   using MultiCompressorWrapper::MultiCompressorWrapper;
   const char* Name() const override;
-  Status CompressBlock(Slice uncompressed_data, std::string* compressed_output,
+  Status CompressBlock(Slice uncompressed_data, char* compressed_output,
+                       size_t* compressed_output_size,
                        CompressionType* out_compression_type,
                        ManagedWorkingArea* wa) override;
   static RelaxedAtomic<uint64_t> block_counter;

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

@@ -3,17 +3,25 @@
 //  COPYING file in the root directory) and Apache 2.0 License
 //  (found in the LICENSE.Apache file in the root directory).
 
+// Because there are a small set of tests for Slice and there's a cost in having
+// extra test binaries for each component, this test file has evolved into a
+// "grab bag" of small tests for various reusable components, mostly in  util/.
+
 #include "rocksdb/slice.h"
 
 #include <gtest/gtest.h>
 
+#include <semaphore>
+
 #include "port/port.h"
 #include "port/stack_trace.h"
 #include "rocksdb/data_structure.h"
 #include "rocksdb/types.h"
 #include "test_util/testharness.h"
 #include "test_util/testutil.h"
+#include "util/bit_fields.h"
 #include "util/cast_util.h"
+#include "util/semaphore.h"
 #include "util/string_util.h"
 
 namespace ROCKSDB_NAMESPACE {
@@ -422,6 +430,134 @@ TEST(ToBaseCharsStringTest, Tests) {
   ASSERT_EQ(ToBaseCharsString<32>(2, 255, false), "7v");
 }
 
+TEST(SemaphoreTest, CountingSemaphore) {
+  CountingSemaphore sem{0};
+  int kCount = 5;
+  std::vector<std::thread> threads;
+  for (int i = 0; i < kCount; ++i) {
+    threads.emplace_back([&sem] { sem.Release(); });
+  }
+  for (int i = 0; i < kCount; ++i) {
+    threads.emplace_back([&sem] { sem.Acquire(); });
+  }
+  for (auto& t : threads) {
+    t.join();
+  }
+  // Nothing left on the semaphore
+  ASSERT_FALSE(sem.TryAcquire());
+  // Keep testing
+  sem.Release(2);
+  ASSERT_TRUE(sem.TryAcquire());
+  sem.Acquire();
+  ASSERT_FALSE(sem.TryAcquire());
+}
+
+TEST(SemaphoreTest, BinarySemaphore) {
+  BinarySemaphore sem{0};
+  int kCount = 5;
+  std::vector<std::thread> threads;
+  for (int i = 0; i < kCount; ++i) {
+    threads.emplace_back([&sem] {
+      sem.Acquire();
+      sem.Release();
+    });
+  }
+  threads.emplace_back([&sem] { sem.Release(); });
+  for (auto& t : threads) {
+    t.join();
+  }
+  // Only able to acquire one excess release
+  ASSERT_TRUE(sem.TryAcquire());
+  ASSERT_FALSE(sem.TryAcquire());
+}
+
+TEST(BitFieldsTest, BitFields) {
+  // Start by verifying example from BitFields comment
+  struct MyState : public BitFields<uint32_t, MyState> {
+    // Extra helper declarations and/or field type declarations
+  };
+
+  using Field1 = UnsignedBitField<MyState, 16, NoPrevBitField>;
+  using Field2 = BoolBitField<MyState, Field1>;
+  using Field3 = BoolBitField<MyState, Field2>;
+  using Field4 = UnsignedBitField<MyState, 5, Field3>;
+
+  // MyState{} is zero-initialized
+  auto state = MyState{}.With<Field1>(42U).With<Field2>(true);
+  state.Set<Field4>(3U);
+  state.Ref<Field1>() += state.Get<Field4>();
+
+  ASSERT_EQ(state.Get<Field1>(), 45U);
+  ASSERT_EQ(state.Get<Field2>(), true);
+  ASSERT_EQ(state.Get<Field3>(), false);
+  ASSERT_EQ(state.Get<Field4>(), 3U);
+
+  // Misc operators
+  auto ref = state.Ref<Field3>();
+  auto ref2 = std::move(ref);
+  ref2 = true;
+  ASSERT_EQ(state.Get<Field3>(), true);
+
+  MyState state2;
+  // Basic non-concurrent tests for atomic wrappers
+  {
+    RelaxedBitFieldsAtomic<MyState> relaxed{state};
+    ASSERT_EQ(state, relaxed.LoadRelaxed());
+    relaxed.StoreRelaxed(state2);
+    ASSERT_EQ(state2, relaxed.LoadRelaxed());
+    MyState state3 = relaxed.ExchangeRelaxed(state);
+    ASSERT_EQ(state2, state3);
+    ASSERT_TRUE(relaxed.CasStrongRelaxed(state, state2));
+    while (!relaxed.CasWeakRelaxed(state2, state)) {
+    }
+    ASSERT_EQ(state2, state3);
+    ASSERT_EQ(state, relaxed.LoadRelaxed());
+
+    auto transform1 = Field2::ClearTransform() + Field3::ClearTransform();
+    MyState before, after;
+    relaxed.ApplyRelaxed(transform1, &before, &after);
+    ASSERT_EQ(before, state);
+    ASSERT_NE(after, state);
+    ASSERT_EQ(after.Get<Field2>(), false);
+    ASSERT_EQ(after.Get<Field3>(), false);
+
+    auto transform2 = Field2::SetTransform() + Field3::SetTransform();
+    relaxed.ApplyRelaxed(transform2, &before, &after);
+    ASSERT_NE(before, state);
+    ASSERT_EQ(before.Get<Field2>(), false);
+    ASSERT_EQ(before.Get<Field3>(), false);
+    ASSERT_EQ(after, state);
+  }
+  {
+    AcqRelBitFieldsAtomic<MyState> acqrel{state};
+    ASSERT_EQ(state, acqrel.Load());
+    acqrel.Store(state2);
+    ASSERT_EQ(state2, acqrel.Load());
+    MyState state3 = acqrel.Exchange(state);
+    ASSERT_EQ(state2, state3);
+    ASSERT_TRUE(acqrel.CasStrong(state, state2));
+    while (!acqrel.CasWeak(state2, state)) {
+    }
+    ASSERT_EQ(state2, state3);
+    ASSERT_EQ(state, acqrel.Load());
+
+    auto transform1 = Field2::ClearTransform() + Field3::ClearTransform();
+    MyState before, after;
+    acqrel.Apply(transform1, &before, &after);
+    ASSERT_EQ(before, state);
+    ASSERT_NE(after, state);
+    ASSERT_EQ(after.Get<Field2>(), false);
+    ASSERT_EQ(after.Get<Field3>(), false);
+
+    auto transform2 = Field2::SetTransform() + Field3::SetTransform();
+    acqrel.Apply(transform2, &before, &after);
+    ASSERT_NE(before, state);
+    ASSERT_EQ(before.Get<Field2>(), false);
+    ASSERT_EQ(before.Get<Field3>(), false);
+    ASSERT_EQ(after, state);
+  }
+}
+
 }  // namespace ROCKSDB_NAMESPACE
 
 int main(int argc, char** argv) {

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

@@ -46,6 +46,7 @@ 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
 };
 
 Status::Status(Code _code, SubCode _subcode, const Slice& msg,

package/deps/rocksdb/rocksdb/util/string_util.cc

@@ -20,20 +20,6 @@
 #include "port/sys_time.h"
 #include "rocksdb/slice.h"
 
-#ifndef __has_cpp_attribute
-#define ROCKSDB_HAS_CPP_ATTRIBUTE(x) 0
-#else
-#define ROCKSDB_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)
-#endif
-
-#if ROCKSDB_HAS_CPP_ATTRIBUTE(maybe_unused) && __cplusplus >= 201703L
-#define ROCKSDB_MAYBE_UNUSED [[maybe_unused]]
-#elif ROCKSDB_HAS_CPP_ATTRIBUTE(gnu::unused) || __GNUC__
-#define ROCKSDB_MAYBE_UNUSED [[gnu::unused]]
-#else
-#define ROCKSDB_MAYBE_UNUSED
-#endif
-
 namespace ROCKSDB_NAMESPACE {
 
 const std::string kNullptrString = "nullptr";
@@ -501,7 +487,7 @@ bool TryParseTimeRangeString(const std::string& value, int& start_time,
 // selects proper function.
 
 #if !(defined(_WIN32) && (defined(__MINGW32__) || defined(_MSC_VER)))
-ROCKSDB_MAYBE_UNUSED
+[[maybe_unused]]
 static std::string invoke_strerror_r(int (*strerror_r)(int, char*, size_t),
                                      int err, char* buf, size_t buflen) {
   // Using XSI-compatible strerror_r
@@ -515,7 +501,7 @@ static std::string invoke_strerror_r(int (*strerror_r)(int, char*, size_t),
   return buf;
 }
 
-ROCKSDB_MAYBE_UNUSED
+[[maybe_unused]]
 static std::string invoke_strerror_r(char* (*strerror_r)(int, char*, size_t),
                                      int err, char* buf, size_t buflen) {
   // Using GNU strerror_r