Java BlockCategory.BLOOM属性代码示例

/**
 * 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;
}
 

/**
 * 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;
}
 

/**
 * 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)));
}
 

/**
 * 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) {
  boolean shouldCache =
      isBlockCacheEnabled()
          && (cacheDataOnRead || category == BlockCategory.INDEX || category == BlockCategory.BLOOM);
  return shouldCache;
}
 

/**
 * 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) {
  boolean shouldCache = isBlockCacheEnabled()
      && (cacheDataOnRead ||
          category == BlockCategory.INDEX ||
          category == BlockCategory.BLOOM ||
          (prefetchOnOpen &&
              (category != BlockCategory.META &&
               category != BlockCategory.UNKNOWN)));
  return shouldCache;
}
 

/**
 * 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) {
  boolean shouldCache = isBlockCacheEnabled()
      && (cacheDataOnRead ||
          category == BlockCategory.INDEX ||
          category == BlockCategory.BLOOM);
  return shouldCache;
}
 

/**
 * @param metaBlockName
 * @param cacheBlock Add block to cache, if found
 * @return Block wrapped in a ByteBuffer
 * @throws IOException
 */
@Override
public ByteBuffer getMetaBlock(String metaBlockName, boolean cacheBlock)
    throws IOException {
  if (trailer.getMetaIndexCount() == 0) {
    return null; // there are no meta blocks
  }
  if (metaBlockIndexReader == null) {
    throw new IOException("Meta index not loaded");
  }

  byte[] nameBytes = Bytes.toBytes(metaBlockName);
  int block = metaBlockIndexReader.rootBlockContainingKey(nameBytes, 0,
      nameBytes.length);
  if (block == -1)
    return null;
  long offset = metaBlockIndexReader.getRootBlockOffset(block);
  long nextOffset;
  if (block == metaBlockIndexReader.getRootBlockCount() - 1) {
    nextOffset = trailer.getFileInfoOffset();
  } else {
    nextOffset = metaBlockIndexReader.getRootBlockOffset(block + 1);
  }

  long startTimeNs = System.nanoTime();

  BlockCacheKey cacheKey = new BlockCacheKey(name, offset,
      DataBlockEncoding.NONE, BlockType.META);

  BlockCategory effectiveCategory = BlockCategory.META;
  if (metaBlockName.equals(HFileWriterV1.BLOOM_FILTER_META_KEY) ||
      metaBlockName.equals(HFileWriterV1.BLOOM_FILTER_DATA_KEY)) {
    effectiveCategory = BlockCategory.BLOOM;
  }

  // Per meta key from any given file, synchronize reads for said block
  synchronized (metaBlockIndexReader.getRootBlockKey(block)) {
    // Check cache for block.  If found return.
    if (cacheConf.isBlockCacheEnabled()) {
      HFileBlock cachedBlock =
        (HFileBlock) cacheConf.getBlockCache().getBlock(cacheKey,
            cacheConf.shouldCacheBlockOnRead(effectiveCategory), false);
      if (cachedBlock != null) {
        getSchemaMetrics().updateOnCacheHit(effectiveCategory,
            SchemaMetrics.NO_COMPACTION);
        return cachedBlock.getBufferWithoutHeader();
      }
      // Cache Miss, please load.
    }

    HFileBlock hfileBlock = fsBlockReader.readBlockData(offset,
        nextOffset - offset, metaBlockIndexReader.getRootBlockDataSize(block),
        true);
    passSchemaMetricsTo(hfileBlock);
    hfileBlock.expectType(BlockType.META);

    final long delta = System.nanoTime() - startTimeNs;
    HFile.offerReadLatency(delta, true);
    getSchemaMetrics().updateOnCacheMiss(effectiveCategory,
        SchemaMetrics.NO_COMPACTION, delta);

    // Cache the block
    if (cacheBlock && cacheConf.shouldCacheBlockOnRead(effectiveCategory)) {
      cacheConf.getBlockCache().cacheBlock(cacheKey, hfileBlock,
          cacheConf.isInMemory());
    }

    return hfileBlock.getBufferWithoutHeader();
  }
}
 

/**
 * @param metaBlockName
 * @param cacheBlock Add block to cache, if found
 * @return Block wrapped in a ByteBuffer
 * @throws IOException
 */
@Override
public ByteBuffer getMetaBlock(String metaBlockName, boolean cacheBlock)
    throws IOException {
  if (trailer.getMetaIndexCount() == 0) {
    return null; // there are no meta blocks
  }
  if (metaBlockIndexReader == null) {
    throw new IOException("Meta index not loaded");
  }

  byte[] nameBytes = Bytes.toBytes(metaBlockName);
  int block = metaBlockIndexReader.rootBlockContainingKey(nameBytes, 0,
      nameBytes.length);
  if (block == -1)
    return null;
  long offset = metaBlockIndexReader.getRootBlockOffset(block);
  long nextOffset;
  if (block == metaBlockIndexReader.getRootBlockCount() - 1) {
    nextOffset = trailer.getFileInfoOffset();
  } else {
    nextOffset = metaBlockIndexReader.getRootBlockOffset(block + 1);
  }

  long startTimeNs = System.nanoTime();

  BlockCacheKey cacheKey = HFile.getBlockCacheKey(name, offset);

  BlockCategory effectiveCategory = BlockCategory.META;
  if (metaBlockName.equals(HFileWriterV1.BLOOM_FILTER_META_KEY) ||
      metaBlockName.equals(HFileWriterV1.BLOOM_FILTER_DATA_KEY)) {
    effectiveCategory = BlockCategory.BLOOM;
  }

  // Per meta key from any given file, synchronize reads for said block
  synchronized (metaBlockIndexReader.getRootBlockKey(block)) {
    metaLoads.incrementAndGet();
    // Check cache for block.  If found return.
    if (cacheConf.isBlockCacheEnabled()) {
      HFileBlock cachedBlock =
        (HFileBlock) cacheConf.getBlockCache().getBlock(cacheKey,
            cacheConf.shouldCacheBlockOnRead(effectiveCategory));
      if (cachedBlock != null) {
        cacheHits.incrementAndGet();
        return cachedBlock.getBufferWithoutHeader();
      }
      // Cache Miss, please load.
    }

    HFileBlock hfileBlock = fsBlockReader.readBlockData(offset,
        nextOffset - offset, metaBlockIndexReader.getRootBlockDataSize(block),
        true);
    hfileBlock.expectType(BlockType.META);

    HFile.readTimeNano.addAndGet(System.nanoTime() - startTimeNs);
    HFile.readOps.incrementAndGet();

    // Cache the block
    if (cacheBlock && cacheConf.shouldCacheBlockOnRead(effectiveCategory)) {
      cacheConf.getBlockCache().cacheBlock(cacheKey, hfileBlock,
          cacheConf.isInMemory());
    }

    return hfileBlock.getBufferWithoutHeader();
  }
}
 

/**
 * @param metaBlockName
 * @param cacheBlock Add block to cache, if found
 * @return Block wrapped in a ByteBuffer
 * @throws IOException
 */
@Override
public ByteBuffer getMetaBlock(String metaBlockName, boolean cacheBlock)
    throws IOException {
  if (trailer.getMetaIndexCount() == 0) {
    return null; // there are no meta blocks
  }
  if (metaBlockIndexReader == null) {
    throw new IOException("Meta index not loaded");
  }

  byte[] nameBytes = Bytes.toBytes(metaBlockName);
  int block = metaBlockIndexReader.rootBlockContainingKey(nameBytes, 0,
      nameBytes.length);
  if (block == -1)
    return null;
  long offset = metaBlockIndexReader.getRootBlockOffset(block);
  long nextOffset;
  if (block == metaBlockIndexReader.getRootBlockCount() - 1) {
    nextOffset = trailer.getFileInfoOffset();
  } else {
    nextOffset = metaBlockIndexReader.getRootBlockOffset(block + 1);
  }

  long startTimeNs = System.nanoTime();

  BlockCacheKey cacheKey = new BlockCacheKey(name, offset,
      DataBlockEncoding.NONE, BlockType.META);

  BlockCategory effectiveCategory = BlockCategory.META;
  if (metaBlockName.equals(HFileWriterV1.BLOOM_FILTER_META_KEY) ||
      metaBlockName.equals(HFileWriterV1.BLOOM_FILTER_DATA_KEY)) {
    effectiveCategory = BlockCategory.BLOOM;
  }

  // Per meta key from any given file, synchronize reads for said block
  synchronized (metaBlockIndexReader.getRootBlockKey(block)) {
    // Check cache for block.  If found return.
    if (cacheConf.isBlockCacheEnabled()) {
      HFileBlock cachedBlock =
        (HFileBlock) cacheConf.getBlockCache().getBlock(cacheKey,
            cacheConf.shouldCacheBlockOnRead(effectiveCategory), false);
      if (cachedBlock != null) {
        return cachedBlock.getBufferWithoutHeader();
      }
      // Cache Miss, please load.
    }

    HFileBlock hfileBlock = fsBlockReader.readBlockData(offset,
        nextOffset - offset, metaBlockIndexReader.getRootBlockDataSize(block),
        true);
    hfileBlock.expectType(BlockType.META);

    final long delta = System.nanoTime() - startTimeNs;
    HFile.offerReadLatency(delta, true);

    // Cache the block
    if (cacheBlock && cacheConf.shouldCacheBlockOnRead(effectiveCategory)) {
      cacheConf.getBlockCache().cacheBlock(cacheKey, hfileBlock,
          cacheConf.isInMemory());
    }

    return hfileBlock.getBufferWithoutHeader();
  }
}
 

/**
 * 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.
 *
 * @param category the category
 * @return true, if successful
 */
public boolean shouldCacheBlockOnRead(BlockCategory category) {
  boolean shouldCache = isBlockCacheEnabled()
      && (cacheDataOnRead ||
          category == BlockCategory.INDEX ||
          category == BlockCategory.BLOOM);
  return shouldCache;
}