CNDB-15360: ChunkCache hot and cold inspection POC

Author: lesnik2u

src/java/org/apache/cassandra/cache/ChunkCache.java

@@ -62,6 +62,12 @@
 import org.apache.cassandra.utils.memory.BufferPool;
 import org.apache.cassandra.utils.memory.BufferPools;
 import org.github.jamm.Unmetered;
+import java.util.List;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.Collections;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 public class ChunkCache
         implements RemovalListener<ChunkCache.Key, ChunkCache.Chunk>, CacheSize
@@ -770,4 +776,80 @@ public int sizeOfFile(File file) {
         long mask = - (1 << (CHUNK_SIZE_LOG2_BITS + READER_TYPE_BITS));
         return (int) cacheAsMap.keySet().stream().filter(x -> (x.readerId & mask) == fileId).count();
     }
+
+    public static class ChunkCacheInspectionEntry
+    {
+        public final String filePath;
+        public final long position;
+        public final int size;
+        public final boolean isReady;
+
+        public ChunkCacheInspectionEntry(String filePath, long position, int size, boolean isReady)
+        {
+            this.filePath = filePath;
+            this.position = position;
+            this.size = size;
+            this.isReady = isReady;
+        }
+
+        @Override
+        public String toString()
+        {
+            return String.format("Chunk{file='%s', pos=%d, size=%d}", filePath, position, size);
+        }
+    }
+
+    /**
+     * Inspects the "hottest" (most frequently/recently used) chunks in the cache.
+     *
+     * @param limit maximum number of entries to return
+     * @return List of entries sorted from hottest to less hot
+     */
+    public List<ChunkCacheInspectionEntry> getHotEntries(int limit)
+    {
+        return inspectCacheSegments(limit, true);
+    }
+
+    /**
+     * Inspects the "coldest" (candidates for eviction) chunks in the cache.
+     *
+     * @param limit maximum number of entries to return
+     * @return List of entries sorted from coldest to warmer
+     */
+    public List<ChunkCacheInspectionEntry> getColdEntries(int limit)
+    {
+        return inspectCacheSegments(limit, false);
+    }
+
+    private List<ChunkCacheInspectionEntry> inspectCacheSegments(int limit, boolean hottest)
+    {
+        if (!enabled)
+            return Collections.emptyList();
+
+        Map<Long, String> idToPath = new HashMap<>(fileIdMap.size());
+        fileIdMap.forEach((file, id) -> idToPath.put(id, file.toString()));
+
+        int shift = CHUNK_SIZE_LOG2_BITS + READER_TYPE_BITS;
+
+        return synchronousCache.policy().eviction()
+                               .map(policy -> {
+                                   Map<Key, Chunk> orderedMap = hottest
+                                                                ? policy.hottest(limit)
+                                                                : policy.coldest(limit);
+
+                                   return orderedMap.entrySet().stream().map(entry -> {
+                                       Key key = entry.getKey();
+                                       Chunk chunk = entry.getValue();
+
+                                       long fileId = key.readerId >>> shift;
+
+                                       String path = idToPath.getOrDefault(fileId, "Unknown/StaleFile");
+
+                                       int size = (chunk != null) ? chunk.capacity() : 0;
+
+                                       return new ChunkCacheInspectionEntry(path, key.position, size, chunk != null);
+                                   }).collect(Collectors.toList());
+                               })
+                               .orElse(Collections.emptyList());
+    }
 }