/*
* Copyright (C) 2010 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package dalvik.system.profiler;
import java.io.BufferedInputStream;
import java.io.DataInputStream;
import java.io.EOFException;
import java.io.IOException;
import java.io.InputStream;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
/**
* <pre> {@code
* BinaryHprofReader reader = new BinaryHprofReader(new BufferedInputStream(inputStream));
* reader.setStrict(false); // for RI compatability
* reader.read();
* inputStream.close();
* reader.getVersion();
* reader.getHprofData();
* }</pre>
*/
public final class BinaryHprofReader {
private static final boolean TRACE = false;
private final DataInputStream in;
/**
* By default we try to strictly validate rules followed by
* our HprofWriter. For example, every end thread is preceded
* by a matching start thread.
*/
private boolean strict = true;
/**
* version string from header after read has been performed,
* otherwise null. nullness used to detect if callers try to
* access data before read is called.
*/
private String version;
private final Map<HprofData.StackTrace, int[]> stackTraces
= new HashMap<HprofData.StackTrace, int[]>();
private final HprofData hprofData = new HprofData(stackTraces);
private final Map<Integer, String> idToString = new HashMap<Integer, String>();
private final Map<Integer, String> idToClassName = new HashMap<Integer, String>();
private final Map<Integer, StackTraceElement> idToStackFrame
= new HashMap<Integer, StackTraceElement>();
private final Map<Integer, HprofData.StackTrace> idToStackTrace
= new HashMap<Integer, HprofData.StackTrace>();
/**
* Creates a BinaryHprofReader around the specified {@code
* inputStream}
*/
public BinaryHprofReader(InputStream inputStream) throws IOException {
this.in = new DataInputStream(inputStream);
}
public boolean getStrict () {
return strict;
}
public void setStrict (boolean strict) {
if (version != null) {
throw new IllegalStateException("cannot set strict after read()");
}
this.strict = strict;
}
/**
* throws IllegalStateException if read() has not been called.
*/
private void checkRead() {
if (version == null) {
throw new IllegalStateException("data access before read()");
}
}
public String getVersion() {
checkRead();
return version;
}
public HprofData getHprofData() {
checkRead();
return hprofData;
}
/**
* Read the hprof header and records from the input
*/
public void read() throws IOException {
parseHeader();
parseRecords();
}
private void parseHeader() throws IOException {
if (TRACE) {
System.out.println("hprofTag=HEADER");
}
parseVersion();
parseIdSize();
parseTime();
}
private void parseVersion() throws IOException {
String version = BinaryHprof.readMagic(in);
if (version == null) {
throw new MalformedHprofException("Could not find HPROF version");
}
if (TRACE) {
System.out.println("\tversion=" + version);
}
this.version = version;
}
private void parseIdSize() throws IOException {
int idSize = in.readInt();
if (TRACE) {
System.out.println("\tidSize=" + idSize);
}
if (idSize != BinaryHprof.ID_SIZE) {
throw new MalformedHprofException("Unsupported identifier size: " + idSize);
}
}
private void parseTime() throws IOException {
long time = in.readLong();
if (TRACE) {
System.out.println("\ttime=" + Long.toHexString(time) + " " + new Date(time));
}
hprofData.setStartMillis(time);
}
private void parseRecords() throws IOException {
while (parseRecord()) {
;
}
}
/**
* Read and process the next record. Returns true if a
* record was handled, false on EOF.
*/
private boolean parseRecord() throws IOException {
int tagOrEOF = in.read();
if (tagOrEOF == -1) {
return false;
}
byte tag = (byte) tagOrEOF;
int timeDeltaInMicroseconds = in.readInt();
int recordLength = in.readInt();
BinaryHprof.Tag hprofTag = BinaryHprof.Tag.get(tag);
if (TRACE) {
System.out.println("hprofTag=" + hprofTag);
}
if (hprofTag == null) {
skipRecord(hprofTag, recordLength);
return true;
}
String error = hprofTag.checkSize(recordLength);
if (error != null) {
throw new MalformedHprofException(error);
}
switch (hprofTag) {
case CONTROL_SETTINGS:
parseControlSettings();
return true;
case STRING_IN_UTF8:
parseStringInUtf8(recordLength);
return true;
case START_THREAD:
parseStartThread();
return true;
case END_THREAD:
parseEndThread();
return true;
case LOAD_CLASS:
parseLoadClass();
return true;
case STACK_FRAME:
parseStackFrame();
return true;
case STACK_TRACE:
parseStackTrace(recordLength);
return true;
case CPU_SAMPLES:
parseCpuSamples(recordLength);
return true;
case UNLOAD_CLASS:
case ALLOC_SITES:
case HEAP_SUMMARY:
case HEAP_DUMP:
case HEAP_DUMP_SEGMENT:
case HEAP_DUMP_END:
default:
skipRecord(hprofTag, recordLength);
return true;
}
}
private void skipRecord(BinaryHprof.Tag hprofTag, long recordLength) throws IOException {
if (TRACE) {
System.out.println("\tskipping recordLength=" + recordLength);
}
long skipped = in.skip(recordLength);
if (skipped != recordLength) {
throw new EOFException("Expected to skip " + recordLength
+ " bytes but only skipped " + skipped + " bytes");
}
}
private void parseControlSettings() throws IOException {
int flags = in.readInt();
short depth = in.readShort();
if (TRACE) {
System.out.println("\tflags=" + Integer.toHexString(flags));
System.out.println("\tdepth=" + depth);
}
hprofData.setFlags(flags);
hprofData.setDepth(depth);
}
private void parseStringInUtf8(int recordLength) throws IOException {
int stringId = in.readInt();
byte[] bytes = new byte[recordLength - BinaryHprof.ID_SIZE];
readFully(in, bytes);
String string = new String(bytes, "UTF-8");
if (TRACE) {
System.out.println("\tstring=" + string);
}
String old = idToString.put(stringId, string);
if (old != null) {
throw new MalformedHprofException("Duplicate string id: " + stringId);
}
}
private static void readFully(InputStream in, byte[] dst) throws IOException {
int offset = 0;
int byteCount = dst.length;
while (byteCount > 0) {
int bytesRead = in.read(dst, offset, byteCount);
if (bytesRead < 0) {
throw new EOFException();
}
offset += bytesRead;
byteCount -= bytesRead;
}
}
private void parseLoadClass() throws IOException {
int classId = in.readInt();
int classObjectId = readId();
// serial number apparently not a stack trace id. (int vs ID)
// we don't use this field.
int stackTraceSerialNumber = in.readInt();
String className = readString();
if (TRACE) {
System.out.println("\tclassId=" + classId);
System.out.println("\tclassObjectId=" + classObjectId);
System.out.println("\tstackTraceSerialNumber=" + stackTraceSerialNumber);
System.out.println("\tclassName=" + className);
}
String old = idToClassName.put(classId, className);
if (old != null) {
throw new MalformedHprofException("Duplicate class id: " + classId);
}
}
private int readId() throws IOException {
return in.readInt();
}
private String readString() throws IOException {
int id = readId();
if (id == 0) {
return null;
}
String string = idToString.get(id);
if (string == null) {
throw new MalformedHprofException("Unknown string id " + id);
}
return string;
}
private String readClass() throws IOException {
int id = readId();
String string = idToClassName.get(id);
if (string == null) {
throw new MalformedHprofException("Unknown class id " + id);
}
return string;
}
private void parseStartThread() throws IOException {
int threadId = in.readInt();
int objectId = readId();
// stack trace where thread was created.
// serial number apparently not a stack trace id. (int vs ID)
// we don't use this field.
int stackTraceSerialNumber = in.readInt();
String threadName = readString();
String groupName = readString();
String parentGroupName = readString();
if (TRACE) {
System.out.println("\tthreadId=" + threadId);
System.out.println("\tobjectId=" + objectId);
System.out.println("\tstackTraceSerialNumber=" + stackTraceSerialNumber);
System.out.println("\tthreadName=" + threadName);
System.out.println("\tgroupName=" + groupName);
System.out.println("\tparentGroupName=" + parentGroupName);
}
HprofData.ThreadEvent event
= HprofData.ThreadEvent.start(objectId, threadId,
threadName, groupName, parentGroupName);
hprofData.addThreadEvent(event);
}
private void parseEndThread() throws IOException {
int threadId = in.readInt();
if (TRACE) {
System.out.println("\tthreadId=" + threadId);
}
HprofData.ThreadEvent event = HprofData.ThreadEvent.end(threadId);
hprofData.addThreadEvent(event);
}
private void parseStackFrame() throws IOException {
int stackFrameId = readId();
String methodName = readString();
String methodSignature = readString();
String file = readString();
String className = readClass();
int line = in.readInt();
if (TRACE) {
System.out.println("\tstackFrameId=" + stackFrameId);
System.out.println("\tclassName=" + className);
System.out.println("\tmethodName=" + methodName);
System.out.println("\tmethodSignature=" + methodSignature);
System.out.println("\tfile=" + file);
System.out.println("\tline=" + line);
}
StackTraceElement stackFrame = new StackTraceElement(className, methodName, file, line);
StackTraceElement old = idToStackFrame.put(stackFrameId, stackFrame);
if (old != null) {
throw new MalformedHprofException("Duplicate stack frame id: " + stackFrameId);
}
}
private void parseStackTrace(int recordLength) throws IOException {
int stackTraceId = in.readInt();
int threadId = in.readInt();
int frames = in.readInt();
if (TRACE) {
System.out.println("\tstackTraceId=" + stackTraceId);
System.out.println("\tthreadId=" + threadId);
System.out.println("\tframes=" + frames);
}
int expectedLength = 4 + 4 + 4 + (frames * BinaryHprof.ID_SIZE);
if (recordLength != expectedLength) {
throw new MalformedHprofException("Expected stack trace record of size "
+ expectedLength
+ " based on number of frames but header "
+ "specified a length of " + recordLength);
}
StackTraceElement[] stackFrames = new StackTraceElement[frames];
for (int i = 0; i < frames; i++) {
int stackFrameId = readId();
StackTraceElement stackFrame = idToStackFrame.get(stackFrameId);
if (TRACE) {
System.out.println("\tstackFrameId=" + stackFrameId);
System.out.println("\tstackFrame=" + stackFrame);
}
if (stackFrame == null) {
throw new MalformedHprofException("Unknown stack frame id " + stackFrameId);
}
stackFrames[i] = stackFrame;
}
HprofData.StackTrace stackTrace
= new HprofData.StackTrace(stackTraceId, threadId, stackFrames);
if (strict) {
hprofData.addStackTrace(stackTrace, new int[1]);
} else {
// The RI can have duplicate stacks, presumably they
// have a minor race if two samples with the same
// stack are taken around the same time. if we have a
// duplicate, just skip adding it to hprofData, but
// register it locally in idToStackFrame. if it seen
// in CPU_SAMPLES, we will find a StackTrace is equal
// to the first, so they will share a countCell.
int[] countCell = stackTraces.get(stackTrace);
if (countCell == null) {
hprofData.addStackTrace(stackTrace, new int[1]);
}
}
HprofData.StackTrace old = idToStackTrace.put(stackTraceId, stackTrace);
if (old != null) {
throw new MalformedHprofException("Duplicate stack trace id: " + stackTraceId);
}
}
private void parseCpuSamples(int recordLength) throws IOException {
int totalSamples = in.readInt();
int samplesCount = in.readInt();
if (TRACE) {
System.out.println("\ttotalSamples=" + totalSamples);
System.out.println("\tsamplesCount=" + samplesCount);
}
int expectedLength = 4 + 4 + (samplesCount * (4 + 4));
if (recordLength != expectedLength) {
throw new MalformedHprofException("Expected CPU samples record of size "
+ expectedLength
+ " based on number of samples but header "
+ "specified a length of " + recordLength);
}
int total = 0;
for (int i = 0; i < samplesCount; i++) {
int count = in.readInt();
int stackTraceId = in.readInt();
if (TRACE) {
System.out.println("\tcount=" + count);
System.out.println("\tstackTraceId=" + stackTraceId);
}
HprofData.StackTrace stackTrace = idToStackTrace.get(stackTraceId);
if (stackTrace == null) {
throw new MalformedHprofException("Unknown stack trace id " + stackTraceId);
}
if (count == 0) {
throw new MalformedHprofException("Zero sample count for stack trace "
+ stackTrace);
}
int[] countCell = stackTraces.get(stackTrace);
if (strict) {
if (countCell[0] != 0) {
throw new MalformedHprofException("Setting sample count of stack trace "
+ stackTrace + " to " + count
+ " found it was already initialized to "
+ countCell[0]);
}
} else {
// Coalesce counts from duplicate stack traces.
// For more on this, see comments in parseStackTrace.
count += countCell[0];
}
countCell[0] = count;
total += count;
}
if (strict && totalSamples != total) {
throw new MalformedHprofException("Expected a total of " + totalSamples
+ " samples but saw " + total);
}
}
}