Java ClassSize.estimateBase方法代码示例

import org.apache.hadoop.hbase.util.ClassSize; //导入方法依赖的package包/类
/** Checks if the HeapSize calculator is within reason */
@Test
public void testHeapSizeForBlockIndex() throws IOException {
  Class<HFileBlockIndex.BlockIndexReader> cl =
      HFileBlockIndex.BlockIndexReader.class;
  long expected = ClassSize.estimateBase(cl, false);

  HFileBlockIndex.BlockIndexReader bi =
      new HFileBlockIndex.BlockIndexReader(KeyValue.RAW_COMPARATOR, 1);
  long actual = bi.heapSize();

  // Since the arrays in BlockIndex(byte [][] blockKeys, long [] blockOffsets,
  // int [] blockDataSizes) are all null they are not going to show up in the
  // HeapSize calculation, so need to remove those array costs from expected.
  expected -= ClassSize.align(3 * ClassSize.ARRAY);

  if (expected != actual) {
    ClassSize.estimateBase(cl, true);
    assertEquals(expected, actual);
  }
}
 

import org.apache.hadoop.hbase.util.ClassSize; //导入方法依赖的package包/类
Slab(int blockSize, int numBlocks) {
  buffers = new LinkedBlockingQueue<ByteBuffer>();
  slabs = new ConcurrentLinkedQueue<ByteBuffer>();

  this.blockSize = blockSize;
  this.numBlocks = numBlocks;

  this.heapSize = ClassSize.estimateBase(this.getClass(), false);

  int maxBlocksPerSlab = Integer.MAX_VALUE / blockSize;
  int maxSlabSize = maxBlocksPerSlab * blockSize;

  int numFullSlabs = numBlocks / maxBlocksPerSlab;
  int partialSlabSize = (numBlocks % maxBlocksPerSlab) * blockSize;
  for (int i = 0; i < numFullSlabs; i++) {
    allocateAndSlice(maxSlabSize, blockSize);
  }

  if (partialSlabSize > 0) {
    allocateAndSlice(partialSlabSize, blockSize);
  }
}
 

import org.apache.hadoop.hbase.util.ClassSize; //导入方法依赖的package包/类
/** Checks if the HeapSize calculator is within reason */
@Test
public void testHeapSizeForBlockIndex() throws IOException {
  Class<HFileBlockIndex.BlockIndexReader> cl =
      HFileBlockIndex.BlockIndexReader.class;
  long expected = ClassSize.estimateBase(cl, false);

  HFileBlockIndex.BlockIndexReader bi =
      new HFileBlockIndex.BlockIndexReader(Bytes.BYTES_RAWCOMPARATOR, 1);
  long actual = bi.heapSize();

  // Since the arrays in BlockIndex(byte [][] blockKeys, long [] blockOffsets,
  // int [] blockDataSizes) are all null they are not going to show up in the
  // HeapSize calculation, so need to remove those array costs from expected.
  expected -= ClassSize.align(3 * ClassSize.ARRAY);

  if (expected != actual) {
    ClassSize.estimateBase(cl, true);
    assertEquals(expected, actual);
  }
}
 

import org.apache.hadoop.hbase.util.ClassSize; //导入方法依赖的package包/类
/** Checks if the HeapSize calculator is within reason */
@Test
public void testHeapSizeForBlockIndex() throws IOException {
  Class<HFileBlockIndex.BlockIndexReader> cl =
      HFileBlockIndex.BlockIndexReader.class;
  long expected = ClassSize.estimateBase(cl, false);

  HFileBlockIndex.BlockIndexReader bi =
      new HFileBlockIndex.ByteArrayKeyBlockIndexReader(1);
  long actual = bi.heapSize();

  // Since the arrays in BlockIndex(byte [][] blockKeys, long [] blockOffsets,
  // int [] blockDataSizes) are all null they are not going to show up in the
  // HeapSize calculation, so need to remove those array costs from expected.
  // Already the block keys are not there in this case
  expected -= ClassSize.align(2 * ClassSize.ARRAY);

  if (expected != actual) {
    expected = ClassSize.estimateBase(cl, true);
    assertEquals(expected, actual);
  }
}
 

import org.apache.hadoop.hbase.util.ClassSize; //导入方法依赖的package包/类
/** Checks if the HeapSize calculator is within reason */
//@Test
public void testHeapSizeForBlockIndex() throws IOException {
  Class<HFileBlockIndex.BlockIndexReader> cl =
      HFileBlockIndex.BlockIndexReader.class;
  long expected = ClassSize.estimateBase(cl, false);

  HFileBlockIndex.BlockIndexReader bi =
      new HFileBlockIndex.BlockIndexReader(KeyValue.RAW_COMPARATOR, 1);
  long actual = bi.heapSize();

  // Since the arrays in BlockIndex(byte [][] blockKeys, long [] blockOffsets,
  // int [] blockDataSizes) are all null they are not going to show up in the
  // HeapSize calculation, so need to remove those array costs from expected.
  expected -= ClassSize.align(3 * ClassSize.ARRAY);

  if (expected != actual) {
    ClassSize.estimateBase(cl, true);
    assertEquals(expected, actual);
  }
}
 

import org.apache.hadoop.hbase.util.ClassSize; //导入方法依赖的package包/类
@Test
public void testMutations(){
  Class<?> cl;
  long expected;
  long actual;

  cl = TimeRange.class;
  actual = ClassSize.TIMERANGE;
  expected  = ClassSize.estimateBase(cl, false);
  if (expected != actual) {
    ClassSize.estimateBase(cl, true);
    assertEquals(expected, actual);
  }

  byte[] row = new byte[] { 0 };
  cl = Put.class;
  actual = new Put(row).MUTATION_OVERHEAD + ClassSize.align(ClassSize.ARRAY);
  expected = ClassSize.estimateBase(cl, false);
  //The actual TreeMap is not included in the above calculation
  expected += ClassSize.align(ClassSize.TREEMAP);
  if (expected != actual) {
    ClassSize.estimateBase(cl, true);
    assertEquals(expected, actual);
  }

  cl = Delete.class;
  actual = new Delete(row).MUTATION_OVERHEAD + ClassSize.align(ClassSize.ARRAY);
  expected  = ClassSize.estimateBase(cl, false);
  //The actual TreeMap is not included in the above calculation
  expected += ClassSize.align(ClassSize.TREEMAP);
  if (expected != actual) {
    ClassSize.estimateBase(cl, true);
    assertEquals(expected, actual);
  }
}
 

import org.apache.hadoop.hbase.util.ClassSize; //导入方法依赖的package包/类
private void allocateAndSlice(int size, int sliceSize) {
  ByteBuffer newSlab = ByteBuffer.allocateDirect(size);
  slabs.add(newSlab);
  for (int j = 0; j < newSlab.capacity(); j += sliceSize) {
    newSlab.limit(j + sliceSize).position(j);
    ByteBuffer aSlice = newSlab.slice();
    buffers.add(aSlice);
    heapSize += ClassSize.estimateBase(aSlice.getClass(), false);
  }
}
 

import org.apache.hadoop.hbase.util.ClassSize; //导入方法依赖的package包/类
@Test
public void testMutations(){
  Class<?> cl;
  long expected;
  long actual;

  cl = TimeRange.class;
  actual = ClassSize.TIMERANGE;
  expected  = ClassSize.estimateBase(cl, false);
  if (expected != actual) {
    ClassSize.estimateBase(cl, true);
    assertEquals(expected, actual);
  }

  byte[] row = new byte[] { 0 };
  cl = Put.class;
  actual = Mutation.MUTATION_OVERHEAD + ClassSize.align(ClassSize.ARRAY);
  expected = ClassSize.estimateBase(cl, false);
  //The actual TreeMap is not included in the above calculation
  expected += ClassSize.align(ClassSize.TREEMAP);
  expected += ClassSize.align(ClassSize.INTEGER); // priority
  if (expected != actual) {
    ClassSize.estimateBase(cl, true);
    assertEquals(expected, actual);
  }

  cl = Delete.class;
  actual = Mutation.MUTATION_OVERHEAD + ClassSize.align(ClassSize.ARRAY);
  expected  = ClassSize.estimateBase(cl, false);
  //The actual TreeMap is not included in the above calculation
  expected += ClassSize.align(ClassSize.TREEMAP);
  expected += ClassSize.align(ClassSize.INTEGER); // priority
  if (expected != actual) {
    ClassSize.estimateBase(cl, true);
    assertEquals(expected, actual);
  }
}