@nxtedition/rocksdb 8.2.8 → 9.0.0

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

@@ -53,8 +53,11 @@
 #include <zdict.h>
 #endif  // ZSTD_VERSION_NUMBER >= 10103
 // v1.4.0+
+// ZSTD_Compress2(), ZSTD_compressStream2() and frame parameters all belong to
+// advanced APIs and require v1.4.0+.
+// https://github.com/facebook/zstd/blob/eb9f881eb810f2242f1ef36b3f3e7014eecb8fa6/lib/zstd.h#L297C40-L297C45
 #if ZSTD_VERSION_NUMBER >= 10400
-#define ZSTD_STREAMING
+#define ZSTD_ADVANCED
 #endif  // ZSTD_VERSION_NUMBER >= 10400
 namespace ROCKSDB_NAMESPACE {
 // Need this for the context allocation override
@@ -180,6 +183,9 @@ struct CompressionDict {
       if (level == CompressionOptions::kDefaultCompressionLevel) {
         // 3 is the value of ZSTD_CLEVEL_DEFAULT (not exposed publicly), see
         // https://github.com/facebook/zstd/issues/1148
+        // TODO(cbi): ZSTD_CLEVEL_DEFAULT is exposed after
+        //  https://github.com/facebook/zstd/pull/1174. Use ZSTD_CLEVEL_DEFAULT
+        //  instead of hardcoding 3.
         level = 3;
       }
       // Should be safe (but slower) if below call fails as we'll use the
@@ -363,14 +369,43 @@ class CompressionContext {
  private:
 #if defined(ZSTD) && (ZSTD_VERSION_NUMBER >= 500)
   ZSTD_CCtx* zstd_ctx_ = nullptr;
-  void CreateNativeContext(CompressionType type) {
-    if (type == kZSTD || type == kZSTDNotFinalCompression) {
+
+  ZSTD_CCtx* CreateZSTDContext() {
 #ifdef ROCKSDB_ZSTD_CUSTOM_MEM
-      zstd_ctx_ =
-          ZSTD_createCCtx_advanced(port::GetJeZstdAllocationOverrides());
+    return ZSTD_createCCtx_advanced(port::GetJeZstdAllocationOverrides());
 #else   // ROCKSDB_ZSTD_CUSTOM_MEM
-      zstd_ctx_ = ZSTD_createCCtx();
+    return ZSTD_createCCtx();
 #endif  // ROCKSDB_ZSTD_CUSTOM_MEM
+  }
+
+  void CreateNativeContext(CompressionType type, int level, bool checksum) {
+    if (type == kZSTD || type == kZSTDNotFinalCompression) {
+      zstd_ctx_ = CreateZSTDContext();
+#ifdef ZSTD_ADVANCED
+      if (level == CompressionOptions::kDefaultCompressionLevel) {
+        // 3 is the value of ZSTD_CLEVEL_DEFAULT (not exposed publicly), see
+        // https://github.com/facebook/zstd/issues/1148
+        level = 3;
+      }
+      size_t err =
+          ZSTD_CCtx_setParameter(zstd_ctx_, ZSTD_c_compressionLevel, level);
+      if (ZSTD_isError(err)) {
+        assert(false);
+        ZSTD_freeCCtx(zstd_ctx_);
+        zstd_ctx_ = CreateZSTDContext();
+      }
+      if (checksum) {
+        err = ZSTD_CCtx_setParameter(zstd_ctx_, ZSTD_c_checksumFlag, 1);
+        if (ZSTD_isError(err)) {
+          assert(false);
+          ZSTD_freeCCtx(zstd_ctx_);
+          zstd_ctx_ = CreateZSTDContext();
+        }
+      }
+#else
+      (void)level;
+      (void)checksum;
+#endif
     }
   }
   void DestroyNativeContext() {
@@ -388,12 +423,14 @@ class CompressionContext {
 
 #else   // ZSTD && (ZSTD_VERSION_NUMBER >= 500)
  private:
-  void CreateNativeContext(CompressionType /* type */) {}
+  void CreateNativeContext(CompressionType /* type */, int /* level */,
+                           bool /* checksum */) {}
   void DestroyNativeContext() {}
 #endif  // ZSTD && (ZSTD_VERSION_NUMBER >= 500)
  public:
-  explicit CompressionContext(CompressionType type) {
-    CreateNativeContext(type);
+  explicit CompressionContext(CompressionType type,
+                              const CompressionOptions& options) {
+    CreateNativeContext(type, options.level, options.checksum);
   }
   ~CompressionContext() { DestroyNativeContext(); }
   CompressionContext(const CompressionContext&) = delete;
@@ -525,7 +562,7 @@ inline bool ZSTDNotFinal_Supported() {
 }
 
 inline bool ZSTD_Streaming_Supported() {
-#if defined(ZSTD) && defined(ZSTD_STREAMING)
+#if defined(ZSTD_ADVANCED)
   return true;
 #else
   return false;
@@ -1343,30 +1380,44 @@ inline bool ZSTD_Compress(const CompressionInfo& info, const char* input,
   size_t compressBound = ZSTD_compressBound(length);
   output->resize(static_cast<size_t>(output_header_len + compressBound));
   size_t outlen = 0;
-  int level;
-  if (info.options().level == CompressionOptions::kDefaultCompressionLevel) {
-    // 3 is the value of ZSTD_CLEVEL_DEFAULT (not exposed publicly), see
-    // https://github.com/facebook/zstd/issues/1148
-    level = 3;
-  } else {
-    level = info.options().level;
-  }
 #if ZSTD_VERSION_NUMBER >= 500  // v0.5.0+
   ZSTD_CCtx* context = info.context().ZSTDPreallocCtx();
   assert(context != nullptr);
+#ifdef ZSTD_ADVANCED
+  if (info.dict().GetDigestedZstdCDict() != nullptr) {
+    ZSTD_CCtx_refCDict(context, info.dict().GetDigestedZstdCDict());
+  } else {
+    ZSTD_CCtx_loadDictionary(context, info.dict().GetRawDict().data(),
+                             info.dict().GetRawDict().size());
+  }
+
+  // Compression level is set in `contex` during CreateNativeContext()
+  outlen = ZSTD_compress2(context, &(*output)[output_header_len], compressBound,
+                          input, length);
+#else                           // ZSTD_ADVANCED
 #if ZSTD_VERSION_NUMBER >= 700  // v0.7.0+
   if (info.dict().GetDigestedZstdCDict() != nullptr) {
     outlen = ZSTD_compress_usingCDict(context, &(*output)[output_header_len],
                                       compressBound, input, length,
                                       info.dict().GetDigestedZstdCDict());
   }
-#endif  // ZSTD_VERSION_NUMBER >= 700
+#endif                          // ZSTD_VERSION_NUMBER >= 700
+  // TODO (cbi): error handling for compression.
   if (outlen == 0) {
+    int level;
+    if (info.options().level == CompressionOptions::kDefaultCompressionLevel) {
+      // 3 is the value of ZSTD_CLEVEL_DEFAULT (not exposed publicly), see
+      // https://github.com/facebook/zstd/issues/1148
+      level = 3;
+    } else {
+      level = info.options().level;
+    }
     outlen = ZSTD_compress_usingDict(context, &(*output)[output_header_len],
                                      compressBound, input, length,
                                      info.dict().GetRawDict().data(),
                                      info.dict().GetRawDict().size(), level);
   }
+#endif                          // ZSTD_ADVANCED
 #else   // up to v0.4.x
   outlen = ZSTD_compress(&(*output)[output_header_len], compressBound, input,
                          length, level);
@@ -1387,17 +1438,28 @@ inline bool ZSTD_Compress(const CompressionInfo& info, const char* input,
 
 // @param compression_dict Data for presetting the compression library's
 //    dictionary.
+// @param error_message If not null, will be set if decompression fails.
+//
+// Returns nullptr if decompression fails.
 inline CacheAllocationPtr ZSTD_Uncompress(
     const UncompressionInfo& info, const char* input_data, size_t input_length,
-    size_t* uncompressed_size, MemoryAllocator* allocator = nullptr) {
+    size_t* uncompressed_size, MemoryAllocator* allocator = nullptr,
+    const char** error_message = nullptr) {
 #ifdef ZSTD
+  static const char* const kErrorDecodeOutputSize =
+      "Cannot decode output size.";
+  static const char* const kErrorOutputLenMismatch =
+      "Decompressed size does not match header.";
   uint32_t output_len = 0;
   if (!compression::GetDecompressedSizeInfo(&input_data, &input_length,
                                             &output_len)) {
+    if (error_message) {
+      *error_message = kErrorDecodeOutputSize;
+    }
     return nullptr;
   }
 
-  auto output = AllocateBlock(output_len, allocator);
+  CacheAllocationPtr output = AllocateBlock(output_len, allocator);
   size_t actual_output_length = 0;
 #if ZSTD_VERSION_NUMBER >= 500  // v0.5.0+
   ZSTD_DCtx* context = info.context().GetZSTDContext();
@@ -1407,19 +1469,31 @@ inline CacheAllocationPtr ZSTD_Uncompress(
     actual_output_length = ZSTD_decompress_usingDDict(
         context, output.get(), output_len, input_data, input_length,
         info.dict().GetDigestedZstdDDict());
-  }
+  } else {
 #endif  // ROCKSDB_ZSTD_DDICT
-  if (actual_output_length == 0) {
     actual_output_length = ZSTD_decompress_usingDict(
         context, output.get(), output_len, input_data, input_length,
         info.dict().GetRawDict().data(), info.dict().GetRawDict().size());
+#ifdef ROCKSDB_ZSTD_DDICT
   }
+#endif  // ROCKSDB_ZSTD_DDICT
 #else   // up to v0.4.x
   (void)info;
   actual_output_length =
       ZSTD_decompress(output.get(), output_len, input_data, input_length);
 #endif  // ZSTD_VERSION_NUMBER >= 500
-  assert(actual_output_length == output_len);
+  if (ZSTD_isError(actual_output_length)) {
+    if (error_message) {
+      *error_message = ZSTD_getErrorName(actual_output_length);
+    }
+    return nullptr;
+  } else if (actual_output_length != output_len) {
+    if (error_message) {
+      *error_message = kErrorOutputLenMismatch;
+    }
+    return nullptr;
+  }
+
   *uncompressed_size = actual_output_length;
   return output;
 #else  // ZSTD
@@ -1428,6 +1502,7 @@ inline CacheAllocationPtr ZSTD_Uncompress(
   (void)input_length;
   (void)uncompressed_size;
   (void)allocator;
+  (void)error_message;
   return nullptr;
 #endif
 }
@@ -1530,6 +1605,7 @@ inline std::string ZSTD_FinalizeDictionary(
     return dict_data;
   }
 #else   // up to v1.4.4
+  assert(false);
   (void)samples;
   (void)sample_lens;
   (void)max_dict_bytes;
@@ -1589,7 +1665,8 @@ inline bool CompressData(const Slice& raw,
 inline CacheAllocationPtr UncompressData(
     const UncompressionInfo& uncompression_info, const char* data, size_t n,
     size_t* uncompressed_size, uint32_t compress_format_version,
-    MemoryAllocator* allocator = nullptr) {
+    MemoryAllocator* allocator = nullptr,
+    const char** error_message = nullptr) {
   switch (uncompression_info.type()) {
     case kSnappyCompression:
       return Snappy_Uncompress(data, n, uncompressed_size, allocator);
@@ -1609,8 +1686,9 @@ inline CacheAllocationPtr UncompressData(
       return CacheAllocationPtr(XPRESS_Uncompress(data, n, uncompressed_size));
     case kZSTD:
     case kZSTDNotFinalCompression:
+      // TODO(cbi): error message handling for other compression algorithms.
       return ZSTD_Uncompress(uncompression_info, data, n, uncompressed_size,
-                             allocator);
+                             allocator, error_message);
     default:
       return CacheAllocationPtr();
   }
@@ -1743,7 +1821,7 @@ class ZSTDStreamingCompress final : public StreamingCompress {
                                  size_t max_output_len)
       : StreamingCompress(kZSTD, opts, compress_format_version,
                           max_output_len) {
-#ifdef ZSTD_STREAMING
+#ifdef ZSTD_ADVANCED
     cctx_ = ZSTD_createCCtx();
     // Each compressed frame will have a checksum
     ZSTD_CCtx_setParameter(cctx_, ZSTD_c_checksumFlag, 1);
@@ -1752,14 +1830,14 @@ class ZSTDStreamingCompress final : public StreamingCompress {
 #endif
   }
   ~ZSTDStreamingCompress() override {
-#ifdef ZSTD_STREAMING
+#ifdef ZSTD_ADVANCED
     ZSTD_freeCCtx(cctx_);
 #endif
   }
   int Compress(const char* input, size_t input_size, char* output,
                size_t* output_pos) override;
   void Reset() override;
-#ifdef ZSTD_STREAMING
+#ifdef ZSTD_ADVANCED
   ZSTD_CCtx* cctx_;
   ZSTD_inBuffer input_buffer_;
 #endif
@@ -1770,14 +1848,14 @@ class ZSTDStreamingUncompress final : public StreamingUncompress {
   explicit ZSTDStreamingUncompress(uint32_t compress_format_version,
                                    size_t max_output_len)
       : StreamingUncompress(kZSTD, compress_format_version, max_output_len) {
-#ifdef ZSTD_STREAMING
+#ifdef ZSTD_ADVANCED
     dctx_ = ZSTD_createDCtx();
     assert(dctx_ != nullptr);
     input_buffer_ = {/*src=*/nullptr, /*size=*/0, /*pos=*/0};
 #endif
   }
   ~ZSTDStreamingUncompress() override {
-#ifdef ZSTD_STREAMING
+#ifdef ZSTD_ADVANCED
     ZSTD_freeDCtx(dctx_);
 #endif
   }
@@ -1786,7 +1864,7 @@ class ZSTDStreamingUncompress final : public StreamingUncompress {
   void Reset() override;
 
  private:
-#ifdef ZSTD_STREAMING
+#ifdef ZSTD_ADVANCED
   ZSTD_DCtx* dctx_;
   ZSTD_inBuffer input_buffer_;
 #endif

package/deps/rocksdb/rocksdb/util/core_local.h

@@ -13,6 +13,7 @@
 
 #include "port/likely.h"
 #include "port/port.h"
+#include "util/math.h"
 #include "util/random.h"
 
 namespace ROCKSDB_NAMESPACE {
@@ -70,7 +71,7 @@ std::pair<T*, size_t> CoreLocalArray<T>::AccessElementAndIndex() const {
     // cpu id unavailable, just pick randomly
     core_idx = Random::GetTLSInstance()->Uniform(1 << size_shift_);
   } else {
-    core_idx = static_cast<size_t>(cpuid & ((1 << size_shift_) - 1));
+    core_idx = static_cast<size_t>(BottomNBits(cpuid, size_shift_));
   }
   return {AccessAtCore(core_idx), core_idx};
 }

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

@@ -126,7 +126,7 @@ inline void DynamicBloom::MayContain(int num_keys, Slice* keys,
   std::array<size_t, MultiGetContext::MAX_BATCH_SIZE> byte_offsets;
   for (int i = 0; i < num_keys; ++i) {
     hashes[i] = BloomHash(keys[i]);
-    size_t a = FastRange32(kLen, hashes[i]);
+    size_t a = FastRange32(hashes[i], kLen);
     PREFETCH(data_ + a, 0, 3);
     byte_offsets[i] = a;
   }
@@ -142,7 +142,7 @@ inline void DynamicBloom::MayContain(int num_keys, Slice* keys,
 #pragma warning(disable : 4189)
 #endif
 inline void DynamicBloom::Prefetch(uint32_t h32) {
-  size_t a = FastRange32(kLen, h32);
+  size_t a = FastRange32(h32, kLen);
   PREFETCH(data_ + a, 0, 3);
 }
 #if defined(_MSC_VER)
@@ -171,7 +171,7 @@ inline void DynamicBloom::Prefetch(uint32_t h32) {
 // because of false positives.)
 
 inline bool DynamicBloom::MayContainHash(uint32_t h32) const {
-  size_t a = FastRange32(kLen, h32);
+  size_t a = FastRange32(h32, kLen);
   PREFETCH(data_ + a, 0, 3);
   return DoubleProbe(h32, a);
 }
@@ -195,7 +195,7 @@ inline bool DynamicBloom::DoubleProbe(uint32_t h32, size_t byte_offset) const {
 
 template <typename OrFunc>
 inline void DynamicBloom::AddHash(uint32_t h32, const OrFunc& or_func) {
-  size_t a = FastRange32(kLen, h32);
+  size_t a = FastRange32(h32, kLen);
   PREFETCH(data_ + a, 0, 3);
   // Expand/remix with 64-bit golden ratio
   uint64_t h = 0x9e3779b97f4a7c13ULL * h32;

package/deps/rocksdb/rocksdb/util/filelock_test.cc

@@ -11,6 +11,9 @@
 #include <sys/types.h>
 #include <sys/wait.h>
 #endif
+#ifdef __OpenBSD__
+#include <sys/wait.h>
+#endif
 #include <vector>
 
 #include "test_util/testharness.h"

package/deps/rocksdb/rocksdb/util/hash.h

@@ -128,10 +128,14 @@ inline uint32_t Upper32of64(uint64_t v) {
 }
 inline uint32_t Lower32of64(uint64_t v) { return static_cast<uint32_t>(v); }
 
-// std::hash compatible interface.
-// TODO: consider rename to SliceHasher32
-struct SliceHasher {
+// std::hash-like interface.
+struct SliceHasher32 {
   uint32_t operator()(const Slice& s) const { return GetSliceHash(s); }
 };
+struct SliceNPHasher64 {
+  uint64_t operator()(const Slice& s, uint64_t seed = 0) const {
+    return GetSliceNPHash64(s, seed);
+  }
+};
 
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/util/hash_test.cc

@@ -565,6 +565,8 @@ size_t FastRange64(uint64_t hash, size_t range) {
 // Tests for math.h / math128.h (not worth a separate test binary)
 using ROCKSDB_NAMESPACE::BitParity;
 using ROCKSDB_NAMESPACE::BitsSetToOne;
+using ROCKSDB_NAMESPACE::BitwiseAnd;
+using ROCKSDB_NAMESPACE::BottomNBits;
 using ROCKSDB_NAMESPACE::ConstexprFloorLog2;
 using ROCKSDB_NAMESPACE::CountTrailingZeroBits;
 using ROCKSDB_NAMESPACE::DecodeFixed128;
@@ -580,6 +582,19 @@ using ROCKSDB_NAMESPACE::Upper64of128;
 
 int blah(int x) { return DownwardInvolution(x); }
 
+template <typename T1, typename T2>
+static void test_BitwiseAnd(T1 v1, T2 v2) {
+  auto a = BitwiseAnd(v1, v2);
+  // Essentially repeating the implementation :-/
+  if constexpr (sizeof(T1) < sizeof(T2)) {
+    static_assert(std::is_same_v<decltype(a), T1>);
+    EXPECT_EQ(a, static_cast<T1>(v1 & v2));
+  } else {
+    static_assert(std::is_same_v<decltype(a), T2>);
+    EXPECT_EQ(a, static_cast<T2>(v1 & v2));
+  }
+}
+
 template <typename T>
 static void test_BitOps() {
   // This complex code is to generalize to 128-bit values. Otherwise
@@ -598,6 +613,22 @@ static void test_BitOps() {
     // If we could directly use arithmetic:
     // T vm1 = static_cast<T>(v - 1);
 
+    // BottomNBits
+    {
+      // An essentially full length value
+      T x = everyOtherBit;
+      if (i > 2) {
+        // Make it slightly irregular
+        x = x ^ (T{1} << (i / 2));
+      }
+      auto a = BottomNBits(x, i);
+      auto b = BottomNBits(~x, i);
+      EXPECT_EQ(x | a, x);
+      EXPECT_EQ(a | b, vm1);
+      EXPECT_EQ(a & b, T{0});
+      EXPECT_EQ(BottomNBits(x ^ a, i), T{0});
+    }
+
     // FloorLog2
     if (v > 0) {
       EXPECT_EQ(FloorLog2(v), i);
@@ -707,9 +738,22 @@ static void test_BitOps() {
       }
     }
 
+    // BitwiseAnd
+    {
+      test_BitwiseAnd(vm1, static_cast<char>(0x99));
+      test_BitwiseAnd(v, static_cast<char>(0x99));
+      test_BitwiseAnd(char{0x66}, vm1);
+      test_BitwiseAnd(char{0x66}, v);
+      test_BitwiseAnd(v, int16_t{0x6699});
+      test_BitwiseAnd(v, uint16_t{0x9966});
+      test_BitwiseAnd(int64_t{0x1234234534564567}, v);
+      test_BitwiseAnd(uint64_t{0x9876876576545432}, v);
+    }
+
     vm1 = (vm1 << 1) | 1;
   }
 
+  // ConstexprFloorLog2
   EXPECT_EQ(ConstexprFloorLog2(T{1}), 0);
   EXPECT_EQ(ConstexprFloorLog2(T{2}), 1);
   EXPECT_EQ(ConstexprFloorLog2(T{3}), 1);

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

@@ -9,6 +9,9 @@
 #ifdef _MSC_VER
 #include <intrin.h>
 #endif
+#ifdef __BMI2__
+#include <immintrin.h>
+#endif
 
 #include <cstdint>
 #include <type_traits>
@@ -20,11 +23,33 @@ ASSERT_FEATURE_COMPAT_HEADER();
 
 namespace ROCKSDB_NAMESPACE {
 
+// Fast implementation of extracting the bottom n bits of an integer.
+// To ensure fast implementation, undefined if n bits is full width or more.
+template <typename T>
+inline T BottomNBits(T v, int nbits) {
+  static_assert(std::is_integral_v<T>, "non-integral type");
+  static_assert(!std::is_reference_v<T>, "use std::remove_reference_t");
+  assert(nbits >= 0);
+  assert(nbits < int{8 * sizeof(T)});
+#ifdef __BMI2__
+  if constexpr (sizeof(T) <= 4) {
+    return static_cast<T>(_bzhi_u32(static_cast<uint32_t>(v), nbits));
+  }
+  if constexpr (sizeof(T) <= 8) {
+    return static_cast<T>(_bzhi_u64(static_cast<uint64_t>(v), 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));
+}
+
 // Fast implementation of floor(log2(v)). Undefined for 0 or negative
 // numbers (in case of signed type).
 template <typename T>
 inline int FloorLog2(T v) {
-  static_assert(std::is_integral<T>::value, "non-integral type");
+  static_assert(std::is_integral_v<T>, "non-integral type");
+  static_assert(!std::is_reference_v<T>, "use std::remove_reference_t");
   assert(v > 0);
 #ifdef _MSC_VER
   static_assert(sizeof(T) <= sizeof(uint64_t), "type too big");
@@ -63,6 +88,8 @@ inline int FloorLog2(T v) {
 // Constexpr version of FloorLog2
 template <typename T>
 constexpr int ConstexprFloorLog2(T v) {
+  // NOTE: not checking is_integral so that this works with Unsigned128
+  static_assert(!std::is_reference_v<T>, "use std::remove_reference_t");
   int rv = 0;
   while (v > T{1}) {
     ++rv;
@@ -74,7 +101,8 @@ constexpr int ConstexprFloorLog2(T v) {
 // Number of low-order zero bits before the first 1 bit. Undefined for 0.
 template <typename T>
 inline int CountTrailingZeroBits(T v) {
-  static_assert(std::is_integral<T>::value, "non-integral type");
+  static_assert(std::is_integral_v<T>, "non-integral type");
+  static_assert(!std::is_reference_v<T>, "use std::remove_reference_t");
   assert(v != 0);
 #ifdef _MSC_VER
   static_assert(sizeof(T) <= sizeof(uint64_t), "type too big");
@@ -115,6 +143,9 @@ namespace detail {
 
 template <typename T>
 int BitsSetToOneFallback(T v) {
+  static_assert(std::is_integral_v<T>, "non-integral type");
+  static_assert(!std::is_reference_v<T>, "use std::remove_reference_t");
+
   const int kBits = static_cast<int>(sizeof(T)) * 8;
   static_assert((kBits & (kBits - 1)) == 0, "must be power of two bits");
   // we static_cast these bit patterns in order to truncate them to the correct
@@ -140,7 +171,9 @@ int BitsSetToOneFallback(T v) {
 // Number of bits set to 1. Also known as "population count".
 template <typename T>
 inline int BitsSetToOne(T v) {
-  static_assert(std::is_integral<T>::value, "non-integral type");
+  static_assert(std::is_integral_v<T>, "non-integral type");
+  static_assert(!std::is_reference_v<T>, "use std::remove_reference_t");
+
 #ifdef _MSC_VER
   static_assert(sizeof(T) <= sizeof(uint64_t), "type too big");
   if (sizeof(T) < sizeof(uint32_t)) {
@@ -192,7 +225,9 @@ inline int BitsSetToOne(T v) {
 
 template <typename T>
 inline int BitParity(T v) {
-  static_assert(std::is_integral<T>::value, "non-integral type");
+  static_assert(std::is_integral_v<T>, "non-integral type");
+  static_assert(!std::is_reference_v<T>, "use std::remove_reference_t");
+
 #ifdef _MSC_VER
   // bit parity == oddness of popcount
   return BitsSetToOne(v) & 1;
@@ -214,7 +249,8 @@ inline int BitParity(T v) {
 // encode/decode big endian.
 template <typename T>
 inline T EndianSwapValue(T v) {
-  static_assert(std::is_integral<T>::value, "non-integral type");
+  static_assert(std::is_integral_v<T>, "non-integral type");
+  static_assert(!std::is_reference_v<T>, "use std::remove_reference_t");
 
 #ifdef _MSC_VER
   if (sizeof(T) == 2) {
@@ -244,6 +280,9 @@ inline T EndianSwapValue(T v) {
 // Reverses the order of bits in an integral value
 template <typename T>
 inline T ReverseBits(T v) {
+  static_assert(std::is_integral_v<T>, "non-integral type");
+  static_assert(!std::is_reference_v<T>, "use std::remove_reference_t");
+
   T r = EndianSwapValue(v);
   const T kHighestByte = T{1} << ((sizeof(T) - 1) * 8);
   const T kEveryByte = kHighestByte | (kHighestByte / 255);
@@ -277,7 +316,8 @@ inline T ReverseBits(T v) {
 // is that all square sub-matrices that include the top row are invertible.
 template <typename T>
 inline T DownwardInvolution(T v) {
-  static_assert(std::is_integral<T>::value, "non-integral type");
+  static_assert(std::is_integral_v<T>, "non-integral type");
+  static_assert(!std::is_reference_v<T>, "use std::remove_reference_t");
   static_assert(sizeof(T) <= 8, "only supported up to 64 bits");
 
   uint64_t r = static_cast<uint64_t>(v);
@@ -296,4 +336,16 @@ inline T DownwardInvolution(T v) {
   return static_cast<T>(r);
 }
 
+// Bitwise-And with typing that allows you to avoid writing an explicit cast
+// to the smaller type, or the type of the right parameter if same size.
+template <typename A, typename B>
+inline std::conditional_t<sizeof(A) < sizeof(B), A, B> BitwiseAnd(A a, B b) {
+  static_assert(std::is_integral_v<A>, "non-integral type");
+  static_assert(std::is_integral_v<B>, "non-integral type");
+  static_assert(!std::is_reference_v<A>, "use std::remove_reference_t");
+  static_assert(!std::is_reference_v<B>, "use std::remove_reference_t");
+  using Smaller = std::conditional_t<sizeof(A) < sizeof(B), A, B>;
+  return static_cast<Smaller>(a & b);
+}
+
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/util/math128.h

@@ -41,13 +41,13 @@ struct Unsigned128 {
     hi = upper;
   }
 
-  explicit operator uint64_t() { return lo; }
-
-  explicit operator uint32_t() { return static_cast<uint32_t>(lo); }
-
-  explicit operator uint16_t() { return static_cast<uint16_t>(lo); }
-
-  explicit operator uint8_t() { return static_cast<uint8_t>(lo); }
+  // Convert to any integer 64 bits or less.
+  template <typename T,
+            typename = std::enable_if_t<std::is_integral_v<T> &&
+                                        sizeof(T) <= sizeof(uint64_t)> >
+  explicit operator T() {
+    return static_cast<T>(lo);
+  }
 };
 
 inline Unsigned128 operator<<(const Unsigned128& lhs, unsigned shift) {
@@ -190,6 +190,16 @@ inline Unsigned128 Multiply64to128(uint64_t a, uint64_t b) {
 #endif
 }
 
+template <>
+inline Unsigned128 BottomNBits(Unsigned128 v, int nbits) {
+  if (nbits < 64) {
+    return BottomNBits(Lower64of128(v), nbits);
+  } else {
+    return (Unsigned128{BottomNBits(Upper64of128(v), nbits - 64)} << 64) |
+           Lower64of128(v);
+  }
+}
+
 template <>
 inline int FloorLog2(Unsigned128 v) {
   if (Upper64of128(v) == 0) {
@@ -236,6 +246,18 @@ inline Unsigned128 DownwardInvolution(Unsigned128 v) {
          DownwardInvolution(Upper64of128(v) ^ Lower64of128(v));
 }
 
+template <typename A>
+inline std::remove_reference_t<A> BitwiseAnd(A a, Unsigned128 b) {
+  static_assert(sizeof(A) <= sizeof(Unsigned128));
+  return static_cast<A>(a & b);
+}
+
+template <typename B>
+inline std::remove_reference_t<B> BitwiseAnd(Unsigned128 a, B b) {
+  static_assert(sizeof(B) <= sizeof(Unsigned128));
+  return static_cast<B>(a & b);
+}
+
 template <typename T>
 struct IsUnsignedUpTo128
     : std::integral_constant<bool, std::is_unsigned<T>::value ||