@nxtedition/rocksdb 8.1.4 → 8.1.6

package/deps/rocksdb/rocksdb/table/block_based/block_based_table_reader.h

@@ -21,6 +21,7 @@
 #include "rocksdb/table_properties.h"
 #include "table/block_based/block.h"
 #include "table/block_based/block_based_table_factory.h"
+#include "table/block_based/block_cache.h"
 #include "table/block_based/block_type.h"
 #include "table/block_based/cachable_entry.h"
 #include "table/block_based/filter_block.h"
@@ -315,22 +316,6 @@ class BlockBasedTable : public TableReader {
   void UpdateCacheMissMetrics(BlockType block_type,
                               GetContext* get_context) const;
 
-  Cache::Handle* GetEntryFromCache(const CacheTier& cache_tier,
-                                   Cache* block_cache, const Slice& key,
-                                   BlockType block_type, const bool wait,
-                                   GetContext* get_context,
-                                   const Cache::CacheItemHelper* cache_helper,
-                                   const Cache::CreateCallback& create_cb,
-                                   Cache::Priority priority) const;
-
-  template <typename TBlocklike>
-  Status InsertEntryToCache(const CacheTier& cache_tier, Cache* block_cache,
-                            const Slice& key,
-                            const Cache::CacheItemHelper* cache_helper,
-                            std::unique_ptr<TBlocklike>&& block_holder,
-                            size_t charge, Cache::Handle** cache_handle,
-                            Cache::Priority priority) const;
-
   // Either Block::NewDataIterator() or Block::NewIndexIterator().
   template <typename TBlockIter>
   static TBlockIter* InitBlockIterator(const Rep* rep, Block* block,
@@ -348,26 +333,24 @@ class BlockBasedTable : public TableReader {
   //    in uncompressed block cache, also sets cache_handle to reference that
   //    block.
   template <typename TBlocklike>
-  Status MaybeReadBlockAndLoadToCache(
+  WithBlocklikeCheck<Status, TBlocklike> MaybeReadBlockAndLoadToCache(
       FilePrefetchBuffer* prefetch_buffer, const ReadOptions& ro,
       const BlockHandle& handle, const UncompressionDict& uncompression_dict,
       const bool wait, const bool for_compaction,
-      CachableEntry<TBlocklike>* block_entry, BlockType block_type,
-      GetContext* get_context, BlockCacheLookupContext* lookup_context,
-      BlockContents* contents, bool async_read) const;
+      CachableEntry<TBlocklike>* block_entry, GetContext* get_context,
+      BlockCacheLookupContext* lookup_context, BlockContents* contents,
+      bool async_read) const;
 
   // Similar to the above, with one crucial difference: it will retrieve the
   // block from the file even if there are no caches configured (assuming the
   // read options allow I/O).
   template <typename TBlocklike>
-  Status RetrieveBlock(FilePrefetchBuffer* prefetch_buffer,
-                       const ReadOptions& ro, const BlockHandle& handle,
-                       const UncompressionDict& uncompression_dict,
-                       CachableEntry<TBlocklike>* block_entry,
-                       BlockType block_type, GetContext* get_context,
-                       BlockCacheLookupContext* lookup_context,
-                       bool for_compaction, bool use_cache, bool wait_for_cache,
-                       bool async_read) const;
+  WithBlocklikeCheck<Status, TBlocklike> RetrieveBlock(
+      FilePrefetchBuffer* prefetch_buffer, const ReadOptions& ro,
+      const BlockHandle& handle, const UncompressionDict& uncompression_dict,
+      CachableEntry<TBlocklike>* block_entry, GetContext* get_context,
+      BlockCacheLookupContext* lookup_context, bool for_compaction,
+      bool use_cache, bool wait_for_cache, bool async_read) const;
 
   DECLARE_SYNC_AND_ASYNC_CONST(
       void, RetrieveMultipleBlocks, const ReadOptions& options,
@@ -403,13 +386,12 @@ class BlockBasedTable : public TableReader {
   // @param uncompression_dict Data for presetting the compression library's
   //    dictionary.
   template <typename TBlocklike>
-  Status GetDataBlockFromCache(const Slice& cache_key, Cache* block_cache,
-                               Cache* block_cache_compressed,
-                               const ReadOptions& read_options,
-                               CachableEntry<TBlocklike>* block,
-                               const UncompressionDict& uncompression_dict,
-                               BlockType block_type, const bool wait,
-                               GetContext* get_context) const;
+  WithBlocklikeCheck<Status, TBlocklike> GetDataBlockFromCache(
+      const Slice& cache_key, BlockCacheInterface<TBlocklike> block_cache,
+      CompressedBlockCacheInterface block_cache_compressed,
+      const ReadOptions& read_options, CachableEntry<TBlocklike>* block,
+      const UncompressionDict& uncompression_dict, const bool wait,
+      GetContext* get_context) const;
 
   // Put a maybe compressed block to the corresponding block caches.
   // This method will perform decompression against block_contents if needed
@@ -422,15 +404,13 @@ class BlockBasedTable : public TableReader {
   // @param uncompression_dict Data for presetting the compression library's
   //    dictionary.
   template <typename TBlocklike>
-  Status PutDataBlockToCache(const Slice& cache_key, Cache* block_cache,
-                             Cache* block_cache_compressed,
-                             CachableEntry<TBlocklike>* cached_block,
-                             BlockContents&& block_contents,
-                             CompressionType block_comp_type,
-                             const UncompressionDict& uncompression_dict,
-                             MemoryAllocator* memory_allocator,
-                             BlockType block_type,
-                             GetContext* get_context) const;
+  WithBlocklikeCheck<Status, TBlocklike> PutDataBlockToCache(
+      const Slice& cache_key, BlockCacheInterface<TBlocklike> block_cache,
+      CompressedBlockCacheInterface block_cache_compressed,
+      CachableEntry<TBlocklike>* cached_block, BlockContents&& block_contents,
+      CompressionType block_comp_type,
+      const UncompressionDict& uncompression_dict,
+      MemoryAllocator* memory_allocator, GetContext* get_context) const;
 
   // Calls (*handle_result)(arg, ...) repeatedly, starting with the entry found
   // after a call to Seek(key), until handle_result returns false.
@@ -599,6 +579,13 @@ struct BlockBasedTable::Rep {
 
   std::shared_ptr<FragmentedRangeTombstoneList> fragmented_range_dels;
 
+  // FIXME
+  // If true, data blocks in this file are definitely ZSTD compressed. If false
+  // they might not be. When false we skip creating a ZSTD digested
+  // uncompression dictionary. Even if we get a false negative, things should
+  // still work, just not as quickly.
+  BlockCreateContext create_context;
+
   // If global_seqno is used, all Keys in this file will have the same
   // seqno with value `global_seqno`.
   //
@@ -617,12 +604,6 @@ struct BlockBasedTable::Rep {
   // before reading individual blocks enables certain optimizations.
   bool blocks_maybe_compressed = true;
 
-  // If true, data blocks in this file are definitely ZSTD compressed. If false
-  // they might not be. When false we skip creating a ZSTD digested
-  // uncompression dictionary. Even if we get a false negative, things should
-  // still work, just not as quickly.
-  bool blocks_definitely_zstd_compressed = false;
-
   // These describe how index is encoded.
   bool index_has_first_key = false;
   bool index_key_includes_seq = true;

package/deps/rocksdb/rocksdb/table/block_based/block_based_table_reader_impl.h

@@ -7,6 +7,10 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file. See the AUTHORS file for names of contributors.
 #pragma once
+#include <type_traits>
+
+#include "block.h"
+#include "block_cache.h"
 #include "table/block_based/block_based_table_reader.h"
 #include "table/block_based/reader_common.h"
 
@@ -16,6 +20,25 @@
 // are templates.
 
 namespace ROCKSDB_NAMESPACE {
+namespace {
+using IterPlaceholderCacheInterface =
+    PlaceholderCacheInterface<CacheEntryRole::kMisc>;
+
+template <typename TBlockIter>
+struct IterTraits {};
+
+template <>
+struct IterTraits<DataBlockIter> {
+  using IterBlocklike = Block_kData;
+};
+
+template <>
+struct IterTraits<IndexBlockIter> {
+  using IterBlocklike = Block_kIndex;
+};
+
+}  // namespace
+
 // Convert an index iterator value (i.e., an encoded BlockHandle)
 // into an iterator over the contents of the corresponding block.
 // If input_iter is null, new a iterator
@@ -27,6 +50,7 @@ TBlockIter* BlockBasedTable::NewDataBlockIterator(
     BlockCacheLookupContext* lookup_context,
     FilePrefetchBuffer* prefetch_buffer, bool for_compaction, bool async_read,
     Status& s) const {
+  using IterBlocklike = typename IterTraits<TBlockIter>::IterBlocklike;
   PERF_TIMER_GUARD(new_table_block_iter_nanos);
 
   TBlockIter* iter = input_iter != nullptr ? input_iter : new TBlockIter;
@@ -39,9 +63,13 @@ TBlockIter* BlockBasedTable::NewDataBlockIterator(
   if (rep_->uncompression_dict_reader && block_type == BlockType::kData) {
     CachableEntry<UncompressionDict> uncompression_dict;
     const bool no_io = (ro.read_tier == kBlockCacheTier);
+    // For async scans, don't use the prefetch buffer since an async prefetch
+    // might already be under way and this would invalidate it. Also, the
+    // uncompression dict is typically at the end of the file and would
+    // most likely break the sequentiality of the access pattern.
     s = rep_->uncompression_dict_reader->GetOrReadUncompressionDictionary(
-        prefetch_buffer, no_io, ro.verify_checksums, get_context,
-        lookup_context, &uncompression_dict);
+        ro.async_io ? nullptr : prefetch_buffer, no_io, ro.verify_checksums,
+        get_context, lookup_context, &uncompression_dict);
     if (!s.ok()) {
       iter->Invalidate(s);
       return iter;
@@ -49,14 +77,14 @@ TBlockIter* BlockBasedTable::NewDataBlockIterator(
     const UncompressionDict& dict = uncompression_dict.GetValue()
                                         ? *uncompression_dict.GetValue()
                                         : UncompressionDict::GetEmptyDict();
-    s = RetrieveBlock(prefetch_buffer, ro, handle, dict, &block, block_type,
-                      get_context, lookup_context, for_compaction,
-                      /* use_cache */ true, /* wait_for_cache */ true,
-                      async_read);
+    s = RetrieveBlock(
+        prefetch_buffer, ro, handle, dict, &block.As<IterBlocklike>(),
+        get_context, lookup_context, for_compaction,
+        /* use_cache */ true, /* wait_for_cache */ true, async_read);
   } else {
     s = RetrieveBlock(
-        prefetch_buffer, ro, handle, UncompressionDict::GetEmptyDict(), &block,
-        block_type, get_context, lookup_context, for_compaction,
+        prefetch_buffer, ro, handle, UncompressionDict::GetEmptyDict(),
+        &block.As<IterBlocklike>(), get_context, lookup_context, for_compaction,
         /* use_cache */ true, /* wait_for_cache */ true, async_read);
   }
 
@@ -87,18 +115,20 @@ TBlockIter* BlockBasedTable::NewDataBlockIterator(
 
   if (!block.IsCached()) {
     if (!ro.fill_cache) {
-      Cache* const block_cache = rep_->table_options.block_cache.get();
+      IterPlaceholderCacheInterface block_cache{
+          rep_->table_options.block_cache.get()};
       if (block_cache) {
         // insert a dummy record to block cache to track the memory usage
         Cache::Handle* cache_handle = nullptr;
-        CacheKey key = CacheKey::CreateUniqueForCacheLifetime(block_cache);
-        s = block_cache->Insert(key.AsSlice(), nullptr,
-                                block.GetValue()->ApproximateMemoryUsage(),
-                                nullptr, &cache_handle);
+        CacheKey key =
+            CacheKey::CreateUniqueForCacheLifetime(block_cache.get());
+        s = block_cache.Insert(key.AsSlice(),
+                               block.GetValue()->ApproximateMemoryUsage(),
+                               &cache_handle);
 
         if (s.ok()) {
           assert(cache_handle != nullptr);
-          iter->RegisterCleanup(&ForceReleaseCachedEntry, block_cache,
+          iter->RegisterCleanup(&ForceReleaseCachedEntry, block_cache.get(),
                                 cache_handle);
         }
       }
@@ -145,18 +175,20 @@ TBlockIter* BlockBasedTable::NewDataBlockIterator(const ReadOptions& ro,
 
   if (!block.IsCached()) {
     if (!ro.fill_cache) {
-      Cache* const block_cache = rep_->table_options.block_cache.get();
+      IterPlaceholderCacheInterface block_cache{
+          rep_->table_options.block_cache.get()};
       if (block_cache) {
         // insert a dummy record to block cache to track the memory usage
         Cache::Handle* cache_handle = nullptr;
-        CacheKey key = CacheKey::CreateUniqueForCacheLifetime(block_cache);
-        s = block_cache->Insert(key.AsSlice(), nullptr,
-                                block.GetValue()->ApproximateMemoryUsage(),
-                                nullptr, &cache_handle);
+        CacheKey key =
+            CacheKey::CreateUniqueForCacheLifetime(block_cache.get());
+        s = block_cache.Insert(key.AsSlice(),
+                               block.GetValue()->ApproximateMemoryUsage(),
+                               &cache_handle);
 
         if (s.ok()) {
           assert(cache_handle != nullptr);
-          iter->RegisterCleanup(&ForceReleaseCachedEntry, block_cache,
+          iter->RegisterCleanup(&ForceReleaseCachedEntry, block_cache.get(),
                                 cache_handle);
         }
       }

package/deps/rocksdb/rocksdb/table/block_based/block_based_table_reader_sync_and_async.h

@@ -54,7 +54,7 @@ DEFINE_SYNC_AND_ASYNC(void, BlockBasedTable::RetrieveMultipleBlocks)
 
       (*statuses)[idx_in_batch] =
           RetrieveBlock(nullptr, options, handle, uncompression_dict,
-                        &(*results)[idx_in_batch], BlockType::kData,
+                        &(*results)[idx_in_batch].As<Block_kData>(),
                         mget_iter->get_context, &lookup_data_block_context,
                         /* for_compaction */ false, /* use_cache */ true,
                         /* wait_for_cache */ true, /* async_read */ false);
@@ -269,7 +269,7 @@ DEFINE_SYNC_AND_ASYNC(void, BlockBasedTable::RetrieveMultipleBlocks)
         // will avoid looking up the block cache
         s = MaybeReadBlockAndLoadToCache(
             nullptr, options, handle, uncompression_dict, /*wait=*/true,
-            /*for_compaction=*/false, block_entry, BlockType::kData,
+            /*for_compaction=*/false, &block_entry->As<Block_kData>(),
             mget_iter->get_context, &lookup_data_block_context,
             &serialized_block, /*async_read=*/false);
 
@@ -441,7 +441,7 @@ DEFINE_SYNC_AND_ASYNC(void, BlockBasedTable::MultiGet)
                                             ? *uncompression_dict.GetValue()
                                             : UncompressionDict::GetEmptyDict();
         Status s = RetrieveBlock(
-            nullptr, ro, handle, dict, &(results.back()), BlockType::kData,
+            nullptr, ro, handle, dict, &(results.back()).As<Block_kData>(),
             miter->get_context, &lookup_data_block_context,
             /* for_compaction */ false, /* use_cache */ true,
             /* wait_for_cache */ false, /* async_read */ false);

package/deps/rocksdb/rocksdb/table/block_based/block_based_table_reader_test.cc

@@ -50,7 +50,7 @@ class BlockBasedTableReaderBaseTest : public testing::Test {
         // Internal key is constructed directly from this key,
         // and internal key size is required to be >= 8 bytes,
         // so use %08u as the format string.
-        sprintf(k, "%08u", key);
+        snprintf(k, sizeof(k), "%08u", key);
         std::string v;
         if (mixed_with_human_readable_string_value) {
           v = (block % 2) ? rnd.HumanReadableString(256)

package/deps/rocksdb/rocksdb/table/block_based/block_cache.cc

@@ -0,0 +1,96 @@
+//  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).
+
+#include "table/block_based/block_cache.h"
+
+namespace ROCKSDB_NAMESPACE {
+
+void BlockCreateContext::Create(std::unique_ptr<Block_kData>* parsed_out,
+                                BlockContents&& block) {
+  parsed_out->reset(new Block_kData(
+      std::move(block), table_options->read_amp_bytes_per_bit, statistics));
+}
+void BlockCreateContext::Create(std::unique_ptr<Block_kIndex>* parsed_out,
+                                BlockContents&& block) {
+  parsed_out->reset(new Block_kIndex(std::move(block),
+                                     /*read_amp_bytes_per_bit*/ 0, statistics));
+}
+void BlockCreateContext::Create(
+    std::unique_ptr<Block_kFilterPartitionIndex>* parsed_out,
+    BlockContents&& block) {
+  parsed_out->reset(new Block_kFilterPartitionIndex(
+      std::move(block), /*read_amp_bytes_per_bit*/ 0, statistics));
+}
+void BlockCreateContext::Create(
+    std::unique_ptr<Block_kRangeDeletion>* parsed_out, BlockContents&& block) {
+  parsed_out->reset(new Block_kRangeDeletion(
+      std::move(block), /*read_amp_bytes_per_bit*/ 0, statistics));
+}
+void BlockCreateContext::Create(std::unique_ptr<Block_kMetaIndex>* parsed_out,
+                                BlockContents&& block) {
+  parsed_out->reset(new Block_kMetaIndex(
+      std::move(block), /*read_amp_bytes_per_bit*/ 0, statistics));
+}
+
+void BlockCreateContext::Create(
+    std::unique_ptr<ParsedFullFilterBlock>* parsed_out, BlockContents&& block) {
+  parsed_out->reset(new ParsedFullFilterBlock(
+      table_options->filter_policy.get(), std::move(block)));
+}
+
+void BlockCreateContext::Create(std::unique_ptr<UncompressionDict>* parsed_out,
+                                BlockContents&& block) {
+  parsed_out->reset(new UncompressionDict(
+      block.data, std::move(block.allocation), using_zstd));
+}
+
+namespace {
+// For getting SecondaryCache-compatible helpers from a BlockType. This is
+// useful for accessing block cache in untyped contexts, such as for generic
+// cache warming in table builder.
+constexpr std::array<const Cache::CacheItemHelper*,
+                     static_cast<unsigned>(BlockType::kInvalid) + 1>
+    kCacheItemFullHelperForBlockType{{
+        &BlockCacheInterface<Block_kData>::kFullHelper,
+        &BlockCacheInterface<ParsedFullFilterBlock>::kFullHelper,
+        &BlockCacheInterface<Block_kFilterPartitionIndex>::kFullHelper,
+        nullptr,  // kProperties
+        &BlockCacheInterface<UncompressionDict>::kFullHelper,
+        &BlockCacheInterface<Block_kRangeDeletion>::kFullHelper,
+        nullptr,  // kHashIndexPrefixes
+        nullptr,  // kHashIndexMetadata
+        nullptr,  // kMetaIndex (not yet stored in block cache)
+        &BlockCacheInterface<Block_kIndex>::kFullHelper,
+        nullptr,  // kInvalid
+    }};
+
+// For getting basic helpers from a BlockType (no SecondaryCache support)
+constexpr std::array<const Cache::CacheItemHelper*,
+                     static_cast<unsigned>(BlockType::kInvalid) + 1>
+    kCacheItemBasicHelperForBlockType{{
+        &BlockCacheInterface<Block_kData>::kBasicHelper,
+        &BlockCacheInterface<ParsedFullFilterBlock>::kBasicHelper,
+        &BlockCacheInterface<Block_kFilterPartitionIndex>::kBasicHelper,
+        nullptr,  // kProperties
+        &BlockCacheInterface<UncompressionDict>::kBasicHelper,
+        &BlockCacheInterface<Block_kRangeDeletion>::kBasicHelper,
+        nullptr,  // kHashIndexPrefixes
+        nullptr,  // kHashIndexMetadata
+        nullptr,  // kMetaIndex (not yet stored in block cache)
+        &BlockCacheInterface<Block_kIndex>::kBasicHelper,
+        nullptr,  // kInvalid
+    }};
+}  // namespace
+
+const Cache::CacheItemHelper* GetCacheItemHelper(
+    BlockType block_type, CacheTier lowest_used_cache_tier) {
+  if (lowest_used_cache_tier == CacheTier::kNonVolatileBlockTier) {
+    return kCacheItemFullHelperForBlockType[static_cast<unsigned>(block_type)];
+  } else {
+    return kCacheItemBasicHelperForBlockType[static_cast<unsigned>(block_type)];
+  }
+}
+
+}  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/table/block_based/block_cache.h

@@ -0,0 +1,132 @@
+//  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).
+
+// Code supporting block cache (Cache) access for block-based table, based on
+// the convenient APIs in typed_cache.h
+
+#pragma once
+
+#include <type_traits>
+
+#include "cache/typed_cache.h"
+#include "port/lang.h"
+#include "table/block_based/block.h"
+#include "table/block_based/block_type.h"
+#include "table/block_based/parsed_full_filter_block.h"
+#include "table/format.h"
+
+namespace ROCKSDB_NAMESPACE {
+
+// Metaprogramming wrappers for Block, to give each type a single role when
+// used with FullTypedCacheInterface.
+// (NOTE: previous attempts to create actual derived classes of Block with
+// virtual calls resulted in performance regression)
+
+class Block_kData : public Block {
+ public:
+  using Block::Block;
+
+  static constexpr CacheEntryRole kCacheEntryRole = CacheEntryRole::kDataBlock;
+  static constexpr BlockType kBlockType = BlockType::kData;
+};
+
+class Block_kIndex : public Block {
+ public:
+  using Block::Block;
+
+  static constexpr CacheEntryRole kCacheEntryRole = CacheEntryRole::kIndexBlock;
+  static constexpr BlockType kBlockType = BlockType::kIndex;
+};
+
+class Block_kFilterPartitionIndex : public Block {
+ public:
+  using Block::Block;
+
+  static constexpr CacheEntryRole kCacheEntryRole =
+      CacheEntryRole::kFilterMetaBlock;
+  static constexpr BlockType kBlockType = BlockType::kFilterPartitionIndex;
+};
+
+class Block_kRangeDeletion : public Block {
+ public:
+  using Block::Block;
+
+  static constexpr CacheEntryRole kCacheEntryRole = CacheEntryRole::kOtherBlock;
+  static constexpr BlockType kBlockType = BlockType::kRangeDeletion;
+};
+
+// Useful for creating the Block even though meta index blocks are not
+// yet stored in block cache
+class Block_kMetaIndex : public Block {
+ public:
+  using Block::Block;
+
+  static constexpr CacheEntryRole kCacheEntryRole = CacheEntryRole::kOtherBlock;
+  static constexpr BlockType kBlockType = BlockType::kMetaIndex;
+};
+
+struct BlockCreateContext : public Cache::CreateContext {
+  BlockCreateContext() {}
+  BlockCreateContext(const BlockBasedTableOptions* _table_options,
+                     Statistics* _statistics, bool _using_zstd)
+      : table_options(_table_options),
+        statistics(_statistics),
+        using_zstd(_using_zstd) {}
+
+  const BlockBasedTableOptions* table_options = nullptr;
+  Statistics* statistics = nullptr;
+  bool using_zstd = false;
+
+  // For TypedCacheInterface
+  template <typename TBlocklike>
+  inline void Create(std::unique_ptr<TBlocklike>* parsed_out,
+                     size_t* charge_out, const Slice& data,
+                     MemoryAllocator* alloc) {
+    Create(parsed_out,
+           BlockContents(AllocateAndCopyBlock(data, alloc), data.size()));
+    *charge_out = parsed_out->get()->ApproximateMemoryUsage();
+  }
+
+  void Create(std::unique_ptr<Block_kData>* parsed_out, BlockContents&& block);
+  void Create(std::unique_ptr<Block_kIndex>* parsed_out, BlockContents&& block);
+  void Create(std::unique_ptr<Block_kFilterPartitionIndex>* parsed_out,
+              BlockContents&& block);
+  void Create(std::unique_ptr<Block_kRangeDeletion>* parsed_out,
+              BlockContents&& block);
+  void Create(std::unique_ptr<Block_kMetaIndex>* parsed_out,
+              BlockContents&& block);
+  void Create(std::unique_ptr<ParsedFullFilterBlock>* parsed_out,
+              BlockContents&& block);
+  void Create(std::unique_ptr<UncompressionDict>* parsed_out,
+              BlockContents&& block);
+};
+
+// Convenient cache interface to use with block_cache_compressed
+using CompressedBlockCacheInterface =
+    BasicTypedCacheInterface<BlockContents, CacheEntryRole::kOtherBlock>;
+
+// Convenient cache interface to use for block_cache, with support for
+// SecondaryCache.
+template <typename TBlocklike>
+using BlockCacheInterface =
+    FullTypedCacheInterface<TBlocklike, BlockCreateContext>;
+
+// Shortcut name for cache handles under BlockCacheInterface
+template <typename TBlocklike>
+using BlockCacheTypedHandle =
+    typename BlockCacheInterface<TBlocklike>::TypedHandle;
+
+// Selects the right helper based on BlockType and CacheTier
+const Cache::CacheItemHelper* GetCacheItemHelper(
+    BlockType block_type,
+    CacheTier lowest_used_cache_tier = CacheTier::kNonVolatileBlockTier);
+
+// For SFINAE check that a type is "blocklike" with a kCacheEntryRole member.
+// Can get difficult compiler/linker errors without a good check like this.
+template <typename TUse, typename TBlocklike>
+using WithBlocklikeCheck = std::enable_if_t<
+    TBlocklike::kCacheEntryRole == CacheEntryRole::kMisc || true, TUse>;
+
+}  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/table/block_based/cachable_entry.h

@@ -10,6 +10,7 @@
 #pragma once
 
 #include <cassert>
+#include <type_traits>
 
 #include "port/likely.h"
 #include "rocksdb/cache.h"
@@ -191,6 +192,29 @@ class CachableEntry {
     return true;
   }
 
+  // Since this class is essentially an elaborate pointer, it's sometimes
+  // useful to be able to upcast or downcast the base type of the pointer,
+  // especially when interacting with typed_cache.h.
+  template <class TWrapper>
+  std::enable_if_t<sizeof(TWrapper) == sizeof(T) &&
+                       (std::is_base_of_v<TWrapper, T> ||
+                        std::is_base_of_v<T, TWrapper>),
+                   /* Actual return type */
+                   CachableEntry<TWrapper>&>
+  As() {
+    CachableEntry<TWrapper>* result_ptr =
+        reinterpret_cast<CachableEntry<TWrapper>*>(this);
+    // Ensure no weirdness in template instantiations
+    assert(static_cast<void*>(&this->value_) ==
+           static_cast<void*>(&result_ptr->value_));
+    assert(&this->cache_handle_ == &result_ptr->cache_handle_);
+    // This function depends on no arithmetic involved in the pointer
+    // conversion, which is not statically checkable.
+    assert(static_cast<void*>(this->value_) ==
+           static_cast<void*>(result_ptr->value_));
+    return *result_ptr;
+  }
+
  private:
   void ReleaseResource() noexcept {
     if (LIKELY(cache_handle_ != nullptr)) {
@@ -223,6 +247,10 @@ class CachableEntry {
   }
 
  private:
+  // Have to be your own best friend
+  template <class TT>
+  friend class CachableEntry;
+
   T* value_ = nullptr;
   Cache* cache_ = nullptr;
   Cache::Handle* cache_handle_ = nullptr;

package/deps/rocksdb/rocksdb/table/block_based/filter_block_reader_common.cc

@@ -6,6 +6,7 @@
 
 #include "table/block_based/filter_block_reader_common.h"
 
+#include "block_cache.h"
 #include "monitoring/perf_context_imp.h"
 #include "table/block_based/block_based_table_reader.h"
 #include "table/block_based/parsed_full_filter_block.h"
@@ -17,7 +18,7 @@ Status FilterBlockReaderCommon<TBlocklike>::ReadFilterBlock(
     const BlockBasedTable* table, FilePrefetchBuffer* prefetch_buffer,
     const ReadOptions& read_options, bool use_cache, GetContext* get_context,
     BlockCacheLookupContext* lookup_context,
-    CachableEntry<TBlocklike>* filter_block, BlockType block_type) {
+    CachableEntry<TBlocklike>* filter_block) {
   PERF_TIMER_GUARD(read_filter_block_nanos);
 
   assert(table);
@@ -30,7 +31,7 @@ Status FilterBlockReaderCommon<TBlocklike>::ReadFilterBlock(
   const Status s =
       table->RetrieveBlock(prefetch_buffer, read_options, rep->filter_handle,
                            UncompressionDict::GetEmptyDict(), filter_block,
-                           block_type, get_context, lookup_context,
+                           get_context, lookup_context,
                            /* for_compaction */ false, use_cache,
                            /* wait_for_cache */ true, /* async_read */ false);
 
@@ -68,7 +69,7 @@ template <typename TBlocklike>
 Status FilterBlockReaderCommon<TBlocklike>::GetOrReadFilterBlock(
     bool no_io, GetContext* get_context,
     BlockCacheLookupContext* lookup_context,
-    CachableEntry<TBlocklike>* filter_block, BlockType block_type,
+    CachableEntry<TBlocklike>* filter_block,
     Env::IOPriority rate_limiter_priority) const {
   assert(filter_block);
 
@@ -85,7 +86,7 @@ Status FilterBlockReaderCommon<TBlocklike>::GetOrReadFilterBlock(
 
   return ReadFilterBlock(table_, nullptr /* prefetch_buffer */, read_options,
                          cache_filter_blocks(), get_context, lookup_context,
-                         filter_block, block_type);
+                         filter_block);
 }
 
 template <typename TBlocklike>
@@ -158,7 +159,7 @@ bool FilterBlockReaderCommon<TBlocklike>::IsFilterCompatible(
 
 // Explicitly instantiate templates for both "blocklike" types we use.
 // This makes it possible to keep the template definitions in the .cc file.
-template class FilterBlockReaderCommon<Block>;
+template class FilterBlockReaderCommon<Block_kFilterPartitionIndex>;
 template class FilterBlockReaderCommon<ParsedFullFilterBlock>;
 
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/table/block_based/filter_block_reader_common.h

@@ -8,7 +8,6 @@
 
 #include <cassert>
 
-#include "block_type.h"
 #include "table/block_based/cachable_entry.h"
 #include "table/block_based/filter_block.h"
 
@@ -49,8 +48,7 @@ class FilterBlockReaderCommon : public FilterBlockReader {
                                 const ReadOptions& read_options, bool use_cache,
                                 GetContext* get_context,
                                 BlockCacheLookupContext* lookup_context,
-                                CachableEntry<TBlocklike>* filter_block,
-                                BlockType block_type);
+                                CachableEntry<TBlocklike>* filter_block);
 
   const BlockBasedTable* table() const { return table_; }
   const SliceTransform* table_prefix_extractor() const;
@@ -60,7 +58,6 @@ class FilterBlockReaderCommon : public FilterBlockReader {
   Status GetOrReadFilterBlock(bool no_io, GetContext* get_context,
                               BlockCacheLookupContext* lookup_context,
                               CachableEntry<TBlocklike>* filter_block,
-                              BlockType block_type,
                               Env::IOPriority rate_limiter_priority) const;
 
   size_t ApproximateFilterBlockMemoryUsage() const;