CacheConfig (Apache HBase 1.4.11 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
`static String`	`BLOCKCACHE_BLOCKSIZE_KEY` The target block size used by blockcache instances.
`static String`	`BUCKET_CACHE_BUCKETS_KEY` A comma-delimited array of values for use as bucket sizes.
`static String`	`BUCKET_CACHE_COMBINED_KEY` If the bucket cache is used in league with the lru on-heap block cache (meta blocks such as indices and blooms are kept in the lru blockcache and the data blocks in the bucket cache).
`static String`	`BUCKET_CACHE_PERSISTENT_PATH_KEY` If the chosen ioengine can persist its state across restarts, the path to the file to persist to.
`static String`	`BUCKET_CACHE_WRITER_QUEUE_KEY`
`static String`	`BUCKET_CACHE_WRITER_THREADS_KEY`
`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_DATA_BLOCKS_COMPRESSED_KEY` Configuration key to cache data blocks in compressed and/or encrypted format.
`static String`	`CACHE_INDEX_BLOCKS_ON_WRITE_KEY` Configuration key to cache leaf and intermediate-level index blocks on write.
`static boolean`	`DEFAULT_BUCKET_CACHE_COMBINED` Defaults for Bucket cache
`static int`	`DEFAULT_BUCKET_CACHE_WRITER_QUEUE`
`static int`	`DEFAULT_BUCKET_CACHE_WRITER_THREADS`
`static boolean`	`DEFAULT_CACHE_BLOOMS_ON_WRITE`
`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 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.
`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.

Constructor Summary

Constructors
Constructor and Description
`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, HColumnDescriptor family)` Create a cache configuration using the specified configuration object and family descriptor.

Method Summary

Methods
Modifier and Type	Method and Description
`BlockCache`	`getBlockCache()` Returns the block cache.
`CacheStats`	`getL1Stats()`
`CacheStats`	`getL2Stats()`
`static BlockCache`	`instantiateBlockCache(org.apache.hadoop.conf.Configuration conf)` Returns the block cache or `null` in case none should be used.
`boolean`	`isBlockCacheEnabled()` Checks whether the block cache is enabled.
`boolean`	`isCacheDataInL1()`
`boolean`	`isInMemory()`
`void`	`setCacheDataInL1(boolean cacheDataInL1)` Only used for testing.
`void`	`setCacheDataOnWrite(boolean cacheDataOnWrite)` Only used for testing.
`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`	`shouldCacheCompressed(BlockType.BlockCategory category)`
`boolean`	`shouldCacheDataCompressed()`
`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()`
`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
  - 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
  - BUCKET_CACHE_PERSISTENT_PATH_KEY
```
public static final String BUCKET_CACHE_PERSISTENT_PATH_KEY
```
    If the chosen ioengine can persist its state across restarts, the path to the file to persist to. This file is NOT the data file. It is a file into which we will serialize the map of what is in the data file. For example, if you pass the following argument as BUCKET_CACHE_IOENGINE_KEY ("hbase.bucketcache.ioengine"), file:/tmp/bucketcache.data , then we will write the bucketcache data to the file /tmp/bucketcache.data but the metadata on where the data is in the supplied file is an in-memory map that needs to be persisted across restarts. Where to store this in-memory state is what you supply here: e.g. /tmp/bucketcache.map.
    
    See Also:
    Constant Field Values
  - BUCKET_CACHE_COMBINED_KEY
```
public static final String BUCKET_CACHE_COMBINED_KEY
```
    If the bucket cache is used in league with the lru on-heap block cache (meta blocks such as indices and blooms are kept in the lru blockcache and the data blocks in the bucket cache).
    
    See Also:
    Constant Field Values
  - BUCKET_CACHE_WRITER_THREADS_KEY
```
public static final String BUCKET_CACHE_WRITER_THREADS_KEY
```
    See Also:
    Constant Field Values
  - BUCKET_CACHE_WRITER_QUEUE_KEY
```
public static final String BUCKET_CACHE_WRITER_QUEUE_KEY
```
    See Also:
    Constant Field Values
  - BUCKET_CACHE_BUCKETS_KEY
```
public static final String BUCKET_CACHE_BUCKETS_KEY
```
    A comma-delimited array of values for use as bucket sizes.
    
    See Also:
    Constant Field Values
  - DEFAULT_BUCKET_CACHE_COMBINED
```
public static final boolean DEFAULT_BUCKET_CACHE_COMBINED
```
    Defaults for Bucket cache
    
    See Also:
    Constant Field Values
  - DEFAULT_BUCKET_CACHE_WRITER_THREADS
```
public static final int DEFAULT_BUCKET_CACHE_WRITER_THREADS
```
    See Also:
    Constant Field Values
  - DEFAULT_BUCKET_CACHE_WRITER_QUEUE
```
public static final int DEFAULT_BUCKET_CACHE_WRITER_QUEUE
```
    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
  - BLOCKCACHE_BLOCKSIZE_KEY
```
public static final String BLOCKCACHE_BLOCKSIZE_KEY
```
    The target block size used by blockcache instances. Defaults to HConstants.DEFAULT_BLOCKSIZE.
    
    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
- Constructor Detail
  - CacheConfig
```
public CacheConfig(org.apache.hadoop.conf.Configuration conf,
           HColumnDescriptor family)
```
    Create a cache configuration using the specified configuration object and family descriptor.
    
    Parameters:
    conf - hbase configuration
    family - column family configuration
  - 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. Prefer CacheConfig(Configuration, HColumnDescriptor)
    
    Parameters:
    conf - hbase configuration
    See Also:
    CacheConfig(Configuration, HColumnDescriptor)
  - CacheConfig
```
public CacheConfig(CacheConfig cacheConf)
```
    Constructs a cache configuration copied from the specified configuration.
    
    Parameters:
    cacheConf -
- Method Detail
  - isBlockCacheEnabled
```
public boolean isBlockCacheEnabled()
```
    Checks whether the block cache is enabled.
  - getBlockCache
```
public BlockCache getBlockCache()
```
    Returns the block cache.
    
    Returns:
    the block cache, or null if caching is completely disabled
  - 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
  - isCacheDataInL1
```
public boolean isCacheDataInL1()
```
    Returns:
    True if cache data blocks in L1 tier (if more than one tier in block cache deploy).
  - 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)
```
    Only used for testing.
    
    Parameters:
    cacheDataOnWrite - whether data blocks should be written to the cache when an HFile is written
  - setCacheDataInL1
```
public void setCacheDataInL1(boolean cacheDataInL1)
```
    Only used for testing.
    
    Parameters:
    cacheDataInL1 - Whether to cache data blocks up in l1 (if a multi-tier cache implementation).
  - 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
  - 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
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - getL1Stats
```
public CacheStats getL1Stats()
```
  - getL2Stats
```
public CacheStats getL2Stats()
```
  - instantiateBlockCache
```
public static BlockCache instantiateBlockCache(org.apache.hadoop.conf.Configuration conf)
```
    Returns the block cache or null in case none should be used. Sets GLOBAL_BLOCK_CACHE_INSTANCE
    
    Parameters:
    conf - The current configuration.
    
    Returns:
    The block cache or null.

Class CacheConfig

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

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

BUCKET_CACHE_PERSISTENT_PATH_KEY

BUCKET_CACHE_COMBINED_KEY

BUCKET_CACHE_WRITER_THREADS_KEY

BUCKET_CACHE_WRITER_QUEUE_KEY

BUCKET_CACHE_BUCKETS_KEY

DEFAULT_BUCKET_CACHE_COMBINED

DEFAULT_BUCKET_CACHE_WRITER_THREADS

DEFAULT_BUCKET_CACHE_WRITER_QUEUE

PREFETCH_BLOCKS_ON_OPEN_KEY

BLOCKCACHE_BLOCKSIZE_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

Constructor Detail

CacheConfig

CacheConfig

CacheConfig

Method Detail

isBlockCacheEnabled

getBlockCache

shouldCacheDataOnRead

shouldDropBehindCompaction

shouldCacheBlockOnRead

isInMemory

isCacheDataInL1

shouldCacheDataOnWrite

setCacheDataOnWrite

setCacheDataInL1

shouldCacheIndexesOnWrite

shouldCacheBloomsOnWrite

shouldEvictOnClose

setEvictOnClose

shouldCacheDataCompressed

shouldCacheCompressed

shouldPrefetchOnOpen

shouldReadBlockFromCache

shouldLockOnCacheMiss

toString

getL1Stats

getL2Stats

instantiateBlockCache