Uses of Class
org.apache.hadoop.hbase.io.hfile.BlockCacheKey

Packages that use BlockCacheKey

Package	Description
org.apache.hadoop.hbase.io.hfile	Provides implementations of HFile and HFile BlockCache.
org.apache.hadoop.hbase.io.hfile.bucket	Provides BucketCache, an implementation of BlockCache.

Uses of BlockCacheKey in org.apache.hadoop.hbase.io.hfile

Fields in org.apache.hadoop.hbase.io.hfile declared as BlockCacheKey

Modifier and Type	Field	Description
private final BlockCacheKey	LruCachedBlock.cacheKey
private final BlockCacheKey	TinyLfuBlockCache.CachedBlockView.key

Fields in org.apache.hadoop.hbase.io.hfile with type parameters of type BlockCacheKey

Modifier and Type	Field	Description
(package private) final com.github.benmanes.caffeine.cache.Cache<BlockCacheKey,Cacheable>	TinyLfuBlockCache.cache
private final ConcurrentHashMap<BlockCacheKey,LruCachedBlock>	LruAdaptiveBlockCache.map	Defined the cache map as ConcurrentHashMap here, because in LruAdaptiveBlockCache.getBlock(org.apache.hadoop.hbase.io.hfile.BlockCacheKey, boolean, boolean, boolean), we need to guarantee the atomicity of map#computeIfPresent (key, func).
private final ConcurrentHashMap<BlockCacheKey,LruCachedBlock>	LruBlockCache.map	Defined the cache map as ConcurrentHashMap here, because in LruBlockCache.getBlock(org.apache.hadoop.hbase.io.hfile.BlockCacheKey, boolean, boolean, boolean), we need to guarantee the atomicity of map#k (key, func).
private final com.github.benmanes.caffeine.cache.Policy.Eviction<BlockCacheKey,Cacheable>	TinyLfuBlockCache.policy

Methods in org.apache.hadoop.hbase.io.hfile that return BlockCacheKey

Modifier and Type	Method	Description
BlockCacheKey	LruCachedBlock.getCacheKey()

Methods in org.apache.hadoop.hbase.io.hfile that return types with arguments of type BlockCacheKey

Modifier and Type	Method	Description
(package private) Map<BlockCacheKey,LruCachedBlock>	LruAdaptiveBlockCache.getMapForTests()
(package private) Map<BlockCacheKey,LruCachedBlock>	LruBlockCache.getMapForTests()

Methods in org.apache.hadoop.hbase.io.hfile with parameters of type BlockCacheKey

Modifier and Type	Method	Description
void	BlockCache.cacheBlock(BlockCacheKey cacheKey, Cacheable buf)	Add block to cache (defaults to not in-memory).
void	BlockCache.cacheBlock(BlockCacheKey cacheKey, Cacheable buf, boolean inMemory)	Add block to cache.
default void	BlockCache.cacheBlock(BlockCacheKey cacheKey, Cacheable buf, boolean inMemory, boolean waitWhenCache)	Add block to cache.
void	CombinedBlockCache.cacheBlock(BlockCacheKey cacheKey, Cacheable buf)
void	CombinedBlockCache.cacheBlock(BlockCacheKey cacheKey, Cacheable buf, boolean inMemory)
void	CombinedBlockCache.cacheBlock(BlockCacheKey cacheKey, Cacheable buf, boolean inMemory, boolean waitWhenCache)
void	InclusiveCombinedBlockCache.cacheBlock(BlockCacheKey cacheKey, Cacheable buf, boolean inMemory)
void	IndexOnlyLruBlockCache.cacheBlock(BlockCacheKey cacheKey, Cacheable buf, boolean inMemory)	Cache only index block with the specified name and buffer
void	LruAdaptiveBlockCache.cacheBlock(BlockCacheKey cacheKey, Cacheable buf)	Cache the block with the specified name and buffer.
void	LruAdaptiveBlockCache.cacheBlock(BlockCacheKey cacheKey, Cacheable buf, boolean inMemory)	Cache the block with the specified name and buffer.
void	LruBlockCache.cacheBlock(BlockCacheKey cacheKey, Cacheable buf)	Cache the block with the specified name and buffer.
void	LruBlockCache.cacheBlock(BlockCacheKey cacheKey, Cacheable buf, boolean inMemory)	Cache the block with the specified name and buffer.
void	MemcachedBlockCache.cacheBlock(BlockCacheKey cacheKey, Cacheable buf)
void	MemcachedBlockCache.cacheBlock(BlockCacheKey cacheKey, Cacheable buf, boolean inMemory)
void	TinyLfuBlockCache.cacheBlock(BlockCacheKey key, Cacheable value)
void	TinyLfuBlockCache.cacheBlock(BlockCacheKey cacheKey, Cacheable value, boolean inMemory)
boolean	FirstLevelBlockCache.containsBlock(BlockCacheKey cacheKey)	Whether the cache contains the block with specified cacheKey
boolean	LruAdaptiveBlockCache.containsBlock(BlockCacheKey cacheKey)	Whether the cache contains block with specified cacheKey
boolean	LruBlockCache.containsBlock(BlockCacheKey cacheKey)	Whether the cache contains block with specified cacheKey
boolean	TinyLfuBlockCache.containsBlock(BlockCacheKey cacheKey)
boolean	BlockCache.evictBlock(BlockCacheKey cacheKey)	Evict block from cache.
boolean	CombinedBlockCache.evictBlock(BlockCacheKey cacheKey)
boolean	InclusiveCombinedBlockCache.evictBlock(BlockCacheKey cacheKey)
boolean	LruAdaptiveBlockCache.evictBlock(BlockCacheKey cacheKey)
boolean	LruBlockCache.evictBlock(BlockCacheKey cacheKey)
boolean	MemcachedBlockCache.evictBlock(BlockCacheKey cacheKey)
boolean	TinyLfuBlockCache.evictBlock(BlockCacheKey cacheKey)
Cacheable	BlockCache.getBlock(BlockCacheKey cacheKey, boolean caching, boolean repeat, boolean updateCacheMetrics)	Fetch block from cache.
default Cacheable	BlockCache.getBlock(BlockCacheKey cacheKey, boolean caching, boolean repeat, boolean updateCacheMetrics, BlockType blockType)	Fetch block from cache.
Cacheable	CombinedBlockCache.getBlock(BlockCacheKey cacheKey, boolean caching, boolean repeat, boolean updateCacheMetrics)
Cacheable	CombinedBlockCache.getBlock(BlockCacheKey cacheKey, boolean caching, boolean repeat, boolean updateCacheMetrics, BlockType blockType)
Cacheable	InclusiveCombinedBlockCache.getBlock(BlockCacheKey cacheKey, boolean caching, boolean repeat, boolean updateCacheMetrics)
Cacheable	LruAdaptiveBlockCache.getBlock(BlockCacheKey cacheKey, boolean caching, boolean repeat, boolean updateCacheMetrics)	Get the buffer of the block with the specified name.
Cacheable	LruBlockCache.getBlock(BlockCacheKey cacheKey, boolean caching, boolean repeat, boolean updateCacheMetrics)	Get the buffer of the block with the specified name.
Cacheable	MemcachedBlockCache.getBlock(BlockCacheKey cacheKey, boolean caching, boolean repeat, boolean updateCacheMetrics)
Cacheable	TinyLfuBlockCache.getBlock(BlockCacheKey cacheKey, boolean caching, boolean repeat, boolean updateCacheMetrics)
default Optional<Integer>	BlockCache.getBlockSize(BlockCacheKey key)	Returns an Optional containing the size of the block related to the passed key.
Optional<Integer>	CombinedBlockCache.getBlockSize(BlockCacheKey key)
private Cacheable	CombinedBlockCache.getBlockWithType(BlockCacheKey cacheKey, boolean caching, boolean repeat, boolean updateCacheMetrics)
private HFileBlock	HFileReaderImpl.getCachedBlock(BlockCacheKey cacheKey, boolean cacheBlock, boolean useLock, boolean updateCacheMetrics, BlockType expectedBlockType, DataBlockEncoding expectedDataBlockEncoding)	Retrieve block from cache.
int	CombinedBlockCache.getRpcRefCount(BlockCacheKey cacheKey)
default Optional<Boolean>	BlockCache.isAlreadyCached(BlockCacheKey key)	Checks whether the block for the passed key is already cached.
Optional<Boolean>	CombinedBlockCache.isAlreadyCached(BlockCacheKey key)
void	TinyLfuBlockCache.EvictionListener.onRemoval(BlockCacheKey key, Cacheable value, com.github.benmanes.caffeine.cache.RemovalCause cause)
private void	HFileReaderImpl.returnAndEvictBlock(BlockCache cache, BlockCacheKey cacheKey, Cacheable block)
static boolean	BlockCacheUtil.shouldReplaceExistingCacheBlock(BlockCache blockCache, BlockCacheKey cacheKey, Cacheable newBlock)	Because of the region splitting, it's possible that the split key locate in the middle of a block.
private void	CombinedBlockCache.updateBlockMetrics(Cacheable block, BlockCacheKey key, BlockCache cache, boolean caching)
static int	BlockCacheUtil.validateBlockAddition(Cacheable existing, Cacheable newBlock, BlockCacheKey cacheKey)	Validate that the existing and newBlock are the same without including the nextBlockMetadata, if not, throw an exception.

Constructors in org.apache.hadoop.hbase.io.hfile with parameters of type BlockCacheKey

Modifier	Constructor	Description
	CachedBlockView(BlockCacheKey key, Cacheable value, long now)
	LruCachedBlock(BlockCacheKey cacheKey, Cacheable buf, long accessTime)
	LruCachedBlock(BlockCacheKey cacheKey, Cacheable buf, long accessTime, boolean inMemory)

Uses of BlockCacheKey in org.apache.hadoop.hbase.io.hfile.bucket

Fields in org.apache.hadoop.hbase.io.hfile.bucket declared as BlockCacheKey

Modifier and Type	Field	Description
private final BlockCacheKey	BucketCache.RAMQueueEntry.key

Fields in org.apache.hadoop.hbase.io.hfile.bucket with type parameters of type BlockCacheKey

Modifier and Type	Field	Description
(package private) Map<BlockCacheKey,BucketEntry>	BucketCache.backingMap
(package private) NavigableSet<BlockCacheKey>	BucketCache.blocksByHFile
private static final Comparator<Map.Entry<BlockCacheKey,BucketEntry>>	CachedEntryQueue.COMPARATOR
(package private) final ConcurrentHashMap<BlockCacheKey,BucketCache.RAMQueueEntry>	BucketCache.RAMCache.delegate	Defined the map as ConcurrentHashMap explicitly here, because in BucketCache.RAMCache.get(BlockCacheKey) and BucketCache.RAMCache.putIfAbsent(BlockCacheKey, BucketCache.RAMQueueEntry) , we need to guarantee the atomicity of map#computeIfPresent(key, func) and map#putIfAbsent(key, func).
private org.apache.hbase.thirdparty.com.google.common.collect.MinMaxPriorityQueue<Map.Entry<BlockCacheKey,BucketEntry>>	CachedEntryQueue.queue

Methods in org.apache.hadoop.hbase.io.hfile.bucket that return BlockCacheKey

Modifier and Type	Method	Description
BlockCacheKey	BucketCache.RAMQueueEntry.getKey()

Methods in org.apache.hadoop.hbase.io.hfile.bucket that return types with arguments of type BlockCacheKey

Modifier and Type	Method	Description
(package private) static Pair<ConcurrentHashMap<BlockCacheKey,BucketEntry>,NavigableSet<BlockCacheKey>>	BucketProtoUtils.fromPB(Map<Integer,String> deserializers, org.apache.hadoop.hbase.shaded.protobuf.generated.BucketCacheProtos.BackingMap backingMap, Function<BucketEntry,ByteBuffAllocator.Recycler> createRecycler)
(package private) static Pair<ConcurrentHashMap<BlockCacheKey,BucketEntry>,NavigableSet<BlockCacheKey>>	BucketProtoUtils.fromPB(Map<Integer,String> deserializers, org.apache.hadoop.hbase.shaded.protobuf.generated.BucketCacheProtos.BackingMap backingMap, Function<BucketEntry,ByteBuffAllocator.Recycler> createRecycler)
private Set<BlockCacheKey>	BucketCache.getAllCacheKeysForFile(String hfileName, long init, long end)
Map<BlockCacheKey,BucketEntry>	BucketCache.getBackingMap()
Map.Entry<BlockCacheKey,BucketEntry>	CachedEntryQueue.poll()	Returns The next element in this queue, or null if the queue is empty.
Map.Entry<BlockCacheKey,BucketEntry>	CachedEntryQueue.pollLast()	Returns The last element in this queue, or null if the queue is empty.

Methods in org.apache.hadoop.hbase.io.hfile.bucket with parameters of type BlockCacheKey

Modifier and Type	Method	Description
(package private) void	BucketCache.blockEvicted(BlockCacheKey cacheKey, BucketEntry bucketEntry, boolean decrementBlockNumber, boolean evictedByEvictionProcess)	This method is invoked after the bucketEntry is removed from BucketCache.backingMap
void	BucketCache.cacheBlock(BlockCacheKey cacheKey, Cacheable buf)	Cache the block with the specified name and buffer.
void	BucketCache.cacheBlock(BlockCacheKey cacheKey, Cacheable cachedItem, boolean inMemory)	Cache the block with the specified name and buffer.
void	BucketCache.cacheBlock(BlockCacheKey cacheKey, Cacheable cachedItem, boolean inMemory, boolean waitWhenCache)	Cache the block with the specified name and buffer.
void	BucketCache.cacheBlockWithWait(BlockCacheKey cacheKey, Cacheable cachedItem, boolean inMemory, boolean wait)	Cache the block to ramCache
protected void	BucketCache.cacheBlockWithWaitInternal(BlockCacheKey cacheKey, Cacheable cachedItem, boolean inMemory, boolean wait)
boolean	BucketCache.RAMCache.containsKey(BlockCacheKey key)
private boolean	BucketCache.doEvictBlock(BlockCacheKey cacheKey, BucketEntry bucketEntry, boolean evictedByEvictionProcess)	Evict the BlockCacheKey and BucketEntry from BucketCache.backingMap and BucketCache.ramCache.
boolean	BucketCache.evictBlock(BlockCacheKey cacheKey)	Try to evict the block from BlockCache by force.
boolean	BucketCache.evictBlockIfNoRpcReferenced(BlockCacheKey blockCacheKey)	NOTE: This method is only for test.
(package private) boolean	BucketCache.evictBucketEntryIfNoRpcReferenced(BlockCacheKey blockCacheKey, BucketEntry bucketEntry)	Evict BlockCacheKey and its corresponding BucketEntry only if BucketEntry.isRpcRef() is false.
BucketCache.RAMQueueEntry	BucketCache.RAMCache.get(BlockCacheKey key)
Cacheable	BucketCache.getBlock(BlockCacheKey key, boolean caching, boolean repeat, boolean updateCacheMetrics)	Get the buffer of the block with the specified key.
BucketEntry	BucketCache.getBlockForReference(BlockCacheKey key)	If the passed cache key relates to a reference (<hfile>.<parentEncRegion>), this method looks for the block from the referred file, in the cache.
Optional<Integer>	BucketCache.getBlockSize(BlockCacheKey key)
int	BucketCache.getRpcRefCount(BlockCacheKey cacheKey)
Optional<Boolean>	BucketCache.isAlreadyCached(BlockCacheKey key)
BucketCache.RAMQueueEntry	BucketCache.RAMCache.putIfAbsent(BlockCacheKey key, BucketCache.RAMQueueEntry entry)	Return the previous associated value, or null if absent.
protected void	BucketCache.putIntoBackingMap(BlockCacheKey key, BucketEntry bucketEntry)	Put the new bucket entry into backingMap.
boolean	BucketCache.RAMCache.remove(BlockCacheKey key)
boolean	BucketCache.RAMCache.remove(BlockCacheKey key, Consumer<BucketCache.RAMQueueEntry> action)	Defined an Consumer here, because once the removed entry release its reference count, then it's ByteBuffers may be recycled and accessing it outside this method will be thrown an exception.
protected boolean	BucketCache.removeFromRamCache(BlockCacheKey cacheKey)
protected boolean	BucketCache.shouldReplaceExistingCacheBlock(BlockCacheKey cacheKey, Cacheable newBlock)
private static org.apache.hadoop.hbase.shaded.protobuf.generated.BucketCacheProtos.BlockCacheKey	BucketProtoUtils.toPB(BlockCacheKey key)

Method parameters in org.apache.hadoop.hbase.io.hfile.bucket with type arguments of type BlockCacheKey

Modifier and Type	Method	Description
void	BucketCache.BucketEntryGroup.add(Map.Entry<BlockCacheKey,BucketEntry> block)
void	CachedEntryQueue.add(Map.Entry<BlockCacheKey,BucketEntry> entry)	Attempt to add the specified entry to this queue.
private static void	BucketProtoUtils.addEntryToBuilder(Map.Entry<BlockCacheKey,BucketEntry> entry, org.apache.hadoop.hbase.shaded.protobuf.generated.BucketCacheProtos.BackingMapEntry.Builder entryBuilder, org.apache.hadoop.hbase.shaded.protobuf.generated.BucketCacheProtos.BackingMap.Builder builder)

Constructors in org.apache.hadoop.hbase.io.hfile.bucket with parameters of type BlockCacheKey

Modifier	Constructor	Description
(package private)	RAMQueueEntry(BlockCacheKey bck, Cacheable data, long accessCounter, boolean inMemory, boolean isCachePersistent)

Constructor parameters in org.apache.hadoop.hbase.io.hfile.bucket with type arguments of type BlockCacheKey

Modifier	Constructor	Description
(package private)	BucketAllocator(long availableSpace, int[] bucketSizes, Map<BlockCacheKey,BucketEntry> map, LongAdder realCacheSize)	Rebuild the allocator's data structures from a persisted map.