@nxtedition/rocksdb 8.2.0 → 8.2.2

package/deps/rocksdb/rocksdb/cache/clock_cache.cc

@@ -16,7 +16,7 @@
 #include "cache/secondary_cache_adapter.h"
 #include "logging/logging.h"
 #include "monitoring/perf_context_imp.h"
-#include "monitoring/statistics.h"
+#include "monitoring/statistics_impl.h"
 #include "port/lang.h"
 #include "rocksdb/env.h"
 #include "util/hash.h"
@@ -130,7 +130,8 @@ HyperClockTable::HyperClockTable(
     size_t capacity, bool /*strict_capacity_limit*/,
     CacheMetadataChargePolicy metadata_charge_policy,
     MemoryAllocator* allocator,
-    const Cache::EvictionCallback* eviction_callback, const Opts& opts)
+    const Cache::EvictionCallback* eviction_callback, const uint32_t* hash_seed,
+    const Opts& opts)
     : length_bits_(CalcHashBits(capacity, opts.estimated_value_size,
                                 metadata_charge_policy)),
       length_bits_mask_((size_t{1} << length_bits_) - 1),
@@ -138,7 +139,8 @@ HyperClockTable::HyperClockTable(
                                            kStrictLoadFactor)),
       array_(new HandleImpl[size_t{1} << length_bits_]),
       allocator_(allocator),
-      eviction_callback_(*eviction_callback) {
+      eviction_callback_(*eviction_callback),
+      hash_seed_(*hash_seed) {
   if (metadata_charge_policy ==
       CacheMetadataChargePolicy::kFullChargeCacheMetadata) {
     usage_ += size_t{GetTableSize()} * sizeof(HandleImpl);
@@ -1010,7 +1012,7 @@ inline void HyperClockTable::Evict(size_t requested_charge,
         if (eviction_callback_) {
           took_ownership =
               eviction_callback_(ClockCacheShard<HyperClockTable>::ReverseHash(
-                                     h.GetHash(), &unhashed),
+                                     h.GetHash(), &unhashed, hash_seed_),
                                  reinterpret_cast<Cache::Handle*>(&h));
         }
         if (!took_ownership) {
@@ -1039,11 +1041,11 @@ ClockCacheShard<Table>::ClockCacheShard(
     size_t capacity, bool strict_capacity_limit,
     CacheMetadataChargePolicy metadata_charge_policy,
     MemoryAllocator* allocator,
-    const Cache::EvictionCallback* eviction_callback,
+    const Cache::EvictionCallback* eviction_callback, const uint32_t* hash_seed,
     const typename Table::Opts& opts)
     : CacheShardBase(metadata_charge_policy),
       table_(capacity, strict_capacity_limit, metadata_charge_policy, allocator,
-             eviction_callback, opts),
+             eviction_callback, hash_seed, opts),
       capacity_(capacity),
       strict_capacity_limit_(strict_capacity_limit) {
   // Initial charge metadata should not exceed capacity
@@ -1082,10 +1084,11 @@ void ClockCacheShard<Table>::ApplyToSomeEntries(
     *state = index_end << (sizeof(size_t) * 8u - length_bits);
   }
 
+  auto hash_seed = table_.GetHashSeed();
   table_.ConstApplyToEntriesRange(
-      [callback](const HandleImpl& h) {
+      [callback, hash_seed](const HandleImpl& h) {
         UniqueId64x2 unhashed;
-        callback(ReverseHash(h.hashed_key, &unhashed), h.value,
+        callback(ReverseHash(h.hashed_key, &unhashed, hash_seed), h.value,
                  h.GetTotalCharge(), h.helper);
       },
       index_begin, index_end, false);
@@ -1282,25 +1285,20 @@ size_t ClockCacheShard<Table>::GetTableAddressCount() const {
 // Explicit instantiation
 template class ClockCacheShard<HyperClockTable>;
 
-HyperClockCache::HyperClockCache(
-    size_t capacity, size_t estimated_value_size, int num_shard_bits,
-    bool strict_capacity_limit,
-    CacheMetadataChargePolicy metadata_charge_policy,
-    std::shared_ptr<MemoryAllocator> memory_allocator)
-    : ShardedCache(capacity, num_shard_bits, strict_capacity_limit,
-                   std::move(memory_allocator)) {
-  assert(estimated_value_size > 0 ||
-         metadata_charge_policy != kDontChargeCacheMetadata);
+HyperClockCache::HyperClockCache(const HyperClockCacheOptions& opts)
+    : ShardedCache(opts) {
+  assert(opts.estimated_entry_charge > 0 ||
+         opts.metadata_charge_policy != kDontChargeCacheMetadata);
   // TODO: should not need to go through two levels of pointer indirection to
   // get to table entries
   size_t per_shard = GetPerShardCapacity();
   MemoryAllocator* alloc = this->memory_allocator();
-  const Cache::EvictionCallback* eviction_callback = &eviction_callback_;
-  InitShards([=](Shard* cs) {
-    HyperClockTable::Opts opts;
-    opts.estimated_value_size = estimated_value_size;
-    new (cs) Shard(per_shard, strict_capacity_limit, metadata_charge_policy,
-                   alloc, eviction_callback, opts);
+  InitShards([&](Shard* cs) {
+    HyperClockTable::Opts table_opts;
+    table_opts.estimated_value_size = opts.estimated_entry_charge;
+    new (cs) Shard(per_shard, opts.strict_capacity_limit,
+                   opts.metadata_charge_policy, alloc, &eviction_callback_,
+                   &hash_seed_, table_opts);
   });
 }
 
@@ -1460,21 +1458,23 @@ std::shared_ptr<Cache> NewClockCache(
 }
 
 std::shared_ptr<Cache> HyperClockCacheOptions::MakeSharedCache() const {
-  auto my_num_shard_bits = num_shard_bits;
-  if (my_num_shard_bits >= 20) {
+  // For sanitized options
+  HyperClockCacheOptions opts = *this;
+  if (opts.num_shard_bits >= 20) {
     return nullptr;  // The cache cannot be sharded into too many fine pieces.
   }
-  if (my_num_shard_bits < 0) {
+  if (opts.num_shard_bits < 0) {
     // Use larger shard size to reduce risk of large entries clustering
     // or skewing individual shards.
     constexpr size_t min_shard_size = 32U * 1024U * 1024U;
-    my_num_shard_bits = GetDefaultCacheShardBits(capacity, min_shard_size);
+    opts.num_shard_bits =
+        GetDefaultCacheShardBits(opts.capacity, min_shard_size);
   }
-  std::shared_ptr<Cache> cache = std::make_shared<clock_cache::HyperClockCache>(
-      capacity, estimated_entry_charge, my_num_shard_bits,
-      strict_capacity_limit, metadata_charge_policy, memory_allocator);
-  if (secondary_cache) {
-    cache = std::make_shared<CacheWithSecondaryAdapter>(cache, secondary_cache);
+  std::shared_ptr<Cache> cache =
+      std::make_shared<clock_cache::HyperClockCache>(opts);
+  if (opts.secondary_cache) {
+    cache = std::make_shared<CacheWithSecondaryAdapter>(cache,
+                                                        opts.secondary_cache);
   }
   return cache;
 }

package/deps/rocksdb/rocksdb/cache/clock_cache.h

@@ -407,7 +407,7 @@ class HyperClockTable {
                   CacheMetadataChargePolicy metadata_charge_policy,
                   MemoryAllocator* allocator,
                   const Cache::EvictionCallback* eviction_callback,
-                  const Opts& opts);
+                  const uint32_t* hash_seed, const Opts& opts);
   ~HyperClockTable();
 
   Status Insert(const ClockHandleBasicData& proto, HandleImpl** handle,
@@ -448,6 +448,8 @@ class HyperClockTable {
     return standalone_usage_.load(std::memory_order_relaxed);
   }
 
+  uint32_t GetHashSeed() const { return hash_seed_; }
+
   // Acquire/release N references
   void TEST_RefN(HandleImpl& handle, size_t n);
   void TEST_ReleaseN(HandleImpl* handle, size_t n);
@@ -546,6 +548,9 @@ class HyperClockTable {
   // A reference to Cache::eviction_callback_
   const Cache::EvictionCallback& eviction_callback_;
 
+  // A reference to ShardedCacheBase::hash_seed_
+  const uint32_t& hash_seed_;
+
   // We partition the following members into different cache lines
   // to avoid false sharing among Lookup, Release, Erase and Insert
   // operations in ClockCacheShard.
@@ -573,7 +578,7 @@ class ALIGN_AS(CACHE_LINE_SIZE) ClockCacheShard final : public CacheShardBase {
                   CacheMetadataChargePolicy metadata_charge_policy,
                   MemoryAllocator* allocator,
                   const Cache::EvictionCallback* eviction_callback,
-                  const typename Table::Opts& opts);
+                  const uint32_t* hash_seed, const typename Table::Opts& opts);
 
   // For CacheShard concept
   using HandleImpl = typename Table::HandleImpl;
@@ -583,22 +588,23 @@ class ALIGN_AS(CACHE_LINE_SIZE) ClockCacheShard final : public CacheShardBase {
   static inline uint32_t HashPieceForSharding(HashCref hash) {
     return Upper32of64(hash[0]);
   }
-  static inline HashVal ComputeHash(const Slice& key) {
+  static inline HashVal ComputeHash(const Slice& key, uint32_t seed) {
     assert(key.size() == kCacheKeySize);
     HashVal in;
     HashVal out;
     // NOTE: endian dependence
     // TODO: use GetUnaligned?
     std::memcpy(&in, key.data(), kCacheKeySize);
-    BijectiveHash2x64(in[1], in[0], &out[1], &out[0]);
+    BijectiveHash2x64(in[1], in[0] ^ seed, &out[1], &out[0]);
     return out;
   }
 
   // For reconstructing key from hashed_key. Requires the caller to provide
   // backing storage for the Slice in `unhashed`
   static inline Slice ReverseHash(const UniqueId64x2& hashed,
-                                  UniqueId64x2* unhashed) {
+                                  UniqueId64x2* unhashed, uint32_t seed) {
     BijectiveUnhash2x64(hashed[1], hashed[0], &(*unhashed)[1], &(*unhashed)[0]);
+    (*unhashed)[0] ^= seed;
     // NOTE: endian dependence
     return Slice(reinterpret_cast<const char*>(unhashed), kCacheKeySize);
   }
@@ -682,10 +688,7 @@ class HyperClockCache
  public:
   using Shard = ClockCacheShard<HyperClockTable>;
 
-  HyperClockCache(size_t capacity, size_t estimated_value_size,
-                  int num_shard_bits, bool strict_capacity_limit,
-                  CacheMetadataChargePolicy metadata_charge_policy,
-                  std::shared_ptr<MemoryAllocator> memory_allocator);
+  explicit HyperClockCache(const HyperClockCacheOptions& opts);
 
   const char* Name() const override { return "HyperClockCache"; }
 

package/deps/rocksdb/rocksdb/cache/compressed_secondary_cache.cc

@@ -9,7 +9,7 @@
 #include <cstdint>
 #include <memory>
 
-#include "memory/memory_allocator.h"
+#include "memory/memory_allocator_impl.h"
 #include "monitoring/perf_context_imp.h"
 #include "util/compression.h"
 #include "util/string_util.h"
@@ -17,23 +17,8 @@
 namespace ROCKSDB_NAMESPACE {
 
 CompressedSecondaryCache::CompressedSecondaryCache(
-    size_t capacity, int num_shard_bits, bool strict_capacity_limit,
-    double high_pri_pool_ratio, double low_pri_pool_ratio,
-    std::shared_ptr<MemoryAllocator> memory_allocator, bool use_adaptive_mutex,
-    CacheMetadataChargePolicy metadata_charge_policy,
-    CompressionType compression_type, uint32_t compress_format_version,
-    bool enable_custom_split_merge,
-    const CacheEntryRoleSet& do_not_compress_roles)
-    : cache_options_(capacity, num_shard_bits, strict_capacity_limit,
-                     high_pri_pool_ratio, low_pri_pool_ratio, memory_allocator,
-                     use_adaptive_mutex, metadata_charge_policy,
-                     compression_type, compress_format_version,
-                     enable_custom_split_merge, do_not_compress_roles) {
-  cache_ =
-      NewLRUCache(capacity, num_shard_bits, strict_capacity_limit,
-                  high_pri_pool_ratio, memory_allocator, use_adaptive_mutex,
-                  metadata_charge_policy, low_pri_pool_ratio);
-}
+    const CompressedSecondaryCacheOptions& opts)
+    : cache_(opts.LRUCacheOptions::MakeSharedCache()), cache_options_(opts) {}
 
 CompressedSecondaryCache::~CompressedSecondaryCache() { cache_.reset(); }
 
@@ -311,31 +296,9 @@ const Cache::CacheItemHelper* CompressedSecondaryCache::GetHelper(
   }
 }
 
-std::shared_ptr<SecondaryCache> NewCompressedSecondaryCache(
-    size_t capacity, int num_shard_bits, bool strict_capacity_limit,
-    double high_pri_pool_ratio, double low_pri_pool_ratio,
-    std::shared_ptr<MemoryAllocator> memory_allocator, bool use_adaptive_mutex,
-    CacheMetadataChargePolicy metadata_charge_policy,
-    CompressionType compression_type, uint32_t compress_format_version,
-    bool enable_custom_split_merge,
-    const CacheEntryRoleSet& do_not_compress_roles) {
-  return std::make_shared<CompressedSecondaryCache>(
-      capacity, num_shard_bits, strict_capacity_limit, high_pri_pool_ratio,
-      low_pri_pool_ratio, memory_allocator, use_adaptive_mutex,
-      metadata_charge_policy, compression_type, compress_format_version,
-      enable_custom_split_merge, do_not_compress_roles);
-}
-
-std::shared_ptr<SecondaryCache> NewCompressedSecondaryCache(
-    const CompressedSecondaryCacheOptions& opts) {
-  // The secondary_cache is disabled for this LRUCache instance.
-  assert(opts.secondary_cache == nullptr);
-  return NewCompressedSecondaryCache(
-      opts.capacity, opts.num_shard_bits, opts.strict_capacity_limit,
-      opts.high_pri_pool_ratio, opts.low_pri_pool_ratio, opts.memory_allocator,
-      opts.use_adaptive_mutex, opts.metadata_charge_policy,
-      opts.compression_type, opts.compress_format_version,
-      opts.enable_custom_split_merge, opts.do_not_compress_roles);
+std::shared_ptr<SecondaryCache>
+CompressedSecondaryCacheOptions::MakeSharedSecondaryCache() const {
+  return std::make_shared<CompressedSecondaryCache>(*this);
 }
 
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/cache/compressed_secondary_cache.h

@@ -10,7 +10,7 @@
 #include <memory>
 
 #include "cache/lru_cache.h"
-#include "memory/memory_allocator.h"
+#include "memory/memory_allocator_impl.h"
 #include "rocksdb/secondary_cache.h"
 #include "rocksdb/slice.h"
 #include "rocksdb/status.h"
@@ -69,18 +69,8 @@ class CompressedSecondaryCacheResultHandle : public SecondaryCacheResultHandle {
 
 class CompressedSecondaryCache : public SecondaryCache {
  public:
-  CompressedSecondaryCache(
-      size_t capacity, int num_shard_bits, bool strict_capacity_limit,
-      double high_pri_pool_ratio, double low_pri_pool_ratio,
-      std::shared_ptr<MemoryAllocator> memory_allocator = nullptr,
-      bool use_adaptive_mutex = kDefaultToAdaptiveMutex,
-      CacheMetadataChargePolicy metadata_charge_policy =
-          kDefaultCacheMetadataChargePolicy,
-      CompressionType compression_type = CompressionType::kLZ4Compression,
-      uint32_t compress_format_version = 2,
-      bool enable_custom_split_merge = false,
-      const CacheEntryRoleSet& do_not_compress_roles = {
-          CacheEntryRole::kFilterBlock});
+  explicit CompressedSecondaryCache(
+      const CompressedSecondaryCacheOptions& opts);
   ~CompressedSecondaryCache() override;
 
   const char* Name() const override { return "CompressedSecondaryCache"; }

package/deps/rocksdb/rocksdb/cache/compressed_secondary_cache_test.cc

@@ -626,8 +626,9 @@ class CompressedSecondaryCacheTestBase : public testing::Test,
 
     using CacheValueChunk = CompressedSecondaryCache::CacheValueChunk;
     std::unique_ptr<CompressedSecondaryCache> sec_cache =
-        std::make_unique<CompressedSecondaryCache>(1000, 0, true, 0.5, 0.0,
-                                                   allocator);
+        std::make_unique<CompressedSecondaryCache>(
+            CompressedSecondaryCacheOptions(1000, 0, true, 0.5, 0.0,
+                                            allocator));
     Random rnd(301);
     // 8500 = 8169 + 233 + 98, so there should be 3 chunks after split.
     size_t str_size{8500};
@@ -678,7 +679,8 @@ class CompressedSecondaryCacheTestBase : public testing::Test,
     std::string str = str1 + str2 + str3;
 
     std::unique_ptr<CompressedSecondaryCache> sec_cache =
-        std::make_unique<CompressedSecondaryCache>(1000, 0, true, 0.5, 0.0);
+        std::make_unique<CompressedSecondaryCache>(
+            CompressedSecondaryCacheOptions(1000, 0, true, 0.5, 0.0));
     size_t charge{0};
     CacheAllocationPtr value =
         sec_cache->MergeChunksIntoValue(chunks_head, charge);
@@ -708,8 +710,9 @@ class CompressedSecondaryCacheTestBase : public testing::Test,
 
     using CacheValueChunk = CompressedSecondaryCache::CacheValueChunk;
     std::unique_ptr<CompressedSecondaryCache> sec_cache =
-        std::make_unique<CompressedSecondaryCache>(1000, 0, true, 0.5, 0.0,
-                                                   allocator);
+        std::make_unique<CompressedSecondaryCache>(
+            CompressedSecondaryCacheOptions(1000, 0, true, 0.5, 0.0,
+                                            allocator));
     Random rnd(301);
     // 8500 = 8169 + 233 + 98, so there should be 3 chunks after split.
     size_t str_size{8500};

package/deps/rocksdb/rocksdb/cache/lru_cache.cc

@@ -16,7 +16,7 @@
 
 #include "cache/secondary_cache_adapter.h"
 #include "monitoring/perf_context_imp.h"
-#include "monitoring/statistics.h"
+#include "monitoring/statistics_impl.h"
 #include "port/lang.h"
 #include "util/distributed_mutex.h"
 
@@ -646,23 +646,15 @@ void LRUCacheShard::AppendPrintableOptions(std::string& str) const {
   str.append(buffer);
 }
 
-LRUCache::LRUCache(size_t capacity, int num_shard_bits,
-                   bool strict_capacity_limit, double high_pri_pool_ratio,
-                   double low_pri_pool_ratio,
-                   std::shared_ptr<MemoryAllocator> allocator,
-                   bool use_adaptive_mutex,
-                   CacheMetadataChargePolicy metadata_charge_policy)
-    : ShardedCache(capacity, num_shard_bits, strict_capacity_limit,
-                   std::move(allocator)) {
+LRUCache::LRUCache(const LRUCacheOptions& opts) : ShardedCache(opts) {
   size_t per_shard = GetPerShardCapacity();
   MemoryAllocator* alloc = memory_allocator();
-  const EvictionCallback* eviction_callback = &eviction_callback_;
-  InitShards([=](LRUCacheShard* cs) {
-    new (cs) LRUCacheShard(per_shard, strict_capacity_limit,
-                           high_pri_pool_ratio, low_pri_pool_ratio,
-                           use_adaptive_mutex, metadata_charge_policy,
-                           /* max_upper_hash_bits */ 32 - num_shard_bits, alloc,
-                           eviction_callback);
+  InitShards([&](LRUCacheShard* cs) {
+    new (cs) LRUCacheShard(per_shard, opts.strict_capacity_limit,
+                           opts.high_pri_pool_ratio, opts.low_pri_pool_ratio,
+                           opts.use_adaptive_mutex, opts.metadata_charge_policy,
+                           /* max_upper_hash_bits */ 32 - opts.num_shard_bits,
+                           alloc, &eviction_callback_);
   });
 }
 
@@ -692,13 +684,7 @@ double LRUCache::GetHighPriPoolRatio() {
 
 }  // namespace lru_cache
 
-std::shared_ptr<Cache> NewLRUCache(
-    size_t capacity, int num_shard_bits, bool strict_capacity_limit,
-    double high_pri_pool_ratio,
-    std::shared_ptr<MemoryAllocator> memory_allocator, bool use_adaptive_mutex,
-    CacheMetadataChargePolicy metadata_charge_policy,
-    const std::shared_ptr<SecondaryCache>& secondary_cache,
-    double low_pri_pool_ratio) {
+std::shared_ptr<Cache> LRUCacheOptions::MakeSharedCache() const {
   if (num_shard_bits >= 20) {
     return nullptr;  // The cache cannot be sharded into too many fine pieces.
   }
@@ -714,36 +700,24 @@ std::shared_ptr<Cache> NewLRUCache(
     // Invalid high_pri_pool_ratio and low_pri_pool_ratio combination
     return nullptr;
   }
-  if (num_shard_bits < 0) {
-    num_shard_bits = GetDefaultCacheShardBits(capacity);
+  // For sanitized options
+  LRUCacheOptions opts = *this;
+  if (opts.num_shard_bits < 0) {
+    opts.num_shard_bits = GetDefaultCacheShardBits(capacity);
   }
-  std::shared_ptr<Cache> cache = std::make_shared<LRUCache>(
-      capacity, num_shard_bits, strict_capacity_limit, high_pri_pool_ratio,
-      low_pri_pool_ratio, std::move(memory_allocator), use_adaptive_mutex,
-      metadata_charge_policy);
+  std::shared_ptr<Cache> cache = std::make_shared<LRUCache>(opts);
   if (secondary_cache) {
     cache = std::make_shared<CacheWithSecondaryAdapter>(cache, secondary_cache);
   }
   return cache;
 }
 
-std::shared_ptr<Cache> NewLRUCache(const LRUCacheOptions& cache_opts) {
-  return NewLRUCache(cache_opts.capacity, cache_opts.num_shard_bits,
-                     cache_opts.strict_capacity_limit,
-                     cache_opts.high_pri_pool_ratio,
-                     cache_opts.memory_allocator, cache_opts.use_adaptive_mutex,
-                     cache_opts.metadata_charge_policy,
-                     cache_opts.secondary_cache, cache_opts.low_pri_pool_ratio);
-}
-
-std::shared_ptr<Cache> NewLRUCache(
-    size_t capacity, int num_shard_bits, bool strict_capacity_limit,
-    double high_pri_pool_ratio,
-    std::shared_ptr<MemoryAllocator> memory_allocator, bool use_adaptive_mutex,
-    CacheMetadataChargePolicy metadata_charge_policy,
-    double low_pri_pool_ratio) {
-  return NewLRUCache(capacity, num_shard_bits, strict_capacity_limit,
-                     high_pri_pool_ratio, memory_allocator, use_adaptive_mutex,
-                     metadata_charge_policy, nullptr, low_pri_pool_ratio);
+std::shared_ptr<GeneralCache> LRUCacheOptions::MakeSharedGeneralCache() const {
+  if (secondary_cache) {
+    // Not allowed for a GeneralCache
+    return nullptr;
+  }
+  // Works while GeneralCache is an alias for Cache
+  return MakeSharedCache();
 }
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/cache/lru_cache.h

@@ -279,8 +279,8 @@ class ALIGN_AS(CACHE_LINE_SIZE) LRUCacheShard final : public CacheShardBase {
   using HashCref = uint32_t;
 
  public:  // Function definitions expected as parameter to ShardedCache
-  static inline HashVal ComputeHash(const Slice& key) {
-    return Lower32of64(GetSliceNPHash64(key));
+  static inline HashVal ComputeHash(const Slice& key, uint32_t seed) {
+    return Lower32of64(GetSliceNPHash64(key, seed));
   }
 
   // Separate from constructor so caller can easily make an array of LRUCache
@@ -446,12 +446,7 @@ class LRUCache
 #endif
     : public ShardedCache<LRUCacheShard> {
  public:
-  LRUCache(size_t capacity, int num_shard_bits, bool strict_capacity_limit,
-           double high_pri_pool_ratio, double low_pri_pool_ratio,
-           std::shared_ptr<MemoryAllocator> memory_allocator = nullptr,
-           bool use_adaptive_mutex = kDefaultToAdaptiveMutex,
-           CacheMetadataChargePolicy metadata_charge_policy =
-               kDontChargeCacheMetadata);
+  explicit LRUCache(const LRUCacheOptions& opts);
   const char* Name() const override { return "LRUCache"; }
   ObjectPtr Value(Handle* handle) override;
   size_t GetCharge(Handle* handle) const override;

package/deps/rocksdb/rocksdb/cache/lru_cache_test.cc

@@ -397,7 +397,7 @@ class ClockCacheTest : public testing::Test {
     opts.estimated_value_size = 1;
     new (shard_)
         Shard(capacity, strict_capacity_limit, kDontChargeCacheMetadata,
-              /*allocator*/ nullptr, &eviction_callback_, opts);
+              /*allocator*/ nullptr, &eviction_callback_, &hash_seed_, opts);
   }
 
   Status Insert(const UniqueId64x2& hashed_key,
@@ -455,6 +455,7 @@ class ClockCacheTest : public testing::Test {
 
  private:
   Cache::EvictionCallback eviction_callback_;
+  uint32_t hash_seed_ = 0;
 };
 
 TEST_F(ClockCacheTest, Misc) {

package/deps/rocksdb/rocksdb/cache/secondary_cache_adapter.cc

@@ -95,8 +95,7 @@ Cache::Handle* CacheWithSecondaryAdapter::Promote(
   PERF_COUNTER_ADD(secondary_cache_hit_count, 1);
   RecordTick(stats, SECONDARY_CACHE_HITS);
 
-  // FIXME? using charge=Size() is suspicious but inherited from older
-  // implementation
+  // Note: SecondaryCache::Size() is really charge (from the CreateCallback)
   size_t charge = secondary_handle->Size();
   Handle* result = nullptr;
   // Insert into primary cache, possibly as a standalone+dummy entries.

package/deps/rocksdb/rocksdb/cache/sharded_cache.cc

@@ -13,20 +13,57 @@
 #include <cstdint>
 #include <memory>
 
+#include "env/unique_id_gen.h"
+#include "rocksdb/env.h"
 #include "util/hash.h"
 #include "util/math.h"
 #include "util/mutexlock.h"
 
 namespace ROCKSDB_NAMESPACE {
+namespace {
+// The generated seeds must fit in 31 bits so that
+// ShardedCacheOptions::hash_seed can be set to it explicitly, for
+// diagnostic/debugging purposes.
+constexpr uint32_t kSeedMask = 0x7fffffff;
+uint32_t DetermineSeed(int32_t hash_seed_option) {
+  if (hash_seed_option >= 0) {
+    // User-specified exact seed
+    return static_cast<uint32_t>(hash_seed_option);
+  }
+  static SemiStructuredUniqueIdGen gen;
+  if (hash_seed_option == ShardedCacheOptions::kHostHashSeed) {
+    std::string hostname;
+    Status s = Env::Default()->GetHostNameString(&hostname);
+    if (s.ok()) {
+      return GetSliceHash(hostname) & kSeedMask;
+    } else {
+      // Fall back on something stable within the process.
+      return static_cast<uint32_t>(gen.GetBaseUpper()) & kSeedMask;
+    }
+  } else {
+    // for kQuasiRandomHashSeed and fallback
+    uint32_t val = gen.GenerateNext<uint32_t>() & kSeedMask;
+    // Perform some 31-bit bijective transformations so that we get
+    // quasirandom, not just incrementing. (An incrementing seed from a
+    // random starting point would be fine, but hard to describe in a name.)
+    // See https://en.wikipedia.org/wiki/Quasirandom and using a murmur-like
+    // transformation here for our bijection in the lower 31 bits.
+    // See https://en.wikipedia.org/wiki/MurmurHash
+    val *= /*31-bit prime*/ 1150630961;
+    val ^= (val & kSeedMask) >> 17;
+    val *= /*31-bit prime*/ 1320603883;
+    return val & kSeedMask;
+  }
+}
+}  // namespace
 
-ShardedCacheBase::ShardedCacheBase(size_t capacity, int num_shard_bits,
-                                   bool strict_capacity_limit,
-                                   std::shared_ptr<MemoryAllocator> allocator)
-    : Cache(std::move(allocator)),
+ShardedCacheBase::ShardedCacheBase(const ShardedCacheOptions& opts)
+    : Cache(opts.memory_allocator),
       last_id_(1),
-      shard_mask_((uint32_t{1} << num_shard_bits) - 1),
-      strict_capacity_limit_(strict_capacity_limit),
-      capacity_(capacity) {}
+      shard_mask_((uint32_t{1} << opts.num_shard_bits) - 1),
+      hash_seed_(DetermineSeed(opts.hash_seed)),
+      strict_capacity_limit_(opts.strict_capacity_limit),
+      capacity_(opts.capacity) {}
 
 size_t ShardedCacheBase::ComputePerShardCapacity(size_t capacity) const {
   uint32_t num_shards = GetNumShards();

package/deps/rocksdb/rocksdb/cache/sharded_cache.h

@@ -34,8 +34,8 @@ class CacheShardBase {
   std::string GetPrintableOptions() const { return ""; }
   using HashVal = uint64_t;
   using HashCref = uint64_t;
-  static inline HashVal ComputeHash(const Slice& key) {
-    return GetSliceNPHash64(key);
+  static inline HashVal ComputeHash(const Slice& key, uint32_t seed) {
+    return GetSliceNPHash64(key, seed);
   }
   static inline uint32_t HashPieceForSharding(HashCref hash) {
     return Lower32of64(hash);
@@ -89,9 +89,7 @@ class CacheShardBase {
 // Portions of ShardedCache that do not depend on the template parameter
 class ShardedCacheBase : public Cache {
  public:
-  ShardedCacheBase(size_t capacity, int num_shard_bits,
-                   bool strict_capacity_limit,
-                   std::shared_ptr<MemoryAllocator> memory_allocator);
+  explicit ShardedCacheBase(const ShardedCacheOptions& opts);
   virtual ~ShardedCacheBase() = default;
 
   int GetNumShardBits() const;
@@ -106,6 +104,8 @@ class ShardedCacheBase : public Cache {
   size_t GetUsage(Handle* handle) const override;
   std::string GetPrintableOptions() const override;
 
+  uint32_t GetHashSeed() const override { return hash_seed_; }
+
  protected:  // fns
   virtual void AppendPrintableOptions(std::string& str) const = 0;
   size_t GetPerShardCapacity() const;
@@ -114,6 +114,7 @@ class ShardedCacheBase : public Cache {
  protected:                        // data
   std::atomic<uint64_t> last_id_;  // For NewId
   const uint32_t shard_mask_;
+  const uint32_t hash_seed_;
 
   // Dynamic configuration parameters, guarded by config_mutex_
   bool strict_capacity_limit_;
@@ -134,10 +135,8 @@ class ShardedCache : public ShardedCacheBase {
   using HashCref = typename CacheShard::HashCref;
   using HandleImpl = typename CacheShard::HandleImpl;
 
-  ShardedCache(size_t capacity, int num_shard_bits, bool strict_capacity_limit,
-               std::shared_ptr<MemoryAllocator> allocator)
-      : ShardedCacheBase(capacity, num_shard_bits, strict_capacity_limit,
-                         allocator),
+  explicit ShardedCache(const ShardedCacheOptions& opts)
+      : ShardedCacheBase(opts),
         shards_(reinterpret_cast<CacheShard*>(port::cacheline_aligned_alloc(
             sizeof(CacheShard) * GetNumShards()))),
         destroy_shards_in_dtor_(false) {}
@@ -175,7 +174,7 @@ class ShardedCache : public ShardedCacheBase {
                 size_t charge, Handle** handle = nullptr,
                 Priority priority = Priority::LOW) override {
     assert(helper);
-    HashVal hash = CacheShard::ComputeHash(key);
+    HashVal hash = CacheShard::ComputeHash(key, hash_seed_);
     auto h_out = reinterpret_cast<HandleImpl**>(handle);
     return GetShard(hash).Insert(key, hash, obj, helper, charge, h_out,
                                  priority);
@@ -185,7 +184,7 @@ class ShardedCache : public ShardedCacheBase {
                            const CacheItemHelper* helper, size_t charge,
                            bool allow_uncharged) override {
     assert(helper);
-    HashVal hash = CacheShard::ComputeHash(key);
+    HashVal hash = CacheShard::ComputeHash(key, hash_seed_);
     HandleImpl* result = GetShard(hash).CreateStandalone(
         key, hash, obj, helper, charge, allow_uncharged);
     return reinterpret_cast<Handle*>(result);
@@ -195,14 +194,14 @@ class ShardedCache : public ShardedCacheBase {
                  CreateContext* create_context = nullptr,
                  Priority priority = Priority::LOW,
                  Statistics* stats = nullptr) override {
-    HashVal hash = CacheShard::ComputeHash(key);
+    HashVal hash = CacheShard::ComputeHash(key, hash_seed_);
     HandleImpl* result = GetShard(hash).Lookup(key, hash, helper,
                                                create_context, priority, stats);
     return reinterpret_cast<Handle*>(result);
   }
 
   void Erase(const Slice& key) override {
-    HashVal hash = CacheShard::ComputeHash(key);
+    HashVal hash = CacheShard::ComputeHash(key, hash_seed_);
     GetShard(hash).Erase(key, hash);
   }
 
@@ -226,7 +225,7 @@ class ShardedCache : public ShardedCacheBase {
     return SumOverShards2(&CacheShard::GetPinnedUsage);
   }
   size_t GetOccupancyCount() const override {
-    return SumOverShards2(&CacheShard::GetPinnedUsage);
+    return SumOverShards2(&CacheShard::GetOccupancyCount);
   }
   size_t GetTableAddressCount() const override {
     return SumOverShards2(&CacheShard::GetTableAddressCount);