dalvik/src/main/java/dalvik/system/profiler/BinaryHprofReader.java - platform/libcore2 - Git at Google

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