@nxtedition/rocksdb 8.1.4 → 8.1.6

package/deps/rocksdb/rocksdb/cache/charged_cache.cc

@@ -17,25 +17,10 @@ ChargedCache::ChargedCache(std::shared_ptr<Cache> cache,
               CacheReservationManagerImpl<CacheEntryRole::kBlobCache>>(
               block_cache))) {}
 
-Status ChargedCache::Insert(const Slice& key, void* value, size_t charge,
-                            DeleterFn deleter, Handle** handle,
-                            Priority priority) {
-  Status s = cache_->Insert(key, value, charge, deleter, handle, priority);
-  if (s.ok()) {
-    // Insert may cause the cache entry eviction if the cache is full. So we
-    // directly call the reservation manager to update the total memory used
-    // in the cache.
-    assert(cache_res_mgr_);
-    cache_res_mgr_->UpdateCacheReservation(cache_->GetUsage())
-        .PermitUncheckedError();
-  }
-  return s;
-}
-
-Status ChargedCache::Insert(const Slice& key, void* value,
+Status ChargedCache::Insert(const Slice& key, ObjectPtr obj,
                             const CacheItemHelper* helper, size_t charge,
                             Handle** handle, Priority priority) {
-  Status s = cache_->Insert(key, value, helper, charge, handle, priority);
+  Status s = cache_->Insert(key, obj, helper, charge, handle, priority);
   if (s.ok()) {
     // Insert may cause the cache entry eviction if the cache is full. So we
     // directly call the reservation manager to update the total memory used
@@ -47,22 +32,21 @@ Status ChargedCache::Insert(const Slice& key, void* value,
   return s;
 }
 
-Cache::Handle* ChargedCache::Lookup(const Slice& key, Statistics* stats) {
-  return cache_->Lookup(key, stats);
-}
-
 Cache::Handle* ChargedCache::Lookup(const Slice& key,
                                     const CacheItemHelper* helper,
-                                    const CreateCallback& create_cb,
+                                    CreateContext* create_context,
                                     Priority priority, bool wait,
                                     Statistics* stats) {
-  auto handle = cache_->Lookup(key, helper, create_cb, priority, wait, stats);
+  auto handle =
+      cache_->Lookup(key, helper, create_context, priority, wait, stats);
   // Lookup may promote the KV pair from the secondary cache to the primary
   // cache. So we directly call the reservation manager to update the total
   // memory used in the cache.
-  assert(cache_res_mgr_);
-  cache_res_mgr_->UpdateCacheReservation(cache_->GetUsage())
-      .PermitUncheckedError();
+  if (helper && helper->create_cb) {
+    assert(cache_res_mgr_);
+    cache_res_mgr_->UpdateCacheReservation(cache_->GetUsage())
+        .PermitUncheckedError();
+  }
   return handle;
 }
 

package/deps/rocksdb/rocksdb/cache/charged_cache.h

@@ -23,16 +23,14 @@ class ChargedCache : public Cache {
                std::shared_ptr<Cache> block_cache);
   ~ChargedCache() override = default;
 
-  Status Insert(const Slice& key, void* value, size_t charge, DeleterFn deleter,
-                Handle** handle, Priority priority) override;
-  Status Insert(const Slice& key, void* value, const CacheItemHelper* helper,
+  Status Insert(const Slice& key, ObjectPtr obj, const CacheItemHelper* helper,
                 size_t charge, Handle** handle = nullptr,
                 Priority priority = Priority::LOW) override;
 
-  Cache::Handle* Lookup(const Slice& key, Statistics* stats) override;
   Cache::Handle* Lookup(const Slice& key, const CacheItemHelper* helper,
-                        const CreateCallback& create_cb, Priority priority,
-                        bool wait, Statistics* stats = nullptr) override;
+                        CreateContext* create_context,
+                        Priority priority = Priority::LOW, bool wait = true,
+                        Statistics* stats = nullptr) override;
 
   bool Release(Cache::Handle* handle, bool useful,
                bool erase_if_last_ref = false) override;
@@ -56,7 +54,9 @@ class ChargedCache : public Cache {
     return cache_->HasStrictCapacityLimit();
   }
 
-  void* Value(Cache::Handle* handle) override { return cache_->Value(handle); }
+  ObjectPtr Value(Cache::Handle* handle) override {
+    return cache_->Value(handle);
+  }
 
   bool IsReady(Cache::Handle* handle) override {
     return cache_->IsReady(handle);
@@ -84,22 +84,17 @@ class ChargedCache : public Cache {
     return cache_->GetCharge(handle);
   }
 
-  Cache::DeleterFn GetDeleter(Cache::Handle* handle) const override {
-    return cache_->GetDeleter(handle);
+  const CacheItemHelper* GetCacheItemHelper(Handle* handle) const override {
+    return cache_->GetCacheItemHelper(handle);
   }
 
   void ApplyToAllEntries(
-      const std::function<void(const Slice& key, void* value, size_t charge,
-                               Cache::DeleterFn deleter)>& callback,
+      const std::function<void(const Slice& key, ObjectPtr value, size_t charge,
+                               const CacheItemHelper* helper)>& callback,
       const Cache::ApplyToAllEntriesOptions& opts) override {
     cache_->ApplyToAllEntries(callback, opts);
   }
 
-  void ApplyToAllCacheEntries(void (*callback)(void* value, size_t charge),
-                              bool thread_safe) override {
-    cache_->ApplyToAllCacheEntries(callback, thread_safe);
-  }
-
   std::string GetPrintableOptions() const override {
     return cache_->GetPrintableOptions();
   }

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

@@ -50,12 +50,12 @@ inline uint64_t GetInitialCountdown(Cache::Priority priority) {
   }
 }
 
-inline void FreeDataMarkEmpty(ClockHandle& h) {
+inline void FreeDataMarkEmpty(ClockHandle& h, MemoryAllocator* allocator) {
   // NOTE: in theory there's more room for parallelism if we copy the handle
   // data and delay actions like this until after marking the entry as empty,
   // but performance tests only show a regression by copying the few words
   // of data.
-  h.FreeData();
+  h.FreeData(allocator);
 
 #ifndef NDEBUG
   // Mark slot as empty, with assertion
@@ -115,24 +115,23 @@ inline bool ClockUpdate(ClockHandle& h) {
 
 }  // namespace
 
-void ClockHandleBasicData::FreeData() const {
-  if (deleter) {
-    UniqueId64x2 unhashed;
-    (*deleter)(
-        ClockCacheShard<HyperClockTable>::ReverseHash(hashed_key, &unhashed),
-        value);
+void ClockHandleBasicData::FreeData(MemoryAllocator* allocator) const {
+  if (helper->del_cb) {
+    helper->del_cb(value, allocator);
   }
 }
 
 HyperClockTable::HyperClockTable(
     size_t capacity, bool /*strict_capacity_limit*/,
-    CacheMetadataChargePolicy metadata_charge_policy, const Opts& opts)
+    CacheMetadataChargePolicy metadata_charge_policy,
+    MemoryAllocator* allocator, const Opts& opts)
     : length_bits_(CalcHashBits(capacity, opts.estimated_value_size,
                                 metadata_charge_policy)),
       length_bits_mask_((size_t{1} << length_bits_) - 1),
       occupancy_limit_(static_cast<size_t>((uint64_t{1} << length_bits_) *
                                            kStrictLoadFactor)),
-      array_(new HandleImpl[size_t{1} << length_bits_]) {
+      array_(new HandleImpl[size_t{1} << length_bits_]),
+      allocator_(allocator) {
   if (metadata_charge_policy ==
       CacheMetadataChargePolicy::kFullChargeCacheMetadata) {
     usage_ += size_t{GetTableSize()} * sizeof(HandleImpl);
@@ -154,7 +153,7 @@ HyperClockTable::~HyperClockTable() {
       case ClockHandle::kStateInvisible:  // rare but possible
       case ClockHandle::kStateVisible:
         assert(GetRefcount(h.meta) == 0);
-        h.FreeData();
+        h.FreeData(allocator_);
 #ifndef NDEBUG
         Rollback(h.hashed_key, &h);
         ReclaimEntryUsage(h.GetTotalCharge());
@@ -415,7 +414,7 @@ Status HyperClockTable::Insert(const ClockHandleBasicData& proto,
       if (handle == nullptr) {
         // Don't insert the entry but still return ok, as if the entry
         // inserted into cache and evicted immediately.
-        proto.FreeData();
+        proto.FreeData(allocator_);
         return Status::OK();
       } else {
         // Need to track usage of fallback detached insert
@@ -556,7 +555,7 @@ Status HyperClockTable::Insert(const ClockHandleBasicData& proto,
     if (handle == nullptr) {
       revert_usage_fn();
       // As if unrefed entry immdiately evicted
-      proto.FreeData();
+      proto.FreeData(allocator_);
       return Status::OK();
     }
   }
@@ -698,14 +697,14 @@ bool HyperClockTable::Release(HandleImpl* h, bool useful,
     // Took ownership
     size_t total_charge = h->GetTotalCharge();
     if (UNLIKELY(h->IsDetached())) {
-      h->FreeData();
+      h->FreeData(allocator_);
       // Delete detached handle
       delete h;
       detached_usage_.fetch_sub(total_charge, std::memory_order_relaxed);
       usage_.fetch_sub(total_charge, std::memory_order_relaxed);
     } else {
       Rollback(h->hashed_key, h);
-      FreeDataMarkEmpty(*h);
+      FreeDataMarkEmpty(*h, allocator_);
       ReclaimEntryUsage(total_charge);
     }
     return true;
@@ -790,7 +789,7 @@ void HyperClockTable::Erase(const UniqueId64x2& hashed_key) {
                 // Took ownership
                 assert(hashed_key == h->hashed_key);
                 size_t total_charge = h->GetTotalCharge();
-                FreeDataMarkEmpty(*h);
+                FreeDataMarkEmpty(*h, allocator_);
                 ReclaimEntryUsage(total_charge);
                 // We already have a copy of hashed_key in this case, so OK to
                 // delay Rollback until after releasing the entry
@@ -878,7 +877,7 @@ void HyperClockTable::EraseUnRefEntries() {
       // Took ownership
       size_t total_charge = h.GetTotalCharge();
       Rollback(h.hashed_key, &h);
-      FreeDataMarkEmpty(h);
+      FreeDataMarkEmpty(h, allocator_);
       ReclaimEntryUsage(total_charge);
     }
   }
@@ -968,7 +967,7 @@ inline void HyperClockTable::Evict(size_t requested_charge,
         Rollback(h.hashed_key, &h);
         *freed_charge += h.GetTotalCharge();
         *freed_count += 1;
-        FreeDataMarkEmpty(h);
+        FreeDataMarkEmpty(h, allocator_);
       }
     }
 
@@ -990,9 +989,10 @@ template <class Table>
 ClockCacheShard<Table>::ClockCacheShard(
     size_t capacity, bool strict_capacity_limit,
     CacheMetadataChargePolicy metadata_charge_policy,
-    const typename Table::Opts& opts)
+    MemoryAllocator* allocator, const typename Table::Opts& opts)
     : CacheShardBase(metadata_charge_policy),
-      table_(capacity, strict_capacity_limit, metadata_charge_policy, opts),
+      table_(capacity, strict_capacity_limit, metadata_charge_policy, allocator,
+             opts),
       capacity_(capacity),
       strict_capacity_limit_(strict_capacity_limit) {
   // Initial charge metadata should not exceed capacity
@@ -1006,8 +1006,9 @@ void ClockCacheShard<Table>::EraseUnRefEntries() {
 
 template <class Table>
 void ClockCacheShard<Table>::ApplyToSomeEntries(
-    const std::function<void(const Slice& key, void* value, size_t charge,
-                             DeleterFn deleter)>& callback,
+    const std::function<void(const Slice& key, Cache::ObjectPtr value,
+                             size_t charge,
+                             const Cache::CacheItemHelper* helper)>& callback,
     size_t average_entries_per_lock, size_t* state) {
   // The state is essentially going to be the starting hash, which works
   // nicely even if we resize between calls because we use upper-most
@@ -1034,7 +1035,7 @@ void ClockCacheShard<Table>::ApplyToSomeEntries(
       [callback](const HandleImpl& h) {
         UniqueId64x2 unhashed;
         callback(ReverseHash(h.hashed_key, &unhashed), h.value,
-                 h.GetTotalCharge(), h.deleter);
+                 h.GetTotalCharge(), h.helper);
       },
       index_begin, index_end, false);
 }
@@ -1078,9 +1079,9 @@ void ClockCacheShard<Table>::SetStrictCapacityLimit(
 template <class Table>
 Status ClockCacheShard<Table>::Insert(const Slice& key,
                                       const UniqueId64x2& hashed_key,
-                                      void* value, size_t charge,
-                                      Cache::DeleterFn deleter,
-                                      HandleImpl** handle,
+                                      Cache::ObjectPtr value,
+                                      const Cache::CacheItemHelper* helper,
+                                      size_t charge, HandleImpl** handle,
                                       Cache::Priority priority) {
   if (UNLIKELY(key.size() != kCacheKeySize)) {
     return Status::NotSupported("ClockCache only supports key size " +
@@ -1089,7 +1090,7 @@ Status ClockCacheShard<Table>::Insert(const Slice& key,
   ClockHandleBasicData proto;
   proto.hashed_key = hashed_key;
   proto.value = value;
-  proto.deleter = deleter;
+  proto.helper = helper;
   proto.total_charge = charge;
   Status s = table_.Insert(
       proto, handle, priority, capacity_.load(std::memory_order_relaxed),
@@ -1223,15 +1224,16 @@ HyperClockCache::HyperClockCache(
   // 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();
   InitShards([=](Shard* cs) {
     HyperClockTable::Opts opts;
     opts.estimated_value_size = estimated_value_size;
-    new (cs)
-        Shard(per_shard, strict_capacity_limit, metadata_charge_policy, opts);
+    new (cs) Shard(per_shard, strict_capacity_limit, metadata_charge_policy,
+                   alloc, opts);
   });
 }
 
-void* HyperClockCache::Value(Handle* handle) {
+Cache::ObjectPtr HyperClockCache::Value(Handle* handle) {
   return reinterpret_cast<const HandleImpl*>(handle)->value;
 }
 
@@ -1239,9 +1241,10 @@ size_t HyperClockCache::GetCharge(Handle* handle) const {
   return reinterpret_cast<const HandleImpl*>(handle)->GetTotalCharge();
 }
 
-Cache::DeleterFn HyperClockCache::GetDeleter(Handle* handle) const {
+const Cache::CacheItemHelper* HyperClockCache::GetCacheItemHelper(
+    Handle* handle) const {
   auto h = reinterpret_cast<const HandleImpl*>(handle);
-  return h->deleter;
+  return h->helper;
 }
 
 namespace {

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

@@ -305,8 +305,8 @@ constexpr double kLoadFactor = 0.7;
 constexpr double kStrictLoadFactor = 0.84;
 
 struct ClockHandleBasicData {
-  void* value = nullptr;
-  Cache::DeleterFn deleter = nullptr;
+  Cache::ObjectPtr value = nullptr;
+  const Cache::CacheItemHelper* helper = nullptr;
   // A lossless, reversible hash of the fixed-size (16 byte) cache key. This
   // eliminates the need to store a hash separately.
   UniqueId64x2 hashed_key = kNullUniqueId64x2;
@@ -321,7 +321,7 @@ struct ClockHandleBasicData {
   inline size_t GetTotalCharge() const { return total_charge; }
 
   // Calls deleter (if non-null) on cache key and value
-  void FreeData() const;
+  void FreeData(MemoryAllocator* allocator) const;
 
   // Required by concept HandleImpl
   const UniqueId64x2& GetHash() const { return hashed_key; }
@@ -411,7 +411,7 @@ class HyperClockTable {
 
   HyperClockTable(size_t capacity, bool strict_capacity_limit,
                   CacheMetadataChargePolicy metadata_charge_policy,
-                  const Opts& opts);
+                  MemoryAllocator* allocator, const Opts& opts);
   ~HyperClockTable();
 
   Status Insert(const ClockHandleBasicData& proto, HandleImpl** handle,
@@ -519,6 +519,8 @@ class HyperClockTable {
   // Updates `detached_usage_` but not `usage_` nor `occupancy_`.
   inline HandleImpl* DetachedInsert(const ClockHandleBasicData& proto);
 
+  MemoryAllocator* GetAllocator() const { return allocator_; }
+
   // Returns the number of bits used to hash an element in the hash
   // table.
   static int CalcHashBits(size_t capacity, size_t estimated_value_size,
@@ -538,6 +540,9 @@ class HyperClockTable {
   // Array of slots comprising the hash table.
   const std::unique_ptr<HandleImpl[]> array_;
 
+  // From Cache, for deleter
+  MemoryAllocator* const allocator_;
+
   // We partition the following members into different cache lines
   // to avoid false sharing among Lookup, Release, Erase and Insert
   // operations in ClockCacheShard.
@@ -563,7 +568,7 @@ class ALIGN_AS(CACHE_LINE_SIZE) ClockCacheShard final : public CacheShardBase {
  public:
   ClockCacheShard(size_t capacity, bool strict_capacity_limit,
                   CacheMetadataChargePolicy metadata_charge_policy,
-                  const typename Table::Opts& opts);
+                  MemoryAllocator* allocator, const typename Table::Opts& opts);
 
   // For CacheShard concept
   using HandleImpl = typename Table::HandleImpl;
@@ -600,9 +605,9 @@ class ALIGN_AS(CACHE_LINE_SIZE) ClockCacheShard final : public CacheShardBase {
 
   void SetStrictCapacityLimit(bool strict_capacity_limit);
 
-  Status Insert(const Slice& key, const UniqueId64x2& hashed_key, void* value,
-                size_t charge, Cache::DeleterFn deleter, HandleImpl** handle,
-                Cache::Priority priority);
+  Status Insert(const Slice& key, const UniqueId64x2& hashed_key,
+                Cache::ObjectPtr value, const Cache::CacheItemHelper* helper,
+                size_t charge, HandleImpl** handle, Cache::Priority priority);
 
   HandleImpl* Lookup(const Slice& key, const UniqueId64x2& hashed_key);
 
@@ -629,25 +634,18 @@ class ALIGN_AS(CACHE_LINE_SIZE) ClockCacheShard final : public CacheShardBase {
   size_t GetTableAddressCount() const;
 
   void ApplyToSomeEntries(
-      const std::function<void(const Slice& key, void* value, size_t charge,
-                               DeleterFn deleter)>& callback,
+      const std::function<void(const Slice& key, Cache::ObjectPtr obj,
+                               size_t charge,
+                               const Cache::CacheItemHelper* helper)>& callback,
       size_t average_entries_per_lock, size_t* state);
 
   void EraseUnRefEntries();
 
   std::string GetPrintableOptions() const { return std::string{}; }
 
-  // SecondaryCache not yet supported
-  Status Insert(const Slice& key, const UniqueId64x2& hashed_key, void* value,
-                const Cache::CacheItemHelper* helper, size_t charge,
-                HandleImpl** handle, Cache::Priority priority) {
-    return Insert(key, hashed_key, value, charge, helper->del_cb, handle,
-                  priority);
-  }
-
   HandleImpl* Lookup(const Slice& key, const UniqueId64x2& hashed_key,
                      const Cache::CacheItemHelper* /*helper*/,
-                     const Cache::CreateCallback& /*create_cb*/,
+                     Cache::CreateContext* /*create_context*/,
                      Cache::Priority /*priority*/, bool /*wait*/,
                      Statistics* /*stats*/) {
     return Lookup(key, hashed_key);
@@ -686,11 +684,11 @@ class HyperClockCache
 
   const char* Name() const override { return "HyperClockCache"; }
 
-  void* Value(Handle* handle) override;
+  Cache::ObjectPtr Value(Handle* handle) override;
 
   size_t GetCharge(Handle* handle) const override;
 
-  DeleterFn GetDeleter(Handle* handle) const override;
+  const CacheItemHelper* GetCacheItemHelper(Handle* handle) const override;
 
   void ReportProblems(
       const std::shared_ptr<Logger>& /*info_log*/) const override;

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

@@ -37,8 +37,10 @@ CompressedSecondaryCache::CompressedSecondaryCache(
 CompressedSecondaryCache::~CompressedSecondaryCache() { cache_.reset(); }
 
 std::unique_ptr<SecondaryCacheResultHandle> CompressedSecondaryCache::Lookup(
-    const Slice& key, const Cache::CreateCallback& create_cb, bool /*wait*/,
-    bool advise_erase, bool& is_in_sec_cache) {
+    const Slice& key, const Cache::CacheItemHelper* helper,
+    Cache::CreateContext* create_context, bool /*wait*/, bool advise_erase,
+    bool& is_in_sec_cache) {
+  assert(helper);
   std::unique_ptr<SecondaryCacheResultHandle> handle;
   is_in_sec_cache = false;
   Cache::Handle* lru_handle = cache_->Lookup(key);
@@ -64,12 +66,14 @@ std::unique_ptr<SecondaryCacheResultHandle> CompressedSecondaryCache::Lookup(
     ptr = reinterpret_cast<CacheAllocationPtr*>(handle_value);
     handle_value_charge = cache_->GetCharge(lru_handle);
   }
+  MemoryAllocator* allocator = cache_options_.memory_allocator.get();
 
   Status s;
-  void* value{nullptr};
+  Cache::ObjectPtr value{nullptr};
   size_t charge{0};
   if (cache_options_.compression_type == kNoCompression) {
-    s = create_cb(ptr->get(), handle_value_charge, &value, &charge);
+    s = helper->create_cb(Slice(ptr->get(), handle_value_charge),
+                          create_context, allocator, &value, &charge);
   } else {
     UncompressionContext uncompression_context(cache_options_.compression_type);
     UncompressionInfo uncompression_info(uncompression_context,
@@ -79,14 +83,14 @@ std::unique_ptr<SecondaryCacheResultHandle> CompressedSecondaryCache::Lookup(
     size_t uncompressed_size{0};
     CacheAllocationPtr uncompressed = UncompressData(
         uncompression_info, (char*)ptr->get(), handle_value_charge,
-        &uncompressed_size, cache_options_.compress_format_version,
-        cache_options_.memory_allocator.get());
+        &uncompressed_size, cache_options_.compress_format_version, allocator);
 
     if (!uncompressed) {
       cache_->Release(lru_handle, /*erase_if_last_ref=*/true);
       return nullptr;
     }
-    s = create_cb(uncompressed.get(), uncompressed_size, &value, &charge);
+    s = helper->create_cb(Slice(uncompressed.get(), uncompressed_size),
+                          create_context, allocator, &value, &charge);
   }
 
   if (!s.ok()) {
@@ -98,8 +102,9 @@ std::unique_ptr<SecondaryCacheResultHandle> CompressedSecondaryCache::Lookup(
     cache_->Release(lru_handle, /*erase_if_last_ref=*/true);
     // Insert a dummy handle.
     cache_
-        ->Insert(key, /*value=*/nullptr, /*charge=*/0,
-                 GetDeletionCallback(cache_options_.enable_custom_split_merge))
+        ->Insert(key, /*obj=*/nullptr,
+                 GetHelper(cache_options_.enable_custom_split_merge),
+                 /*charge=*/0)
         .PermitUncheckedError();
   } else {
     is_in_sec_cache = true;
@@ -109,19 +114,20 @@ std::unique_ptr<SecondaryCacheResultHandle> CompressedSecondaryCache::Lookup(
   return handle;
 }
 
-Status CompressedSecondaryCache::Insert(const Slice& key, void* value,
+Status CompressedSecondaryCache::Insert(const Slice& key,
+                                        Cache::ObjectPtr value,
                                         const Cache::CacheItemHelper* helper) {
   if (value == nullptr) {
     return Status::InvalidArgument();
   }
 
   Cache::Handle* lru_handle = cache_->Lookup(key);
-  Cache::DeleterFn del_cb =
-      GetDeletionCallback(cache_options_.enable_custom_split_merge);
+  auto internal_helper = GetHelper(cache_options_.enable_custom_split_merge);
   if (lru_handle == nullptr) {
     PERF_COUNTER_ADD(compressed_sec_cache_insert_dummy_count, 1);
     // Insert a dummy handle if the handle is evicted for the first time.
-    return cache_->Insert(key, /*value=*/nullptr, /*charge=*/0, del_cb);
+    return cache_->Insert(key, /*obj=*/nullptr, internal_helper,
+                          /*charge=*/0);
   } else {
     cache_->Release(lru_handle, /*erase_if_last_ref=*/false);
   }
@@ -169,10 +175,10 @@ Status CompressedSecondaryCache::Insert(const Slice& key, void* value,
     size_t charge{0};
     CacheValueChunk* value_chunks_head =
         SplitValueIntoChunks(val, cache_options_.compression_type, charge);
-    return cache_->Insert(key, value_chunks_head, charge, del_cb);
+    return cache_->Insert(key, value_chunks_head, internal_helper, charge);
   } else {
     CacheAllocationPtr* buf = new CacheAllocationPtr(std::move(ptr));
-    return cache_->Insert(key, buf, size, del_cb);
+    return cache_->Insert(key, buf, internal_helper, size);
   }
 }
 
@@ -276,23 +282,29 @@ CacheAllocationPtr CompressedSecondaryCache::MergeChunksIntoValue(
   return ptr;
 }
 
-Cache::DeleterFn CompressedSecondaryCache::GetDeletionCallback(
-    bool enable_custom_split_merge) {
+const Cache::CacheItemHelper* CompressedSecondaryCache::GetHelper(
+    bool enable_custom_split_merge) const {
   if (enable_custom_split_merge) {
-    return [](const Slice& /*key*/, void* obj) {
-      CacheValueChunk* chunks_head = reinterpret_cast<CacheValueChunk*>(obj);
-      while (chunks_head != nullptr) {
-        CacheValueChunk* tmp_chunk = chunks_head;
-        chunks_head = chunks_head->next;
-        tmp_chunk->Free();
-        obj = nullptr;
-      };
-    };
+    static const Cache::CacheItemHelper kHelper{
+        CacheEntryRole::kMisc,
+        [](Cache::ObjectPtr obj, MemoryAllocator* /*alloc*/) {
+          CacheValueChunk* chunks_head = static_cast<CacheValueChunk*>(obj);
+          while (chunks_head != nullptr) {
+            CacheValueChunk* tmp_chunk = chunks_head;
+            chunks_head = chunks_head->next;
+            tmp_chunk->Free();
+            obj = nullptr;
+          };
+        }};
+    return &kHelper;
   } else {
-    return [](const Slice& /*key*/, void* obj) {
-      delete reinterpret_cast<CacheAllocationPtr*>(obj);
-      obj = nullptr;
-    };
+    static const Cache::CacheItemHelper kHelper{
+        CacheEntryRole::kMisc,
+        [](Cache::ObjectPtr obj, MemoryAllocator* /*alloc*/) {
+          delete static_cast<CacheAllocationPtr*>(obj);
+          obj = nullptr;
+        }};
+    return &kHelper;
   }
 }
 

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

@@ -21,7 +21,7 @@ namespace ROCKSDB_NAMESPACE {
 
 class CompressedSecondaryCacheResultHandle : public SecondaryCacheResultHandle {
  public:
-  CompressedSecondaryCacheResultHandle(void* value, size_t size)
+  CompressedSecondaryCacheResultHandle(Cache::ObjectPtr value, size_t size)
       : value_(value), size_(size) {}
   ~CompressedSecondaryCacheResultHandle() override = default;
 
@@ -34,12 +34,12 @@ class CompressedSecondaryCacheResultHandle : public SecondaryCacheResultHandle {
 
   void Wait() override {}
 
-  void* Value() override { return value_; }
+  Cache::ObjectPtr Value() override { return value_; }
 
   size_t Size() override { return size_; }
 
  private:
-  void* value_;
+  Cache::ObjectPtr value_;
   size_t size_;
 };
 
@@ -83,12 +83,13 @@ class CompressedSecondaryCache : public SecondaryCache {
 
   const char* Name() const override { return "CompressedSecondaryCache"; }
 
-  Status Insert(const Slice& key, void* value,
+  Status Insert(const Slice& key, Cache::ObjectPtr value,
                 const Cache::CacheItemHelper* helper) override;
 
   std::unique_ptr<SecondaryCacheResultHandle> Lookup(
-      const Slice& key, const Cache::CreateCallback& create_cb, bool /*wait*/,
-      bool advise_erase, bool& is_in_sec_cache) override;
+      const Slice& key, const Cache::CacheItemHelper* helper,
+      Cache::CreateContext* create_context, bool /*wait*/, bool advise_erase,
+      bool& is_in_sec_cache) override;
 
   bool SupportForceErase() const override { return true; }
 
@@ -129,8 +130,8 @@ class CompressedSecondaryCache : public SecondaryCache {
   CacheAllocationPtr MergeChunksIntoValue(const void* chunks_head,
                                           size_t& charge);
 
-  // An implementation of Cache::DeleterFn.
-  static Cache::DeleterFn GetDeletionCallback(bool enable_custom_split_merge);
+  // TODO: clean up to use cleaner interfaces in typed_cache.h
+  const Cache::CacheItemHelper* GetHelper(bool enable_custom_split_merge) const;
   std::shared_ptr<Cache> cache_;
   CompressedSecondaryCacheOptions cache_options_;
   mutable port::Mutex capacity_mutex_;