Java RamUsageEstimator.shallowSizeOfInstance方法代码示例

import org.apache.lucene.util.RamUsageEstimator; //导入方法依赖的package包/类
/** expert: instantiates a new reader */
@SuppressWarnings("deprecation")
protected Lucene45DocValuesProducer(SegmentReadState state, String dataCodec, String dataExtension, String metaCodec, String metaExtension) throws IOException {
  Version ver = state.segmentInfo.getVersion();
  lenientFieldInfoCheck = Version.LUCENE_4_9_0.onOrAfter(ver);
  String metaName = IndexFileNames.segmentFileName(state.segmentInfo.name, state.segmentSuffix, metaExtension);
  // read in the entries from the metadata file.
  ChecksumIndexInput in = state.directory.openChecksumInput(metaName, state.context);
  this.maxDoc = state.segmentInfo.getDocCount();
  boolean success = false;
  try {
    version = CodecUtil.checkHeader(in, metaCodec, 
                                    Lucene45DocValuesFormat.VERSION_START,
                                    Lucene45DocValuesFormat.VERSION_CURRENT);
    numerics = new HashMap<>();
    ords = new HashMap<>();
    ordIndexes = new HashMap<>();
    binaries = new HashMap<>();
    sortedSets = new HashMap<>();
    readFields(in, state.fieldInfos);

    if (version >= Lucene45DocValuesFormat.VERSION_CHECKSUM) {
      CodecUtil.checkFooter(in);
    } else {
      CodecUtil.checkEOF(in);
    }

    success = true;
  } finally {
    if (success) {
      IOUtils.close(in);
    } else {
      IOUtils.closeWhileHandlingException(in);
    }
  }

  String dataName = IndexFileNames.segmentFileName(state.segmentInfo.name, state.segmentSuffix, dataExtension);
  this.data = state.directory.openInput(dataName, state.context);
  success = false;
  try {
    final int version2 = CodecUtil.checkHeader(data, dataCodec, 
                                               Lucene45DocValuesFormat.VERSION_START,
                                               Lucene45DocValuesFormat.VERSION_CURRENT);
    if (version != version2) {
      throw new CorruptIndexException("Format versions mismatch");
    }
    
    if (version >= Lucene45DocValuesFormat.VERSION_CHECKSUM) {
      // NOTE: data file is too costly to verify checksum against all the bytes on open,
      // but for now we at least verify proper structure of the checksum footer: which looks
      // for FOOTER_MAGIC + algorithmID. This is cheap and can detect some forms of corruption
      // such as file truncation.
      CodecUtil.retrieveChecksum(data);
    }

    success = true;
  } finally {
    if (!success) {
      IOUtils.closeWhileHandlingException(this.data);
    }
  }
  
  ramBytesUsed = new AtomicLong(RamUsageEstimator.shallowSizeOfInstance(getClass()));
}
 

import org.apache.lucene.util.RamUsageEstimator; //导入方法依赖的package包/类
/** expert: instantiates a new reader */
Lucene49DocValuesProducer(SegmentReadState state, String dataCodec, String dataExtension, String metaCodec, String metaExtension) throws IOException {
  String metaName = IndexFileNames.segmentFileName(state.segmentInfo.name, state.segmentSuffix, metaExtension);
  // read in the entries from the metadata file.
  ChecksumIndexInput in = state.directory.openChecksumInput(metaName, state.context);
  this.maxDoc = state.segmentInfo.getDocCount();
  boolean success = false;
  try {
    version = CodecUtil.checkHeader(in, metaCodec, 
                                    Lucene49DocValuesFormat.VERSION_START,
                                    Lucene49DocValuesFormat.VERSION_CURRENT);
    numerics = new HashMap<>();
    ords = new HashMap<>();
    ordIndexes = new HashMap<>();
    binaries = new HashMap<>();
    sortedSets = new HashMap<>();
    sortedNumerics = new HashMap<>();
    readFields(in, state.fieldInfos);

    CodecUtil.checkFooter(in);
    success = true;
  } finally {
    if (success) {
      IOUtils.close(in);
    } else {
      IOUtils.closeWhileHandlingException(in);
    }
  }

  String dataName = IndexFileNames.segmentFileName(state.segmentInfo.name, state.segmentSuffix, dataExtension);
  this.data = state.directory.openInput(dataName, state.context);
  success = false;
  try {
    final int version2 = CodecUtil.checkHeader(data, dataCodec, 
                                               Lucene49DocValuesFormat.VERSION_START,
                                               Lucene49DocValuesFormat.VERSION_CURRENT);
    if (version != version2) {
      throw new CorruptIndexException("Format versions mismatch");
    }
    
    // NOTE: data file is too costly to verify checksum against all the bytes on open,
    // but for now we at least verify proper structure of the checksum footer: which looks
    // for FOOTER_MAGIC + algorithmID. This is cheap and can detect some forms of corruption
    // such as file truncation.
    CodecUtil.retrieveChecksum(data);

    success = true;
  } finally {
    if (!success) {
      IOUtils.closeWhileHandlingException(this.data);
    }
  }
  
  ramBytesUsed = new AtomicLong(RamUsageEstimator.shallowSizeOfInstance(getClass()));
}
 

import org.apache.lucene.util.RamUsageEstimator; //导入方法依赖的package包/类
Lucene49NormsProducer(SegmentReadState state, String dataCodec, String dataExtension, String metaCodec, String metaExtension) throws IOException {
  maxDoc = state.segmentInfo.getDocCount();
  String metaName = IndexFileNames.segmentFileName(state.segmentInfo.name, state.segmentSuffix, metaExtension);
  // read in the entries from the metadata file.
  ChecksumIndexInput in = state.directory.openChecksumInput(metaName, state.context);
  boolean success = false;
  ramBytesUsed = new AtomicLong(RamUsageEstimator.shallowSizeOfInstance(getClass()));
  try {
    version = CodecUtil.checkHeader(in, metaCodec, VERSION_START, VERSION_CURRENT);
    readFields(in, state.fieldInfos);
    CodecUtil.checkFooter(in);
    success = true;
  } finally {
    if (success) {
      IOUtils.close(in);
    } else {
      IOUtils.closeWhileHandlingException(in);
    }
  }

  String dataName = IndexFileNames.segmentFileName(state.segmentInfo.name, state.segmentSuffix, dataExtension);
  this.data = state.directory.openInput(dataName, state.context);
  success = false;
  try {
    final int version2 = CodecUtil.checkHeader(data, dataCodec, VERSION_START, VERSION_CURRENT);
    if (version != version2) {
      throw new CorruptIndexException("Format versions mismatch");
    }
    
    // NOTE: data file is too costly to verify checksum against all the bytes on open,
    // but for now we at least verify proper structure of the checksum footer: which looks
    // for FOOTER_MAGIC + algorithmID. This is cheap and can detect some forms of corruption
    // such as file truncation.
    CodecUtil.retrieveChecksum(data);

    success = true;
  } finally {
    if (!success) {
      IOUtils.closeWhileHandlingException(this.data);
    }
  }
}
 

import org.apache.lucene.util.RamUsageEstimator; //导入方法依赖的package包/类
/**
 * Loads the segment information at segment load time.
 * 
 * @param indexEnum
 *          the term enum.
 * @param indexDivisor
 *          the index divisor.
 * @param tiiFileLength
 *          the size of the tii file, used to approximate the size of the
 *          buffer.
 * @param totalIndexInterval
 *          the total index interval.
 */
TermInfosReaderIndex(SegmentTermEnum indexEnum, int indexDivisor, long tiiFileLength, int totalIndexInterval) throws IOException {
  this.totalIndexInterval = totalIndexInterval;
  indexSize = 1 + ((int) indexEnum.size - 1) / indexDivisor;
  skipInterval = indexEnum.skipInterval;
  // this is only an inital size, it will be GCed once the build is complete
  long initialSize = (long) (tiiFileLength * 1.5) / indexDivisor;
  PagedBytes dataPagedBytes = new PagedBytes(estimatePageBits(initialSize));
  PagedBytesDataOutput dataOutput = dataPagedBytes.getDataOutput();

  final int bitEstimate = 1+MathUtil.log(tiiFileLength, 2);
  GrowableWriter indexToTerms = new GrowableWriter(bitEstimate, indexSize, PackedInts.DEFAULT);

  String currentField = null;
  List<String> fieldStrs = new ArrayList<>();
  int fieldCounter = -1;
  for (int i = 0; indexEnum.next(); i++) {
    Term term = indexEnum.term();
    if (currentField == null || !currentField.equals(term.field())) {
      currentField = term.field();
      fieldStrs.add(currentField);
      fieldCounter++;
    }
    TermInfo termInfo = indexEnum.termInfo();
    indexToTerms.set(i, dataOutput.getPosition());
    dataOutput.writeVInt(fieldCounter);
    dataOutput.writeString(term.text());
    dataOutput.writeVInt(termInfo.docFreq);
    if (termInfo.docFreq >= skipInterval) {
      dataOutput.writeVInt(termInfo.skipOffset);
    }
    dataOutput.writeVLong(termInfo.freqPointer);
    dataOutput.writeVLong(termInfo.proxPointer);
    dataOutput.writeVLong(indexEnum.indexPointer);
    for (int j = 1; j < indexDivisor; j++) {
      if (!indexEnum.next()) {
        break;
      }
    }
  }

  fields = new Term[fieldStrs.size()];
  for (int i = 0; i < fields.length; i++) {
    fields[i] = new Term(fieldStrs.get(i));
  }
  
  dataPagedBytes.freeze(true);
  dataInput = dataPagedBytes.getDataInput();
  indexToDataOffset = indexToTerms.getMutable();

  long ramBytesUsed = RamUsageEstimator.shallowSizeOf(fields);
  ramBytesUsed += RamUsageEstimator.shallowSizeOf(dataInput);
  ramBytesUsed += fields.length * RamUsageEstimator.shallowSizeOfInstance(Term.class);
  ramBytesUsed += dataPagedBytes.ramBytesUsed();
  ramBytesUsed += indexToDataOffset.ramBytesUsed();
  this.ramBytesUsed = ramBytesUsed;
}
 

import org.apache.lucene.util.RamUsageEstimator; //导入方法依赖的package包/类
Lucene42DocValuesProducer(SegmentReadState state, String dataCodec, String dataExtension, String metaCodec, String metaExtension) throws IOException {
  maxDoc = state.segmentInfo.getDocCount();
  String metaName = IndexFileNames.segmentFileName(state.segmentInfo.name, state.segmentSuffix, metaExtension);
  // read in the entries from the metadata file.
  ChecksumIndexInput in = state.directory.openChecksumInput(metaName, state.context);
  boolean success = false;
  ramBytesUsed = new AtomicLong(RamUsageEstimator.shallowSizeOfInstance(getClass()));
  try {
    version = CodecUtil.checkHeader(in, metaCodec, 
                                    VERSION_START,
                                    VERSION_CURRENT);
    numerics = new HashMap<>();
    binaries = new HashMap<>();
    fsts = new HashMap<>();
    readFields(in, state.fieldInfos);

    if (version >= VERSION_CHECKSUM) {
      CodecUtil.checkFooter(in);
    } else {
      CodecUtil.checkEOF(in);
    }
    
    success = true;
  } finally {
    if (success) {
      IOUtils.close(in);
    } else {
      IOUtils.closeWhileHandlingException(in);
    }
  }

  String dataName = IndexFileNames.segmentFileName(state.segmentInfo.name, state.segmentSuffix, dataExtension);
  this.data = state.directory.openInput(dataName, state.context);
  success = false;
  try {
    final int version2 = CodecUtil.checkHeader(data, dataCodec, 
                                               VERSION_START,
                                               VERSION_CURRENT);
    if (version != version2) {
      throw new CorruptIndexException("Format versions mismatch");
    }
    
    if (version >= VERSION_CHECKSUM) {
      // NOTE: data file is too costly to verify checksum against all the bytes on open,
      // but for now we at least verify proper structure of the checksum footer: which looks
      // for FOOTER_MAGIC + algorithmID. This is cheap and can detect some forms of corruption
      // such as file truncation.
      CodecUtil.retrieveChecksum(data);
    }

    success = true;
  } finally {
    if (!success) {
      IOUtils.closeWhileHandlingException(this.data);
    }
  }
}
 

import org.apache.lucene.util.RamUsageEstimator; //导入方法依赖的package包/类
/** expert: instantiates a new reader */
Lucene410DocValuesProducer(SegmentReadState state, String dataCodec, String dataExtension, String metaCodec, String metaExtension) throws IOException {
  String metaName = IndexFileNames.segmentFileName(state.segmentInfo.name, state.segmentSuffix, metaExtension);
  // read in the entries from the metadata file.
  ChecksumIndexInput in = state.directory.openChecksumInput(metaName, state.context);
  this.maxDoc = state.segmentInfo.getDocCount();
  boolean success = false;
  try {
    version = CodecUtil.checkHeader(in, metaCodec, 
                                    Lucene410DocValuesFormat.VERSION_START,
                                    Lucene410DocValuesFormat.VERSION_CURRENT);
    numerics = new HashMap<>();
    ords = new HashMap<>();
    ordIndexes = new HashMap<>();
    binaries = new HashMap<>();
    sortedSets = new HashMap<>();
    sortedNumerics = new HashMap<>();
    readFields(in, state.fieldInfos);

    CodecUtil.checkFooter(in);
    success = true;
  } finally {
    if (success) {
      IOUtils.close(in);
    } else {
      IOUtils.closeWhileHandlingException(in);
    }
  }

  String dataName = IndexFileNames.segmentFileName(state.segmentInfo.name, state.segmentSuffix, dataExtension);
  this.data = state.directory.openInput(dataName, state.context);
  success = false;
  try {
    final int version2 = CodecUtil.checkHeader(data, dataCodec, 
                                               Lucene410DocValuesFormat.VERSION_START,
                                               Lucene410DocValuesFormat.VERSION_CURRENT);
    if (version != version2) {
      throw new CorruptIndexException("Format versions mismatch");
    }
    
    // NOTE: data file is too costly to verify checksum against all the bytes on open,
    // but for now we at least verify proper structure of the checksum footer: which looks
    // for FOOTER_MAGIC + algorithmID. This is cheap and can detect some forms of corruption
    // such as file truncation.
    CodecUtil.retrieveChecksum(data);

    success = true;
  } finally {
    if (!success) {
      IOUtils.closeWhileHandlingException(this.data);
    }
  }
  
  ramBytesUsed = new AtomicLong(RamUsageEstimator.shallowSizeOfInstance(getClass()));
}