dalvik/src/main/java/dalvik/system/profiler/BinaryHprofWriter.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.DataOutputStream;
 import java.io.IOException;
 import java.io.OutputStream;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Set;

 /**
  * BinaryHprofWriter produces hprof compatible binary output for use
  * with third party tools. Such files can be converted to text with
  * with {@link HprofBinaryToAscii} or read back in with {@link BinaryHprofReader}.
  */
 public final class BinaryHprofWriter {

     private int nextStringId = 1; // id 0 => null
     private int nextClassId = 1;
     private int nextStackFrameId = 1;
     private final Map<String, Integer> stringToId = new HashMap<String, Integer>();
     private final Map<String, Integer> classNameToId = new HashMap<String, Integer>();
     private final Map<StackTraceElement, Integer> stackFrameToId
             = new HashMap<StackTraceElement, Integer>();

     private final HprofData data;
     private final DataOutputStream out;

     /**
      * Writes the provided data to the specified stream.
      */
     public static void write(HprofData data, OutputStream outputStream) throws IOException {
         new BinaryHprofWriter(data, outputStream).write();
     }

     private BinaryHprofWriter(HprofData data, OutputStream outputStream) {
         this.data = data;
         this.out = new DataOutputStream(outputStream);
     }

     private void write() throws IOException {
         try {
             writeHeader(data.getStartMillis());

             writeControlSettings(data.getFlags(), data.getDepth());

             for (HprofData.ThreadEvent event : data.getThreadHistory()) {
                 writeThreadEvent(event);
             }

             Set<HprofData.Sample> samples = data.getSamples();
             int total = 0;
             for (HprofData.Sample sample : samples) {
                 total += sample.count;
                 writeStackTrace(sample.stackTrace);
             }
             writeCpuSamples(total, samples);

         } finally {
             out.flush();
         }
     }

     private void writeHeader(long dumpTimeInMilliseconds) throws IOException {
         out.writeBytes(BinaryHprof.MAGIC + "1.0.2");
         out.writeByte(0); // null terminated string
         out.writeInt(BinaryHprof.ID_SIZE);
         out.writeLong(dumpTimeInMilliseconds);
     }

     private void writeControlSettings(int flags, int depth) throws IOException {
         if (depth > Short.MAX_VALUE) {
             throw new IllegalArgumentException("depth too large for binary hprof: "
                                                + depth + " > " + Short.MAX_VALUE);
         }
         writeRecordHeader(BinaryHprof.Tag.CONTROL_SETTINGS,
                           0,
                           BinaryHprof.Tag.CONTROL_SETTINGS.maximumSize);
         out.writeInt(flags);
         out.writeShort((short) depth);
     }

     private void writeThreadEvent(HprofData.ThreadEvent e) throws IOException {
         switch (e.type) {
             case START:
                 writeStartThread(e);
                 return;
             case END:
                 writeStopThread(e);
                 return;
         }
         throw new IllegalStateException(e.type.toString());
     }

     private void writeStartThread(HprofData.ThreadEvent e) throws IOException {
         int threadNameId = writeString(e.threadName);
         int groupNameId = writeString(e.groupName);
         int parentGroupNameId = writeString(e.parentGroupName);
         writeRecordHeader(BinaryHprof.Tag.START_THREAD,
                           0,
                           BinaryHprof.Tag.START_THREAD.maximumSize);
         out.writeInt(e.threadId);
         writeId(e.objectId);
         out.writeInt(0); // stack trace where thread was started unavailable
         writeId(threadNameId);
         writeId(groupNameId);
         writeId(parentGroupNameId);
     }

     private void writeStopThread(HprofData.ThreadEvent e) throws IOException {
         writeRecordHeader(BinaryHprof.Tag.END_THREAD,
                           0,
                           BinaryHprof.Tag.END_THREAD.maximumSize);
         out.writeInt(e.threadId);
     }

     private void writeRecordHeader(BinaryHprof.Tag hprofTag,
                                    int timeDeltaInMicroseconds,
                                    int recordLength) throws IOException {
         String error = hprofTag.checkSize(recordLength);
         if (error != null) {
             throw new AssertionError(error);
         }
         out.writeByte(hprofTag.tag);
         out.writeInt(timeDeltaInMicroseconds);
         out.writeInt(recordLength);
     }

     private void writeId(int id) throws IOException {
         out.writeInt(id);
     }

     /**
      * Ensures that a string has been writen to the out and
      * returns its ID. The ID of a null string is zero, and
      * doesn't actually result in any output. In a string has
      * already been written previously, the earlier ID will be
      * returned and no output will be written.
      */
     private int writeString(String string) throws IOException {
         if (string == null) {
             return 0;
         }
         Integer identifier = stringToId.get(string);
         if (identifier != null) {
             return identifier;
         }

         int id = nextStringId++;
         stringToId.put(string, id);

         byte[] bytes = string.getBytes("UTF-8");
         writeRecordHeader(BinaryHprof.Tag.STRING_IN_UTF8,
                           0,
                           BinaryHprof.ID_SIZE + bytes.length);
         out.writeInt(id);
         out.write(bytes, 0, bytes.length);

         return id;
     }

     private void writeCpuSamples(int totalSamples, Set<HprofData.Sample> samples)
             throws IOException {
         int samplesCount = samples.size();
         if (samplesCount == 0) {
             return;
         }
         writeRecordHeader(BinaryHprof.Tag.CPU_SAMPLES, 0, 4 + 4 + (samplesCount * (4 + 4)));
         out.writeInt(totalSamples);
         out.writeInt(samplesCount);
         for (HprofData.Sample sample : samples) {
             out.writeInt(sample.count);
             out.writeInt(sample.stackTrace.stackTraceId);
         }
     }

     private void writeStackTrace(HprofData.StackTrace stackTrace) throws IOException {
         int frames = stackTrace.stackFrames.length;
         int[] stackFrameIds = new int[frames];
         for (int i = 0; i < frames; i++) {
             stackFrameIds[i] = writeStackFrame(stackTrace.stackFrames[i]);
         }
         writeRecordHeader(BinaryHprof.Tag.STACK_TRACE,
                           0,
                           4 + 4 + 4 + (frames * BinaryHprof.ID_SIZE));
         out.writeInt(stackTrace.stackTraceId);
         out.writeInt(stackTrace.threadId);
         out.writeInt(frames);
         for (int stackFrameId : stackFrameIds) {
             writeId(stackFrameId);
         }
     }

     private int writeLoadClass(String className) throws IOException {
         Integer identifier = classNameToId.get(className);
         if (identifier != null) {
             return identifier;
         }
         int id = nextClassId++;
         classNameToId.put(className, id);

         int classNameId = writeString(className);
         writeRecordHeader(BinaryHprof.Tag.LOAD_CLASS,
                           0,
                           BinaryHprof.Tag.LOAD_CLASS.maximumSize);
         out.writeInt(id);
         writeId(0); // class object ID
         out.writeInt(0); // stack trace where class was loaded is unavailable
         writeId(classNameId);

         return id;
     }

     private int writeStackFrame(StackTraceElement stackFrame) throws IOException {
         Integer identifier = stackFrameToId.get(stackFrame);
         if (identifier != null) {
             return identifier;
         }

         int id = nextStackFrameId++;
         stackFrameToId.put(stackFrame, id);

         int classId = writeLoadClass(stackFrame.getClassName());
         int methodNameId = writeString(stackFrame.getMethodName());
         int sourceId = writeString(stackFrame.getFileName());
         writeRecordHeader(BinaryHprof.Tag.STACK_FRAME,
                           0,
                           BinaryHprof.Tag.STACK_FRAME.maximumSize);
         writeId(id);
         writeId(methodNameId);
         writeId(0); // method signature is unavailable from StackTraceElement
         writeId(sourceId);
         out.writeInt(classId);
         out.writeInt(stackFrame.getLineNumber());

         return id;
     }
 }
	/*
	* 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.DataOutputStream;
	import java.io.IOException;
	import java.io.OutputStream;
	import java.util.HashMap;
	import java.util.Map;
	import java.util.Set;

	/**
	* BinaryHprofWriter produces hprof compatible binary output for use
	* with third party tools. Such files can be converted to text with
	* with {@link HprofBinaryToAscii} or read back in with {@link BinaryHprofReader}.
	*/
	public final class BinaryHprofWriter {

	private int nextStringId = 1; // id 0 => null
	private int nextClassId = 1;
	private int nextStackFrameId = 1;
	private final Map<String, Integer> stringToId = new HashMap<String, Integer>();
	private final Map<String, Integer> classNameToId = new HashMap<String, Integer>();
	private final Map<StackTraceElement, Integer> stackFrameToId
	= new HashMap<StackTraceElement, Integer>();

	private final HprofData data;
	private final DataOutputStream out;

	/**
	* Writes the provided data to the specified stream.
	*/
	public static void write(HprofData data, OutputStream outputStream) throws IOException {
	new BinaryHprofWriter(data, outputStream).write();
	}

	private BinaryHprofWriter(HprofData data, OutputStream outputStream) {
	this.data = data;
	this.out = new DataOutputStream(outputStream);
	}

	private void write() throws IOException {
	try {
	writeHeader(data.getStartMillis());

	writeControlSettings(data.getFlags(), data.getDepth());

	for (HprofData.ThreadEvent event : data.getThreadHistory()) {
	writeThreadEvent(event);
	}

	Set<HprofData.Sample> samples = data.getSamples();
	int total = 0;
	for (HprofData.Sample sample : samples) {
	total += sample.count;
	writeStackTrace(sample.stackTrace);
	}
	writeCpuSamples(total, samples);

	} finally {
	out.flush();
	}
	}

	private void writeHeader(long dumpTimeInMilliseconds) throws IOException {
	out.writeBytes(BinaryHprof.MAGIC + "1.0.2");
	out.writeByte(0); // null terminated string
	out.writeInt(BinaryHprof.ID_SIZE);
	out.writeLong(dumpTimeInMilliseconds);
	}

	private void writeControlSettings(int flags, int depth) throws IOException {
	if (depth > Short.MAX_VALUE) {
	throw new IllegalArgumentException("depth too large for binary hprof: "
	+ depth + " > " + Short.MAX_VALUE);
	}
	writeRecordHeader(BinaryHprof.Tag.CONTROL_SETTINGS,
	0,
	BinaryHprof.Tag.CONTROL_SETTINGS.maximumSize);
	out.writeInt(flags);
	out.writeShort((short) depth);
	}

	private void writeThreadEvent(HprofData.ThreadEvent e) throws IOException {
	switch (e.type) {
	case START:
	writeStartThread(e);
	return;
	case END:
	writeStopThread(e);
	return;
	}
	throw new IllegalStateException(e.type.toString());
	}

	private void writeStartThread(HprofData.ThreadEvent e) throws IOException {
	int threadNameId = writeString(e.threadName);
	int groupNameId = writeString(e.groupName);
	int parentGroupNameId = writeString(e.parentGroupName);
	writeRecordHeader(BinaryHprof.Tag.START_THREAD,
	0,
	BinaryHprof.Tag.START_THREAD.maximumSize);
	out.writeInt(e.threadId);
	writeId(e.objectId);
	out.writeInt(0); // stack trace where thread was started unavailable
	writeId(threadNameId);
	writeId(groupNameId);
	writeId(parentGroupNameId);
	}

	private void writeStopThread(HprofData.ThreadEvent e) throws IOException {
	writeRecordHeader(BinaryHprof.Tag.END_THREAD,
	0,
	BinaryHprof.Tag.END_THREAD.maximumSize);
	out.writeInt(e.threadId);
	}

	private void writeRecordHeader(BinaryHprof.Tag hprofTag,
	int timeDeltaInMicroseconds,
	int recordLength) throws IOException {
	String error = hprofTag.checkSize(recordLength);
	if (error != null) {
	throw new AssertionError(error);
	}
	out.writeByte(hprofTag.tag);
	out.writeInt(timeDeltaInMicroseconds);
	out.writeInt(recordLength);
	}

	private void writeId(int id) throws IOException {
	out.writeInt(id);
	}

	/**
	* Ensures that a string has been writen to the out and
	* returns its ID. The ID of a null string is zero, and
	* doesn't actually result in any output. In a string has
	* already been written previously, the earlier ID will be
	* returned and no output will be written.
	*/
	private int writeString(String string) throws IOException {
	if (string == null) {
	return 0;
	}
	Integer identifier = stringToId.get(string);
	if (identifier != null) {
	return identifier;
	}

	int id = nextStringId++;
	stringToId.put(string, id);

	byte[] bytes = string.getBytes("UTF-8");
	writeRecordHeader(BinaryHprof.Tag.STRING_IN_UTF8,
	0,
	BinaryHprof.ID_SIZE + bytes.length);
	out.writeInt(id);
	out.write(bytes, 0, bytes.length);

	return id;
	}

	private void writeCpuSamples(int totalSamples, Set<HprofData.Sample> samples)
	throws IOException {
	int samplesCount = samples.size();
	if (samplesCount == 0) {
	return;
	}
	writeRecordHeader(BinaryHprof.Tag.CPU_SAMPLES, 0, 4 + 4 + (samplesCount * (4 + 4)));
	out.writeInt(totalSamples);
	out.writeInt(samplesCount);
	for (HprofData.Sample sample : samples) {
	out.writeInt(sample.count);
	out.writeInt(sample.stackTrace.stackTraceId);
	}
	}

	private void writeStackTrace(HprofData.StackTrace stackTrace) throws IOException {
	int frames = stackTrace.stackFrames.length;
	int[] stackFrameIds = new int[frames];
	for (int i = 0; i < frames; i++) {
	stackFrameIds[i] = writeStackFrame(stackTrace.stackFrames[i]);
	}
	writeRecordHeader(BinaryHprof.Tag.STACK_TRACE,
	0,
	4 + 4 + 4 + (frames * BinaryHprof.ID_SIZE));
	out.writeInt(stackTrace.stackTraceId);
	out.writeInt(stackTrace.threadId);
	out.writeInt(frames);
	for (int stackFrameId : stackFrameIds) {
	writeId(stackFrameId);
	}
	}

	private int writeLoadClass(String className) throws IOException {
	Integer identifier = classNameToId.get(className);
	if (identifier != null) {
	return identifier;
	}
	int id = nextClassId++;
	classNameToId.put(className, id);

	int classNameId = writeString(className);
	writeRecordHeader(BinaryHprof.Tag.LOAD_CLASS,
	0,
	BinaryHprof.Tag.LOAD_CLASS.maximumSize);
	out.writeInt(id);
	writeId(0); // class object ID
	out.writeInt(0); // stack trace where class was loaded is unavailable
	writeId(classNameId);

	return id;
	}

	private int writeStackFrame(StackTraceElement stackFrame) throws IOException {
	Integer identifier = stackFrameToId.get(stackFrame);
	if (identifier != null) {
	return identifier;
	}

	int id = nextStackFrameId++;
	stackFrameToId.put(stackFrame, id);

	int classId = writeLoadClass(stackFrame.getClassName());
	int methodNameId = writeString(stackFrame.getMethodName());
	int sourceId = writeString(stackFrame.getFileName());
	writeRecordHeader(BinaryHprof.Tag.STACK_FRAME,
	0,
	BinaryHprof.Tag.STACK_FRAME.maximumSize);
	writeId(id);
	writeId(methodNameId);
	writeId(0); // method signature is unavailable from StackTraceElement
	writeId(sourceId);
	out.writeInt(classId);
	out.writeInt(stackFrame.getLineNumber());

	return id;
	}
	}