Java BlockCategory类代码示例

import org.apache.hadoop.hbase.io.hfile.BlockType.BlockCategory; //导入依赖的package包/类
/**
 * Return true if we may find this type of block in block cache.
 * <p/>
 * TODO: today {@code family.isBlockCacheEnabled()} only means {@code cacheDataOnRead}, so here we
 * consider lots of other configurations such as {@code cacheDataOnWrite}. We should fix this in
 * the future, {@code cacheDataOnWrite} should honor the CF level {@code isBlockCacheEnabled}
 * configuration.
 */
public boolean shouldReadBlockFromCache(BlockType blockType) {
  if (!isBlockCacheEnabled()) {
    return false;
  }
  if (cacheDataOnRead) {
    return true;
  }
  if (prefetchOnOpen) {
    return true;
  }
  if (cacheDataOnWrite) {
    return true;
  }
  if (blockType == null) {
    return true;
  }
  if (blockType.getCategory() == BlockCategory.BLOOM ||
          blockType.getCategory() == BlockCategory.INDEX) {
    return true;
  }
  return false;
}
 

import org.apache.hadoop.hbase.io.hfile.BlockType.BlockCategory; //导入依赖的package包/类
/**
 * Return true if we may find this type of block in block cache.
 * <p>
 * TODO: today {@code family.isBlockCacheEnabled()} only means {@code cacheDataOnRead}, so here we
 * consider lots of other configurations such as {@code cacheDataOnWrite}. We should fix this in
 * the future, {@code cacheDataOnWrite} should honor the CF level {@code isBlockCacheEnabled}
 * configuration.
 */
public boolean shouldReadBlockFromCache(BlockType blockType) {
  if (!isBlockCacheEnabled()) {
    return false;
  }
  if (cacheDataOnRead) {
    return true;
  }
  if (prefetchOnOpen) {
    return true;
  }
  if (cacheDataOnWrite) {
    return true;
  }
  if (blockType == null) {
    return true;
  }
  if (blockType.getCategory() == BlockCategory.BLOOM ||
          blockType.getCategory() == BlockCategory.INDEX) {
    return true;
  }
  return false;
}
 

import org.apache.hadoop.hbase.io.hfile.BlockType.BlockCategory; //导入依赖的package包/类
/**
 * 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.
 */
public boolean shouldCacheBlockOnRead(BlockCategory category) {
  return isBlockCacheEnabled()
      && (cacheDataOnRead ||
          category == BlockCategory.INDEX ||
          category == BlockCategory.BLOOM ||
          (prefetchOnOpen &&
              (category != BlockCategory.META &&
               category != BlockCategory.UNKNOWN)));
}
 

import org.apache.hadoop.hbase.io.hfile.BlockType.BlockCategory; //导入依赖的package包/类
/**
 * @return true if this {@link BlockCategory} should be compressed in blockcache, false otherwise
 */
public boolean shouldCacheCompressed(BlockCategory category) {
  if (!isBlockCacheEnabled()) return false;
  switch (category) {
    case DATA:
      return this.cacheDataCompressed;
    default:
      return false;
  }
}
 

import org.apache.hadoop.hbase.io.hfile.BlockType.BlockCategory; //导入依赖的package包/类
@Override
public void cacheBlock(BlockCacheKey cacheKey, Cacheable buf, boolean inMemory,
    final boolean cacheDataInL1) {
  boolean isMetaBlock = buf.getBlockType().getCategory() != BlockCategory.DATA;
  if (isMetaBlock || cacheDataInL1) {
    lruCache.cacheBlock(cacheKey, buf, inMemory, cacheDataInL1);
  } else {
    l2Cache.cacheBlock(cacheKey, buf, inMemory, false);
  }
}
 

import org.apache.hadoop.hbase.io.hfile.BlockType.BlockCategory; //导入依赖的package包/类
private static final int getBlockMetricIndex(BlockCategory blockCategory,
    boolean isCompaction, BlockMetricType metricType) {
  int i = 0;
  i = i * NUM_BLOCK_CATEGORIES + blockCategory.ordinal();
  i = i * BOOL_VALUES.length + (isCompaction ? 1 : 0);
  i = i * NUM_METRIC_TYPES + metricType.ordinal();
  return i;
}
 

import org.apache.hadoop.hbase.io.hfile.BlockType.BlockCategory; //导入依赖的package包/类
public String getBlockMetricName(BlockCategory blockCategory,
    boolean isCompaction, BlockMetricType metricType) {
  if (isCompaction && !metricType.compactionAware) {
    throw new IllegalArgumentException("isCompaction cannot be true for "
        + metricType);
  }
  return blockMetricNames[getBlockMetricIndex(blockCategory, isCompaction,
      metricType)];
}
 

import org.apache.hadoop.hbase.io.hfile.BlockType.BlockCategory; //导入依赖的package包/类
/**
 * Increments the given metric, both per-CF and aggregate, for both the given
 * category and all categories in aggregate (four counters total).
 */
private void incrNumericMetric(BlockCategory blockCategory,
    boolean isCompaction, BlockMetricType metricType, long amount) {
  if (blockCategory == null) {
    blockCategory = BlockCategory.UNKNOWN;  // So that we see this in stats.
  }
  RegionMetricsStorage.incrNumericMetric(getBlockMetricName(blockCategory,
      isCompaction, metricType), amount);

  if (blockCategory != BlockCategory.ALL_CATEGORIES) {
    incrNumericMetric(BlockCategory.ALL_CATEGORIES, isCompaction,
        metricType, amount);
  }
}
 

import org.apache.hadoop.hbase.io.hfile.BlockType.BlockCategory; //导入依赖的package包/类
private void addToReadTime(BlockCategory blockCategory,
    boolean isCompaction, long timeMs) {
  RegionMetricsStorage.incrTimeVaryingMetric(getBlockMetricName(blockCategory,
      isCompaction, BlockMetricType.READ_TIME), timeMs);

  // Also update the read time aggregated across all block categories
  if (blockCategory != BlockCategory.ALL_CATEGORIES) {
    addToReadTime(BlockCategory.ALL_CATEGORIES, isCompaction, timeMs);
  }
}
 

import org.apache.hadoop.hbase.io.hfile.BlockType.BlockCategory; //导入依赖的package包/类
/**
 * Updates the number of hits and the total number of block reads on a block
 * cache hit.
 */
public void updateOnCacheHit(BlockCategory blockCategory,
    boolean isCompaction, long count) {
  blockCategory.expectSpecific();
  int idx = getCacheHitMetricIndex(blockCategory, isCompaction);
  
  if (this.onHitCacheMetrics.addAndGet(idx, count) > THRESHOLD_METRICS_FLUSH) {
    flushCertainOnCacheHitMetrics(blockCategory, isCompaction);
  }
  
  if (this != ALL_SCHEMA_METRICS) {
    ALL_SCHEMA_METRICS.updateOnCacheHit(blockCategory, isCompaction, count);
  }
}
 

import org.apache.hadoop.hbase.io.hfile.BlockType.BlockCategory; //导入依赖的package包/类
private void flushCertainOnCacheHitMetrics(BlockCategory blockCategory, boolean isCompaction) {
  int idx = getCacheHitMetricIndex(blockCategory, isCompaction);
  long tempCount = this.onHitCacheMetrics.getAndSet(idx, 0);
  
  if (tempCount > 0) {
    incrNumericMetric(blockCategory, isCompaction, BlockMetricType.CACHE_HIT, tempCount);
    incrNumericMetric(blockCategory, isCompaction, BlockMetricType.READ_COUNT, tempCount);
  }
}
 

import org.apache.hadoop.hbase.io.hfile.BlockType.BlockCategory; //导入依赖的package包/类
/**
 * Flush the on cache hit metrics;
 */
private void flushOnCacheHitMetrics() {
  for (BlockCategory blockCategory : BlockCategory.values()) {
    for (boolean isCompaction : BOOL_VALUES) {
      flushCertainOnCacheHitMetrics (blockCategory, isCompaction);
    }
  }
  
  if (this != ALL_SCHEMA_METRICS) {
    ALL_SCHEMA_METRICS.flushOnCacheHitMetrics();
  }
}
 

import org.apache.hadoop.hbase.io.hfile.BlockType.BlockCategory; //导入依赖的package包/类
/**
 * Updates read time, the number of misses, and the total number of block
 * reads on a block cache miss.
 */
public void updateOnCacheMiss(BlockCategory blockCategory,
    boolean isCompaction, long timeMs) {
  blockCategory.expectSpecific();
  addToReadTime(blockCategory, isCompaction, timeMs);
  incrNumericMetric(blockCategory, isCompaction, BlockMetricType.CACHE_MISS);
  incrNumericMetric(blockCategory, isCompaction, BlockMetricType.READ_COUNT);
  if (this != ALL_SCHEMA_METRICS) {
    ALL_SCHEMA_METRICS.updateOnCacheMiss(blockCategory, isCompaction,
        timeMs);
  }
}
 

import org.apache.hadoop.hbase.io.hfile.BlockType.BlockCategory; //导入依赖的package包/类
/**
 * Adds the given delta to the cache size for the given block category and
 * the aggregate metric for all block categories. Updates both the per-CF
 * counter and the counter for all CFs (four metrics total). The cache size
 * metric is "persistent", i.e. it does not get reset when metrics are
 * collected.
 */
public void addToCacheSize(BlockCategory category, long cacheSizeDelta) {
  if (category == null) {
    category = BlockCategory.ALL_CATEGORIES;
  }
  RegionMetricsStorage.incrNumericPersistentMetric(getBlockMetricName(category, false,
      BlockMetricType.CACHE_SIZE), cacheSizeDelta);

  if (category != BlockCategory.ALL_CATEGORIES) {
    addToCacheSize(BlockCategory.ALL_CATEGORIES, cacheSizeDelta);
  }
}
 

import org.apache.hadoop.hbase.io.hfile.BlockType.BlockCategory; //导入依赖的package包/类
public void updateOnCachePutOrEvict(BlockCategory blockCategory,
    long cacheSizeDelta, boolean isEviction) {
  addToCacheSize(blockCategory, cacheSizeDelta);
  incrNumericMetric(blockCategory, false,
      isEviction ? BlockMetricType.EVICTED : BlockMetricType.CACHED);
  if (this != ALL_SCHEMA_METRICS) {
    ALL_SCHEMA_METRICS.updateOnCachePutOrEvict(blockCategory, cacheSizeDelta,
        isEviction);
  }
}