CacheConfig (Apache HBase 2.5.0 API)

java.lang.Object
- org.apache.hadoop.hbase.io.hfile.CacheConfig

@InterfaceAudience.Private
public class CacheConfig
extends Object

Stores all of the cache objects and configuration for a single HFile.

Field Summary

Fields
Modifier and Type	Field and Description
`private BlockCache`	`blockCache`
`private ByteBuffAllocator`	`byteBuffAllocator`
`static String`	`CACHE_BLOCKS_ON_WRITE_KEY` Configuration key to cache data blocks on write.
`static String`	`CACHE_BLOOM_BLOCKS_ON_WRITE_KEY` Configuration key to cache compound bloom filter blocks on write.
`static String`	`CACHE_COMPACTED_BLOCKS_ON_WRITE_KEY` Configuration key to cache blocks when a compacted file is written
`static String`	`CACHE_COMPACTED_BLOCKS_ON_WRITE_THRESHOLD_KEY` Configuration key to determine total size in bytes of compacted files beyond which we do not cache blocks on compaction
`static String`	`CACHE_DATA_BLOCKS_COMPRESSED_KEY` Configuration key to cache data blocks in compressed and/or encrypted format.
`static String`	`CACHE_DATA_ON_READ_KEY` Configuration key to cache data blocks on read.
`static String`	`CACHE_INDEX_BLOCKS_ON_WRITE_KEY` Configuration key to cache leaf and intermediate-level index blocks on write.
`private boolean`	`cacheBloomsOnWrite` Whether compound bloom filter blocks should be cached on write
`private boolean`	`cacheCompactedDataOnWrite` Whether data blocks should be cached when compacted file is written
`private long`	`cacheCompactedDataOnWriteThreshold` Determine threshold beyond which we do not cache blocks on compaction
`private boolean`	`cacheDataCompressed` Whether data blocks should be stored in compressed and/or encrypted form in the cache
`private boolean`	`cacheDataOnRead` Whether blocks should be cached on read (default is on if there is a cache but this can be turned off on a per-family or per-request basis).
`private boolean`	`cacheDataOnWrite` Whether data blocks should be cached when new files are written
`private boolean`	`cacheIndexesOnWrite` Whether index blocks should be cached when new files are written
`static boolean`	`DEFAULT_CACHE_BLOOMS_ON_WRITE`
`static boolean`	`DEFAULT_CACHE_COMPACTED_BLOCKS_ON_WRITE`
`static long`	`DEFAULT_CACHE_COMPACTED_BLOCKS_ON_WRITE_THRESHOLD`
`static boolean`	`DEFAULT_CACHE_DATA_COMPRESSED`
`static boolean`	`DEFAULT_CACHE_DATA_ON_READ`
`static boolean`	`DEFAULT_CACHE_DATA_ON_WRITE`
`static boolean`	`DEFAULT_CACHE_INDEXES_ON_WRITE`
`static boolean`	`DEFAULT_EVICT_ON_CLOSE`
`static boolean`	`DEFAULT_IN_MEMORY`
`static boolean`	`DEFAULT_PREFETCH_ON_OPEN`
`static CacheConfig`	`DISABLED` Disabled cache configuration
`static boolean`	`DROP_BEHIND_CACHE_COMPACTION_DEFAULT`
`static String`	`DROP_BEHIND_CACHE_COMPACTION_KEY`
`private boolean`	`dropBehindCompaction`
`static String`	`EVICT_BLOCKS_ON_CLOSE_KEY` Configuration key to evict all blocks of a given file from the block cache when the file is closed.
`private boolean`	`evictOnClose` Whether blocks of a file should be evicted when the file is closed
`private boolean`	`inMemory` Whether blocks should be flagged as in-memory when being cached
`private static org.slf4j.Logger`	`LOG`
`static String`	`PREFETCH_BLOCKS_ON_OPEN_KEY` Configuration key to prefetch all blocks of a given file into the block cache when the file is opened.
`private boolean`	`prefetchOnOpen` Whether data blocks should be prefetched into the cache

Constructor Summary

Constructors
Modifier	Constructor and Description
`private`	`CacheConfig()`
	`CacheConfig(CacheConfig cacheConf)` Constructs a cache configuration copied from the specified configuration.
	`CacheConfig(org.apache.hadoop.conf.Configuration conf)` Create a cache configuration using the specified configuration object and defaults for family level settings.
	`CacheConfig(org.apache.hadoop.conf.Configuration conf, BlockCache blockCache)`
	`CacheConfig(org.apache.hadoop.conf.Configuration conf, ColumnFamilyDescriptor family, BlockCache blockCache, ByteBuffAllocator byteBuffAllocator)` Create a cache configuration using the specified configuration object and family descriptor.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`enableCacheOnWrite()` Enable cache on write including: cacheDataOnWrite cacheIndexesOnWrite cacheBloomsOnWrite
`Optional<BlockCache>`	`getBlockCache()` Returns the block cache.
`ByteBuffAllocator`	`getByteBuffAllocator()`
`long`	`getCacheCompactedBlocksOnWriteThreshold()` Returns total file size in bytes threshold for caching while writing during compaction
`private long`	`getCacheCompactedBlocksOnWriteThreshold(org.apache.hadoop.conf.Configuration conf)`
`boolean`	`isCombinedBlockCache()`
`boolean`	`isInMemory()` Returns true if blocks in this file should be flagged as in-memory
`void`	`setCacheDataOnWrite(boolean cacheDataOnWrite)`
`void`	`setEvictOnClose(boolean evictOnClose)` Only used for testing.
`boolean`	`shouldCacheBlockOnRead(BlockType.BlockCategory category)` Should we cache a block of a particular category? We always cache important blocks such as index blocks, as long as the block cache is available.
`boolean`	`shouldCacheBloomsOnWrite()`
`boolean`	`shouldCacheCompactedBlocksOnWrite()` Returns true if blocks should be cached while writing during compaction, false if not
`boolean`	`shouldCacheCompressed(BlockType.BlockCategory category)` Returns true if this `BlockType.BlockCategory` should be compressed in blockcache, false otherwise
`boolean`	`shouldCacheDataCompressed()` Returns true if data blocks should be compressed in the cache, false if not
`boolean`	`shouldCacheDataOnRead()` Returns whether the DATA blocks of this HFile should be cached on read or not (we always cache the meta blocks, the INDEX and BLOOM blocks).
`boolean`	`shouldCacheDataOnWrite()`
`boolean`	`shouldCacheIndexesOnWrite()`
`boolean`	`shouldDropBehindCompaction()`
`boolean`	`shouldEvictOnClose()`
`boolean`	`shouldLockOnCacheMiss(BlockType blockType)` If we make sure the block could not be cached, we will not acquire the lock otherwise we will acquire lock
`boolean`	`shouldPrefetchOnOpen()` Returns true if blocks should be prefetched into the cache on open, false if not
`boolean`	`shouldReadBlockFromCache(BlockType blockType)` Return true if we may find this type of block in block cache.
`String`	`toString()`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - LOG
```
private static final org.slf4j.Logger LOG
```
  - DISABLED
```
public static final CacheConfig DISABLED
```
    Disabled cache configuration
  - CACHE_DATA_ON_READ_KEY
```
public static final String CACHE_DATA_ON_READ_KEY
```
    Configuration key to cache data blocks on read. Bloom blocks and index blocks are always be cached if the block cache is enabled.
    
    See Also:
    
    Constant Field Values
  - CACHE_BLOCKS_ON_WRITE_KEY
```
public static final String CACHE_BLOCKS_ON_WRITE_KEY
```
    Configuration key to cache data blocks on write. There are separate switches for bloom blocks and non-root index blocks.
    
    See Also:
    
    Constant Field Values
  - CACHE_INDEX_BLOCKS_ON_WRITE_KEY
```
public static final String CACHE_INDEX_BLOCKS_ON_WRITE_KEY
```
    Configuration key to cache leaf and intermediate-level index blocks on write.
    
    See Also:
    
    Constant Field Values
  - CACHE_BLOOM_BLOCKS_ON_WRITE_KEY
```
public static final String CACHE_BLOOM_BLOCKS_ON_WRITE_KEY
```
    Configuration key to cache compound bloom filter blocks on write.
    
    See Also:
    
    Constant Field Values
  - CACHE_DATA_BLOCKS_COMPRESSED_KEY
```
public static final String CACHE_DATA_BLOCKS_COMPRESSED_KEY
```
    Configuration key to cache data blocks in compressed and/or encrypted format.
    
    See Also:
    
    Constant Field Values
  - EVICT_BLOCKS_ON_CLOSE_KEY
```
public static final String EVICT_BLOCKS_ON_CLOSE_KEY
```
    Configuration key to evict all blocks of a given file from the block cache when the file is closed.
    
    See Also:
    
    Constant Field Values
  - PREFETCH_BLOCKS_ON_OPEN_KEY
```
public static final String PREFETCH_BLOCKS_ON_OPEN_KEY
```
    Configuration key to prefetch all blocks of a given file into the block cache when the file is opened.
    
    See Also:
    
    Constant Field Values
  - CACHE_COMPACTED_BLOCKS_ON_WRITE_KEY
```
public static final String CACHE_COMPACTED_BLOCKS_ON_WRITE_KEY
```
    Configuration key to cache blocks when a compacted file is written
    
    See Also:
    
    Constant Field Values
  - CACHE_COMPACTED_BLOCKS_ON_WRITE_THRESHOLD_KEY
```
public static final String CACHE_COMPACTED_BLOCKS_ON_WRITE_THRESHOLD_KEY
```
    Configuration key to determine total size in bytes of compacted files beyond which we do not cache blocks on compaction
    
    See Also:
    
    Constant Field Values
  - DROP_BEHIND_CACHE_COMPACTION_KEY
```
public static final String DROP_BEHIND_CACHE_COMPACTION_KEY
```
    See Also:
    
    Constant Field Values
  - DEFAULT_CACHE_DATA_ON_READ
```
public static final boolean DEFAULT_CACHE_DATA_ON_READ
```
    See Also:
    
    Constant Field Values
  - DEFAULT_CACHE_DATA_ON_WRITE
```
public static final boolean DEFAULT_CACHE_DATA_ON_WRITE
```
    See Also:
    
    Constant Field Values
  - DEFAULT_IN_MEMORY
```
public static final boolean DEFAULT_IN_MEMORY
```
    See Also:
    
    Constant Field Values
  - DEFAULT_CACHE_INDEXES_ON_WRITE
```
public static final boolean DEFAULT_CACHE_INDEXES_ON_WRITE
```
    See Also:
    
    Constant Field Values
  - DEFAULT_CACHE_BLOOMS_ON_WRITE
```
public static final boolean DEFAULT_CACHE_BLOOMS_ON_WRITE
```
    See Also:
    
    Constant Field Values
  - DEFAULT_EVICT_ON_CLOSE
```
public static final boolean DEFAULT_EVICT_ON_CLOSE
```
    See Also:
    
    Constant Field Values
  - DEFAULT_CACHE_DATA_COMPRESSED
```
public static final boolean DEFAULT_CACHE_DATA_COMPRESSED
```
    See Also:
    
    Constant Field Values
  - DEFAULT_PREFETCH_ON_OPEN
```
public static final boolean DEFAULT_PREFETCH_ON_OPEN
```
    See Also:
    
    Constant Field Values
  - DEFAULT_CACHE_COMPACTED_BLOCKS_ON_WRITE
```
public static final boolean DEFAULT_CACHE_COMPACTED_BLOCKS_ON_WRITE
```
    See Also:
    
    Constant Field Values
  - DROP_BEHIND_CACHE_COMPACTION_DEFAULT
```
public static final boolean DROP_BEHIND_CACHE_COMPACTION_DEFAULT
```
    See Also:
    
    Constant Field Values
  - DEFAULT_CACHE_COMPACTED_BLOCKS_ON_WRITE_THRESHOLD
```
public static final long DEFAULT_CACHE_COMPACTED_BLOCKS_ON_WRITE_THRESHOLD
```
    See Also:
    
    Constant Field Values
  - cacheDataOnRead
```
private final boolean cacheDataOnRead
```
    Whether blocks should be cached on read (default is on if there is a cache but this can be turned off on a per-family or per-request basis). If off we will STILL cache meta blocks; i.e. INDEX and BLOOM types. This cannot be disabled.
  - inMemory
```
private final boolean inMemory
```
    Whether blocks should be flagged as in-memory when being cached
  - cacheDataOnWrite
```
private boolean cacheDataOnWrite
```
    Whether data blocks should be cached when new files are written
  - cacheIndexesOnWrite
```
private boolean cacheIndexesOnWrite
```
    Whether index blocks should be cached when new files are written
  - cacheBloomsOnWrite
```
private boolean cacheBloomsOnWrite
```
    Whether compound bloom filter blocks should be cached on write
  - evictOnClose
```
private volatile boolean evictOnClose
```
    Whether blocks of a file should be evicted when the file is closed
  - cacheDataCompressed
```
private final boolean cacheDataCompressed
```
    Whether data blocks should be stored in compressed and/or encrypted form in the cache
  - prefetchOnOpen
```
private final boolean prefetchOnOpen
```
    Whether data blocks should be prefetched into the cache
  - cacheCompactedDataOnWrite
```
private final boolean cacheCompactedDataOnWrite
```
    Whether data blocks should be cached when compacted file is written
  - cacheCompactedDataOnWriteThreshold
```
private long cacheCompactedDataOnWriteThreshold
```
    Determine threshold beyond which we do not cache blocks on compaction
  - dropBehindCompaction
```
private final boolean dropBehindCompaction
```
  - blockCache
```
private final BlockCache blockCache
```
  - byteBuffAllocator
```
private final ByteBuffAllocator byteBuffAllocator
```
- Constructor Detail
  - CacheConfig
```
public CacheConfig(org.apache.hadoop.conf.Configuration conf)
```
    Create a cache configuration using the specified configuration object and defaults for family level settings. Only use if no column family context.
    
    Parameters:
    
    conf - hbase configuration
  - CacheConfig
```
public CacheConfig(org.apache.hadoop.conf.Configuration conf,
                   BlockCache blockCache)
```
  - CacheConfig
```
public CacheConfig(org.apache.hadoop.conf.Configuration conf,
                   ColumnFamilyDescriptor family,
                   BlockCache blockCache,
                   ByteBuffAllocator byteBuffAllocator)
```
    Create a cache configuration using the specified configuration object and family descriptor.
    
    Parameters:
    
    conf - hbase configuration
    
    family - column family configuration
  - CacheConfig
```
public CacheConfig(CacheConfig cacheConf)
```
    Constructs a cache configuration copied from the specified configuration.
  - CacheConfig
```
private CacheConfig()
```
- Method Detail
  - shouldCacheDataOnRead
```
public boolean shouldCacheDataOnRead()
```
    Returns whether the DATA blocks of this HFile should be cached on read or not (we always cache the meta blocks, the INDEX and BLOOM blocks).
    
    Returns:
    
    true if blocks should be cached on read, false if not
  - shouldDropBehindCompaction
```
public boolean shouldDropBehindCompaction()
```
  - shouldCacheBlockOnRead
```
public boolean shouldCacheBlockOnRead(BlockType.BlockCategory category)
```
    Should we cache a block of a particular category? We always cache important blocks such as index blocks, as long as the block cache is available.
  - isInMemory
```
public boolean isInMemory()
```
    Returns true if blocks in this file should be flagged as in-memory
  - shouldCacheDataOnWrite
```
public boolean shouldCacheDataOnWrite()
```
    Returns:
    
    true if data blocks should be written to the cache when an HFile is written, false if not
  - setCacheDataOnWrite
```
public void setCacheDataOnWrite(boolean cacheDataOnWrite)
```
    Parameters:
    
    cacheDataOnWrite - whether data blocks should be written to the cache when an HFile is written
  - enableCacheOnWrite
```
public void enableCacheOnWrite()
```
    Enable cache on write including: cacheDataOnWrite cacheIndexesOnWrite cacheBloomsOnWrite
  - shouldCacheIndexesOnWrite
```
public boolean shouldCacheIndexesOnWrite()
```
    Returns:
    
    true if index blocks should be written to the cache when an HFile is written, false if not
  - shouldCacheBloomsOnWrite
```
public boolean shouldCacheBloomsOnWrite()
```
    Returns:
    
    true if bloom blocks should be written to the cache when an HFile is written, false if not
  - shouldEvictOnClose
```
public boolean shouldEvictOnClose()
```
    Returns:
    
    true if blocks should be evicted from the cache when an HFile reader is closed, false if not
  - setEvictOnClose
```
public void setEvictOnClose(boolean evictOnClose)
```
    Only used for testing.
    
    Parameters:
    
    evictOnClose - whether blocks should be evicted from the cache when an HFile reader is closed
  - shouldCacheDataCompressed
```
public boolean shouldCacheDataCompressed()
```
    Returns true if data blocks should be compressed in the cache, false if not
  - shouldCacheCompressed
```
public boolean shouldCacheCompressed(BlockType.BlockCategory category)
```
    Returns true if this BlockType.BlockCategory should be compressed in blockcache, false otherwise
  - shouldPrefetchOnOpen
```
public boolean shouldPrefetchOnOpen()
```
    Returns true if blocks should be prefetched into the cache on open, false if not
  - shouldCacheCompactedBlocksOnWrite
```
public boolean shouldCacheCompactedBlocksOnWrite()
```
    Returns true if blocks should be cached while writing during compaction, false if not
  - getCacheCompactedBlocksOnWriteThreshold
```
public long getCacheCompactedBlocksOnWriteThreshold()
```
    Returns total file size in bytes threshold for caching while writing during compaction
  - shouldReadBlockFromCache
```
public boolean shouldReadBlockFromCache(BlockType blockType)
```
    Return true if we may find this type of block in block cache.
    TODO: today family.isBlockCacheEnabled() only means cacheDataOnRead, so here we consider lots of other configurations such as cacheDataOnWrite. We should fix this in the future, cacheDataOnWrite should honor the CF level isBlockCacheEnabled configuration.
  - shouldLockOnCacheMiss
```
public boolean shouldLockOnCacheMiss(BlockType blockType)
```
    If we make sure the block could not be cached, we will not acquire the lock otherwise we will acquire lock
  - getBlockCache
```
public Optional<BlockCache> getBlockCache()
```
    Returns the block cache.
    
    Returns:
    
    the block cache, or null if caching is completely disabled
  - isCombinedBlockCache
```
public boolean isCombinedBlockCache()
```
  - getByteBuffAllocator
```
public ByteBuffAllocator getByteBuffAllocator()
```
  - getCacheCompactedBlocksOnWriteThreshold
```
private long getCacheCompactedBlocksOnWriteThreshold(org.apache.hadoop.conf.Configuration conf)
```
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object

Class CacheConfig

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

LOG

DISABLED

CACHE_DATA_ON_READ_KEY

CACHE_BLOCKS_ON_WRITE_KEY

CACHE_INDEX_BLOCKS_ON_WRITE_KEY

CACHE_BLOOM_BLOCKS_ON_WRITE_KEY

CACHE_DATA_BLOCKS_COMPRESSED_KEY

EVICT_BLOCKS_ON_CLOSE_KEY

PREFETCH_BLOCKS_ON_OPEN_KEY

CACHE_COMPACTED_BLOCKS_ON_WRITE_KEY

CACHE_COMPACTED_BLOCKS_ON_WRITE_THRESHOLD_KEY

DROP_BEHIND_CACHE_COMPACTION_KEY

DEFAULT_CACHE_DATA_ON_READ

DEFAULT_CACHE_DATA_ON_WRITE

DEFAULT_IN_MEMORY

DEFAULT_CACHE_INDEXES_ON_WRITE

DEFAULT_CACHE_BLOOMS_ON_WRITE

DEFAULT_EVICT_ON_CLOSE

DEFAULT_CACHE_DATA_COMPRESSED

DEFAULT_PREFETCH_ON_OPEN

DEFAULT_CACHE_COMPACTED_BLOCKS_ON_WRITE

DROP_BEHIND_CACHE_COMPACTION_DEFAULT

DEFAULT_CACHE_COMPACTED_BLOCKS_ON_WRITE_THRESHOLD

cacheDataOnRead

inMemory

cacheDataOnWrite

cacheIndexesOnWrite

cacheBloomsOnWrite

evictOnClose

cacheDataCompressed

prefetchOnOpen

cacheCompactedDataOnWrite

cacheCompactedDataOnWriteThreshold

dropBehindCompaction

blockCache

byteBuffAllocator

Constructor Detail

CacheConfig

CacheConfig

CacheConfig

CacheConfig

CacheConfig

Method Detail

shouldCacheDataOnRead

shouldDropBehindCompaction

shouldCacheBlockOnRead

isInMemory

shouldCacheDataOnWrite

setCacheDataOnWrite

enableCacheOnWrite

shouldCacheIndexesOnWrite

shouldCacheBloomsOnWrite

shouldEvictOnClose

setEvictOnClose

shouldCacheDataCompressed

shouldCacheCompressed

shouldPrefetchOnOpen

shouldCacheCompactedBlocksOnWrite

getCacheCompactedBlocksOnWriteThreshold

shouldReadBlockFromCache

shouldLockOnCacheMiss

getBlockCache

isCombinedBlockCache

getByteBuffAllocator

getCacheCompactedBlocksOnWriteThreshold

toString