@nxtedition/rocksdb 13.5.8 → 13.5.9

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

@@ -0,0 +1,229 @@
+//  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).
+//
+// Testing the features of auto skip compression manager
+//
+// ***********************************************************************
+// EXPERIMENTAL - subject to change while under development
+// ***********************************************************************
+
+#include <cstdlib>
+#include <memory>
+
+#include "db/db_test_util.h"
+#include "port/stack_trace.h"
+#include "rocksdb/flush_block_policy.h"
+#include "table/block_based/block_builder.h"
+#include "test_util/testutil.h"
+#include "util/random.h"
+
+namespace ROCKSDB_NAMESPACE {
+
+class AutoSkipTestFlushBlockPolicy : public FlushBlockPolicy {
+ public:
+  explicit AutoSkipTestFlushBlockPolicy(const int window,
+                                        const BlockBuilder& data_block_builder,
+                                        std::shared_ptr<Statistics> statistics)
+      : window_(window),
+        num_keys_(0),
+        data_block_builder_(data_block_builder),
+        statistics_(statistics) {}
+
+  bool Update(const Slice& /*key*/, const Slice& /*value*/) override {
+    auto nth_window = num_keys_ / window_;
+    if (data_block_builder_.empty()) {
+      // First key in this block
+      return false;
+    }
+    // Check every window
+    if (num_keys_ % window_ == 0) {
+      auto set_exploration = [&](void* arg) {
+        bool* exploration = static_cast<bool*>(arg);
+        *exploration = true;
+      };
+      auto unset_exploration = [&](void* arg) {
+        bool* exploration = static_cast<bool*>(arg);
+        *exploration = false;
+      };
+      SyncPoint::GetInstance()->DisableProcessing();
+      SyncPoint::GetInstance()->ClearAllCallBacks();
+      // We force exploration to set the predicted rejection ratio for odd
+      // window and then test that the prediction is exploited in the even
+      // window
+      if (nth_window % 2 == 0) {
+        SyncPoint::GetInstance()->SetCallBack(
+            "AutoSkipCompressorWrapper::CompressBlock::exploitOrExplore",
+            set_exploration);
+      } else {
+        SyncPoint::GetInstance()->SetCallBack(
+            "AutoSkipCompressorWrapper::CompressBlock::exploitOrExplore",
+            unset_exploration);
+      }
+      SyncPoint::GetInstance()->EnableProcessing();
+
+      auto compressed_count = PopStat(NUMBER_BLOCK_COMPRESSED);
+      auto bypassed_count = PopStat(NUMBER_BLOCK_COMPRESSION_BYPASSED);
+      auto rejected_count = PopStat(NUMBER_BLOCK_COMPRESSION_REJECTED);
+      auto total = compressed_count + rejected_count + bypassed_count;
+      int rejection_percentage, bypassed_percentage, compressed_percentage;
+      if (total != 0) {
+        rejection_percentage = static_cast<int>(rejected_count * 100 / total);
+        bypassed_percentage = static_cast<int>(bypassed_count * 100 / total);
+        compressed_percentage =
+            static_cast<int>(compressed_count * 100 / total);
+        // use nth window to detect test cases and set the expected
+        switch (nth_window) {
+          case 1:
+            // In first window we only explore and thus here we verify that the
+            // correct prediction has been made by the end of the window
+            // Since 6 of 10 blocks are compression unfriendly, the predicted
+            // rejection ratio should be 60%
+            EXPECT_EQ(rejection_percentage, 60);
+            EXPECT_EQ(bypassed_percentage, 0);
+            EXPECT_EQ(compressed_percentage, 40);
+            break;
+          case 2:
+            // With the rejection ratio set to 0.6 all the blocks should be
+            // bypassed in next window
+            EXPECT_EQ(rejection_percentage, 0);
+            EXPECT_EQ(bypassed_percentage, 100);
+            EXPECT_EQ(compressed_percentage, 0);
+            break;
+          case 3:
+            // In third window we only explore and verify that the correct
+            // prediction has been made by the end of the window
+            // since 4 of 10 blocks are compression ufriendly, the predicted
+            // rejection ratio should be 40%
+            EXPECT_EQ(rejection_percentage, 40);
+            EXPECT_EQ(bypassed_percentage, 0);
+            EXPECT_EQ(compressed_percentage, 60);
+            break;
+          case 4:
+            // With the rejection ratio set to 0.4 all the blocks should be
+            // attempted to be compressed
+            // 6 of 10 blocks are compression unfriendly and thus should be
+            // rejected 4 of 10 blocks are compression friendly and thus should
+            // be compressed
+            EXPECT_EQ(rejection_percentage, 60);
+            EXPECT_EQ(bypassed_percentage, 0);
+            EXPECT_EQ(compressed_percentage, 40);
+        }
+      }
+    }
+    num_keys_++;
+    return true;
+  }
+  uint64_t PopStat(Tickers t) { return statistics_->getAndResetTickerCount(t); }
+
+ private:
+  int window_;
+  int num_keys_;
+  const BlockBuilder& data_block_builder_;
+  std::shared_ptr<Statistics> statistics_;
+};
+
+class AutoSkipTestFlushBlockPolicyFactory : public FlushBlockPolicyFactory {
+ public:
+  explicit AutoSkipTestFlushBlockPolicyFactory(
+      const int window, std::shared_ptr<Statistics> statistics)
+      : window_(window), statistics_(statistics) {}
+
+  virtual const char* Name() const override {
+    return "AutoSkipTestFlushBlockPolicyFactory";
+  }
+
+  virtual FlushBlockPolicy* NewFlushBlockPolicy(
+      const BlockBasedTableOptions& /*table_options*/,
+      const BlockBuilder& data_block_builder) const override {
+    (void)data_block_builder;
+    return new AutoSkipTestFlushBlockPolicy(window_, data_block_builder,
+                                            statistics_);
+  }
+
+ private:
+  int window_;
+  std::shared_ptr<Statistics> statistics_;
+};
+
+class DBAutoSkip : public DBTestBase {
+ public:
+  Options options;
+  Random rnd_;
+  int key_index_;
+  DBAutoSkip()
+      : DBTestBase("db_auto_skip", /*env_do_fsync=*/true),
+        options(CurrentOptions()),
+        rnd_(231),
+        key_index_(0) {
+    options.compression_manager =
+        CreateAutoSkipCompressionManager(GetBuiltinV2CompressionManager());
+    auto statistics = ROCKSDB_NAMESPACE::CreateDBStatistics();
+    options.statistics = statistics;
+    options.statistics->set_stats_level(StatsLevel::kExceptTimeForMutex);
+    BlockBasedTableOptions bbto;
+    bbto.enable_index_compression = false;
+    bbto.flush_block_policy_factory.reset(
+        new AutoSkipTestFlushBlockPolicyFactory(10, statistics));
+    options.table_factory.reset(NewBlockBasedTableFactory(bbto));
+    DestroyAndReopen(options);
+  }
+
+  bool CompressionFriendlyPut(const int no_of_kvs, const int size_of_value) {
+    auto value = std::string(size_of_value, 'A');
+    for (int i = 0; i < no_of_kvs; ++i) {
+      auto status = Put(Key(key_index_), value);
+      EXPECT_EQ(status.ok(), true);
+      key_index_++;
+    }
+    return true;
+  }
+  bool CompressionUnfriendlyPut(const int no_of_kvs, const int size_of_value) {
+    auto value = rnd_.RandomBinaryString(size_of_value);
+    for (int i = 0; i < no_of_kvs; ++i) {
+      auto status = Put(Key(key_index_), value);
+      EXPECT_EQ(status.ok(), true);
+      key_index_++;
+    }
+    return true;
+  }
+};
+
+// FIXME: the test is failing the assertion in auto_skip_compressor.cc
+// when run on nightly build in build-linux-arm-test-full mode [1].
+//
+// [1]
+// auto_skip_compressor.cc:101: Assertion `preferred != kNoCompression' failed.
+TEST_F(DBAutoSkip, DISABLED_AutoSkipCompressionManager) {
+  if (GetSupportedCompressions().size() > 1) {
+    const int kValueSize = 20000;
+    // This will set the rejection ratio to 60%
+    CompressionUnfriendlyPut(6, kValueSize);
+    CompressionFriendlyPut(4, kValueSize);
+    // This will verify all the data block compressions are bypassed based on
+    // previous prediction
+    CompressionUnfriendlyPut(6, kValueSize);
+    CompressionFriendlyPut(4, kValueSize);
+    // This will set the rejection ratio to 40%
+    CompressionUnfriendlyPut(4, kValueSize);
+    CompressionFriendlyPut(6, kValueSize);
+    // This will verify all the data block compression are attempted based on
+    // previous prediction
+    // Compression will be rejected for 6 compression unfriendly blocks
+    // Compression will be accepted for 4 compression friendly blocks
+    CompressionUnfriendlyPut(6, kValueSize);
+    CompressionFriendlyPut(4, kValueSize);
+    // Extra block write to ensure that the all above cases are checked
+    CompressionFriendlyPut(6, kValueSize);
+    CompressionFriendlyPut(4, kValueSize);
+    ASSERT_OK(Flush());
+  }
+}
+}  // namespace ROCKSDB_NAMESPACE
+int main(int argc, char** argv) {
+  ROCKSDB_NAMESPACE::port::InstallStackTraceHandler();
+  ::testing::InitGoogleTest(&argc, argv);
+  RegisterCustomObjects(argc, argv);
+  return RUN_ALL_TESTS();
+}

package/deps/rocksdb/rocksdb/util/crc32c_arm64.cc

@@ -10,7 +10,7 @@
 #if defined(__linux__)
 #include <asm/hwcap.h>
 #endif
-#ifdef ROCKSDB_AUXV_GETAUXVAL_PRESENT
+#if defined(ROCKSDB_AUXV_GETAUXVAL_PRESENT)
 #include <sys/auxv.h>
 #endif
 #ifndef HWCAP_CRC32
@@ -37,15 +37,15 @@
   crc0 = crc32c_u64(crc0, *(buf64 + (ITR)));
 
 /* unfolding to compute 24 * 7 = 168 bytes parallelly */
-#define CRC32C7X24BYTES(ITR)   \
-  do {                         \
-    CRC32C24BYTES((ITR)*7 + 0) \
-    CRC32C24BYTES((ITR)*7 + 1) \
-    CRC32C24BYTES((ITR)*7 + 2) \
-    CRC32C24BYTES((ITR)*7 + 3) \
-    CRC32C24BYTES((ITR)*7 + 4) \
-    CRC32C24BYTES((ITR)*7 + 5) \
-    CRC32C24BYTES((ITR)*7 + 6) \
+#define CRC32C7X24BYTES(ITR)     \
+  do {                           \
+    CRC32C24BYTES((ITR) * 7 + 0) \
+    CRC32C24BYTES((ITR) * 7 + 1) \
+    CRC32C24BYTES((ITR) * 7 + 2) \
+    CRC32C24BYTES((ITR) * 7 + 3) \
+    CRC32C24BYTES((ITR) * 7 + 4) \
+    CRC32C24BYTES((ITR) * 7 + 5) \
+    CRC32C24BYTES((ITR) * 7 + 6) \
   } while (0)
 #endif
 

package/deps/rocksdb/rocksdb/util/crc32c_ppc.c

@@ -9,6 +9,7 @@
 #include <stdint.h>
 #include <stdlib.h>
 #include <strings.h>
+
 #include "util/crc32c_ppc_constants.h"
 
 #define VMX_ALIGN 16

package/deps/rocksdb/rocksdb/util/data_structure.cc

@@ -13,4 +13,6 @@ int CountTrailingZeroBitsForSmallEnumSet(uint64_t v) {
   return CountTrailingZeroBits(v);
 }
 
+int BitsSetToOneForSmallEnumSet(uint64_t v) { return BitsSetToOne(v); }
+
 }  // namespace ROCKSDB_NAMESPACE::detail

package/deps/rocksdb/rocksdb/util/file_reader_writer_test.cc

@@ -205,9 +205,7 @@ TEST_F(WritableFileWriterTest, IncrementalBuffer) {
     env_options.writable_file_max_buffer_size =
         (attempt < kNumAttempts / 2) ? 512 * 1024 : 700 * 1024;
     std::string actual;
-    std::unique_ptr<FakeWF> wf(new FakeWF(&actual,
-                                          attempt % 2 == 1,
-                                          no_flush));
+    std::unique_ptr<FakeWF> wf(new FakeWF(&actual, attempt % 2 == 1, no_flush));
     std::unique_ptr<WritableFileWriter> writer(new WritableFileWriter(
         std::move(wf), "" /* don't care */, env_options));
 

package/deps/rocksdb/rocksdb/util/ppc-opcode.h

@@ -7,11 +7,11 @@
 
 #pragma once
 
-#define __PPC_RA(a) (((a)&0x1f) << 16)
-#define __PPC_RB(b) (((b)&0x1f) << 11)
-#define __PPC_XA(a) ((((a)&0x1f) << 16) | (((a)&0x20) >> 3))
-#define __PPC_XB(b) ((((b)&0x1f) << 11) | (((b)&0x20) >> 4))
-#define __PPC_XS(s) ((((s)&0x1f) << 21) | (((s)&0x20) >> 5))
+#define __PPC_RA(a) (((a) & 0x1f) << 16)
+#define __PPC_RB(b) (((b) & 0x1f) << 11)
+#define __PPC_XA(a) ((((a) & 0x1f) << 16) | (((a) & 0x20) >> 3))
+#define __PPC_XB(b) ((((b) & 0x1f) << 11) | (((b) & 0x20) >> 4))
+#define __PPC_XS(s) ((((s) & 0x1f) << 21) | (((s) & 0x20) >> 5))
 #define __PPC_XT(s) __PPC_XS(s)
 #define VSX_XX3(t, a, b) (__PPC_XT(t) | __PPC_XA(a) | __PPC_XB(b))
 #define VSX_XX1(s, a, b) (__PPC_XS(s) | __PPC_RA(a) | __PPC_RB(b))

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

@@ -0,0 +1,108 @@
+//  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).
+//
+// Creates mixed compressor wrapper which uses multiple compression algorithm
+// within same SST file.
+
+#include "simple_mixed_compressor.h"
+
+#include <options/options_helper.h>
+
+#include "random.h"
+#include "rocksdb/advanced_compression.h"
+namespace ROCKSDB_NAMESPACE {
+
+// MultiCompressorWrapper implementation
+MultiCompressorWrapper::MultiCompressorWrapper(const CompressionOptions& opts,
+                                               CompressionDict&& dict) {
+  // TODO: make the compression manager a field
+  auto builtInManager = GetBuiltinV2CompressionManager();
+  const auto& compressions = GetSupportedCompressions();
+  for (auto type : compressions) {
+    if (type == kNoCompression) {
+      continue;
+    }
+    compressors_.push_back(builtInManager->GetCompressor(opts, type));
+  }
+  (void)dict;
+}
+
+size_t MultiCompressorWrapper::GetMaxSampleSizeIfWantDict(
+    CacheEntryRole block_type) const {
+  return compressors_.back()->GetMaxSampleSizeIfWantDict(block_type);
+}
+
+Slice MultiCompressorWrapper::GetSerializedDict() const {
+  return compressors_.back()->GetSerializedDict();
+}
+
+CompressionType MultiCompressorWrapper::GetPreferredCompressionType() const {
+  return compressors_.back()->GetPreferredCompressionType();
+}
+
+Compressor::ManagedWorkingArea MultiCompressorWrapper::ObtainWorkingArea() {
+  return compressors_.back()->ObtainWorkingArea();
+}
+
+std::unique_ptr<Compressor> MultiCompressorWrapper::MaybeCloneSpecialized(
+    CacheEntryRole block_type, DictSampleArgs&& dict_samples) {
+  // 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));
+}
+
+// RandomMixedCompressor implementation
+const char* RandomMixedCompressor::Name() const {
+  return "RandomMixedCompressor";
+}
+
+Status RandomMixedCompressor::CompressBlock(
+    Slice uncompressed_data, std::string* compressed_output,
+    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);
+}
+
+const char* RandomMixedCompressionManager::Name() const {
+  return "RandomMixedCompressionManager";
+}
+
+std::unique_ptr<Compressor> RandomMixedCompressionManager::GetCompressorForSST(
+    const FilterBuildingContext& /*context*/, const CompressionOptions& opts,
+    CompressionType /*preferred*/) {
+  return std::make_unique<RandomMixedCompressor>(opts);
+}
+
+// RoundRobinCompressor implementation
+const char* RoundRobinCompressor::Name() const {
+  return "RoundRobinCompressor";
+}
+
+Status RoundRobinCompressor::CompressBlock(
+    Slice uncompressed_data, std::string* compressed_output,
+    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);
+}
+
+RelaxedAtomic<uint64_t> RoundRobinCompressor::block_counter{0};
+
+// RoundRobinManager implementation
+const char* RoundRobinManager::Name() const { return "RoundRobinManager"; }
+
+std::unique_ptr<Compressor> RoundRobinManager::GetCompressorForSST(
+    const FilterBuildingContext& /*context*/, const CompressionOptions& opts,
+    CompressionType /*preferred*/) {
+  return std::make_unique<RoundRobinCompressor>(opts);
+}
+
+}  // namespace ROCKSDB_NAMESPACE

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

@@ -0,0 +1,67 @@
+//  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).
+//
+// Creates mixed compressor wrapper which uses multiple compression algorithm
+// within same SST file.
+
+#pragma once
+#include <memory>
+#include <vector>
+
+#include "compression.h"
+#include "rocksdb/advanced_compression.h"
+
+namespace ROCKSDB_NAMESPACE {
+
+class MultiCompressorWrapper : public Compressor {
+ public:
+  explicit MultiCompressorWrapper(const CompressionOptions& opts,
+                                  CompressionDict&& dict = {});
+
+  size_t GetMaxSampleSizeIfWantDict(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) override;
+
+ protected:
+  std::vector<std::unique_ptr<Compressor>> compressors_;
+};
+
+struct RandomMixedCompressor : public MultiCompressorWrapper {
+  using MultiCompressorWrapper::MultiCompressorWrapper;
+  const char* Name() const override;
+  Status CompressBlock(Slice uncompressed_data, std::string* compressed_output,
+                       CompressionType* out_compression_type,
+                       ManagedWorkingArea* wa) override;
+};
+
+class RandomMixedCompressionManager : public CompressionManagerWrapper {
+  using CompressionManagerWrapper::CompressionManagerWrapper;
+  const char* Name() const override;
+  std::unique_ptr<Compressor> GetCompressorForSST(
+      const FilterBuildingContext& context, const CompressionOptions& opts,
+      CompressionType preferred) override;
+};
+
+struct RoundRobinCompressor : public MultiCompressorWrapper {
+  using MultiCompressorWrapper::MultiCompressorWrapper;
+  const char* Name() const override;
+  Status CompressBlock(Slice uncompressed_data, std::string* compressed_output,
+                       CompressionType* out_compression_type,
+                       ManagedWorkingArea* wa) override;
+  static RelaxedAtomic<uint64_t> block_counter;
+};
+
+class RoundRobinManager : public CompressionManagerWrapper {
+  using CompressionManagerWrapper::CompressionManagerWrapper;
+  const char* Name() const override;
+  std::unique_ptr<Compressor> GetCompressorForSST(
+      const FilterBuildingContext& context, const CompressionOptions& opts,
+      CompressionType preferred) override;
+};
+
+}  // namespace ROCKSDB_NAMESPACE

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

@@ -14,6 +14,7 @@
 #include "test_util/testharness.h"
 #include "test_util/testutil.h"
 #include "util/cast_util.h"
+#include "util/string_util.h"
 
 namespace ROCKSDB_NAMESPACE {
 
@@ -177,18 +178,23 @@ class SmallEnumSetTest : public testing::Test {
 TEST_F(SmallEnumSetTest, SmallEnumSetTest1) {
   FileTypeSet fs;  // based on a legacy enum type
   ASSERT_TRUE(fs.empty());
+  ASSERT_EQ(fs.count(), 0U);
   ASSERT_TRUE(fs.Add(FileType::kIdentityFile));
   ASSERT_FALSE(fs.empty());
+  ASSERT_EQ(fs.count(), 1U);
   ASSERT_FALSE(fs.Add(FileType::kIdentityFile));
   ASSERT_TRUE(fs.Add(FileType::kInfoLogFile));
   ASSERT_TRUE(fs.Contains(FileType::kIdentityFile));
   ASSERT_FALSE(fs.Contains(FileType::kDBLockFile));
   ASSERT_FALSE(fs.empty());
+  ASSERT_EQ(fs.count(), 2U);
   ASSERT_FALSE(fs.Remove(FileType::kDBLockFile));
   ASSERT_TRUE(fs.Remove(FileType::kIdentityFile));
   ASSERT_FALSE(fs.empty());
+  ASSERT_EQ(fs.count(), 1U);
   ASSERT_TRUE(fs.Remove(FileType::kInfoLogFile));
   ASSERT_TRUE(fs.empty());
+  ASSERT_EQ(fs.count(), 0U);
 }
 
 namespace {
@@ -224,12 +230,16 @@ TEST_F(SmallEnumSetTest, SmallEnumSetTest2) {
   ASSERT_NE(cs, MyEnumClassSet{MyEnumClass::B});
   ASSERT_NE(cs, MyEnumClassSet::All());
 
+  ASSERT_EQ(MyEnumClassSet{}.count(), 0U);
+  ASSERT_EQ(MyEnumClassSet::All().count(), 3U);
+
   int count = 0;
   for (MyEnumClass e : cs) {
     ASSERT_EQ(e, MyEnumClass::A);
     ++count;
   }
   ASSERT_EQ(count, 1);
+  ASSERT_EQ(cs.count(), 1U);
 
   count = 0;
   for (MyEnumClass e : MyEnumClassSet::All().Without(MyEnumClass::B)) {
@@ -244,6 +254,68 @@ TEST_F(SmallEnumSetTest, SmallEnumSetTest2) {
   }
 }
 
+template <typename ENUM_TYPE, ENUM_TYPE MAX_ENUMERATOR>
+void TestBiggerEnumSet() {
+  using MySet = SmallEnumSet<ENUM_TYPE, MAX_ENUMERATOR>;
+  constexpr int kMaxValue = static_cast<int>(MAX_ENUMERATOR);
+  SCOPED_TRACE("kMaxValue = " + std::to_string(kMaxValue));
+
+  ASSERT_EQ(sizeof(MySet), (kMaxValue + 1 + 63) / 64 * 8);
+
+  MySet s;
+  ASSERT_TRUE(s.empty());
+  ASSERT_EQ(s.count(), 0U);
+  ASSERT_TRUE(s.Add(ENUM_TYPE(0)));
+  ASSERT_FALSE(s.empty());
+  ASSERT_EQ(s.count(), 1U);
+  ASSERT_TRUE(s.Add(ENUM_TYPE(kMaxValue - 1)));
+  ASSERT_FALSE(s.empty());
+  ASSERT_EQ(s.count(), 2U);
+  ASSERT_TRUE(s.Add(ENUM_TYPE(kMaxValue)));
+  ASSERT_FALSE(s.empty());
+  ASSERT_EQ(s.count(), 3U);
+
+  int count = 0;
+  for (ENUM_TYPE e : s) {
+    ASSERT_TRUE(e == ENUM_TYPE(0) || e == ENUM_TYPE(kMaxValue - 1) ||
+                e == ENUM_TYPE(kMaxValue));
+    ++count;
+  }
+  ASSERT_EQ(count, 3);
+
+  ASSERT_TRUE(s.Remove(ENUM_TYPE(0)));
+  ASSERT_TRUE(s.Remove(ENUM_TYPE(kMaxValue)));
+  ASSERT_FALSE(s.empty());
+  ASSERT_EQ(s.count(), 1U);
+
+  count = 0;
+  for (ENUM_TYPE e : s) {
+    ASSERT_EQ(e, ENUM_TYPE(kMaxValue - 1));
+    ++count;
+  }
+  ASSERT_EQ(count, 1);
+}
+
+TEST_F(SmallEnumSetTest, BiggerEnumClasses) {
+  enum class BiggerEnumClass63 { A, B, C = 63 };
+  enum class BiggerEnumClass64 { A, B, C = 64 };
+  enum class BiggerEnumClass65 { A, B, C = 65 };
+  enum class BiggerEnumClass127 { A, B, C = 127 };
+  enum class BiggerEnumClass128 { A, B, C = 128 };
+  enum class BiggerEnumClass129 { A, B, C = 129 };
+  enum class BiggerEnumClass150 { A, B, C = 150 };
+  enum class BiggerEnumClass255 { A, B, C = 255 };
+
+  TestBiggerEnumSet<BiggerEnumClass63, BiggerEnumClass63::C>();
+  TestBiggerEnumSet<BiggerEnumClass64, BiggerEnumClass64::C>();
+  TestBiggerEnumSet<BiggerEnumClass65, BiggerEnumClass65::C>();
+  TestBiggerEnumSet<BiggerEnumClass127, BiggerEnumClass127::C>();
+  TestBiggerEnumSet<BiggerEnumClass128, BiggerEnumClass128::C>();
+  TestBiggerEnumSet<BiggerEnumClass129, BiggerEnumClass129::C>();
+  TestBiggerEnumSet<BiggerEnumClass150, BiggerEnumClass150::C>();
+  TestBiggerEnumSet<BiggerEnumClass255, BiggerEnumClass255::C>();
+}
+
 // ***************************************************************** //
 // Unit test for Status
 TEST(StatusTest, Update) {
@@ -339,6 +411,17 @@ TEST(UnownedPtrTest, Tests) {
   }
 }
 
+TEST(ToBaseCharsStringTest, Tests) {
+  using ROCKSDB_NAMESPACE::ToBaseCharsString;
+  // Base 16
+  ASSERT_EQ(ToBaseCharsString<16>(5, 0, true), "00000");
+  ASSERT_EQ(ToBaseCharsString<16>(5, 42, true), "0002A");
+  ASSERT_EQ(ToBaseCharsString<16>(5, 42, false), "0002a");
+  ASSERT_EQ(ToBaseCharsString<16>(2, 255, false), "ff");
+  // Base 32
+  ASSERT_EQ(ToBaseCharsString<32>(2, 255, false), "7v");
+}
+
 }  // namespace ROCKSDB_NAMESPACE
 
 int main(int argc, char** argv) {

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

@@ -296,7 +296,6 @@ bool StartsWith(const std::string& string, const std::string& pattern) {
   return string.compare(0, pattern.size(), pattern) == 0;
 }
 
-
 bool ParseBoolean(const std::string& type, const std::string& value) {
   if (value == "true" || value == "1") {
     return true;
@@ -334,7 +333,6 @@ int32_t ParseInt32(const std::string& value) {
   }
 }
 
-
 uint64_t ParseUint64(const std::string& value) {
   size_t endchar;
 #ifndef CYGWIN

package/deps/rocksdb/rocksdb/util/string_util.h

@@ -40,6 +40,16 @@ inline void PutBaseChars(char** buf, size_t n, uint64_t v, bool uppercase) {
   *buf += n;
 }
 
+// Construct a string of n digits from v in base kBase
+template <size_t kBase>
+inline std::string ToBaseCharsString(size_t n, uint64_t v, bool uppercase) {
+  std::string result;
+  result.resize(n);
+  char* buf = &result[0];
+  PutBaseChars<kBase>(&buf, n, v, uppercase);
+  return result;
+}
+
 // Parse n digits from *buf in base kBase to *v and advance *buf to the
 // position after what was read. On success, true is returned. On failure,
 // false is returned, *buf is placed at the first bad character, and *v

package/deps/rocksdb/rocksdb/util/thread_operation.h

@@ -47,7 +47,8 @@ static OperationInfo global_operation_table[] = {
     {ThreadStatus::OP_VERIFY_FILE_CHECKSUMS, "VerifyFileChecksums"},
     {ThreadStatus::OP_GETENTITY, "GetEntity"},
     {ThreadStatus::OP_MULTIGETENTITY, "MultiGetEntity"},
-    {ThreadStatus::OP_READ_MANIFEST, "ReadManifest"},
+    {ThreadStatus::OP_GET_FILE_CHECKSUMS_FROM_CURRENT_MANIFEST,
+     "GetFileChecksumsFromCurrentManifest"},
 
 };