dalvik/src/main/java/dalvik/system/profiler/HprofData.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.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map.Entry;
 import java.util.Map;
 import java.util.Set;

 /**
  * Represents sampling profiler data. Can be converted to ASCII or
  * binary hprof-style output using {@link AsciiHprofWriter} or
  * {@link BinaryHprofWriter}.
  * <p>
  * The data includes:
  * <ul>
  * <li>the start time of the last sampling period
  * <li>the history of thread start and end events
  * <li>stack traces with frequency counts
  * <ul>
  */
 public final class HprofData {

     public static enum ThreadEventType { START, END };

     /**
      * ThreadEvent represents thread creation and death events for
      * reporting. It provides a record of the thread and thread group
      * names for tying samples back to their source thread.
      */
     public static final class ThreadEvent {

         public final ThreadEventType type;
         public final int objectId;
         public final int threadId;
         public final String threadName;
         public final String groupName;
         public final String parentGroupName;

         public static ThreadEvent start(int objectId, int threadId, String threadName,
                                         String groupName, String parentGroupName) {
             return new ThreadEvent(ThreadEventType.START, objectId, threadId,
                                    threadName, groupName, parentGroupName);
         }

         public static ThreadEvent end(int threadId) {
             return new ThreadEvent(ThreadEventType.END, threadId);
         }

         private ThreadEvent(ThreadEventType type, int objectId, int threadId,
                             String threadName, String groupName, String parentGroupName) {
             if (threadName == null) {
                 throw new NullPointerException("threadName == null");
             }
             this.type = ThreadEventType.START;
             this.objectId = objectId;
             this.threadId = threadId;
             this.threadName = threadName;
             this.groupName = groupName;
             this.parentGroupName = parentGroupName;
         }

         private ThreadEvent(ThreadEventType type, int threadId) {
             this.type = ThreadEventType.END;
             this.objectId = -1;
             this.threadId = threadId;
             this.threadName = null;
             this.groupName = null;
             this.parentGroupName = null;
         }

         @Override public int hashCode() {
             int result = 17;
             result = 31 * result + objectId;
             result = 31 * result + threadId;
             result = 31 * result + hashCode(threadName);
             result = 31 * result + hashCode(groupName);
             result = 31 * result + hashCode(parentGroupName);
             return result;
         }

         private static int hashCode(Object o) {
             return (o == null) ? 0 : o.hashCode();
         }

         @Override public boolean equals(Object o) {
             if (!(o instanceof ThreadEvent)) {
                 return false;
             }
             ThreadEvent event = (ThreadEvent) o;
             return (this.type == event.type
                     && this.objectId == event.objectId
                     && this.threadId == event.threadId
                     && equal(this.threadName, event.threadName)
                     && equal(this.groupName, event.groupName)
                     && equal(this.parentGroupName, event.parentGroupName));
         }

         private static boolean equal(Object a, Object b) {
             return a == b || (a != null && a.equals(b));
         }

         @Override public String toString() {
             switch (type) {
                 case START:
                     return String.format(
                             "THREAD START (obj=%d, id = %d, name=\"%s\", group=\"%s\")",
                             objectId, threadId, threadName, groupName);
                 case END:
                     return String.format("THREAD END (id = %d)", threadId);
             }
             throw new IllegalStateException(type.toString());
         }
     }

     /**
      * A unique stack trace for a specific thread.
      */
     public static final class StackTrace {

         public final int stackTraceId;
         int threadId;
         StackTraceElement[] stackFrames;

         StackTrace() {
             this.stackTraceId = -1;
         }

         public StackTrace(int stackTraceId, int threadId, StackTraceElement[] stackFrames) {
             if (stackFrames == null) {
                 throw new NullPointerException("stackFrames == null");
             }
             this.stackTraceId = stackTraceId;
             this.threadId = threadId;
             this.stackFrames = stackFrames;
         }

         public int getThreadId() {
             return threadId;
         }

         public StackTraceElement[] getStackFrames() {
             return stackFrames;
         }

         @Override public int hashCode() {
             int result = 17;
             result = 31 * result + threadId;
             result = 31 * result + Arrays.hashCode(stackFrames);
             return result;
         }

         @Override public boolean equals(Object o) {
             if (!(o instanceof StackTrace)) {
                 return false;
             }
             StackTrace s = (StackTrace) o;
             return threadId == s.threadId && Arrays.equals(stackFrames, s.stackFrames);
         }

         @Override public String toString() {
             StringBuilder frames = new StringBuilder();
             if (stackFrames.length > 0) {
                 frames.append('\n');
                 for (StackTraceElement stackFrame : stackFrames) {
                     frames.append("\t at ");
                     frames.append(stackFrame);
                     frames.append('\n');
                 }
             } else {
                 frames.append("<empty>");
             }
             return "StackTrace[stackTraceId=" + stackTraceId
                     + ", threadId=" + threadId
                     + ", frames=" + frames + "]";

         }
     }

     /**
      * A read only container combining a stack trace with its frequency.
      */
     public static final class Sample {

         public final StackTrace stackTrace;
         public final int count;

         private Sample(StackTrace stackTrace, int count) {
             if (stackTrace == null) {
                 throw new NullPointerException("stackTrace == null");
             }
             if (count < 0) {
                 throw new IllegalArgumentException("count < 0:" + count);
             }
             this.stackTrace = stackTrace;
             this.count = count;
         }

         @Override public int hashCode() {
             int result = 17;
             result = 31 * result + stackTrace.hashCode();
             result = 31 * result + count;
             return result;
         }

         @Override public boolean equals(Object o) {
             if (!(o instanceof Sample)) {
                 return false;
             }
             Sample s = (Sample) o;
             return count == s.count && stackTrace.equals(s.stackTrace);
         }

         @Override public String toString() {
             return "Sample[count=" + count + " " + stackTrace + "]";
         }

     }

     /**
      * Start of last sampling period.
      */
     private long startMillis;

     /**
      * CONTROL_SETTINGS flags
      */
     private int flags;

     /**
      * stack sampling depth
      */
     private int depth;

     /**
      * List of thread creation and death events.
      */
     private final List<ThreadEvent> threadHistory = new ArrayList<ThreadEvent>();

     /**
      * Map of thread id to a start ThreadEvent
      */
     private final Map<Integer, ThreadEvent> threadIdToThreadEvent
             = new HashMap<Integer, ThreadEvent>();

     /**
      * Map of stack traces to a mutable sample count. The map is
      * provided by the creator of the HprofData so only have
      * mutable access to the int[] cells that contain the sample
      * count. Only an unmodifiable iterator view is available to
      * users of the HprofData.
      */
     private final Map<HprofData.StackTrace, int[]> stackTraces;

     public HprofData(Map<StackTrace, int[]> stackTraces) {
         if (stackTraces == null) {
             throw new NullPointerException("stackTraces == null");
         }
         this.stackTraces = stackTraces;
     }

     /**
      * The start time in milliseconds of the last profiling period.
      */
     public long getStartMillis() {
         return startMillis;
     }

     /**
      * Set the time for the start of the current sampling period.
      */
     public void setStartMillis(long startMillis) {
         this.startMillis = startMillis;
     }

     /**
      * Get the {@link BinaryHprof.ControlSettings} flags
      */
     public int getFlags() {
         return flags;
     }

     /**
      * Set the {@link BinaryHprof.ControlSettings} flags
      */
     public void setFlags(int flags) {
         this.flags = flags;
     }

     /**
      * Get the stack sampling depth
      */
     public int getDepth() {
         return depth;
     }

     /**
      * Set the stack sampling depth
      */
     public void setDepth(int depth) {
         this.depth = depth;
     }

     /**
      * Return an unmodifiable history of start and end thread events.
      */
     public List<ThreadEvent> getThreadHistory() {
         return Collections.unmodifiableList(threadHistory);
     }

     /**
      * Return a new set containing the current sample data.
      */
     public Set<Sample> getSamples() {
         Set<Sample> samples = new HashSet<Sample>(stackTraces.size());
         for (Entry<StackTrace, int[]> e : stackTraces.entrySet()) {
             StackTrace stackTrace = e.getKey();
             int countCell[] = e.getValue();
             int count = countCell[0];
             Sample sample = new Sample(stackTrace, count);
             samples.add(sample);
         }
         return samples;
     }

     /**
      * Record an event in the thread history.
      */
     public void addThreadEvent(ThreadEvent event) {
         if (event == null) {
             throw new NullPointerException("event == null");
         }
         ThreadEvent old = threadIdToThreadEvent.put(event.threadId, event);
         switch (event.type) {
             case START:
                 if (old != null) {
                     throw new IllegalArgumentException("ThreadEvent already registered for id "
                                                        + event.threadId);
                 }
                 break;
             case END:
                 // Do not assert that the END_THREAD matches a
                 // START_THREAD unless in strict mode. While thhis
                 // hold true in the binary hprof BinaryHprofWriter
                 // produces, it is not true of hprof files created
                 // by the RI. However, if there is an event
                 // already registed for a thread id, it should be
                 // the matching start, not a duplicate end.
                 if (old != null && old.type == ThreadEventType.END) {
                     throw new IllegalArgumentException("Duplicate ThreadEvent.end for id "
                                                        + event.threadId);
                 }
                 break;
         }
         threadHistory.add(event);
     }

     /**
      * Record an stack trace and an associated int[] cell of
      * sample cound for the stack trace. The caller is allowed
      * retain a pointer to the cell to update the count. The
      * SamplingProfiler intentionally does not present a mutable
      * view of the count.
      */
     public void addStackTrace(StackTrace stackTrace, int[] countCell) {
         if (!threadIdToThreadEvent.containsKey(stackTrace.threadId)) {
             throw new IllegalArgumentException("Unknown thread id " + stackTrace.threadId);
         }
         int[] old = stackTraces.put(stackTrace, countCell);
         if (old != null) {
             throw new IllegalArgumentException("StackTrace already registered for id "
                                                + stackTrace.stackTraceId + ":\n" + stackTrace);
         }
     }
 }
	/*
	* 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.util.ArrayList;
	import java.util.Arrays;
	import java.util.Collections;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.List;
	import java.util.Map.Entry;
	import java.util.Map;
	import java.util.Set;

	/**
	* Represents sampling profiler data. Can be converted to ASCII or
	* binary hprof-style output using {@link AsciiHprofWriter} or
	* {@link BinaryHprofWriter}.
	* <p>
	* The data includes:
	* <ul>
	* <li>the start time of the last sampling period
	* <li>the history of thread start and end events
	* <li>stack traces with frequency counts
	* <ul>
	*/
	public final class HprofData {

	public static enum ThreadEventType { START, END };

	/**
	* ThreadEvent represents thread creation and death events for
	* reporting. It provides a record of the thread and thread group
	* names for tying samples back to their source thread.
	*/
	public static final class ThreadEvent {

	public final ThreadEventType type;
	public final int objectId;
	public final int threadId;
	public final String threadName;
	public final String groupName;
	public final String parentGroupName;

	public static ThreadEvent start(int objectId, int threadId, String threadName,
	String groupName, String parentGroupName) {
	return new ThreadEvent(ThreadEventType.START, objectId, threadId,
	threadName, groupName, parentGroupName);
	}

	public static ThreadEvent end(int threadId) {
	return new ThreadEvent(ThreadEventType.END, threadId);
	}

	private ThreadEvent(ThreadEventType type, int objectId, int threadId,
	String threadName, String groupName, String parentGroupName) {
	if (threadName == null) {
	throw new NullPointerException("threadName == null");
	}
	this.type = ThreadEventType.START;
	this.objectId = objectId;
	this.threadId = threadId;
	this.threadName = threadName;
	this.groupName = groupName;
	this.parentGroupName = parentGroupName;
	}

	private ThreadEvent(ThreadEventType type, int threadId) {
	this.type = ThreadEventType.END;
	this.objectId = -1;
	this.threadId = threadId;
	this.threadName = null;
	this.groupName = null;
	this.parentGroupName = null;
	}

	@Override public int hashCode() {
	int result = 17;
	result = 31 * result + objectId;
	result = 31 * result + threadId;
	result = 31 * result + hashCode(threadName);
	result = 31 * result + hashCode(groupName);
	result = 31 * result + hashCode(parentGroupName);
	return result;
	}

	private static int hashCode(Object o) {
	return (o == null) ? 0 : o.hashCode();
	}

	@Override public boolean equals(Object o) {
	if (!(o instanceof ThreadEvent)) {
	return false;
	}
	ThreadEvent event = (ThreadEvent) o;
	return (this.type == event.type
	&& this.objectId == event.objectId
	&& this.threadId == event.threadId
	&& equal(this.threadName, event.threadName)
	&& equal(this.groupName, event.groupName)
	&& equal(this.parentGroupName, event.parentGroupName));
	}

	private static boolean equal(Object a, Object b) {
	return a == b \|\| (a != null && a.equals(b));
	}

	@Override public String toString() {
	switch (type) {
	case START:
	return String.format(
	"THREAD START (obj=%d, id = %d, name=\"%s\", group=\"%s\")",
	objectId, threadId, threadName, groupName);
	case END:
	return String.format("THREAD END (id = %d)", threadId);
	}
	throw new IllegalStateException(type.toString());
	}
	}

	/**
	* A unique stack trace for a specific thread.
	*/
	public static final class StackTrace {

	public final int stackTraceId;
	int threadId;
	StackTraceElement[] stackFrames;

	StackTrace() {
	this.stackTraceId = -1;
	}

	public StackTrace(int stackTraceId, int threadId, StackTraceElement[] stackFrames) {
	if (stackFrames == null) {
	throw new NullPointerException("stackFrames == null");
	}
	this.stackTraceId = stackTraceId;
	this.threadId = threadId;
	this.stackFrames = stackFrames;
	}

	public int getThreadId() {
	return threadId;
	}

	public StackTraceElement[] getStackFrames() {
	return stackFrames;
	}

	@Override public int hashCode() {
	int result = 17;
	result = 31 * result + threadId;
	result = 31 * result + Arrays.hashCode(stackFrames);
	return result;
	}

	@Override public boolean equals(Object o) {
	if (!(o instanceof StackTrace)) {
	return false;
	}
	StackTrace s = (StackTrace) o;
	return threadId == s.threadId && Arrays.equals(stackFrames, s.stackFrames);
	}

	@Override public String toString() {
	StringBuilder frames = new StringBuilder();
	if (stackFrames.length > 0) {
	frames.append('\n');
	for (StackTraceElement stackFrame : stackFrames) {
	frames.append("\t at ");
	frames.append(stackFrame);
	frames.append('\n');
	}
	} else {
	frames.append("<empty>");
	}
	return "StackTrace[stackTraceId=" + stackTraceId
	+ ", threadId=" + threadId
	+ ", frames=" + frames + "]";

	}
	}

	/**
	* A read only container combining a stack trace with its frequency.
	*/
	public static final class Sample {

	public final StackTrace stackTrace;
	public final int count;

	private Sample(StackTrace stackTrace, int count) {
	if (stackTrace == null) {
	throw new NullPointerException("stackTrace == null");
	}
	if (count < 0) {
	throw new IllegalArgumentException("count < 0:" + count);
	}
	this.stackTrace = stackTrace;
	this.count = count;
	}

	@Override public int hashCode() {
	int result = 17;
	result = 31 * result + stackTrace.hashCode();
	result = 31 * result + count;
	return result;
	}

	@Override public boolean equals(Object o) {
	if (!(o instanceof Sample)) {
	return false;
	}
	Sample s = (Sample) o;
	return count == s.count && stackTrace.equals(s.stackTrace);
	}

	@Override public String toString() {
	return "Sample[count=" + count + " " + stackTrace + "]";
	}

	}

	/**
	* Start of last sampling period.
	*/
	private long startMillis;

	/**
	* CONTROL_SETTINGS flags
	*/
	private int flags;

	/**
	* stack sampling depth
	*/
	private int depth;

	/**
	* List of thread creation and death events.
	*/
	private final List<ThreadEvent> threadHistory = new ArrayList<ThreadEvent>();

	/**
	* Map of thread id to a start ThreadEvent
	*/
	private final Map<Integer, ThreadEvent> threadIdToThreadEvent
	= new HashMap<Integer, ThreadEvent>();

	/**
	* Map of stack traces to a mutable sample count. The map is
	* provided by the creator of the HprofData so only have
	* mutable access to the int[] cells that contain the sample
	* count. Only an unmodifiable iterator view is available to
	* users of the HprofData.
	*/
	private final Map<HprofData.StackTrace, int[]> stackTraces;

	public HprofData(Map<StackTrace, int[]> stackTraces) {
	if (stackTraces == null) {
	throw new NullPointerException("stackTraces == null");
	}
	this.stackTraces = stackTraces;
	}

	/**
	* The start time in milliseconds of the last profiling period.
	*/
	public long getStartMillis() {
	return startMillis;
	}

	/**
	* Set the time for the start of the current sampling period.
	*/
	public void setStartMillis(long startMillis) {
	this.startMillis = startMillis;
	}

	/**
	* Get the {@link BinaryHprof.ControlSettings} flags
	*/
	public int getFlags() {
	return flags;
	}

	/**
	* Set the {@link BinaryHprof.ControlSettings} flags
	*/
	public void setFlags(int flags) {
	this.flags = flags;
	}

	/**
	* Get the stack sampling depth
	*/
	public int getDepth() {
	return depth;
	}

	/**
	* Set the stack sampling depth
	*/
	public void setDepth(int depth) {
	this.depth = depth;
	}

	/**
	* Return an unmodifiable history of start and end thread events.
	*/
	public List<ThreadEvent> getThreadHistory() {
	return Collections.unmodifiableList(threadHistory);
	}

	/**
	* Return a new set containing the current sample data.
	*/
	public Set<Sample> getSamples() {
	Set<Sample> samples = new HashSet<Sample>(stackTraces.size());
	for (Entry<StackTrace, int[]> e : stackTraces.entrySet()) {
	StackTrace stackTrace = e.getKey();
	int countCell[] = e.getValue();
	int count = countCell[0];
	Sample sample = new Sample(stackTrace, count);
	samples.add(sample);
	}
	return samples;
	}

	/**
	* Record an event in the thread history.
	*/
	public void addThreadEvent(ThreadEvent event) {
	if (event == null) {
	throw new NullPointerException("event == null");
	}
	ThreadEvent old = threadIdToThreadEvent.put(event.threadId, event);
	switch (event.type) {
	case START:
	if (old != null) {
	throw new IllegalArgumentException("ThreadEvent already registered for id "
	+ event.threadId);
	}
	break;
	case END:
	// Do not assert that the END_THREAD matches a
	// START_THREAD unless in strict mode. While thhis
	// hold true in the binary hprof BinaryHprofWriter
	// produces, it is not true of hprof files created
	// by the RI. However, if there is an event
	// already registed for a thread id, it should be
	// the matching start, not a duplicate end.
	if (old != null && old.type == ThreadEventType.END) {
	throw new IllegalArgumentException("Duplicate ThreadEvent.end for id "
	+ event.threadId);
	}
	break;
	}
	threadHistory.add(event);
	}

	/**
	* Record an stack trace and an associated int[] cell of
	* sample cound for the stack trace. The caller is allowed
	* retain a pointer to the cell to update the count. The
	* SamplingProfiler intentionally does not present a mutable
	* view of the count.
	*/
	public void addStackTrace(StackTrace stackTrace, int[] countCell) {
	if (!threadIdToThreadEvent.containsKey(stackTrace.threadId)) {
	throw new IllegalArgumentException("Unknown thread id " + stackTrace.threadId);
	}
	int[] old = stackTraces.put(stackTrace, countCell);
	if (old != null) {
	throw new IllegalArgumentException("StackTrace already registered for id "
	+ stackTrace.stackTraceId + ":\n" + stackTrace);
	}
	}
	}