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 . |
Modifier and Type | Interface and Description |
---|---|
interface |
CacheableDeserializer<T extends Cacheable>
Interface for a deserializer.
|
Modifier and Type | Class and Description |
---|---|
class |
ExclusiveMemHFileBlock
The
ByteBuffAllocator won't allocate pooled heap ByteBuff now; at the same time,
if allocate an off-heap ByteBuff from allocator, then it must be a pooled one. |
class |
HFileBlock
Cacheable Blocks of an
HFile version 2 file. |
class |
SharedMemHFileBlock
The
ByteBuffAllocator won't allocate pooled heap ByteBuff now; at the same time,
if allocate an off-heap ByteBuff from allocator, then it must be a pooled one. |
Modifier and Type | Field and Description |
---|---|
private Cacheable |
LruCachedBlock.buf |
private Cacheable |
TinyLfuBlockCache.CachedBlockView.value |
Modifier and Type | Field and Description |
---|---|
static CacheableDeserializer<Cacheable> |
HFileBlock.BLOCK_DESERIALIZER
Used deserializing blocks from Cache.
|
(package private) com.github.benmanes.caffeine.cache.Cache<BlockCacheKey,Cacheable> |
TinyLfuBlockCache.cache |
private com.github.benmanes.caffeine.cache.Policy.Eviction<BlockCacheKey,Cacheable> |
TinyLfuBlockCache.policy |
private static Map<Integer,CacheableDeserializer<Cacheable>> |
CacheableDeserializerIdManager.registeredDeserializers |
Modifier and Type | Method and Description |
---|---|
private Cacheable |
LruBlockCache.asReferencedHeapBlock(Cacheable buf)
The block cached in LRUBlockCache will always be an heap block: on the one side, the heap
access will be more faster then off-heap, the small index block or meta block cached in
CombinedBlockCache will benefit a lot.
|
private Cacheable |
LruAdaptiveBlockCache.asReferencedHeapBlock(Cacheable buf)
The block cached in LruAdaptiveBlockCache will always be an heap block: on the one side, the
heap access will be more faster then off-heap, the small index block or meta block cached in
CombinedBlockCache will benefit a lot.
|
private Cacheable |
TinyLfuBlockCache.asReferencedHeapBlock(Cacheable buf)
The block cached in TinyLfuBlockCache will always be an heap block: on the one side, the heap
access will be more faster then off-heap, the small index block or meta block cached in
CombinedBlockCache will benefit a lot.
|
Cacheable |
LruBlockCache.getBlock(BlockCacheKey cacheKey,
boolean caching,
boolean repeat,
boolean updateCacheMetrics)
Get the buffer of the block with the specified name.
|
Cacheable |
LruAdaptiveBlockCache.getBlock(BlockCacheKey cacheKey,
boolean caching,
boolean repeat,
boolean updateCacheMetrics)
Get the buffer of the block with the specified name.
|
Cacheable |
BlockCache.getBlock(BlockCacheKey cacheKey,
boolean caching,
boolean repeat,
boolean updateCacheMetrics)
Fetch block from cache.
|
Cacheable |
TinyLfuBlockCache.getBlock(BlockCacheKey cacheKey,
boolean caching,
boolean repeat,
boolean updateCacheMetrics) |
Cacheable |
CombinedBlockCache.getBlock(BlockCacheKey cacheKey,
boolean caching,
boolean repeat,
boolean updateCacheMetrics) |
Cacheable |
InclusiveCombinedBlockCache.getBlock(BlockCacheKey cacheKey,
boolean caching,
boolean repeat,
boolean updateCacheMetrics) |
Cacheable |
MemcachedBlockCache.getBlock(BlockCacheKey cacheKey,
boolean caching,
boolean repeat,
boolean updateCacheMetrics) |
Cacheable |
LruCachedBlock.getBuffer() |
default Cacheable |
Cacheable.retain()
Increase its reference count, and only when no reference we can free the object's memory.
|
Modifier and Type | Method and Description |
---|---|
CacheableDeserializer<Cacheable> |
Cacheable.getDeserializer()
Returns CacheableDeserializer instance which reconstructs original object from ByteBuffer.
|
CacheableDeserializer<Cacheable> |
HFileBlock.getDeserializer() |
static CacheableDeserializer<Cacheable> |
CacheableDeserializerIdManager.getDeserializer(int id)
Get the cacheable deserializer registered at the given identifier Id.
|
Modifier and Type | Method and Description |
---|---|
private Cacheable |
LruBlockCache.asReferencedHeapBlock(Cacheable buf)
The block cached in LRUBlockCache will always be an heap block: on the one side, the heap
access will be more faster then off-heap, the small index block or meta block cached in
CombinedBlockCache will benefit a lot.
|
private Cacheable |
LruAdaptiveBlockCache.asReferencedHeapBlock(Cacheable buf)
The block cached in LruAdaptiveBlockCache will always be an heap block: on the one side, the
heap access will be more faster then off-heap, the small index block or meta block cached in
CombinedBlockCache will benefit a lot.
|
private Cacheable |
TinyLfuBlockCache.asReferencedHeapBlock(Cacheable buf)
The block cached in TinyLfuBlockCache will always be an heap block: on the one side, the heap
access will be more faster then off-heap, the small index block or meta block cached in
CombinedBlockCache will benefit a lot.
|
void |
LruBlockCache.cacheBlock(BlockCacheKey cacheKey,
Cacheable buf)
Cache the block with the specified name and buffer.
|
void |
LruAdaptiveBlockCache.cacheBlock(BlockCacheKey cacheKey,
Cacheable buf)
Cache the block with the specified name and buffer.
|
void |
BlockCache.cacheBlock(BlockCacheKey cacheKey,
Cacheable buf)
Add block to cache (defaults to not in-memory).
|
void |
TinyLfuBlockCache.cacheBlock(BlockCacheKey key,
Cacheable value) |
void |
CombinedBlockCache.cacheBlock(BlockCacheKey cacheKey,
Cacheable buf) |
void |
MemcachedBlockCache.cacheBlock(BlockCacheKey cacheKey,
Cacheable buf) |
void |
LruBlockCache.cacheBlock(BlockCacheKey cacheKey,
Cacheable buf,
boolean inMemory)
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 |
IndexOnlyLruBlockCache.cacheBlock(BlockCacheKey cacheKey,
Cacheable buf,
boolean inMemory)
Cache only index block with the specified name and buffer
|
void |
BlockCache.cacheBlock(BlockCacheKey cacheKey,
Cacheable buf,
boolean inMemory)
Add block to cache.
|
void |
TinyLfuBlockCache.cacheBlock(BlockCacheKey cacheKey,
Cacheable value,
boolean inMemory) |
void |
CombinedBlockCache.cacheBlock(BlockCacheKey cacheKey,
Cacheable buf,
boolean inMemory) |
void |
InclusiveCombinedBlockCache.cacheBlock(BlockCacheKey cacheKey,
Cacheable buf,
boolean inMemory) |
void |
MemcachedBlockCache.cacheBlock(BlockCacheKey cacheKey,
Cacheable buf,
boolean inMemory) |
private static int |
BlockCacheUtil.compareCacheBlock(Cacheable left,
Cacheable right,
boolean includeNextBlockMetadata) |
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.
|
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.
|
Modifier and Type | Method and Description |
---|---|
static int |
CacheableDeserializerIdManager.registerDeserializer(CacheableDeserializer<Cacheable> cd)
Register the given
Cacheable -- usually an hfileblock instance, these implement the
Cacheable Interface -- deserializer and generate a unique identifier id for it and return this
as our result. |
Constructor and Description |
---|
CachedBlockView(BlockCacheKey key,
Cacheable value,
long now) |
LruCachedBlock(BlockCacheKey cacheKey,
Cacheable buf,
long accessTime) |
LruCachedBlock(BlockCacheKey cacheKey,
Cacheable buf,
long accessTime,
boolean inMemory) |
Modifier and Type | Field and Description |
---|---|
private Cacheable |
BucketCache.RAMQueueEntry.data |
Modifier and Type | Method and Description |
---|---|
Cacheable |
BucketCache.getBlock(BlockCacheKey key,
boolean caching,
boolean repeat,
boolean updateCacheMetrics)
Get the buffer of the block with the specified key.
|
Cacheable |
BucketCache.RAMQueueEntry.getData() |
abstract Cacheable |
FileMmapIOEngine.read(BucketEntry be) |
Cacheable |
SharedMemoryMmapIOEngine.read(BucketEntry be) |
Cacheable |
ExclusiveMemoryMmapIOEngine.read(BucketEntry be) |
Cacheable |
FileIOEngine.read(BucketEntry be)
Transfers data from file to the given byte buffer
|
Cacheable |
ByteBufferIOEngine.read(BucketEntry be) |
Cacheable |
IOEngine.read(BucketEntry be)
Transfers data from IOEngine to a Cacheable object.
|
(package private) Cacheable |
BucketEntry.wrapAsCacheable(ByteBuff buf) |
(package private) Cacheable |
BucketEntry.wrapAsCacheable(ByteBuffer[] buffers) |
Modifier and Type | Method and Description |
---|---|
(package private) CacheableDeserializer<Cacheable> |
BucketEntry.deserializerReference() |
Modifier and Type | Method and Description |
---|---|
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.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) |
protected boolean |
BucketCache.shouldReplaceExistingCacheBlock(BlockCacheKey cacheKey,
Cacheable newBlock) |
Modifier and Type | Method and Description |
---|---|
(package private) void |
BucketEntry.setDeserializerReference(CacheableDeserializer<Cacheable> deserializer) |
Constructor and Description |
---|
RAMQueueEntry(BlockCacheKey bck,
Cacheable data,
long accessCounter,
boolean inMemory) |
Copyright © 2007–2020 The Apache Software Foundation. All rights reserved.