Summary(HprofByteBuffer dumpBuffer, long startOffset) { assert dumpBuffer.get(startOffset) == HprofHeap.HEAP_SUMMARY; dumpBuffer.getInt(startOffset + 1); // time dumpBuffer.getInt(startOffset + 1 + 4); // tag length totalLiveBytes = dumpBuffer.getInt(startOffset + 1 + 4 + 4); totalLiveInstances = dumpBuffer.getInt(startOffset + 1 + 4 + 4 + 4); totalAllocatedBytes = dumpBuffer.getLong(startOffset + 1 + 4 + 4 + 4 + 4); totalAllocatedInstances = dumpBuffer.getLong(startOffset + 1 + 4 + 4 + 4 + 4 + 8); time = dumpBuffer.getTime(); }
int readTag(long[] offset) { long start = offset[0]; int tag = dumpBuffer.get(start); //int time = dumpBuffer.getInt(start+1); long len = dumpBuffer.getInt(start + 1 + 4) & 0xFFFFFFFFL; // len is unsigned int offset[0] = start + 1 + 4 + 4 + len; return tag; }
byte getValueType() { HprofByteBuffer buffer = classDump.getHprofBuffer(); return buffer.get(fileOffset + buffer.getIDSize()); } }
void findStaticReferencesFor(long instanceId, List<Value> refs) { int i; HprofByteBuffer buffer = getHprofBuffer(); int idSize = buffer.getIDSize(); long fieldOffset = fileOffset + getStaticFieldOffset(); int fields = buffer.getShort(fieldOffset); List<FieldValue> staticFileds = null; HprofHeap heap = getHprof(); fieldOffset += 2; for (i = 0; i < fields; i++) { byte type = buffer.get(fieldOffset + idSize); int size = heap.getValueSize(type); if ((type == HprofHeap.OBJECT) && (instanceId == buffer.getID(fieldOffset + idSize + 1))) { if (staticFileds == null) { staticFileds = getStaticFieldValues(); } refs.add(staticFileds.get(i)); } fieldOffset += (idSize + 1 + size); } if (instanceId == getClassLoaderId()) { if (staticFileds == null) { staticFileds = getStaticFieldValues(); } refs.add(staticFileds.get(fields)); } }
private String getString(long start) { HprofByteBuffer dumpBuffer = getDumpBuffer(); if (start == -1) { return "<unknown string>"; // NOI18N } int len = dumpBuffer.getInt(start + lengthOffset); byte[] chars = new byte[len - dumpBuffer.getIDSize()]; dumpBuffer.get(start + UTF8CharsOffset, chars); String s = "Error"; // NOI18N try { s = new String(chars, "UTF-8"); // NOI18N } catch (UnsupportedEncodingException ex) { ex.printStackTrace(); } return s; }
int getStaticFiledSize(int staticFieldOffset) { int i; HprofByteBuffer buffer = getHprofBuffer(); int idSize = buffer.getIDSize(); long fieldOffset = fileOffset + staticFieldOffset; int fields = buffer.getShort(fieldOffset); HprofHeap heap = getHprof(); fieldOffset += 2; for (i = 0; i < fields; i++) { byte type = buffer.get(fieldOffset + idSize); int size = heap.getValueSize(type); fieldOffset += (idSize + 1 + size); } return (int) (fieldOffset - staticFieldOffset - fileOffset); }
classDump = classDumpBounds.getPrimitiveArrayClass(dumpBuffer.get(start + 1 + classIdOffset));
int getConstantPoolSize() { long cpOffset = fileOffset + classDumpSegment.constantPoolSizeOffset; HprofByteBuffer buffer = getHprofBuffer(); int cpRecords = buffer.getShort(cpOffset); HprofHeap heap = getHprof(); cpOffset += 2; for (int i = 0; i < cpRecords; i++) { byte type = buffer.get(cpOffset + 2); int size = heap.getValueSize(type); cpOffset += (2 + 1 + size); } return (int) (cpOffset - (fileOffset + classDumpSegment.constantPoolSizeOffset)); }
void addInstanceSize(ClassDump cls, int tag, long instanceOffset) { if ((tag == HprofHeap.OBJECT_ARRAY_DUMP) || (tag == HprofHeap.PRIMITIVE_ARRAY_DUMP)) { Long sizeLong = (Long) arrayMap.get(cls); long size = 0; HprofByteBuffer dumpBuffer = hprofHeap.dumpBuffer; int idSize = dumpBuffer.getIDSize(); long elementsOffset = instanceOffset + 1 + idSize + 4; if (sizeLong != null) { size = sizeLong.longValue(); } int elements = dumpBuffer.getInt(elementsOffset); int elSize; if (tag == HprofHeap.PRIMITIVE_ARRAY_DUMP) { elSize = hprofHeap.getValueSize(dumpBuffer.get(elementsOffset + 4)); } else { elSize = idSize; } size += (getMinimumInstanceSize() + ArrayDump.HPROF_ARRAY_OVERHEAD + (((long)elements) * elSize)); arrayMap.put((JavaClass)cls, Long.valueOf(size)); } }
private byte getType() { HprofByteBuffer dumpBuffer = dumpClass.getHprofBuffer(); int idSize = dumpBuffer.getIDSize(); return dumpBuffer.get(fileOffset + 1 + idSize + 4 + 4); } }
public String getKind() { int k = heap.dumpBuffer.get(fileOffset); return (String) kindMap.get(Integer.valueOf(k & 0xff)); }
List<FieldValue> getStaticFieldValues(boolean addClassLoader) { HprofByteBuffer buffer = getHprofBuffer(); long offset = fileOffset + getStaticFieldOffset(); int i; int fields; List<FieldValue> filedsList; HprofHeap heap = getHprof(); fields = buffer.getShort(offset); offset += 2; filedsList = new ArrayList<FieldValue>(fields+(addClassLoader?0:1)); for (i = 0; i < fields; i++) { byte type = buffer.get(offset + classDumpSegment.fieldTypeOffset); int fieldSize = classDumpSegment.fieldSize + heap.getValueSize(type); HprofFieldValue value; if (type == HprofHeap.OBJECT) { value = new HprofFieldObjectValue(this, offset); } else { value = new HprofFieldValue(this, offset); } filedsList.add(value); offset += fieldSize; } if (addClassLoader) { long classLoaderOffset = fileOffset + classDumpSegment.classLoaderIDOffset; filedsList.add(new ClassLoaderFieldValue(this, classLoaderOffset)); } return filedsList; }
private byte readValue(long[] offset) { byte type = dumpBuffer.get(offset[0]++); offset[0] += getValueSize(type); return type; } }
StackTrace(StackTraceSegment segment, long offset) { super(offset); stackTraceSegment = segment; assert getHprofBuffer().get(offset) == HprofHeap.STACK_TRACE; }
StackFrame(StackFrameSegment segment, long offset) { super(offset); stackFrameSegment = segment; assert getHprofBuffer().get(offset) == HprofHeap.STACK_FRAME; }
ClassDump(ClassDumpSegment segment, long offset) { super(offset); classDumpSegment = segment; assert getHprofBuffer().get(offset) == HprofHeap.CLASS_DUMP; }
LoadClass(LoadClassSegment segment, long offset) { super(offset); loadClassSegment = segment; assert getHprofBuffer().get(offset) == HprofHeap.LOAD_CLASS; }
Object getTypeValue() { HprofByteBuffer dumpBuffer = classDump.getHprofBuffer(); long position = fileOffset + classDump.classDumpSegment.fieldTypeOffset; byte type = dumpBuffer.get(position); return HprofInstanceValue.getTypeValue(dumpBuffer, position + 1, type); } }