@@ -104,9 +104,10 @@ class PAIMON_EXPORT CacheConfig {
     uint64_t hole_size_limit_ = 8 * 1024;
     uint64_t pre_buffer_limit_ = 256 * 1024 * 1024;
     // Blocks are aligned to the END of the file, so a block never reaches past
-    // EOF. 64 KiB matches the footer read of the parquet reader (arrow's
-    // kDefaultFooterReadSize), which then covers exactly one block instead of
-    // straddling two.
+    // EOF. 64 KiB is the granularity the reads no prefetched range covers are
+    // shared at: small enough that a metadata read at the tail of a file is
+    // served by one block instead of straddling two, large enough that a block
+    // fetch does not pull in much more than the reads ask for.
     uint64_t block_size_ = 64 * 1024;
     // One block is enough for the metadata tail of a file; the limit only
     // bounds the pathological case, as blocks are never evicted.
 
@@ -40,7 +40,10 @@ namespace paimon::test {
 class CacheInputStreamTest : public ::testing::Test {
  public:
     void SetUp() override {
-        pool_ = GetDefaultPool();
+        // A pool of its own, so that a cache buffer outliving the pool it was
+        // allocated from shows up instead of being covered by the global pool,
+        // which never goes away.
+        pool_ = std::shared_ptr<MemoryPool>(GetMemoryPool());
         test_dir_ = UniqueTestDirectory::Create();
         ASSERT_TRUE(test_dir_);
         content_ = "abcdefghijklmnopqrstuvwxyz0123456789";
 
@@ -35,18 +35,27 @@
 
 namespace paimon {
 
-/// A cache of fixed-size blocks of one file, serving the reads that no
-/// prefetched range covers: a parquet reader reads the footer and the page index
-/// before any range can be registered, and every reader of the file reads the
-/// same bytes.
+/// A cache of fixed-size blocks of one file, the fallback below the prefetched
+/// ranges: a read that no registered range covers is served here at block
+/// granularity instead of being left to the caller, which would read it from the
+/// underlying stream uncached and pay for it again on the next reader. It is a
+/// general mechanism over the whole file - any reader, any offset, any round of
+/// registered ranges - not a cache of one particular kind of read.
 ///
 /// Blocks are aligned to the END of the file: block 0 is
-/// [file_size - block_size, file_size). The metadata of a parquet/orc file lives
-/// in its tail and arrow reads exactly the last 64 KiB as the footer, so an
-/// end-aligned block matches that read instead of straddling two blocks. It also
-/// keeps every block inside the file, as long as the given file size is the size
-/// of the file: a block fetch failing because the file is shorter than that only
-/// costs the caching of that block, see Read().
+/// [file_size - block_size, file_size). The reads served here concentrate at the
+/// tail of a file: a reader reads the metadata of its file before it knows which
+/// ranges to register, and every reader of the file reads the same bytes. End
+/// alignment gives that region whole blocks - a read of the last block_size bytes
+/// of a file is one block whatever the file size - and leaves the only partial
+/// block at the head of the file. It also keeps every block inside the file, as
+/// long as the given file size is the size of the file: a block fetch failing
+/// because the file is shorter than that only costs the caching of that block,
+/// see Read().
+///
+/// One block serves one read: a read longer than a block, or straddling two, is
+/// declined and left to the caller instead of being fetched in pieces, so a
+/// served read stays one block, one fetch and one copy.
 ///
 /// A block is published before its fetch is dispatched, so concurrent readers of
 /// the same block wait for that one fetch instead of issuing their own.
 
@@ -64,12 +64,15 @@ class PAIMON_EXPORT ReadAheadCacheMetrics {
     /// the block granularity added on top of the requested ones.
     static inline const char BLOCK_FETCHES[] = "read-ahead-cache.block.fetches";
     static inline const char BLOCK_FETCH_BYTES[] = "read-ahead-cache.block.fetch-bytes";
-    /// Number of prefetch IO requests actually issued to the underlying stream.
-    /// These are the same requests that the `io.async.*` metrics of the prefetch
-    /// reader observe one layer below, counted here per cache rather than per
-    /// stream, so the two are expected to agree instead of adding up.
+    /// Number of IO requests the cache itself issued to the underlying stream:
+    /// the prefetch fetches plus the block fetches. The `io.async.*` metrics of
+    /// the prefetch reader count those same requests one layer below, but they
+    /// also count the async reads a sub-reader falls back to after this cache
+    /// declined them, so `io.async.requests >= io.count` rather than the two
+    /// agreeing.
     static inline const char IO_COUNT[] = "read-ahead-cache.io.count";
-    /// Total bytes requested by the prefetch IOs issued to the underlying stream.
+    /// Total bytes requested by the IOs the cache itself issued to the
+    /// underlying stream.
     static inline const char IO_BYTES[] = "read-ahead-cache.io.bytes";
 };
 
@@ -105,10 +108,10 @@ struct PAIMON_EXPORT ByteRange {
 /// ReleaseBuffers() or Reset(). It is meant to hold the prefetched ranges of
 /// a single data file, whose size is bounded by the reader's scan scope.
 ///
-/// Reads that the prefetched ranges do not cover (the footer and the page index
-/// of a parquet file are read before any range is registered) are served by a
-/// FileBlockCache instead of being left to the caller. That block cache is owned
-/// by this one and shares its lifetime: it is configured from `block_size` and
+/// Reads that the prefetched ranges do not cover - a reader reads the metadata
+/// of its file before any range is registered - are served by a FileBlockCache
+/// instead of being left to the caller. That block cache is owned by this one
+/// and shares its lifetime: it is configured from `block_size` and
 /// `block_cache_limit`, it survives Reset() - the blocks belong to the file
 /// rather than to a registration round - and it is released by ReleaseBuffers().
 class PAIMON_EXPORT ReadAheadCache {
@@ -150,11 +153,11 @@ class PAIMON_EXPORT ReadAheadCache {
     /// when the first Read() arrives, racing the caller's own miss fetch.
     void Warmup();
 
-    /// Collect hit/miss counters of Read() calls and the prefetch IO
-    /// counters into the given metrics as counters named after
+    /// Collect the counters of the Read() calls, of the block cache and of the
+    /// IOs into the given metrics as counters named after
     /// `ReadAheadCacheMetrics`. Only reads issued through Read() are counted
-    /// as hits/misses; prefetch fetches dispatched by the cache itself are
-    /// counted in the fetch counters instead.
+    /// as hits, block hits or misses; the fetches the cache dispatches itself
+    /// are counted in the io counters instead.
     /// @param metrics The metrics to write the counters into. A null
     /// pointer or a null shared pointer is a no-op.
     void CollectMetrics(std::shared_ptr<Metrics>* metrics) const;
 
@@ -1679,17 +1679,22 @@ TEST_F(ParquetFileBatchReaderTest, TestPreBufferRangeFeedsReadAheadCache) {
     WriteArray(file_path_, src_array, arrow_schema, /*write_batch_size=*/10,
                /*enable_dictionary=*/true, /*max_row_group_length=*/10);
 
+    // A pool of its own, so that a buffer outliving the pool it was allocated
+    // from shows up instead of being covered by the global pool, which never
+    // goes away. Declared first, so that it outlives the cache and the reader.
+    std::shared_ptr<MemoryPool> pool(GetMemoryPool());
+
     ASSERT_OK_AND_ASSIGN(std::shared_ptr<InputStream> cache_stream, fs_->Open(file_path_));
     // The file size is left unknown so the block cache stays off: this test is
     // about the pre-buffered ranges feeding the cache.
-    auto cache = std::make_shared<ReadAheadCache>(cache_stream, CacheConfig(), /*file_size=*/0,
-                                                  GetDefaultPool());
+    auto cache =
+        std::make_shared<ReadAheadCache>(cache_stream, CacheConfig(), /*file_size=*/0, pool);
     ASSERT_OK_AND_ASSIGN(std::unique_ptr<InputStream> reader_stream, fs_->Open(file_path_));
     auto cache_input_stream = std::make_shared<CacheInputStream>(std::move(reader_stream), cache);
 
     std::map<std::string, std::string> options;
     ParquetReaderBuilder builder(options, batch_size_);
-    builder.WithMemoryPool(GetDefaultPool());
+    builder.WithMemoryPool(pool);
     ASSERT_OK_AND_ASSIGN(std::unique_ptr<FileBatchReader> base_reader,
                          builder.Build(cache_input_stream));
     auto parquet_batch_reader = dynamic_cast<ParquetFileBatchReader*>(base_reader.get());
@@ -2111,17 +2116,22 @@ TEST_F(ParquetFileBatchReaderTest, TestBlockCacheSharesTailReadsAcrossReaders) {
     const int64_t tail_begin = file_length - static_cast<int64_t>(CacheConfig().GetBlockSize());
     ASSERT_GT(tail_begin, 0);
 
+    // A pool of its own, so that a buffer outliving the pool it was allocated
+    // from shows up instead of being covered by the global pool, which never
+    // goes away. Declared first, so that it outlives the cache and the readers.
+    std::shared_ptr<MemoryPool> pool(GetMemoryPool());
+
     auto tail_read_count = std::make_shared<std::atomic<int32_t>>(0);
     ASSERT_OK_AND_ASSIGN(std::unique_ptr<InputStream> cache_stream, fs_->Open(file_path_));
     auto counting_cache_stream = std::make_shared<TailReadCountingInputStream>(
         std::move(cache_stream), tail_begin, tail_read_count);
-    auto cache = std::make_shared<ReadAheadCache>(
-        counting_cache_stream, CacheConfig(), static_cast<uint64_t>(file_length), GetDefaultPool());
+    auto cache = std::make_shared<ReadAheadCache>(counting_cache_stream, CacheConfig(),
+                                                  static_cast<uint64_t>(file_length), pool);
 
     std::map<std::string, std::string> options;
     options[PARQUET_READ_ENABLE_PAGE_INDEX_FILTER] = "true";
     ParquetReaderBuilder builder(options, batch_size_);
-    builder.WithMemoryPool(GetDefaultPool());
+    builder.WithMemoryPool(pool);
 
     constexpr int32_t kReaderCount = 3;
     std::vector<std::future<Result<std::unique_ptr<FileBatchReader>>>> futures;