* @return the number of bytes
*/
public native long getExternalBytesAllocated();
+
+ /**
+ * Tells the VM to enable the JIT compiler. If the VM does not have a JIT
+ * implementation, calling this method should have no effect.
+ *
+ * {@hide}
+ */
+ public native void startJitCompilation();
+
}
+++ /dev/null
-/*
- * Copyright (c) 2000 World Wide Web Consortium,
- * (Massachusetts Institute of Technology, Institut National de
- * Recherche en Informatique et en Automatique, Keio University). All
- * Rights Reserved. This program is distributed under the W3C's Software
- * Intellectual Property License. This program is distributed in the
- * hope that it will be useful, but WITHOUT ANY WARRANTY; without even
- * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
- * PURPOSE.
- * See W3C License http://www.w3.org/Consortium/Legal/ for more details.
- */
-
-package org.w3c.dom.events;
-
-/**
- * The <code>Event</code> interface is used to provide contextual information
- * about an event to the handler processing the event. An object which
- * implements the <code>Event</code> interface is generally passed as the
- * first parameter to an event handler. More specific context information is
- * passed to event handlers by deriving additional interfaces from
- * <code>Event</code> which contain information directly relating to the
- * type of event they accompany. These derived interfaces are also
- * implemented by the object passed to the event listener.
- * <p>See also the <a href='http://www.w3.org/TR/2000/REC-DOM-Level-2-Events-20001113'>Document Object Model (DOM) Level 2 Events Specification</a>.
- * @since DOM Level 2
- */
-public interface Event {
- // PhaseType
- /**
- * The current event phase is the capturing phase.
- */
- public static final short CAPTURING_PHASE = 1;
- /**
- * The event is currently being evaluated at the target
- * <code>EventTarget</code>.
- */
- public static final short AT_TARGET = 2;
- /**
- * The current event phase is the bubbling phase.
- */
- public static final short BUBBLING_PHASE = 3;
-
- /**
- * The name of the event (case-insensitive). The name must be an XML name.
- */
- public String getType();
-
- /**
- * Used to indicate the <code>EventTarget</code> to which the event was
- * originally dispatched.
- */
- public EventTarget getTarget();
-
- /**
- * Used to indicate the <code>EventTarget</code> whose
- * <code>EventListeners</code> are currently being processed. This is
- * particularly useful during capturing and bubbling.
- */
- public EventTarget getCurrentTarget();
-
- /**
- * Used to indicate which phase of event flow is currently being
- * evaluated.
- */
- public short getEventPhase();
-
- /**
- * Used to indicate whether or not an event is a bubbling event. If the
- * event can bubble the value is true, else the value is false.
- */
- public boolean getBubbles();
-
- /**
- * Used to indicate whether or not an event can have its default action
- * prevented. If the default action can be prevented the value is true,
- * else the value is false.
- */
- public boolean getCancelable();
-
- /**
- * Used to specify the time (in milliseconds relative to the epoch) at
- * which the event was created. Due to the fact that some systems may
- * not provide this information the value of <code>timeStamp</code> may
- * be not available for all events. When not available, a value of 0
- * will be returned. Examples of epoch time are the time of the system
- * start or 0:0:0 UTC 1st January 1970.
- */
- public long getTimeStamp();
-
- /**
- * The <code>stopPropagation</code> method is used prevent further
- * propagation of an event during event flow. If this method is called
- * by any <code>EventListener</code> the event will cease propagating
- * through the tree. The event will complete dispatch to all listeners
- * on the current <code>EventTarget</code> before event flow stops. This
- * method may be used during any stage of event flow.
- */
- public void stopPropagation();
-
- /**
- * If an event is cancelable, the <code>preventDefault</code> method is
- * used to signify that the event is to be canceled, meaning any default
- * action normally taken by the implementation as a result of the event
- * will not occur. If, during any stage of event flow, the
- * <code>preventDefault</code> method is called the event is canceled.
- * Any default action associated with the event will not occur. Calling
- * this method for a non-cancelable event has no effect. Once
- * <code>preventDefault</code> has been called it will remain in effect
- * throughout the remainder of the event's propagation. This method may
- * be used during any stage of event flow.
- */
- public void preventDefault();
-
- /**
- * The <code>initEvent</code> method is used to initialize the value of an
- * <code>Event</code> created through the <code>DocumentEvent</code>
- * interface. This method may only be called before the
- * <code>Event</code> has been dispatched via the
- * <code>dispatchEvent</code> method, though it may be called multiple
- * times during that phase if necessary. If called multiple times the
- * final invocation takes precedence. If called from a subclass of
- * <code>Event</code> interface only the values specified in the
- * <code>initEvent</code> method are modified, all other attributes are
- * left unchanged.
- * @param eventTypeArgSpecifies the event type. This type may be any
- * event type currently defined in this specification or a new event
- * type.. The string must be an XML name. Any new event type must not
- * begin with any upper, lower, or mixed case version of the string
- * "DOM". This prefix is reserved for future DOM event sets. It is
- * also strongly recommended that third parties adding their own
- * events use their own prefix to avoid confusion and lessen the
- * probability of conflicts with other new events.
- * @param canBubbleArgSpecifies whether or not the event can bubble.
- * @param cancelableArgSpecifies whether or not the event's default
- * action can be prevented.
- */
- public void initEvent(String eventTypeArg,
- boolean canBubbleArg,
- boolean cancelableArg);
-
-}
+++ /dev/null
-/*
- * Copyright (c) 2000 World Wide Web Consortium,
- * (Massachusetts Institute of Technology, Institut National de
- * Recherche en Informatique et en Automatique, Keio University). All
- * Rights Reserved. This program is distributed under the W3C's Software
- * Intellectual Property License. This program is distributed in the
- * hope that it will be useful, but WITHOUT ANY WARRANTY; without even
- * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
- * PURPOSE.
- * See W3C License http://www.w3.org/Consortium/Legal/ for more details.
- */
-
-package org.w3c.dom.events;
-
-/**
- * Event operations may throw an <code>EventException</code> as specified in
- * their method descriptions.
- * <p>See also the <a href='http://www.w3.org/TR/2000/REC-DOM-Level-2-Events-20001113'>Document Object Model (DOM) Level 2 Events Specification</a>.
- * @since DOM Level 2
- */
-public class EventException extends RuntimeException {
- public EventException(short code, String message) {
- super(message);
- this.code = code;
- }
- public short code;
- // EventExceptionCode
- /**
- * If the <code>Event</code>'s type was not specified by initializing the
- * event before the method was called. Specification of the Event's type
- * as <code>null</code> or an empty string will also trigger this
- * exception.
- */
- public static final short UNSPECIFIED_EVENT_TYPE_ERR = 0;
-
-}
+++ /dev/null
-/*
- * Copyright (c) 2000 World Wide Web Consortium,
- * (Massachusetts Institute of Technology, Institut National de
- * Recherche en Informatique et en Automatique, Keio University). All
- * Rights Reserved. This program is distributed under the W3C's Software
- * Intellectual Property License. This program is distributed in the
- * hope that it will be useful, but WITHOUT ANY WARRANTY; without even
- * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
- * PURPOSE.
- * See W3C License http://www.w3.org/Consortium/Legal/ for more details.
- */
-
-package org.w3c.dom.events;
-
-/**
- * The <code>EventListener</code> interface is the primary method for
- * handling events. Users implement the <code>EventListener</code> interface
- * and register their listener on an <code>EventTarget</code> using the
- * <code>AddEventListener</code> method. The users should also remove their
- * <code>EventListener</code> from its <code>EventTarget</code> after they
- * have completed using the listener.
- * <p> When a <code>Node</code> is copied using the <code>cloneNode</code>
- * method the <code>EventListener</code>s attached to the source
- * <code>Node</code> are not attached to the copied <code>Node</code>. If
- * the user wishes the same <code>EventListener</code>s to be added to the
- * newly created copy the user must add them manually.
- * <p>See also the <a href='http://www.w3.org/TR/2000/REC-DOM-Level-2-Events-20001113'>Document Object Model (DOM) Level 2 Events Specification</a>.
- * @since DOM Level 2
- */
-public interface EventListener {
- /**
- * This method is called whenever an event occurs of the type for which
- * the <code> EventListener</code> interface was registered.
- * @param evt The <code>Event</code> contains contextual information
- * about the event. It also contains the <code>stopPropagation</code>
- * and <code>preventDefault</code> methods which are used in
- * determining the event's flow and default action.
- */
- public void handleEvent(Event evt);
-
-}
+++ /dev/null
-/*
- * Copyright (c) 2000 World Wide Web Consortium,
- * (Massachusetts Institute of Technology, Institut National de
- * Recherche en Informatique et en Automatique, Keio University). All
- * Rights Reserved. This program is distributed under the W3C's Software
- * Intellectual Property License. This program is distributed in the
- * hope that it will be useful, but WITHOUT ANY WARRANTY; without even
- * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
- * PURPOSE.
- * See W3C License http://www.w3.org/Consortium/Legal/ for more details.
- */
-
-package org.w3c.dom.events;
-
-/**
- * The <code>EventTarget</code> interface is implemented by all
- * <code>Nodes</code> in an implementation which supports the DOM Event
- * Model. Therefore, this interface can be obtained by using
- * binding-specific casting methods on an instance of the <code>Node</code>
- * interface. The interface allows registration and removal of
- * <code>EventListeners</code> on an <code>EventTarget</code> and dispatch
- * of events to that <code>EventTarget</code>.
- * <p>See also the <a href='http://www.w3.org/TR/2000/REC-DOM-Level-2-Events-20001113'>Document Object Model (DOM) Level 2 Events Specification</a>.
- * @since DOM Level 2
- */
-public interface EventTarget {
- /**
- * This method allows the registration of event listeners on the event
- * target. If an <code>EventListener</code> is added to an
- * <code>EventTarget</code> while it is processing an event, it will not
- * be triggered by the current actions but may be triggered during a
- * later stage of event flow, such as the bubbling phase.
- * <br> If multiple identical <code>EventListener</code>s are registered
- * on the same <code>EventTarget</code> with the same parameters the
- * duplicate instances are discarded. They do not cause the
- * <code>EventListener</code> to be called twice and since they are
- * discarded they do not need to be removed with the
- * <code>removeEventListener</code> method.
- * @param typeThe event type for which the user is registering
- * @param listenerThe <code>listener</code> parameter takes an interface
- * implemented by the user which contains the methods to be called
- * when the event occurs.
- * @param useCaptureIf true, <code>useCapture</code> indicates that the
- * user wishes to initiate capture. After initiating capture, all
- * events of the specified type will be dispatched to the registered
- * <code>EventListener</code> before being dispatched to any
- * <code>EventTargets</code> beneath them in the tree. Events which
- * are bubbling upward through the tree will not trigger an
- * <code>EventListener</code> designated to use capture.
- */
- public void addEventListener(String type,
- EventListener listener,
- boolean useCapture);
-
- /**
- * This method allows the removal of event listeners from the event
- * target. If an <code>EventListener</code> is removed from an
- * <code>EventTarget</code> while it is processing an event, it will not
- * be triggered by the current actions. <code>EventListener</code>s can
- * never be invoked after being removed.
- * <br>Calling <code>removeEventListener</code> with arguments which do
- * not identify any currently registered <code>EventListener</code> on
- * the <code>EventTarget</code> has no effect.
- * @param typeSpecifies the event type of the <code>EventListener</code>
- * being removed.
- * @param listenerThe <code>EventListener</code> parameter indicates the
- * <code>EventListener </code> to be removed.
- * @param useCaptureSpecifies whether the <code>EventListener</code>
- * being removed was registered as a capturing listener or not. If a
- * listener was registered twice, one with capture and one without,
- * each must be removed separately. Removal of a capturing listener
- * does not affect a non-capturing version of the same listener, and
- * vice versa.
- */
- public void removeEventListener(String type,
- EventListener listener,
- boolean useCapture);
-
- /**
- * This method allows the dispatch of events into the implementations
- * event model. Events dispatched in this manner will have the same
- * capturing and bubbling behavior as events dispatched directly by the
- * implementation. The target of the event is the
- * <code> EventTarget</code> on which <code>dispatchEvent</code> is
- * called.
- * @param evtSpecifies the event type, behavior, and contextual
- * information to be used in processing the event.
- * @return The return value of <code>dispatchEvent</code> indicates
- * whether any of the listeners which handled the event called
- * <code>preventDefault</code>. If <code>preventDefault</code> was
- * called the value is false, else the value is true.
- * @exception EventException
- * UNSPECIFIED_EVENT_TYPE_ERR: Raised if the <code>Event</code>'s type
- * was not specified by initializing the event before
- * <code>dispatchEvent</code> was called. Specification of the
- * <code>Event</code>'s type as <code>null</code> or an empty string
- * will also trigger this exception.
- */
- public boolean dispatchEvent(Event evt)
- throws EventException;
-
-}
case U_UNSUPPORTED_ERROR:
return jniThrowException(env, "java/lang/UnsupportedOperationException", message);
default:
- return jniThrowException(env, "java/lang/RuntimeException", message);
+ return jniThrowRuntimeException(env, message);
}
}
#include <stdlib.h>
#include <string.h>
-// FIXME: move to JNIHelp.h
-static void jniThrowNullPointerException(JNIEnv* env) {
- jniThrowException(env, "java/lang/NullPointerException", NULL);
-}
-
static DecimalFormat* toDecimalFormat(jint addr) {
return reinterpret_cast<DecimalFormat*>(static_cast<uintptr_t>(addr));
}
static jint openDecimalFormatImpl(JNIEnv* env, jclass clazz, jstring pattern0) {
if (pattern0 == NULL) {
- jniThrowNullPointerException(env);
+ jniThrowNullPointerException(env, NULL);
return 0;
}
static void applyPatternImpl(JNIEnv *env, jclass clazz, jint addr, jboolean localized, jstring pattern0) {
if (pattern0 == NULL) {
- jniThrowNullPointerException(env);
+ jniThrowNullPointerException(env, NULL);
return;
}
ScopedJavaUnicodeString pattern(env, pattern0);
env->Throw(except);
}
-static void throwRuntimeException(JNIEnv* env, UErrorCode status)
-{
- jniThrowException(env, "java/lang/RuntimeException", u_errorName(status));
+static void throwRuntimeException(JNIEnv* env, UErrorCode status) {
+ jniThrowRuntimeException(env, u_errorName(status));
}
static void _close(JNIEnv* env, jclass clazz, RegExData* data)
static int forNameImpl(JNIEnv* env, jclass, jstring blockName) {
if (blockName == NULL) {
- jniThrowException(env, "java/lang/NullPointerException", NULL);
+ jniThrowNullPointerException(env, NULL);
return -1;
}
const char* bName = env->GetStringUTFChars(blockName, NULL);
}
env->ReleaseStringUTFChars(nameStr, name);
} else {
- jniThrowException(env, "java/lang/NullPointerException", NULL);
+ jniThrowNullPointerException(env, NULL);
}
return valueStr;
}
} else if (result == EAI_SYSTEM && errno == EACCES) {
/* No permission to use network */
- jniThrowException(
- env, "java/lang/SecurityException",
+ jniThrowException(env, "java/lang/SecurityException",
"Permission denied (maybe missing INTERNET permission)");
} else {
jniThrowException(env, "java/net/UnknownHostException",
jobjectArray InetAddress_getaddrinfo(JNIEnv* env, jobject obj, jstring javaName) {
if (javaName == NULL) {
- jniThrowException(env, "java/lang/NullPointerException", NULL);
+ jniThrowNullPointerException(env, NULL);
return NULL;
}
const char* name = env->GetStringUTFChars(javaName, NULL);
jbyteArray javaAddress)
{
if (javaAddress == NULL) {
- jniThrowException(env, "java/lang/NullPointerException", NULL);
+ jniThrowNullPointerException(env, NULL);
return NULL;
}
jniThrowExceptionWithErrno(env, "java/net/SocketTimeoutException", error);
}
-// TODO(enh): move to JNIHelp.h
-static void throwNullPointerException(JNIEnv *env) {
- jniThrowException(env, "java/lang/NullPointerException", NULL);
-}
-
// Used by functions that shouldn't throw SocketException. (These functions
// aren't meant to see bad addresses, so seeing one really does imply an
// internal error.)
static bool byteArrayToSocketAddress(JNIEnv *env,
jbyteArray addressBytes, int port, sockaddr_storage *sockaddress) {
if (addressBytes == NULL) {
- throwNullPointerException(env);
+ jniThrowNullPointerException(env, NULL);
return false;
}
int port, sockaddr_storage *sockaddress) {
// Get the byte array that stores the IP address bytes in the InetAddress.
if (inetaddress == NULL) {
- throwNullPointerException(env);
+ jniThrowNullPointerException(env, NULL);
return false;
}
jbyteArray addressBytes =
static jstring osNetworkSystem_byteArrayToIpString(JNIEnv* env, jclass,
jbyteArray byteArray) {
if (byteArray == NULL) {
- throwNullPointerException(env);
+ jniThrowNullPointerException(env, NULL);
return NULL;
}
sockaddr_storage ss;
static jbyteArray osNetworkSystem_ipStringToByteArray(JNIEnv* env, jclass,
jstring javaString) {
if (javaString == NULL) {
- throwNullPointerException(env);
+ jniThrowNullPointerException(env, NULL);
return NULL;
}
static int createSocketFileDescriptor(JNIEnv* env, jobject fileDescriptor,
int type) {
if (fileDescriptor == NULL) {
- throwNullPointerException(env);
+ jniThrowNullPointerException(env, NULL);
errno = EBADF;
return -1;
}
// LOGD("ENTER acceptSocketImpl");
if (newSocket == NULL) {
- throwNullPointerException(env);
+ jniThrowNullPointerException(env, NULL);
return;
}
#define TRUE 1
#endif
-
-static void
-throwNewNullPointerException (JNIEnv* env, const char* message)
-{
- jniThrowException(env, "java/lang/NullPointerException", message);
-}
-
-static int isValidHandle (JNIEnv* env, void* handle, const char *message)
-{
+static int isValidHandle (JNIEnv* env, void* handle, const char *message) {
if (handle == NULL) {
- throwNewNullPointerException(env, message);
+ jniThrowNullPointerException(env, message);
return FALSE;
}
- else return TRUE;
+ return TRUE;
}
static int oneValidHandle (JNIEnv* env, void* a)
ERR_remove_state(0);
}
-/**
- * Throws a NullPointerException without any message.
- */
-static void throwNullPointerException(JNIEnv* env) {
- jniThrowException(env, "java/lang/NullPointerException", NULL);
-}
-
-/**
- * Throws a RuntimeException with a human-readable error message.
- */
-static void throwRuntimeException(JNIEnv* env, const char* message) {
- jniThrowException(env, "java/lang/RuntimeException", message);
-}
-
/*
* Checks this thread's OpenSSL error queue and throws a RuntimeException if
* necessary.
char message[50];
ERR_error_string_n(error, message, sizeof(message));
LOGD("OpenSSL error %d: %s", error, message);
- throwRuntimeException(env, message);
+ jniThrowRuntimeException(env, message);
result = 1;
}
if (rsa->n == NULL || rsa->e == NULL) {
rsaDestroyKey(env, clazz, rsa);
- throwRuntimeException(env, "Unable to convert BigInteger to BIGNUM");
+ jniThrowRuntimeException(env, "Unable to convert BigInteger to BIGNUM");
return NULL;
}
if (rsa->n == NULL || rsa->e == NULL || rsa->d == NULL || rsa->p == NULL || rsa->q == NULL) {
rsaDestroyKey(env, clazz, rsa);
- throwRuntimeException(env, "Unable to convert BigInteger to BIGNUM");
+ jniThrowRuntimeException(env, "Unable to convert BigInteger to BIGNUM");
return NULL;
}
if (dsa->p == NULL || dsa->q == NULL || dsa->g == NULL || dsa->pub_key == NULL) {
DSA_free(dsa);
- throwRuntimeException(env, "Unable to convert BigInteger to BIGNUM");
+ jniThrowRuntimeException(env, "Unable to convert BigInteger to BIGNUM");
return NULL;
}
if (rsa->n == NULL || rsa->e == NULL) {
RSA_free(rsa);
- throwRuntimeException(env, "Unable to convert BigInteger to BIGNUM");
+ jniThrowRuntimeException(env, "Unable to convert BigInteger to BIGNUM");
return NULL;
}
// LOGI("NativeCrypto_EVP_DigestFinal%x, %x, %d, %d", ctx, hash, offset);
if (ctx == NULL || hash == NULL) {
- throwNullPointerException(env);
+ jniThrowNullPointerException(env, NULL);
return -1;
}
// LOGI("NativeCrypto_EVP_DigestInit");
if (ctx == NULL || algorithm == NULL) {
- throwNullPointerException(env);
+ jniThrowNullPointerException(env, NULL);
return;
}
env->ReleaseStringUTFChars(algorithm, algorithmChars);
if (digest == NULL) {
- throwRuntimeException(env, "Hash algorithm not found");
+ jniThrowRuntimeException(env, "Hash algorithm not found");
return;
}
// LOGI("NativeCrypto_EVP_DigestSize");
if (ctx == NULL) {
- throwNullPointerException(env);
+ jniThrowNullPointerException(env, NULL);
return -1;
}
// LOGI("NativeCrypto_EVP_DigestBlockSize");
if (ctx == NULL) {
- throwNullPointerException(env);
+ jniThrowNullPointerException(env, NULL);
return -1;
}
// LOGI("NativeCrypto_EVP_DigestUpdate %x, %x, %d, %d", ctx, buffer, offset, length);
if (ctx == NULL || buffer == NULL) {
- throwNullPointerException(env);
+ jniThrowNullPointerException(env, NULL);
return;
}
// LOGI("NativeCrypto_EVP_VerifyInit");
if (ctx == NULL || algorithm == NULL) {
- throwNullPointerException(env);
+ jniThrowNullPointerException(env, NULL);
return;
}
env->ReleaseStringUTFChars(algorithm, algorithmChars);
if (digest == NULL) {
- throwRuntimeException(env, "Hash algorithm not found");
+ jniThrowRuntimeException(env, "Hash algorithm not found");
return;
}
// LOGI("NativeCrypto_EVP_VerifyUpdate %x, %x, %d, %d", ctx, buffer, offset, length);
if (ctx == NULL || buffer == NULL) {
- throwNullPointerException(env);
+ jniThrowNullPointerException(env, NULL);
return;
}
// LOGI("NativeCrypto_EVP_VerifyFinal %x, %x, %d, %d %x", ctx, buffer, offset, length, pkey);
if (ctx == NULL || buffer == NULL || pkey == NULL) {
- throwNullPointerException(env);
+ jniThrowNullPointerException(env, NULL);
return -1;
}
}
/**
- * Throws a NullPointerException without any message.
- */
-static void throwNullPointerException(JNIEnv* env) {
- if (jniThrowException(env, "java/lang/NullPointerException", NULL)) {
- LOGE("Unable to throw");
- }
-}
-
-/**
- * Throws a RuntimeException with a human-readable error message.
- */
-static void throwRuntimeException(JNIEnv* env, const char* message) {
- if (jniThrowException(env, "java/lang/RuntimeException", message)) {
- LOGE("Unable to throw");
- }
-}
-
-/**
* Throws an SocketTimeoutException with the given string as a message.
*/
static void throwSocketTimeoutException(JNIEnv* env, const char* message) {
// LOGD("Entering verifysignature()");
if (msg == NULL || sig == NULL || algorithm == NULL || mod == NULL || exp == NULL) {
- throwNullPointerException(env);
+ jniThrowNullPointerException(env, NULL);
return -1;
}
if (error != 0) {
char message[50];
ERR_error_string_n(error, message, sizeof(message));
- throwRuntimeException(env, message);
+ jniThrowRuntimeException(env, message);
} else {
- throwRuntimeException(env, "Internal error during verification");
+ jniThrowRuntimeException(env, "Internal error during verification");
}
freeSslErrorState();
}
}
/*
+ * Throw a java.lang.NullPointerException, with an optional message.
+ */
+int jniThrowNullPointerException(JNIEnv* env, const char* msg)
+{
+ return jniThrowException(env, "java/lang/NullPointerException", msg);
+}
+
+/*
* Throw a java.lang.RuntimeException, with an optional message.
*/
int jniThrowRuntimeException(JNIEnv* env, const char* msg)
int jniThrowException(C_JNIEnv* env, const char* className, const char* msg);
/*
+ * Throw a java.lang.NullPointerException, with an optional message.
+ */
+int jniThrowNullPointerException(C_JNIEnv* env, const char* msg);
+
+/*
* Throw a java.lang.RuntimeException, with an optional message.
*/
-int jniThrowRuntimeException(JNIEnv* env, const char* msg);
+int jniThrowRuntimeException(C_JNIEnv* env, const char* msg);
/*
* Throw a java.io.IOException, generating the message from errno.
{
return jniThrowException(&env->functions, className, msg);
}
+inline int jniThrowNullPointerException(JNIEnv* env, const char* msg)
+{
+ return jniThrowNullPointerException(&env->functions, msg);
+}
+inline int jniThrowRuntimeException(JNIEnv* env, const char* msg)
+{
+ return jniThrowRuntimeException(&env->functions, msg);
+}
inline int jniThrowIOException(JNIEnv* env, int errnum)
{
return jniThrowIOException(&env->functions, errnum);
/* Size of temporary buffers for escaping html strings */
#define HTML_BUFSIZE 10240
+/* Size of methodId->method cache */
+#define METHOD_CACHE_SIZE 2048
+#define METHOD_CACHE_SIZE_MASK (METHOD_CACHE_SIZE - 1)
+
+/* Some filter constants */
+#define FILTER_TAG '*'
+#define FILTER_FLAG_THREAD '+'
+#define FILTER_TYPE_CLASS 0
+#define FILTER_TYPE_METHOD 1
+
+#define DEFAULT_ACTIVE_THREADS 8
+
char *htmlHeader =
"<html>\n<head>\n<script type=\"text/javascript\" src=\"%ssortable.js\"></script>\n"
"<script langugage=\"javascript\">\n"
ThreadEntry* threads;
int numMethods;
MethodEntry* methods; /* 2 extra methods: "toplevel" and "unknown" */
+ int* methodCache; /* methodId->methodIndex mapping */
+ // TODO change to map methodId->method itself
} DataKeys;
#define TOPLEVEL_INDEX 0
} StackEntry;
typedef struct CallStack {
- int top;
- StackEntry calls[MAX_STACK_DEPTH];
- uint64_t lastEventTime;
- uint64_t threadStartTime;
+ int top;
+ StackEntry calls[MAX_STACK_DEPTH];
+ uint64_t lastEventTime;
+ uint64_t threadStartTime;
+ uint64_t* remTimes;
+ // Note: remTimes keeps a sum of 'un-allocated' time for each thread, in case
+ // we need to allocate it to one (or many) filter later. This would happen when
+ // we see a method exit that maches a filter, but whose entry we hadn't seen.
+ // TODO: consider moving remTimes into FilterTimes and change logic appropriately
} CallStack;
typedef struct DiffEntry {
const char* traceFileName;
const char* diffFileName;
const char* graphFileName;
+ const char* filterFileName;
int keepDotFile;
int dump;
int outputHtml;
UniqueMethodEntry *uniqueMethods;
} TraceData;
+typedef struct FilterKey {
+ int type[2]; /* 0=class, 1=method; 2 needed for start and end keys */
+ uint32_t flags; /* 1st bit = include cross-thread time */
+ char* keys[2]; /* 2 needed for start and end keys */
+} FilterKey;
+
+typedef struct FilterTimes {
+ uint64_t totalWaitTime;
+ uint64_t* threadWaitTimes;
+ uint64_t* threadExecutionTimesWhileWaiting;
+ uint64_t* threadExecutionTimes;
+} FilterTimes;
+
+typedef struct Filter {
+ char* filterName;
+ FilterKey* filterKeys;
+ int numKeys;
+ int activeCount;
+ int* activeThreads;
+ int* activationKeys;
+ FilterTimes times;
+} Filter;
+
+int numFilters = 0; // global
+
static Options gOptions;
/* Escapes characters in the source string that are html special entities.
free(pKeys->fileData);
free(pKeys->threads);
free(pKeys->methods);
+ free(pKeys->methodCache);
free(pKeys);
}
return -1;
}
-/*
- * Count the number of lines until the next token.
- *
- * Returns -1 if none found before EOF.
- */
-int countLinesToToken(const char* data, int len)
+int countLinesToChar(const char* data, int len, const char toFind)
{
int count = 0;
int next;
- while (*data != TOKEN_CHAR) {
+ while (*data != toFind) {
next = findNextChar(data, len, '\n');
if (next < 0)
- return -1;
+ return count;
count++;
data += next+1;
len -= next+1;
}
/*
+ * Count the number of lines until the next token.
+ *
+ * Returns 0 if none found before EOF.
+ */
+int countLinesToToken(const char* data, int len)
+{
+ return countLinesToChar(data, len, TOKEN_CHAR);
+}
+
+/*
* Make sure we're at the start of the right section.
*
* Returns the length of the token line, or -1 if something is wrong.
printf("Methods (%d):\n", pKeys->numMethods);
for (i = 0; i < pKeys->numMethods; i++) {
printf("0x%08x %s : %s : %s\n",
- pKeys->methods[i].methodId, pKeys->methods[i].className,
+ pKeys->methods[i].methodId >> 2, pKeys->methods[i].className,
pKeys->methods[i].methodName, pKeys->methods[i].signature);
}
}
{
int hi, lo, mid;
unsigned int id;
+ int hashedId;
+
+ /* Create cache if it doesn't already exist */
+ if (pKeys->methodCache == NULL) {
+ pKeys->methodCache = (int*) malloc(sizeof(int) * METHOD_CACHE_SIZE);
+ }
+
+ // ids are multiples of 4, so shift
+ hashedId = (methodId >> 2) & METHOD_CACHE_SIZE_MASK;
+ if (pKeys->methodCache[hashedId]) /* cache hit */
+ if (pKeys->methods[pKeys->methodCache[hashedId]].methodId == methodId)
+ return &pKeys->methods[pKeys->methodCache[hashedId]];
lo = 0;
hi = pKeys->numMethods - 1;
mid = (hi + lo) / 2;
id = pKeys->methods[mid].methodId;
- if (id == methodId) /* match */
- return &pKeys->methods[mid];
- else if (id < methodId) /* too low */
+ if (id == methodId) { /* match, put in cache */
+ hashedId = (methodId >> 2) & METHOD_CACHE_SIZE_MASK;
+ pKeys->methodCache[hashedId] = mid;
+ return &pKeys->methods[mid];
+ } else if (id < methodId) /* too low */
lo = mid + 1;
else /* too high */
hi = mid - 1;
char classBuf[HTML_BUFSIZE], methodBuf[HTML_BUFSIZE];
char signatureBuf[HTML_BUFSIZE];
char anchor_buf[80];
- char *anchor_close = "";
total = sumThreadTime;
anchor_buf[0] = 0;
if (gOptions.outputHtml) {
- anchor_close = "</a>";
printf("<a name=\"inclusive\"></a>\n");
printf("<hr>\n");
outputNavigationBar();
}
}
-void printThreadProfile(ThreadEntry *pThreads, int numThreads, uint64_t sumThreadTime)
+void printThreadProfile(ThreadEntry *pThreads, int numThreads, uint64_t sumThreadTime, Filter** filters)
{
- int ii;
+ int ii, jj;
ThreadEntry thread;
double total, per, sum_per;
uint64_t sum;
char threadBuf[HTML_BUFSIZE];
char anchor_buf[80];
- char *anchor_close = "";
+ int drawTable;
total = sumThreadTime;
anchor_buf[0] = 0;
if (gOptions.outputHtml) {
- anchor_close = "</a>";
printf("<a name=\"thread\"></a>\n");
printf("<hr>\n");
outputNavigationBar();
/* Sort the threads into decreasing order of elapsed time. */
qsort(pThreads, numThreads, sizeof(ThreadEntry), compareElapsed);
- printf("\nElapsed times for each thread, sorted by elapsed time.\n\n");
+ printf("\nElapsed times for each thread, sorted by elapsed time.\n");
+ printf("Also includes percentage of time spent during the <i>execution</i> of any filters.\n\n");
if (gOptions.outputHtml) {
printf("<br><br>\n<pre>\n");
}
- printf(" Usecs self %% sum %% tid ThreadName\n");
+ printf(" Usecs self %% sum %%");
+ for (ii = 0; ii < numFilters; ++ii) {
+ printf(" %s %%", filters[ii]->filterName);
+ }
+ printf(" tid ThreadName\n");
sum = 0;
for (ii = 0; ii < numThreads; ++ii) {
if (gOptions.outputHtml) {
threadName = htmlEscape(threadName, threadBuf, HTML_BUFSIZE);
}
- printf("%9llu %6.2f %6.2f %3d %s\n", time, per, sum_per, threadId, threadName);
+
+ printf("%9llu %6.2f %6.2f", time, per, sum_per);
+ for (jj = 0; jj < numFilters; jj++) {
+ printf(" %6.2f", 100.0 * filters[jj]->times.threadExecutionTimes[threadId] / time);
+ }
+ printf(" %3d %s\n", threadId, threadName);
}
if (gOptions.outputHtml)
- printf("</pre>\n");
+ printf("</pre><br />");
+
+ printf("\n\nBreak-down of portion of time spent by each thread while waiting on a filter method.\n");
+
+ for (ii = 0; ii < numFilters; ++ii) {
+ // Draw a table for each filter that measures wait time
+ drawTable = 0;
+ for (jj = 0; jj < filters[ii]->numKeys; jj++)
+ if (filters[ii]->filterKeys[jj].flags == 1)
+ drawTable = 1;
+
+ if (drawTable) {
+
+ if (gOptions.outputHtml)
+ printf("<br/><br/>\n<pre>\n");
+ printf("Filter: %s\n", filters[ii]->filterName);
+ printf("Total waiting cycles: %llu (%6.2f%% of total)\n",
+ filters[ii]->times.totalWaitTime,
+ 100.0 * filters[ii]->times.totalWaitTime / sum);
+
+ if (filters[ii]->times.totalWaitTime > 0) {
+
+ printf("Details: \n\n");
+
+ printf(" Waiting cycles %% of total waiting time execution time while waiting thread name\n");
+
+ for (jj = 0; jj < numThreads; jj++) {
+
+ thread = pThreads[jj];
+
+ char *threadName;
+ threadName = (char*) thread.threadName;
+ if (gOptions.outputHtml) {
+ threadName = htmlEscape(threadName, threadBuf, HTML_BUFSIZE);
+ }
+
+ printf(" %9llu %6.2f %6.2f %s\n",
+ filters[ii]->times.threadWaitTimes[thread.threadId],
+ 100.0 * filters[ii]->times.threadWaitTimes[thread.threadId] / filters[ii]->times.totalWaitTime,
+ 100.0 * filters[ii]->times.threadExecutionTimesWhileWaiting[thread.threadId] / filters[ii]->times.totalWaitTime,
+ threadName);
+ }
+ }
+
+ if (gOptions.outputHtml)
+ printf("</pre>\n");
+
+ }
+ }
}
}
/*
+ * Determines whether the given FilterKey matches the method. The FilterKey's
+ * key that is used to match against the method is determined by index.
+ */
+int keyMatchesMethod(FilterKey filterKey, MethodEntry* method, int index)
+{
+ if (filterKey.type[index] == 0) { // Class
+#if 0
+ fprintf(stderr, " class is %s; filter key is %s\n", method->className, filterKey.keys[index]);
+#endif
+ if (strcmp(method->className, filterKey.keys[index]) == 0) {
+ return 1;
+ }
+ } else { // Method
+ if (method->methodName != NULL) {
+ // Get fully-qualified name
+ // TODO: parse class name and method name an put them in structure to avoid
+ // allocating memory here
+ char* str = malloc ((strlen(method->className) + strlen(method->methodName) + 2) * sizeof(char));
+ strcpy(str, method->className);
+ strcat(str, ".");
+ strcat(str, method->methodName);
+#if 0
+ fprintf(stderr, " method is %s; filter key is %s\n", str, filterKey.keys[index]);
+#endif
+ if (strcmp(str, filterKey.keys[index]) == 0) {
+ free(str);
+ return 1;
+ }
+ free(str);
+ }
+ }
+ return 0;
+}
+
+/*
+ * Adds the appropriate times to the given filter based on the given method. Activates and
+ * de-activates filters as necessary.
+ *
+ * A filter is activated when the given method matches the 'entry' key of one of its FilterKeys.
+ * It is de-activated when the method matches the 'exit' key of the same FilterKey that activated it
+ * in the first place. Thus, a filter may be active more than once on the same thread (activated by
+ * different FilterKeys). A filter may also be active on different threads at the same time.
+ *
+ * While the filter is active on thread 1, elapsed time is allocated to different buckets which
+ * include: thread execution time (i.e., time thread 1 spent executing while filter was active),
+ * thread waiting time (i.e., time thread 1 waited while other threads executed), and execution
+ * time while waiting (i.e., time thread x spent executing while thread 1 was waiting). We also
+ * keep track of the total waiting time for a given filter.
+ *
+ * Lastly, we keep track of remaining (un-allocated) time for cases in which we exit a method we
+ * had not entered before, and that method happens to match the 'exit' key of a FilterKey.
+ */
+int filterMethod(MethodEntry* method, Filter* filter, int entry, int threadId, int numThreads,
+ uint64_t elapsed, uint64_t remTime)
+{
+ int ii, jj;
+ int activeCount, addedWaitTimeThreadsCount;
+ int* activeThreads;
+ int* activationKeys;
+ int* addedWaitTimeThreads;
+
+ // flags
+ int addWaitTime = 0;
+ int deactivation = 0;
+ int addedExecutionTime = 0;
+ int addedExecutionTimeWhileWaiting = 0;
+ int addedWaitTime;
+ int addedRemTime = 0;
+ int threadKeyPairActive = 0;
+
+ if (filter->times.threadWaitTimes == NULL && filter->times.threadExecutionTimes == NULL &&
+ filter->times.threadExecutionTimesWhileWaiting == NULL) {
+ filter->times.threadWaitTimes = (uint64_t*) calloc(MAX_THREADS, sizeof(uint64_t));
+ filter->times.threadExecutionTimesWhileWaiting =
+ (uint64_t*) calloc(MAX_THREADS, sizeof(uint64_t));
+ filter->times.threadExecutionTimes = (uint64_t*) calloc(MAX_THREADS, sizeof(uint64_t));
+ }
+
+ int verbose = 0;
+
+ if (verbose)
+ fprintf(stderr,
+ "Running %s filter for class %s method %s, thread %d; activeCount: %d time: %llu\n",
+ filter->filterName, method->className, method->methodName, threadId,
+ filter->activeCount, elapsed);
+
+ // If active on some thread
+ if (filter->activeCount > 0) {
+
+ // Initialize active structures in case there are any de-activations
+ activeThreads = (int*) calloc(filter->activeCount, sizeof(int));
+ activationKeys = (int*) calloc(filter->activeCount, sizeof(int));
+ activeCount = 0;
+
+ // Initialize structure to help us determine which threads we've already added wait time to
+ addedWaitTimeThreads = (int*) calloc(filter->activeCount, sizeof(int));
+ addedWaitTimeThreadsCount = 0;
+
+ // Add times to appropriate sums and de-activate (if necessary)
+ for (ii = 0; ii < filter->activeCount; ii++) {
+
+ if (verbose) {
+ fprintf(stderr, " Analyzing active thread with id %d, activated by key [%s, %s]\n",
+ filter->activeThreads[ii],
+ filter->filterKeys[filter->activationKeys[ii]].keys[0],
+ filter->filterKeys[filter->activationKeys[ii]].keys[1]);
+ }
+
+ // If active on THIS thread -> add to execution time (only add once!)
+ if (filter->activeThreads[ii] == threadId && !addedExecutionTime) {
+ if (verbose)
+ fprintf(stderr, " Adding execution time to this thead\n");
+ filter->times.threadExecutionTimes[threadId] += elapsed;
+ addedExecutionTime = 1;
+ }
+
+ // If active on ANOTHER thread (or this one too) with CROSS_THREAD_FLAG -> add to
+ // both thread's waiting time + total
+ if (filter->filterKeys[filter->activationKeys[ii]].flags == 1) {
+
+ // Add time to thread that is waiting (add to each waiting thread at most once!)
+ addedWaitTime = 0;
+ for (jj = 0; jj < addedWaitTimeThreadsCount; jj++) {
+ if (addedWaitTimeThreads[jj] == filter->activeThreads[ii])
+ addedWaitTime = 1;
+ }
+ if (!addedWaitTime) {
+ if (verbose)
+ fprintf(stderr, " Adding wait time to waiting thread\n");
+ filter->times.threadWaitTimes[filter->activeThreads[ii]] += elapsed;
+ addedWaitTimeThreads[addedWaitTimeThreadsCount++] = filter->activeThreads[ii];
+ }
+
+ // Add execution time to this thread while the other is waiting (only add once!)
+ // [Flag is needed only because outside for loop might iterate through same
+ // thread twice?] TODO: verify
+ if (!addedExecutionTimeWhileWaiting) {
+ if (verbose)
+ fprintf(stderr, " Adding exec time to this thread while thread waits\n");
+ filter->times.threadExecutionTimesWhileWaiting[threadId] += elapsed;
+ addedExecutionTimeWhileWaiting = 1;
+ }
+
+ addWaitTime = 1;
+ }
+
+ // If a method exit matches the EXIT method of an ACTIVE key -> de-activate
+ // the KEY (not the entire filter!!)
+ if (!entry && keyMatchesMethod(filter->filterKeys[filter->activationKeys[ii]],
+ method, 1)) {
+ if (verbose)
+ fprintf(stderr, " Exit key matched!\n");
+
+ // Deactivate by removing (NOT adding) entries from activeThreads and activationKeys
+ deactivation = 1; // singal that lists should be replaced
+ } else {
+ // No de-activation -> copy old entries into new lists
+ activeThreads[activeCount] = filter->activeThreads[ii];
+ activationKeys[activeCount++] = filter->activationKeys[ii];
+ }
+ }
+
+ // If waiting on ANY thread, add wait time to total (but only ONCE!)
+ if (addWaitTime) {
+ filter->times.totalWaitTime += elapsed;
+ }
+
+ // If de-activation occurred, replace lists
+ if (deactivation) {
+ // TODO: Free memory from old lists
+
+ // Set new lists
+ filter->activeThreads = activeThreads;
+ filter->activationKeys = activationKeys;
+ filter->activeCount = activeCount;
+ } else {
+ // TODO: Free memory from new lists
+ }
+
+ } // Else, continue (we might be activating the filter on a different thread)
+
+
+ if (entry) { // ENTRY
+ if (verbose)
+ fprintf(stderr, " Here at the entry\n");
+ // If method matches entry key -> activate thread (do not add time since it's a new entry!)
+ for (ii = 0; ii < filter->numKeys; ii++) {
+ if (keyMatchesMethod(filter->filterKeys[ii], method, 0)) {
+ if (verbose)
+ fprintf(stderr, " Entry key matched!\n");
+ // Activate thread only if thread/key pair is not already active
+ for (jj = 0; jj < filter->activeCount; jj++) {
+ if (filter->activeThreads[jj] == threadId && filter->activationKeys[jj] == ii)
+ threadKeyPairActive = 1;
+ }
+ // TODO: WORRY ABOUT MEMORY WHEN ACTIVE_COUNT > DEFAULT_ACTIVE_THREAD (unlikely)
+ // TODO: what if the same thread is active multiple times by different keys?
+ // nothing, we just have to make sure we dont double-add, and we dont..
+ if (!threadKeyPairActive) {
+ filter->activeThreads[filter->activeCount] = threadId;
+ filter->activationKeys[filter->activeCount++] = ii;
+ }
+ }
+ }
+ } else { // EXIT
+ // If method matches a terminal key -> add remTime to total (no need to active/de-activate)
+ for (ii = 0; ii < filter->numKeys; ii++) {
+ if (!deactivation && keyMatchesMethod(filter->filterKeys[ii], method, 1) &&
+ keyMatchesMethod(filter->filterKeys[ii], method, 0)) {
+ // Add remTime(s)
+ // TODO: think about how we should add remTimes.. should we add remTime to threads
+ // that were waiting or being waited on? for now, keep it simple and just add the
+ // execution time to the current thread.
+ filter->times.threadExecutionTimes[threadId] += remTime;
+ addedRemTime = 1;
+ }
+ }
+ }
+
+ return addedExecutionTime | (addedRemTime << 1);
+}
+
+void dumpFilters(Filter** filters) {
+ int i;
+ for (i = 0; i < numFilters; i++) {
+ int j;
+ fprintf(stderr, "FILTER %s\n", filters[i]->filterName);
+ for (j = 0; j < filters[i]->numKeys; j++) {
+ fprintf(stderr, "Keys: %s, type %d", filters[i]->filterKeys[j].keys[0],
+ filters[i]->filterKeys[j].type[0]);
+ if (filters[i]->filterKeys[j].keys[1] != NULL) {
+ fprintf(stderr, " AND %s, type %d", filters[i]->filterKeys[j].keys[1],
+ filters[i]->filterKeys[j].type[1]);
+ }
+ fprintf(stderr, "; flags: %d\n", filters[i]->filterKeys[j].flags);
+ }
+ }
+}
+
+/*
+ * See parseFilters for required data format.
+ * 'data' must point to the beginning of a filter definition.
+ */
+char* parseFilter(char* data, char* dataEnd, Filter** filters, int num) {
+
+ Filter* filter;
+ int next, count, i;
+ int tmpOffset, tmpKeyLen;
+ char* tmpKey;
+ char* key1;
+ char* key2;
+
+ filter = (Filter*) malloc(sizeof(Filter));
+ filter->activeCount = 0;
+ filter->activeThreads = (int*) calloc(DEFAULT_ACTIVE_THREADS, sizeof(int));
+ filter->activationKeys = (int*) calloc(DEFAULT_ACTIVE_THREADS, sizeof(int));
+
+ next = findNextChar(data + 1, dataEnd - data - 1, '\n');
+ if (next < 0) {
+ // TODO: what should we do here?
+ // End of file reached...
+ }
+ data[next+1] = '\0';
+ filter->filterName = data + 1;
+ data += next + 2; // Careful
+
+ /*
+ * Count the number of keys (one per line).
+ */
+ count = countLinesToChar(data, dataEnd - data, FILTER_TAG);
+ if (count <= 0) {
+ fprintf(stderr,
+ "ERROR: failed while parsing filter %s (found %d keys)\n",
+ filter->filterName, count);
+ return NULL; // TODO: Should do something else
+ // Could return filter with 0 keys instead (probably better to avoid random segfaults)
+ }
+
+ filter->filterKeys = (FilterKey*) malloc(sizeof(FilterKey) * count);
+
+ /*
+ * Extract all entries.
+ */
+ tmpOffset = 0;
+ for (i = 0; i < count; i++) {
+ next = findNextChar(data, dataEnd - data, '\n');
+ // assert(next > 0); // TODO: revise... (skip if next == 0 ?)
+ data[next] = '\0';
+ tmpKey = data;
+
+ if (*data == FILTER_FLAG_THREAD) {
+ filter->filterKeys[i].flags = 1;
+ tmpKey++;
+ } else {
+ filter->filterKeys[i].flags = 0;
+ }
+
+ tmpOffset = findNextChar(tmpKey, next, ',');
+
+ if (tmpOffset < 0) {
+ // No comma, so only 1 key
+ key1 = tmpKey;
+ key2 = tmpKey;
+
+ // Get type for key1
+ filter->filterKeys[i].type[0] = FILTER_TYPE_CLASS; // default
+ tmpOffset = findNextChar(key1, next, '(');
+ if (tmpOffset > 0) {
+ if (findNextChar(key1, next, ')') == tmpOffset + 1) {
+ filter->filterKeys[i].type[0] = FILTER_TYPE_METHOD;
+ filter->filterKeys[i].type[1] = FILTER_TYPE_METHOD;
+ }
+ key1[tmpOffset] = '\0';
+ }
+ } else {
+ // Pair of keys
+ tmpKey[tmpOffset] = '\0';
+ key1 = tmpKey;
+ key2 = tmpKey + tmpOffset + 1;
+
+ // Get type for key1
+ filter->filterKeys[i].type[0] = FILTER_TYPE_CLASS;
+ tmpKeyLen = tmpOffset;
+ tmpOffset = findNextChar(key1, tmpKeyLen, '(');
+ if (tmpOffset > 0) {
+ if (findNextChar(key1, tmpKeyLen, ')') == tmpOffset + 1) {
+ filter->filterKeys[i].type[0] = FILTER_TYPE_METHOD;
+ }
+ key1[tmpOffset] = '\0';
+ }
+
+ // Get type for key2
+ filter->filterKeys[i].type[1] = FILTER_TYPE_CLASS;
+ tmpOffset = findNextChar(key2, next - tmpKeyLen, '(');
+ if (tmpOffset > 0) {
+ if (findNextChar(key2, next - tmpKeyLen, ')') == tmpOffset + 1) {
+ filter->filterKeys[i].type[1] = FILTER_TYPE_METHOD;
+ }
+ key2[tmpOffset] = '\0';
+ }
+ }
+
+ filter->filterKeys[i].keys[0] = key1;
+ filter->filterKeys[i].keys[1] = key2;
+ data += next+1;
+ }
+
+ filter->numKeys = count;
+ filters[num] = filter;
+
+ return data;
+}
+
+/*
+ * Parses filters from given file. The file must follow the following format:
+ *
+ * *FilterName <- creates a new filter with keys to follow
+ * A.method() <- key that triggers whenever A.method() enters/exit
+ * Class <- key that triggers whenever any method from Class enters/exits
+ * +CrossThread <- same as above, but keeps track of execution times accross threads
+ * B.m(),C.m() <- key that triggers filter on when B.m() enters and off when C.m() exits
+ *
+ * TODO: add concrete example to make things clear
+ */
+Filter** parseFilters(const char* filterFileName) {
+
+ Filter** filters = NULL;
+ FILE* fp = NULL;
+ long len;
+ char* data;
+ char* dataEnd;
+ char* dataStart;
+ int i, next, count;
+
+ fp = fopen(filterFileName, "r");
+ if (fp == NULL)
+ goto bail;
+
+ if (fseek(fp, 0L, SEEK_END) != 0) {
+ perror("fseek");
+ goto bail;
+ }
+
+ len = ftell(fp);
+ if (len == 0) {
+ fprintf(stderr, "WARNING: Filter file is empty.\n");
+ goto bail;
+ }
+ rewind(fp);
+
+ data = (char*) malloc(len);
+ if (data == NULL) {
+ fprintf(stderr, "ERROR: unable to alloc %ld bytes for filter file\n", len);
+ goto bail;
+ }
+
+ // Read file into memory
+ if (fread(data, 1, len, fp) != (size_t) len) {
+ fprintf(stderr, "ERROR: unable to read %ld bytes from filter file\n", len);
+ goto bail;
+ }
+
+ dataStart = data;
+ dataEnd = data + len;
+
+ // Figure out how many filters there are
+ numFilters = 0;
+ next = -1;
+
+ while (1) {
+ if (*data == FILTER_TAG)
+ numFilters++;
+ next = findNextChar(data, len, '\n');
+ if (next < 0)
+ break;
+ data += next+1;
+ len -= next+1;
+ }
+
+ if (numFilters == 0) {
+ fprintf(stderr, "WARNING: no filters found. Continuing without filters\n");
+ goto bail;
+ }
+
+ filters = (Filter**) calloc(numFilters, sizeof(Filter *));
+ if (filters == NULL) {
+ fprintf(stderr, "ERROR: unable to alloc memory for filters");
+ goto bail;
+ }
+
+ data = dataStart;
+ for (i = 0; i < numFilters; i++) {
+ data = parseFilter(data, dataEnd, filters, i);
+ }
+
+ return filters;
+
+bail:
+ if (fp != NULL)
+ fclose(fp);
+
+ return NULL;
+
+}
+
+
+/*
* Read the key and data files and return the MethodEntries for those files
*/
-DataKeys* parseDataKeys(TraceData* traceData, const char* traceFileName, uint64_t* threadTime)
+DataKeys* parseDataKeys(TraceData* traceData, const char* traceFileName,
+ uint64_t* threadTime, Filter** filters)
{
DataKeys* dataKeys = NULL;
MethodEntry **pMethods = NULL;
MethodEntry* method;
FILE* dataFp = NULL;
DataHeader dataHeader;
- int ii;
+ int ii, jj, numThreads;
uint64_t currentTime;
MethodEntry* caller;
goto bail;
if ((dataKeys = parseKeys(dataFp, 0)) == NULL)
- goto bail;
+ goto bail;
if (parseDataHeader(dataFp, &dataHeader) < 0)
goto bail;
+ numThreads = dataKeys->numThreads;
+
#if 0
FILE *dumpStream = fopen("debug", "w");
#endif
int action;
unsigned int methodId;
CallStack *pStack;
+
/*
* Extract values from file.
*/
if (readDataRecord(dataFp, &threadId, &methodVal, ¤tTime))
break;
-
+
action = METHOD_ACTION(methodVal);
methodId = METHOD_ID(methodVal);
pStack->top = 0;
pStack->lastEventTime = currentTime;
pStack->threadStartTime = currentTime;
+ pStack->remTimes = (uint64_t*) calloc(numFilters, sizeof(uint64_t));
traceData->stacks[threadId] = pStack;
}
#if 0
if (method->methodName) {
- fprintf(dumpStream, "%2d %-8llu %d %8llu r %d c %d %s.%s %s\n",
- threadId, currentTime, action, pStack->threadStartTime,
- method->recursiveEntries,
- pStack->top, method->className, method->methodName,
- method->signature);
+ fprintf(dumpStream, "%2d %-8llu %d %8llu r %d c %d %s.%s %s\n",
+ threadId, currentTime, action, pStack->threadStartTime,
+ method->recursiveEntries,
+ pStack->top, method->className, method->methodName,
+ method->signature);
} else {
- fprintf(dumpStream, "%2d %-8llu %d %8llu r %d c %d %s\n",
- threadId, currentTime, action, pStack->threadStartTime,
- method->recursiveEntries,
- pStack->top, method->className);
+ printf(dumpStream, "%2d %-8llu %d %8llu r %d c %d %s\n",
+ threadId, currentTime, action, pStack->threadStartTime,
+ method->recursiveEntries,
+ pStack->top, method->className);
}
#endif
/* Push the method on the stack for this thread */
pStack->calls[pStack->top].method = method;
pStack->calls[pStack->top++].entryTime = currentTime;
+
+ // For each filter
+ int result = 0;
+ for (ii = 0; ii < numFilters; ii++) {
+ result = filterMethod(method, filters[ii], 1, threadId, numThreads,
+ currentTime - pStack->lastEventTime, pStack->remTimes[ii]);
+
+ // TODO: make remTimes work properly
+ // Consider moving remTimes handling together with the rest
+ // of time handling and clean up the return codes
+ /*
+ if (result == 0) { // no time added, no remTime added
+ pStack->remTimes[ii] += currentTime - pStack->lastEventTime;
+ } else if (result == 3 || result == 4) { // remTime added
+ // Reset remTime, since it's been added
+ pStack->remTimes[ii] = 0;
+ }
+ */
+ }
+
} else {
/* This is a method exit */
uint64_t entryTime = 0;
if (method->recursiveEntries == 0) {
method->topExclusive += currentTime - pStack->lastEventTime;
}
+
+ // For each filter
+ int result = 0;
+ for (ii = 0; ii < numFilters; ii++) {
+ result = filterMethod(method, filters[ii], 0, threadId, numThreads,
+ currentTime - pStack->lastEventTime, pStack->remTimes[ii]);
+
+ // TODO: make remTimes work properly
+ /*
+ if (result == 0) { // no time added, no remTime added
+ pStack->remTimes[ii] += currentTime - pStack->lastEventTime;
+ } else if (result == 3 || result == 4) { // remTime added
+ // Reset remTime, since it's been added
+ pStack->remTimes[ii] = 0;
+ }
+ */
+ }
+
}
/* Remember the time of the last entry or exit event */
pStack->lastEventTime = currentTime;
if (pStack == NULL)
continue;
- /* Calculate time spent in thread, and add it to total time */
+ /* Calculate times spent in thread, and add it to total time */
elapsedTime = pStack->lastEventTime - pStack->threadStartTime;
sumThreadTime += elapsedTime;
- /* Save the per-thread elapsed time in the DataKeys struct */
- for (ii = 0; ii < dataKeys->numThreads; ++ii) {
- if (dataKeys->threads[ii].threadId == threadId)
- dataKeys->threads[ii].elapsedTime = elapsedTime;
- }
-
for (ii = 0; ii < pStack->top; ++ii) {
+ //printf("in loop\n");
+
if (ii == 0)
caller = &dataKeys->methods[TOPLEVEL_INDEX];
else
uint64_t entryTime = pStack->calls[ii].entryTime;
uint64_t elapsed = pStack->lastEventTime - entryTime;
addInclusiveTime(caller, method, elapsed);
+
+ // For each filter
+ int result = 0;
+ for (ii = 0; ii < numFilters; ii++) {
+ result = filterMethod(method, filters[ii], 0, threadId, numThreads,
+ currentTime - pStack->lastEventTime, pStack->remTimes[ii]);
+
+ // TODO: make remTimes work properly
+ /*
+ if (result == 0) { // no time added, no remTime added
+ pStack->remTimes[ii] += currentTime - pStack->lastEventTime;
+ } else if (result == 3 || result == 4) { // remTime added
+ // Reset remTime, since it's been added
+ pStack->remTimes[ii] = 0;
+ }
+ */
+ }
}
+
+ /* Save the per-thread elapsed time in the DataKeys struct */
+ for (ii = 0; ii < dataKeys->numThreads; ++ii) {
+ if (dataKeys->threads[ii].threadId == threadId) {
+ dataKeys->threads[ii].elapsedTime = elapsedTime;
+ }
+ }
+
+
}
caller = &dataKeys->methods[TOPLEVEL_INDEX];
caller->elapsedInclusive = sumThreadTime;
return pMethods;
}
+
/*
* Produce a function profile from the following methods
*/
void profileTrace(TraceData* traceData, MethodEntry **pMethods, int numMethods, uint64_t sumThreadTime,
- ThreadEntry *pThreads, int numThreads)
+ ThreadEntry *pThreads, int numThreads, Filter** filters)
{
- /* Print the html header, if necessary */
+ /* Print the html header, if necessary */
if (gOptions.outputHtml) {
printf(htmlHeader, gOptions.sortableUrl);
outputTableOfContents();
printExclusiveProfile(pMethods, numMethods, sumThreadTime);
printInclusiveProfile(pMethods, numMethods, sumThreadTime);
- printThreadProfile(pThreads, numThreads, sumThreadTime);
+ printThreadProfile(pThreads, numThreads, sumThreadTime, filters);
createClassList(traceData, pMethods, numMethods);
printClassProfiles(traceData, sumThreadTime);
int usage(const char *program)
{
- fprintf(stderr, "usage: %s [-ho] [-s sortable] [-d trace-file-name] [-g outfile] trace-file-name\n", program);
+ fprintf(stderr, "usage: %s [-ho] [-s sortable] [-d trace-file-name] [-g outfile] [-f filter-file] trace-file-name\n", program);
fprintf(stderr, " -d trace-file-name - Diff with this trace\n");
fprintf(stderr, " -g outfile - Write graph to 'outfile'\n");
+ fprintf(stderr, " -f filter-file - Filter functions as specified in file\n");
fprintf(stderr, " -k - When writing a graph, keep the intermediate DOT file\n");
fprintf(stderr, " -h - Turn on HTML output\n");
fprintf(stderr, " -o - Dump the dmtrace file instead of profiling\n");
int parseOptions(int argc, char **argv)
{
while (1) {
- int opt = getopt(argc, argv, "d:hg:kos:t:");
+ int opt = getopt(argc, argv, "d:hg:kos:t:f:");
if (opt == -1)
break;
switch (opt) {
case 'g':
gOptions.graphFileName = optarg;
break;
+ case 'f':
+ gOptions.filterFileName = optarg;
+ break;
case 'k':
gOptions.keepDotFile = 1;
break;
*/
int main(int argc, char** argv)
{
+
gOptions.threshold = -1;
-
+
// Parse the options
if (parseOptions(argc, argv) || argc - optind != 1)
return usage(argv[0]);
}
uint64_t sumThreadTime = 0;
-
+
+ Filter** filters = NULL;
+ if (gOptions.filterFileName != NULL) {
+ filters = parseFilters(gOptions.filterFileName);
+ }
+
TraceData data1;
DataKeys* dataKeys = parseDataKeys(&data1, gOptions.traceFileName,
- &sumThreadTime);
+ &sumThreadTime, filters);
if (dataKeys == NULL) {
fprintf(stderr, "Cannot read trace.\n");
exit(1);
if (gOptions.diffFileName != NULL) {
uint64_t sum2;
TraceData data2;
- DataKeys* d2 = parseDataKeys(&data2, gOptions.diffFileName, &sum2);
+ DataKeys* d2 = parseDataKeys(&data2, gOptions.diffFileName, &sum2, filters);
createDiff(d2, sum2, dataKeys, sumThreadTime);
} else {
MethodEntry** methods = parseMethodEntries(dataKeys);
profileTrace(&data1, methods, dataKeys->numMethods, sumThreadTime,
- dataKeys->threads, dataKeys->numThreads);
+ dataKeys->threads, dataKeys->numThreads, filters);
if (gOptions.graphFileName != NULL) {
createInclusiveProfileGraphNew(dataKeys);
}
--- /dev/null
+*GC
+dvmGcScanRootClassLoader
+mspace_walk_free_pages
+dvmCollectGarbageInternal
+doHeapWork
+dvmGetNextHeapWorkerObject
+GC
+GC2
+GC3
+*Net
+setsockopt
++sys_setsockopt [kernel]
+socketSelect
+send
+recv
+sendto
+recvfrom
++sys_sendto [kernel]
++sys_recvfrom [kernel]
+org.apache.harmony.luni.internal.net.www.protocol.http.HttpURLConnection
+android.net.http.ConnectionThread
+PlainSocketImpl
+WebCore::HTMLTokenizer
+*IO
+select
++sys_select [kernel]
+*DB
+android.database.sqlite.SQLiteOpenHelper
+android.database.sqlite.SQLiteQueryBuilder
+android.database.sqlite.SQLiteDatabase
+android.database.sqlite.SQLiteDirectCursorDriver
+android.database.sqlite.SQLiteQuery
+android.database.sqlite.SQLiteProgram
+android.database.AbstractCursor
+android.database.sqlite.SQLiteCursor
+*UI
+android.view.View.draw()
+android.view.ViewGroup
+*Sync
++java.lang.Object.wait()
+*Useless
++android.widget.ProgressBar
--- /dev/null
+#!/bin/bash
+
+failed=0
+for file in $(find $1 -type f -iname 'test*'); do
+ case $file in
+ *testFilters) continue; ;;
+ *Expected) continue; ;;
+ *Trace) continue; ;;
+ *.html) continue; ;;
+ esac
+
+ echo "Running test for $file"
+
+# create_test_dmtrace $file tmp.trace
+ dmtracedump -f testFilters -h "$file"Trace > tmp.html 2> /dev/null
+
+ output=`diff tmp.html "$file"Expected 2>&1`
+ if [ ${#output} -eq 0 ]
+ then
+ echo " OK"
+ else
+ echo " Test failed: $output"
+ failed=`expr $failed + 1`
+ fi
+
+done
+
+rm tmp.trace
+rm tmp.html
+
+if [ $failed -gt 0 ]
+then
+ echo "$failed test(s) failed"
+else
+ echo "All tests passed successfully"
+fi
--- /dev/null
+*FirstFilter
++A.m(),B.m()
++C.m()
++R.m(),S.m()
+*SecondFilter
++D.m(),E.m()
++F.m()
+*RepeatedFilter
++R.m(),S.m()
--- /dev/null
+# ____ ____ _________
+# __|A |___________|B |_____|Z |_______
+#
+# ___________ ____ ____
+# _______|Z |_____|D |_________|E |__
+#
+#
+0 1 A
+2 1 A
+0 2 Z
+4 2 Z
+2 1 B
+4 1 B
+4 2 D
+6 2 D
+4 1 Z
+8 1 Z
+6 2 E
+8 2 E
--- /dev/null
+<html>
+<head>
+<script type="text/javascript" src="(null)sortable.js"></script>
+<script langugage="javascript">
+function toggle(item) {
+ obj=document.getElementById(item);
+ visible=(obj.style.display!="none" && obj.style.display!="");
+ key=document.getElementById("x" + item);
+ if (visible) {
+ obj.style.display="none";
+ key.innerHTML="+";
+ } else {
+ obj.style.display="block";
+ key.innerHTML="-";
+ }
+}
+function onMouseOver(obj) {
+ obj.style.background="lightblue";
+}
+function onMouseOut(obj) {
+ obj.style.background="white";
+}
+</script>
+<style type="text/css">
+div { font-family: courier; font-size: 13 }
+div.parent { margin-left: 15; display: none }
+div.leaf { margin-left: 10 }
+div.header { margin-left: 10 }
+div.link { margin-left: 10; cursor: move }
+span.parent { padding-right: 10; }
+span.leaf { padding-right: 10; }
+a img { border: 0;}
+table.sortable th { border-width: 0px 1px 1px 1px; background-color: #ccc;}
+a { text-decoration: none; }
+a:hover { text-decoration: underline; }
+table.sortable th, table.sortable td { text-align: left;}table.sortable tr.odd td { background-color: #ddd; }
+table.sortable tr.even td { background-color: #fff; }
+</style>
+</head><body>
+
+<a name="contents"></a>
+<h2>Table of Contents</h2>
+<ul>
+ <li><a href="#exclusive">Exclusive profile</a></li>
+ <li><a href="#inclusive">Inclusive profile</a></li>
+ <li><a href="#thread">Thread profile</a></li>
+ <li><a href="#class">Class/method profile</a></li>
+ <li><a href="#method">Method/class profile</a></li>
+</ul>
+
+<a name="exclusive"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+Total cycles: 16
+
+<br><br>
+Exclusive elapsed times for each method, not including time spent in
+children, sorted by exclusive time.
+
+<br><br>
+<pre>
+ Usecs self % sum % Method
+ 8 50.00 50.00 <a href="#m1">[1]</a> Z.m ()
+ 2 12.50 62.50 <a href="#m2">[2]</a> A.m ()
+ 2 12.50 75.00 <a href="#m3">[3]</a> B.m ()
+ 2 12.50 87.50 <a href="#m4">[4]</a> D.m ()
+ 2 12.50 100.00 <a href="#m5">[5]</a> E.m ()
+</pre>
+<a name="inclusive"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Inclusive elapsed times for each method and its parents and children,
+sorted by inclusive time.
+
+<br><br>
+<pre>
+index %/total %/self index calls usecs name
+<a name="m0"></a>----------------------------------------------------
+[0] 100.0% 0+0 16 (toplevel)
+ 0.0% excl 0
+ 50.0% <a href="#m1">[1]</a> 2/2 8 Z.m ()
+ 12.5% <a href="#m2">[2]</a> 1/1 2 A.m ()
+ 12.5% <a href="#m3">[3]</a> 1/1 2 B.m ()
+ 12.5% <a href="#m4">[4]</a> 1/1 2 D.m ()
+ 12.5% <a href="#m5">[5]</a> 1/1 2 E.m ()
+<a name="m1"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 2/2 8 (toplevel)
+[1] 50.0% 2+0 8 Z.m ()
+ 100.0% excl 8
+<a name="m2"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 2 (toplevel)
+[2] 12.5% 1+0 2 A.m ()
+ 100.0% excl 2
+<a name="m3"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 2 (toplevel)
+[3] 12.5% 1+0 2 B.m ()
+ 100.0% excl 2
+<a name="m4"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 2 (toplevel)
+[4] 12.5% 1+0 2 D.m ()
+ 100.0% excl 2
+<a name="m5"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 2 (toplevel)
+[5] 12.5% 1+0 2 E.m ()
+ 100.0% excl 2
+</pre>
+<a name="thread"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Elapsed times for each thread, sorted by elapsed time.
+Also includes percentage of time spent during the <i>execution</i> of any filters.
+
+<br><br>
+<pre>
+ Usecs self % sum % FirstFilter % SecondFilter % RepeatedFilter % tid ThreadName
+ 8 50.00 50.00 50.00 0.00 0.00 1 main
+ 8 50.00 100.00 0.00 50.00 0.00 2 foo
+ 0 0.00 100.00 nan nan nan 3 bar
+ 0 0.00 100.00 nan nan nan 4 blah
+</pre><br />
+
+Break-down of portion of time spent by each thread while waiting on a filter method.
+<br/><br/>
+<pre>
+Filter: FirstFilter
+Total waiting cycles: 8 ( 50.00% of total)
+Details:
+
+ Waiting cycles % of total waiting time execution time while waiting thread name
+ 8 100.00 50.00 main
+ 0 0.00 50.00 foo
+ 0 0.00 0.00 bar
+ 0 0.00 0.00 blah
+</pre>
+<br/><br/>
+<pre>
+Filter: SecondFilter
+Total waiting cycles: 8 ( 50.00% of total)
+Details:
+
+ Waiting cycles % of total waiting time execution time while waiting thread name
+ 0 0.00 50.00 main
+ 8 100.00 50.00 foo
+ 0 0.00 0.00 bar
+ 0 0.00 0.00 blah
+</pre>
+<br/><br/>
+<pre>
+Filter: RepeatedFilter
+Total waiting cycles: 0 ( 0.00% of total)
+</pre>
+<a name="class"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Exclusive elapsed time for each class, summed over all the methods
+in the class.
+
+<br><br>
+<div class="header"><span class="parent"> </span> Cycles %/total Cumul.% Calls+Recur Class</div>
+<div class="link" onClick="javascript:toggle('d0')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd0">+</span> 8 50.0 50.0 2+0 Z</div>
+<div class="parent" id="d0">
+<div class="leaf"><span class="leaf"> </span> 8 8 100.0 100.0 2+0 <a href="#m1">[1]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d1')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd1">+</span> 2 12.5 62.5 1+0 A</div>
+<div class="parent" id="d1">
+<div class="leaf"><span class="leaf"> </span> 2 2 100.0 100.0 1+0 <a href="#m2">[2]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d2')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd2">+</span> 2 12.5 75.0 1+0 B</div>
+<div class="parent" id="d2">
+<div class="leaf"><span class="leaf"> </span> 2 2 100.0 100.0 1+0 <a href="#m3">[3]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d3')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd3">+</span> 2 12.5 87.5 1+0 D</div>
+<div class="parent" id="d3">
+<div class="leaf"><span class="leaf"> </span> 2 2 100.0 100.0 1+0 <a href="#m4">[4]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d4')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd4">+</span> 2 12.5 100.0 1+0 E</div>
+<div class="parent" id="d4">
+<div class="leaf"><span class="leaf"> </span> 2 2 100.0 100.0 1+0 <a href="#m5">[5]</a> m ()</div>
+</div>
+<a name="method"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Exclusive elapsed time for each method, summed over all the classes
+that contain a method with the same name.
+
+<br><br>
+<div class="header"><span class="parent"> </span> Cycles %/total Cumul.% Calls+Recur Method</div>
+<div class="link" onClick="javascript:toggle('e0')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xe0">+</span> 16 100.0 100.0 6+0 m</div>
+<div class="parent" id="e0">
+<div class="leaf"><span class="leaf"> </span> 8 8 50.0 50.0 2+0 <a href="#m1">[1]</a> Z.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 2 2 12.5 62.5 1+0 <a href="#m2">[2]</a> A.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 2 2 12.5 75.0 1+0 <a href="#m3">[3]</a> B.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 2 2 12.5 87.5 1+0 <a href="#m4">[4]</a> D.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 2 2 12.5 100.0 1+0 <a href="#m5">[5]</a> E.m ()</div>
+</div>
+
+</body>
+</html>
--- /dev/null
+# ____ ____ _________
+# __|R |___________|S |_____|Z |_______
+#
+# ___________ ____ ____
+# _______|Z |_____|R |_________|S |__
+#
+#
+0 1 R
+2 1 R
+0 2 Z
+4 2 Z
+2 1 S
+4 1 S
+4 2 R
+6 2 R
+4 1 Z
+8 1 Z
+6 2 S
+8 2 S
--- /dev/null
+<html>
+<head>
+<script type="text/javascript" src="(null)sortable.js"></script>
+<script langugage="javascript">
+function toggle(item) {
+ obj=document.getElementById(item);
+ visible=(obj.style.display!="none" && obj.style.display!="");
+ key=document.getElementById("x" + item);
+ if (visible) {
+ obj.style.display="none";
+ key.innerHTML="+";
+ } else {
+ obj.style.display="block";
+ key.innerHTML="-";
+ }
+}
+function onMouseOver(obj) {
+ obj.style.background="lightblue";
+}
+function onMouseOut(obj) {
+ obj.style.background="white";
+}
+</script>
+<style type="text/css">
+div { font-family: courier; font-size: 13 }
+div.parent { margin-left: 15; display: none }
+div.leaf { margin-left: 10 }
+div.header { margin-left: 10 }
+div.link { margin-left: 10; cursor: move }
+span.parent { padding-right: 10; }
+span.leaf { padding-right: 10; }
+a img { border: 0;}
+table.sortable th { border-width: 0px 1px 1px 1px; background-color: #ccc;}
+a { text-decoration: none; }
+a:hover { text-decoration: underline; }
+table.sortable th, table.sortable td { text-align: left;}table.sortable tr.odd td { background-color: #ddd; }
+table.sortable tr.even td { background-color: #fff; }
+</style>
+</head><body>
+
+<a name="contents"></a>
+<h2>Table of Contents</h2>
+<ul>
+ <li><a href="#exclusive">Exclusive profile</a></li>
+ <li><a href="#inclusive">Inclusive profile</a></li>
+ <li><a href="#thread">Thread profile</a></li>
+ <li><a href="#class">Class/method profile</a></li>
+ <li><a href="#method">Method/class profile</a></li>
+</ul>
+
+<a name="exclusive"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+Total cycles: 16
+
+<br><br>
+Exclusive elapsed times for each method, not including time spent in
+children, sorted by exclusive time.
+
+<br><br>
+<pre>
+ Usecs self % sum % Method
+ 8 50.00 50.00 <a href="#m1">[1]</a> Z.m ()
+ 4 25.00 75.00 <a href="#m2">[2]</a> R.m ()
+ 4 25.00 100.00 <a href="#m3">[3]</a> S.m ()
+</pre>
+<a name="inclusive"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Inclusive elapsed times for each method and its parents and children,
+sorted by inclusive time.
+
+<br><br>
+<pre>
+index %/total %/self index calls usecs name
+<a name="m0"></a>----------------------------------------------------
+[0] 100.0% 0+0 16 (toplevel)
+ 0.0% excl 0
+ 50.0% <a href="#m1">[1]</a> 2/2 8 Z.m ()
+ 25.0% <a href="#m2">[2]</a> 2/2 4 R.m ()
+ 25.0% <a href="#m3">[3]</a> 2/2 4 S.m ()
+<a name="m1"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 2/2 8 (toplevel)
+[1] 50.0% 2+0 8 Z.m ()
+ 100.0% excl 8
+<a name="m2"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 2/2 4 (toplevel)
+[2] 25.0% 2+0 4 R.m ()
+ 100.0% excl 4
+<a name="m3"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 2/2 4 (toplevel)
+[3] 25.0% 2+0 4 S.m ()
+ 100.0% excl 4
+</pre>
+<a name="thread"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Elapsed times for each thread, sorted by elapsed time.
+Also includes percentage of time spent during the <i>execution</i> of any filters.
+
+<br><br>
+<pre>
+ Usecs self % sum % FirstFilter % SecondFilter % RepeatedFilter % tid ThreadName
+ 8 50.00 50.00 50.00 0.00 50.00 1 main
+ 8 50.00 100.00 50.00 0.00 50.00 2 foo
+ 0 0.00 100.00 nan nan nan 3 bar
+ 0 0.00 100.00 nan nan nan 4 blah
+</pre><br />
+
+Break-down of portion of time spent by each thread while waiting on a filter method.
+<br/><br/>
+<pre>
+Filter: FirstFilter
+Total waiting cycles: 16 (100.00% of total)
+Details:
+
+ Waiting cycles % of total waiting time execution time while waiting thread name
+ 8 50.00 50.00 main
+ 8 50.00 50.00 foo
+ 0 0.00 0.00 bar
+ 0 0.00 0.00 blah
+</pre>
+<br/><br/>
+<pre>
+Filter: SecondFilter
+Total waiting cycles: 0 ( 0.00% of total)
+</pre>
+<br/><br/>
+<pre>
+Filter: RepeatedFilter
+Total waiting cycles: 16 (100.00% of total)
+Details:
+
+ Waiting cycles % of total waiting time execution time while waiting thread name
+ 8 50.00 50.00 main
+ 8 50.00 50.00 foo
+ 0 0.00 0.00 bar
+ 0 0.00 0.00 blah
+</pre>
+<a name="class"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Exclusive elapsed time for each class, summed over all the methods
+in the class.
+
+<br><br>
+<div class="header"><span class="parent"> </span> Cycles %/total Cumul.% Calls+Recur Class</div>
+<div class="link" onClick="javascript:toggle('d0')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd0">+</span> 8 50.0 50.0 2+0 Z</div>
+<div class="parent" id="d0">
+<div class="leaf"><span class="leaf"> </span> 8 8 100.0 100.0 2+0 <a href="#m1">[1]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d1')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd1">+</span> 4 25.0 75.0 2+0 R</div>
+<div class="parent" id="d1">
+<div class="leaf"><span class="leaf"> </span> 4 4 100.0 100.0 2+0 <a href="#m2">[2]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d2')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd2">+</span> 4 25.0 100.0 2+0 S</div>
+<div class="parent" id="d2">
+<div class="leaf"><span class="leaf"> </span> 4 4 100.0 100.0 2+0 <a href="#m3">[3]</a> m ()</div>
+</div>
+<a name="method"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Exclusive elapsed time for each method, summed over all the classes
+that contain a method with the same name.
+
+<br><br>
+<div class="header"><span class="parent"> </span> Cycles %/total Cumul.% Calls+Recur Method</div>
+<div class="link" onClick="javascript:toggle('e0')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xe0">+</span> 16 100.0 100.0 6+0 m</div>
+<div class="parent" id="e0">
+<div class="leaf"><span class="leaf"> </span> 8 8 50.0 50.0 2+0 <a href="#m1">[1]</a> Z.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 4 4 25.0 75.0 2+0 <a href="#m2">[2]</a> R.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 4 4 25.0 100.0 2+0 <a href="#m3">[3]</a> S.m ()</div>
+</div>
+
+</body>
+</html>
--- /dev/null
+# ____ ____ _________
+# __|A |___________|B |_____|Z |_______
+#
+# ___________ ____ ____
+# _______|Z |_____|R |_________|S |__
+#
+#
+0 1 A
+2 1 A
+0 2 Z
+4 2 Z
+2 1 B
+4 1 B
+4 2 R
+6 2 R
+4 1 Z
+8 1 Z
+6 2 S
+8 2 S
--- /dev/null
+<html>
+<head>
+<script type="text/javascript" src="(null)sortable.js"></script>
+<script langugage="javascript">
+function toggle(item) {
+ obj=document.getElementById(item);
+ visible=(obj.style.display!="none" && obj.style.display!="");
+ key=document.getElementById("x" + item);
+ if (visible) {
+ obj.style.display="none";
+ key.innerHTML="+";
+ } else {
+ obj.style.display="block";
+ key.innerHTML="-";
+ }
+}
+function onMouseOver(obj) {
+ obj.style.background="lightblue";
+}
+function onMouseOut(obj) {
+ obj.style.background="white";
+}
+</script>
+<style type="text/css">
+div { font-family: courier; font-size: 13 }
+div.parent { margin-left: 15; display: none }
+div.leaf { margin-left: 10 }
+div.header { margin-left: 10 }
+div.link { margin-left: 10; cursor: move }
+span.parent { padding-right: 10; }
+span.leaf { padding-right: 10; }
+a img { border: 0;}
+table.sortable th { border-width: 0px 1px 1px 1px; background-color: #ccc;}
+a { text-decoration: none; }
+a:hover { text-decoration: underline; }
+table.sortable th, table.sortable td { text-align: left;}table.sortable tr.odd td { background-color: #ddd; }
+table.sortable tr.even td { background-color: #fff; }
+</style>
+</head><body>
+
+<a name="contents"></a>
+<h2>Table of Contents</h2>
+<ul>
+ <li><a href="#exclusive">Exclusive profile</a></li>
+ <li><a href="#inclusive">Inclusive profile</a></li>
+ <li><a href="#thread">Thread profile</a></li>
+ <li><a href="#class">Class/method profile</a></li>
+ <li><a href="#method">Method/class profile</a></li>
+</ul>
+
+<a name="exclusive"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+Total cycles: 16
+
+<br><br>
+Exclusive elapsed times for each method, not including time spent in
+children, sorted by exclusive time.
+
+<br><br>
+<pre>
+ Usecs self % sum % Method
+ 8 50.00 50.00 <a href="#m1">[1]</a> Z.m ()
+ 2 12.50 62.50 <a href="#m2">[2]</a> A.m ()
+ 2 12.50 75.00 <a href="#m3">[3]</a> B.m ()
+ 2 12.50 87.50 <a href="#m4">[4]</a> R.m ()
+ 2 12.50 100.00 <a href="#m5">[5]</a> S.m ()
+</pre>
+<a name="inclusive"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Inclusive elapsed times for each method and its parents and children,
+sorted by inclusive time.
+
+<br><br>
+<pre>
+index %/total %/self index calls usecs name
+<a name="m0"></a>----------------------------------------------------
+[0] 100.0% 0+0 16 (toplevel)
+ 0.0% excl 0
+ 50.0% <a href="#m1">[1]</a> 2/2 8 Z.m ()
+ 12.5% <a href="#m2">[2]</a> 1/1 2 A.m ()
+ 12.5% <a href="#m3">[3]</a> 1/1 2 B.m ()
+ 12.5% <a href="#m4">[4]</a> 1/1 2 R.m ()
+ 12.5% <a href="#m5">[5]</a> 1/1 2 S.m ()
+<a name="m1"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 2/2 8 (toplevel)
+[1] 50.0% 2+0 8 Z.m ()
+ 100.0% excl 8
+<a name="m2"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 2 (toplevel)
+[2] 12.5% 1+0 2 A.m ()
+ 100.0% excl 2
+<a name="m3"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 2 (toplevel)
+[3] 12.5% 1+0 2 B.m ()
+ 100.0% excl 2
+<a name="m4"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 2 (toplevel)
+[4] 12.5% 1+0 2 R.m ()
+ 100.0% excl 2
+<a name="m5"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 2 (toplevel)
+[5] 12.5% 1+0 2 S.m ()
+ 100.0% excl 2
+</pre>
+<a name="thread"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Elapsed times for each thread, sorted by elapsed time.
+Also includes percentage of time spent during the <i>execution</i> of any filters.
+
+<br><br>
+<pre>
+ Usecs self % sum % FirstFilter % SecondFilter % RepeatedFilter % tid ThreadName
+ 8 50.00 50.00 50.00 0.00 0.00 1 main
+ 8 50.00 100.00 50.00 0.00 50.00 2 foo
+ 0 0.00 100.00 nan nan nan 3 bar
+ 0 0.00 100.00 nan nan nan 4 blah
+</pre><br />
+
+Break-down of portion of time spent by each thread while waiting on a filter method.
+<br/><br/>
+<pre>
+Filter: FirstFilter
+Total waiting cycles: 16 (100.00% of total)
+Details:
+
+ Waiting cycles % of total waiting time execution time while waiting thread name
+ 8 50.00 50.00 main
+ 8 50.00 50.00 foo
+ 0 0.00 0.00 bar
+ 0 0.00 0.00 blah
+</pre>
+<br/><br/>
+<pre>
+Filter: SecondFilter
+Total waiting cycles: 0 ( 0.00% of total)
+</pre>
+<br/><br/>
+<pre>
+Filter: RepeatedFilter
+Total waiting cycles: 8 ( 50.00% of total)
+Details:
+
+ Waiting cycles % of total waiting time execution time while waiting thread name
+ 0 0.00 50.00 main
+ 8 100.00 50.00 foo
+ 0 0.00 0.00 bar
+ 0 0.00 0.00 blah
+</pre>
+<a name="class"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Exclusive elapsed time for each class, summed over all the methods
+in the class.
+
+<br><br>
+<div class="header"><span class="parent"> </span> Cycles %/total Cumul.% Calls+Recur Class</div>
+<div class="link" onClick="javascript:toggle('d0')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd0">+</span> 8 50.0 50.0 2+0 Z</div>
+<div class="parent" id="d0">
+<div class="leaf"><span class="leaf"> </span> 8 8 100.0 100.0 2+0 <a href="#m1">[1]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d1')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd1">+</span> 2 12.5 62.5 1+0 A</div>
+<div class="parent" id="d1">
+<div class="leaf"><span class="leaf"> </span> 2 2 100.0 100.0 1+0 <a href="#m2">[2]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d2')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd2">+</span> 2 12.5 75.0 1+0 B</div>
+<div class="parent" id="d2">
+<div class="leaf"><span class="leaf"> </span> 2 2 100.0 100.0 1+0 <a href="#m3">[3]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d3')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd3">+</span> 2 12.5 87.5 1+0 R</div>
+<div class="parent" id="d3">
+<div class="leaf"><span class="leaf"> </span> 2 2 100.0 100.0 1+0 <a href="#m4">[4]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d4')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd4">+</span> 2 12.5 100.0 1+0 S</div>
+<div class="parent" id="d4">
+<div class="leaf"><span class="leaf"> </span> 2 2 100.0 100.0 1+0 <a href="#m5">[5]</a> m ()</div>
+</div>
+<a name="method"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Exclusive elapsed time for each method, summed over all the classes
+that contain a method with the same name.
+
+<br><br>
+<div class="header"><span class="parent"> </span> Cycles %/total Cumul.% Calls+Recur Method</div>
+<div class="link" onClick="javascript:toggle('e0')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xe0">+</span> 16 100.0 100.0 6+0 m</div>
+<div class="parent" id="e0">
+<div class="leaf"><span class="leaf"> </span> 8 8 50.0 50.0 2+0 <a href="#m1">[1]</a> Z.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 2 2 12.5 62.5 1+0 <a href="#m2">[2]</a> A.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 2 2 12.5 75.0 1+0 <a href="#m3">[3]</a> B.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 2 2 12.5 87.5 1+0 <a href="#m4">[4]</a> R.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 2 2 12.5 100.0 1+0 <a href="#m5">[5]</a> S.m ()</div>
+</div>
+
+</body>
+</html>
--- /dev/null
+# ____ ____ _________
+# __|A |___________|B |_____|Z |_______
+#
+# ___________ ____ ____
+# _______|Z |_____|A |_________|B |__
+#
+#
+0 1 A
+2 1 A
+0 2 Z
+4 2 Z
+2 1 B
+4 1 B
+4 2 A
+6 2 A
+4 1 Z
+8 1 Z
+6 2 B
+8 2 B
--- /dev/null
+<html>
+<head>
+<script type="text/javascript" src="(null)sortable.js"></script>
+<script langugage="javascript">
+function toggle(item) {
+ obj=document.getElementById(item);
+ visible=(obj.style.display!="none" && obj.style.display!="");
+ key=document.getElementById("x" + item);
+ if (visible) {
+ obj.style.display="none";
+ key.innerHTML="+";
+ } else {
+ obj.style.display="block";
+ key.innerHTML="-";
+ }
+}
+function onMouseOver(obj) {
+ obj.style.background="lightblue";
+}
+function onMouseOut(obj) {
+ obj.style.background="white";
+}
+</script>
+<style type="text/css">
+div { font-family: courier; font-size: 13 }
+div.parent { margin-left: 15; display: none }
+div.leaf { margin-left: 10 }
+div.header { margin-left: 10 }
+div.link { margin-left: 10; cursor: move }
+span.parent { padding-right: 10; }
+span.leaf { padding-right: 10; }
+a img { border: 0;}
+table.sortable th { border-width: 0px 1px 1px 1px; background-color: #ccc;}
+a { text-decoration: none; }
+a:hover { text-decoration: underline; }
+table.sortable th, table.sortable td { text-align: left;}table.sortable tr.odd td { background-color: #ddd; }
+table.sortable tr.even td { background-color: #fff; }
+</style>
+</head><body>
+
+<a name="contents"></a>
+<h2>Table of Contents</h2>
+<ul>
+ <li><a href="#exclusive">Exclusive profile</a></li>
+ <li><a href="#inclusive">Inclusive profile</a></li>
+ <li><a href="#thread">Thread profile</a></li>
+ <li><a href="#class">Class/method profile</a></li>
+ <li><a href="#method">Method/class profile</a></li>
+</ul>
+
+<a name="exclusive"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+Total cycles: 16
+
+<br><br>
+Exclusive elapsed times for each method, not including time spent in
+children, sorted by exclusive time.
+
+<br><br>
+<pre>
+ Usecs self % sum % Method
+ 8 50.00 50.00 <a href="#m1">[1]</a> Z.m ()
+ 4 25.00 75.00 <a href="#m2">[2]</a> A.m ()
+ 4 25.00 100.00 <a href="#m3">[3]</a> B.m ()
+</pre>
+<a name="inclusive"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Inclusive elapsed times for each method and its parents and children,
+sorted by inclusive time.
+
+<br><br>
+<pre>
+index %/total %/self index calls usecs name
+<a name="m0"></a>----------------------------------------------------
+[0] 100.0% 0+0 16 (toplevel)
+ 0.0% excl 0
+ 50.0% <a href="#m1">[1]</a> 2/2 8 Z.m ()
+ 25.0% <a href="#m2">[2]</a> 2/2 4 A.m ()
+ 25.0% <a href="#m3">[3]</a> 2/2 4 B.m ()
+<a name="m1"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 2/2 8 (toplevel)
+[1] 50.0% 2+0 8 Z.m ()
+ 100.0% excl 8
+<a name="m2"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 2/2 4 (toplevel)
+[2] 25.0% 2+0 4 A.m ()
+ 100.0% excl 4
+<a name="m3"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 2/2 4 (toplevel)
+[3] 25.0% 2+0 4 B.m ()
+ 100.0% excl 4
+</pre>
+<a name="thread"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Elapsed times for each thread, sorted by elapsed time.
+Also includes percentage of time spent during the <i>execution</i> of any filters.
+
+<br><br>
+<pre>
+ Usecs self % sum % FirstFilter % SecondFilter % RepeatedFilter % tid ThreadName
+ 8 50.00 50.00 50.00 0.00 0.00 1 main
+ 8 50.00 100.00 50.00 0.00 0.00 2 foo
+ 0 0.00 100.00 nan nan nan 3 bar
+ 0 0.00 100.00 nan nan nan 4 blah
+</pre><br />
+
+Break-down of portion of time spent by each thread while waiting on a filter method.
+<br/><br/>
+<pre>
+Filter: FirstFilter
+Total waiting cycles: 16 (100.00% of total)
+Details:
+
+ Waiting cycles % of total waiting time execution time while waiting thread name
+ 8 50.00 50.00 main
+ 8 50.00 50.00 foo
+ 0 0.00 0.00 bar
+ 0 0.00 0.00 blah
+</pre>
+<br/><br/>
+<pre>
+Filter: SecondFilter
+Total waiting cycles: 0 ( 0.00% of total)
+</pre>
+<br/><br/>
+<pre>
+Filter: RepeatedFilter
+Total waiting cycles: 0 ( 0.00% of total)
+</pre>
+<a name="class"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Exclusive elapsed time for each class, summed over all the methods
+in the class.
+
+<br><br>
+<div class="header"><span class="parent"> </span> Cycles %/total Cumul.% Calls+Recur Class</div>
+<div class="link" onClick="javascript:toggle('d0')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd0">+</span> 8 50.0 50.0 2+0 Z</div>
+<div class="parent" id="d0">
+<div class="leaf"><span class="leaf"> </span> 8 8 100.0 100.0 2+0 <a href="#m1">[1]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d1')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd1">+</span> 4 25.0 75.0 2+0 A</div>
+<div class="parent" id="d1">
+<div class="leaf"><span class="leaf"> </span> 4 4 100.0 100.0 2+0 <a href="#m2">[2]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d2')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd2">+</span> 4 25.0 100.0 2+0 B</div>
+<div class="parent" id="d2">
+<div class="leaf"><span class="leaf"> </span> 4 4 100.0 100.0 2+0 <a href="#m3">[3]</a> m ()</div>
+</div>
+<a name="method"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Exclusive elapsed time for each method, summed over all the classes
+that contain a method with the same name.
+
+<br><br>
+<div class="header"><span class="parent"> </span> Cycles %/total Cumul.% Calls+Recur Method</div>
+<div class="link" onClick="javascript:toggle('e0')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xe0">+</span> 16 100.0 100.0 6+0 m</div>
+<div class="parent" id="e0">
+<div class="leaf"><span class="leaf"> </span> 8 8 50.0 50.0 2+0 <a href="#m1">[1]</a> Z.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 4 4 25.0 75.0 2+0 <a href="#m2">[2]</a> A.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 4 4 25.0 100.0 2+0 <a href="#m3">[3]</a> B.m ()</div>
+</div>
+
+</body>
+</html>
--- /dev/null
+# ____ ____ ____ ________ ____ ____ ____
+# __|A ||Z ||B ||Z ||D ||Z ||E |__
+#
+0 1 A
+2 1 A
+2 1 Z
+4 1 Z
+4 1 B
+6 1 B
+6 1 Z
+10 1 Z
+10 1 D
+12 1 D
+12 1 Z
+14 1 Z
+14 1 E
+16 1 E
--- /dev/null
+<html>
+<head>
+<script type="text/javascript" src="(null)sortable.js"></script>
+<script langugage="javascript">
+function toggle(item) {
+ obj=document.getElementById(item);
+ visible=(obj.style.display!="none" && obj.style.display!="");
+ key=document.getElementById("x" + item);
+ if (visible) {
+ obj.style.display="none";
+ key.innerHTML="+";
+ } else {
+ obj.style.display="block";
+ key.innerHTML="-";
+ }
+}
+function onMouseOver(obj) {
+ obj.style.background="lightblue";
+}
+function onMouseOut(obj) {
+ obj.style.background="white";
+}
+</script>
+<style type="text/css">
+div { font-family: courier; font-size: 13 }
+div.parent { margin-left: 15; display: none }
+div.leaf { margin-left: 10 }
+div.header { margin-left: 10 }
+div.link { margin-left: 10; cursor: move }
+span.parent { padding-right: 10; }
+span.leaf { padding-right: 10; }
+a img { border: 0;}
+table.sortable th { border-width: 0px 1px 1px 1px; background-color: #ccc;}
+a { text-decoration: none; }
+a:hover { text-decoration: underline; }
+table.sortable th, table.sortable td { text-align: left;}table.sortable tr.odd td { background-color: #ddd; }
+table.sortable tr.even td { background-color: #fff; }
+</style>
+</head><body>
+
+<a name="contents"></a>
+<h2>Table of Contents</h2>
+<ul>
+ <li><a href="#exclusive">Exclusive profile</a></li>
+ <li><a href="#inclusive">Inclusive profile</a></li>
+ <li><a href="#thread">Thread profile</a></li>
+ <li><a href="#class">Class/method profile</a></li>
+ <li><a href="#method">Method/class profile</a></li>
+</ul>
+
+<a name="exclusive"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+Total cycles: 16
+
+<br><br>
+Exclusive elapsed times for each method, not including time spent in
+children, sorted by exclusive time.
+
+<br><br>
+<pre>
+ Usecs self % sum % Method
+ 8 50.00 50.00 <a href="#m1">[1]</a> Z.m ()
+ 2 12.50 62.50 <a href="#m2">[2]</a> A.m ()
+ 2 12.50 75.00 <a href="#m3">[3]</a> B.m ()
+ 2 12.50 87.50 <a href="#m4">[4]</a> D.m ()
+ 2 12.50 100.00 <a href="#m5">[5]</a> E.m ()
+</pre>
+<a name="inclusive"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Inclusive elapsed times for each method and its parents and children,
+sorted by inclusive time.
+
+<br><br>
+<pre>
+index %/total %/self index calls usecs name
+<a name="m0"></a>----------------------------------------------------
+[0] 100.0% 0+0 16 (toplevel)
+ 0.0% excl 0
+ 50.0% <a href="#m1">[1]</a> 3/3 8 Z.m ()
+ 12.5% <a href="#m2">[2]</a> 1/1 2 A.m ()
+ 12.5% <a href="#m3">[3]</a> 1/1 2 B.m ()
+ 12.5% <a href="#m4">[4]</a> 1/1 2 D.m ()
+ 12.5% <a href="#m5">[5]</a> 1/1 2 E.m ()
+<a name="m1"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 3/3 8 (toplevel)
+[1] 50.0% 3+0 8 Z.m ()
+ 100.0% excl 8
+<a name="m2"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 2 (toplevel)
+[2] 12.5% 1+0 2 A.m ()
+ 100.0% excl 2
+<a name="m3"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 2 (toplevel)
+[3] 12.5% 1+0 2 B.m ()
+ 100.0% excl 2
+<a name="m4"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 2 (toplevel)
+[4] 12.5% 1+0 2 D.m ()
+ 100.0% excl 2
+<a name="m5"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 2 (toplevel)
+[5] 12.5% 1+0 2 E.m ()
+ 100.0% excl 2
+</pre>
+<a name="thread"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Elapsed times for each thread, sorted by elapsed time.
+Also includes percentage of time spent during the <i>execution</i> of any filters.
+
+<br><br>
+<pre>
+ Usecs self % sum % FirstFilter % SecondFilter % RepeatedFilter % tid ThreadName
+ 16 100.00 100.00 37.50 37.50 0.00 1 main
+ 0 0.00 100.00 nan nan nan 2 foo
+ 0 0.00 100.00 nan nan nan 3 bar
+ 0 0.00 100.00 nan nan nan 4 blah
+</pre><br />
+
+Break-down of portion of time spent by each thread while waiting on a filter method.
+<br/><br/>
+<pre>
+Filter: FirstFilter
+Total waiting cycles: 6 ( 37.50% of total)
+Details:
+
+ Waiting cycles % of total waiting time execution time while waiting thread name
+ 6 100.00 100.00 main
+ 0 0.00 0.00 foo
+ 0 0.00 0.00 bar
+ 0 0.00 0.00 blah
+</pre>
+<br/><br/>
+<pre>
+Filter: SecondFilter
+Total waiting cycles: 6 ( 37.50% of total)
+Details:
+
+ Waiting cycles % of total waiting time execution time while waiting thread name
+ 6 100.00 100.00 main
+ 0 0.00 0.00 foo
+ 0 0.00 0.00 bar
+ 0 0.00 0.00 blah
+</pre>
+<br/><br/>
+<pre>
+Filter: RepeatedFilter
+Total waiting cycles: 0 ( 0.00% of total)
+</pre>
+<a name="class"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Exclusive elapsed time for each class, summed over all the methods
+in the class.
+
+<br><br>
+<div class="header"><span class="parent"> </span> Cycles %/total Cumul.% Calls+Recur Class</div>
+<div class="link" onClick="javascript:toggle('d0')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd0">+</span> 8 50.0 50.0 3+0 Z</div>
+<div class="parent" id="d0">
+<div class="leaf"><span class="leaf"> </span> 8 8 100.0 100.0 3+0 <a href="#m1">[1]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d1')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd1">+</span> 2 12.5 62.5 1+0 A</div>
+<div class="parent" id="d1">
+<div class="leaf"><span class="leaf"> </span> 2 2 100.0 100.0 1+0 <a href="#m2">[2]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d2')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd2">+</span> 2 12.5 75.0 1+0 B</div>
+<div class="parent" id="d2">
+<div class="leaf"><span class="leaf"> </span> 2 2 100.0 100.0 1+0 <a href="#m3">[3]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d3')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd3">+</span> 2 12.5 87.5 1+0 D</div>
+<div class="parent" id="d3">
+<div class="leaf"><span class="leaf"> </span> 2 2 100.0 100.0 1+0 <a href="#m4">[4]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d4')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd4">+</span> 2 12.5 100.0 1+0 E</div>
+<div class="parent" id="d4">
+<div class="leaf"><span class="leaf"> </span> 2 2 100.0 100.0 1+0 <a href="#m5">[5]</a> m ()</div>
+</div>
+<a name="method"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Exclusive elapsed time for each method, summed over all the classes
+that contain a method with the same name.
+
+<br><br>
+<div class="header"><span class="parent"> </span> Cycles %/total Cumul.% Calls+Recur Method</div>
+<div class="link" onClick="javascript:toggle('e0')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xe0">+</span> 16 100.0 100.0 7+0 m</div>
+<div class="parent" id="e0">
+<div class="leaf"><span class="leaf"> </span> 8 8 50.0 50.0 3+0 <a href="#m1">[1]</a> Z.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 2 2 12.5 62.5 1+0 <a href="#m2">[2]</a> A.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 2 2 12.5 75.0 1+0 <a href="#m3">[3]</a> B.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 2 2 12.5 87.5 1+0 <a href="#m4">[4]</a> D.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 2 2 12.5 100.0 1+0 <a href="#m5">[5]</a> E.m ()</div>
+</div>
+
+</body>
+</html>
--- /dev/null
+# ____ ____ ____ ________ ____ ____ ____
+# __|R ||Z ||S ||Z ||R ||Z ||S |__
+#
+0 1 R
+2 1 R
+2 1 Z
+4 1 Z
+4 1 S
+6 1 S
+6 1 Z
+10 1 Z
+10 1 R
+12 1 R
+12 1 Z
+14 1 Z
+14 1 S
+16 1 S
--- /dev/null
+<html>
+<head>
+<script type="text/javascript" src="(null)sortable.js"></script>
+<script langugage="javascript">
+function toggle(item) {
+ obj=document.getElementById(item);
+ visible=(obj.style.display!="none" && obj.style.display!="");
+ key=document.getElementById("x" + item);
+ if (visible) {
+ obj.style.display="none";
+ key.innerHTML="+";
+ } else {
+ obj.style.display="block";
+ key.innerHTML="-";
+ }
+}
+function onMouseOver(obj) {
+ obj.style.background="lightblue";
+}
+function onMouseOut(obj) {
+ obj.style.background="white";
+}
+</script>
+<style type="text/css">
+div { font-family: courier; font-size: 13 }
+div.parent { margin-left: 15; display: none }
+div.leaf { margin-left: 10 }
+div.header { margin-left: 10 }
+div.link { margin-left: 10; cursor: move }
+span.parent { padding-right: 10; }
+span.leaf { padding-right: 10; }
+a img { border: 0;}
+table.sortable th { border-width: 0px 1px 1px 1px; background-color: #ccc;}
+a { text-decoration: none; }
+a:hover { text-decoration: underline; }
+table.sortable th, table.sortable td { text-align: left;}table.sortable tr.odd td { background-color: #ddd; }
+table.sortable tr.even td { background-color: #fff; }
+</style>
+</head><body>
+
+<a name="contents"></a>
+<h2>Table of Contents</h2>
+<ul>
+ <li><a href="#exclusive">Exclusive profile</a></li>
+ <li><a href="#inclusive">Inclusive profile</a></li>
+ <li><a href="#thread">Thread profile</a></li>
+ <li><a href="#class">Class/method profile</a></li>
+ <li><a href="#method">Method/class profile</a></li>
+</ul>
+
+<a name="exclusive"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+Total cycles: 16
+
+<br><br>
+Exclusive elapsed times for each method, not including time spent in
+children, sorted by exclusive time.
+
+<br><br>
+<pre>
+ Usecs self % sum % Method
+ 8 50.00 50.00 <a href="#m1">[1]</a> Z.m ()
+ 4 25.00 75.00 <a href="#m2">[2]</a> R.m ()
+ 4 25.00 100.00 <a href="#m3">[3]</a> S.m ()
+</pre>
+<a name="inclusive"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Inclusive elapsed times for each method and its parents and children,
+sorted by inclusive time.
+
+<br><br>
+<pre>
+index %/total %/self index calls usecs name
+<a name="m0"></a>----------------------------------------------------
+[0] 100.0% 0+0 16 (toplevel)
+ 0.0% excl 0
+ 50.0% <a href="#m1">[1]</a> 3/3 8 Z.m ()
+ 25.0% <a href="#m2">[2]</a> 2/2 4 R.m ()
+ 25.0% <a href="#m3">[3]</a> 2/2 4 S.m ()
+<a name="m1"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 3/3 8 (toplevel)
+[1] 50.0% 3+0 8 Z.m ()
+ 100.0% excl 8
+<a name="m2"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 2/2 4 (toplevel)
+[2] 25.0% 2+0 4 R.m ()
+ 100.0% excl 4
+<a name="m3"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 2/2 4 (toplevel)
+[3] 25.0% 2+0 4 S.m ()
+ 100.0% excl 4
+</pre>
+<a name="thread"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Elapsed times for each thread, sorted by elapsed time.
+Also includes percentage of time spent during the <i>execution</i> of any filters.
+
+<br><br>
+<pre>
+ Usecs self % sum % FirstFilter % SecondFilter % RepeatedFilter % tid ThreadName
+ 16 100.00 100.00 75.00 0.00 75.00 1 main
+ 0 0.00 100.00 nan nan nan 2 foo
+ 0 0.00 100.00 nan nan nan 3 bar
+ 0 0.00 100.00 nan nan nan 4 blah
+</pre><br />
+
+Break-down of portion of time spent by each thread while waiting on a filter method.
+<br/><br/>
+<pre>
+Filter: FirstFilter
+Total waiting cycles: 12 ( 75.00% of total)
+Details:
+
+ Waiting cycles % of total waiting time execution time while waiting thread name
+ 12 100.00 100.00 main
+ 0 0.00 0.00 foo
+ 0 0.00 0.00 bar
+ 0 0.00 0.00 blah
+</pre>
+<br/><br/>
+<pre>
+Filter: SecondFilter
+Total waiting cycles: 0 ( 0.00% of total)
+</pre>
+<br/><br/>
+<pre>
+Filter: RepeatedFilter
+Total waiting cycles: 12 ( 75.00% of total)
+Details:
+
+ Waiting cycles % of total waiting time execution time while waiting thread name
+ 12 100.00 100.00 main
+ 0 0.00 0.00 foo
+ 0 0.00 0.00 bar
+ 0 0.00 0.00 blah
+</pre>
+<a name="class"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Exclusive elapsed time for each class, summed over all the methods
+in the class.
+
+<br><br>
+<div class="header"><span class="parent"> </span> Cycles %/total Cumul.% Calls+Recur Class</div>
+<div class="link" onClick="javascript:toggle('d0')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd0">+</span> 8 50.0 50.0 3+0 Z</div>
+<div class="parent" id="d0">
+<div class="leaf"><span class="leaf"> </span> 8 8 100.0 100.0 3+0 <a href="#m1">[1]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d1')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd1">+</span> 4 25.0 75.0 2+0 R</div>
+<div class="parent" id="d1">
+<div class="leaf"><span class="leaf"> </span> 4 4 100.0 100.0 2+0 <a href="#m2">[2]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d2')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd2">+</span> 4 25.0 100.0 2+0 S</div>
+<div class="parent" id="d2">
+<div class="leaf"><span class="leaf"> </span> 4 4 100.0 100.0 2+0 <a href="#m3">[3]</a> m ()</div>
+</div>
+<a name="method"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Exclusive elapsed time for each method, summed over all the classes
+that contain a method with the same name.
+
+<br><br>
+<div class="header"><span class="parent"> </span> Cycles %/total Cumul.% Calls+Recur Method</div>
+<div class="link" onClick="javascript:toggle('e0')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xe0">+</span> 16 100.0 100.0 7+0 m</div>
+<div class="parent" id="e0">
+<div class="leaf"><span class="leaf"> </span> 8 8 50.0 50.0 3+0 <a href="#m1">[1]</a> Z.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 4 4 25.0 75.0 2+0 <a href="#m2">[2]</a> R.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 4 4 25.0 100.0 2+0 <a href="#m3">[3]</a> S.m ()</div>
+</div>
+
+</body>
+</html>
--- /dev/null
+# ____
+# ____ ____ ____ ________ ____|Z |____
+# __|A ||Z ||B ||Z ||C |__
+#
+0 1 A
+2 1 A
+2 1 Z
+4 1 Z
+4 1 B
+6 1 B
+6 1 Z
+10 1 Z
+10 1 C
+12 1 Z
+14 1 Z
+16 1 C
--- /dev/null
+<html>
+<head>
+<script type="text/javascript" src="(null)sortable.js"></script>
+<script langugage="javascript">
+function toggle(item) {
+ obj=document.getElementById(item);
+ visible=(obj.style.display!="none" && obj.style.display!="");
+ key=document.getElementById("x" + item);
+ if (visible) {
+ obj.style.display="none";
+ key.innerHTML="+";
+ } else {
+ obj.style.display="block";
+ key.innerHTML="-";
+ }
+}
+function onMouseOver(obj) {
+ obj.style.background="lightblue";
+}
+function onMouseOut(obj) {
+ obj.style.background="white";
+}
+</script>
+<style type="text/css">
+div { font-family: courier; font-size: 13 }
+div.parent { margin-left: 15; display: none }
+div.leaf { margin-left: 10 }
+div.header { margin-left: 10 }
+div.link { margin-left: 10; cursor: move }
+span.parent { padding-right: 10; }
+span.leaf { padding-right: 10; }
+a img { border: 0;}
+table.sortable th { border-width: 0px 1px 1px 1px; background-color: #ccc;}
+a { text-decoration: none; }
+a:hover { text-decoration: underline; }
+table.sortable th, table.sortable td { text-align: left;}table.sortable tr.odd td { background-color: #ddd; }
+table.sortable tr.even td { background-color: #fff; }
+</style>
+</head><body>
+
+<a name="contents"></a>
+<h2>Table of Contents</h2>
+<ul>
+ <li><a href="#exclusive">Exclusive profile</a></li>
+ <li><a href="#inclusive">Inclusive profile</a></li>
+ <li><a href="#thread">Thread profile</a></li>
+ <li><a href="#class">Class/method profile</a></li>
+ <li><a href="#method">Method/class profile</a></li>
+</ul>
+
+<a name="exclusive"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+Total cycles: 16
+
+<br><br>
+Exclusive elapsed times for each method, not including time spent in
+children, sorted by exclusive time.
+
+<br><br>
+<pre>
+ Usecs self % sum % Method
+ 8 50.00 50.00 <a href="#m1">[1]</a> Z.m ()
+ 4 25.00 75.00 <a href="#m2">[2]</a> C.m ()
+ 2 12.50 87.50 <a href="#m3">[3]</a> A.m ()
+ 2 12.50 100.00 <a href="#m4">[4]</a> B.m ()
+</pre>
+<a name="inclusive"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Inclusive elapsed times for each method and its parents and children,
+sorted by inclusive time.
+
+<br><br>
+<pre>
+index %/total %/self index calls usecs name
+<a name="m0"></a>----------------------------------------------------
+[0] 100.0% 0+0 16 (toplevel)
+ 0.0% excl 0
+ 37.5% <a href="#m2">[2]</a> 1/1 6 C.m ()
+ 37.5% <a href="#m1">[1]</a> 2/3 6 Z.m ()
+ 12.5% <a href="#m3">[3]</a> 1/1 2 A.m ()
+ 12.5% <a href="#m4">[4]</a> 1/1 2 B.m ()
+<a name="m1"></a>----------------------------------------------------
+ 75.0% <a href="#m0">[0]</a> 2/3 6 (toplevel)
+ 25.0% <a href="#m2">[2]</a> 1/3 2 C.m ()
+[1] 50.0% 3+0 8 Z.m ()
+ 100.0% excl 8
+<a name="m2"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 6 (toplevel)
+[2] 37.5% 1+0 6 C.m ()
+ 66.7% excl 4
+ 33.3% <a href="#m1">[1]</a> 1/3 2 Z.m ()
+<a name="m3"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 2 (toplevel)
+[3] 12.5% 1+0 2 A.m ()
+ 100.0% excl 2
+<a name="m4"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 2 (toplevel)
+[4] 12.5% 1+0 2 B.m ()
+ 100.0% excl 2
+</pre>
+<a name="thread"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Elapsed times for each thread, sorted by elapsed time.
+Also includes percentage of time spent during the <i>execution</i> of any filters.
+
+<br><br>
+<pre>
+ Usecs self % sum % FirstFilter % SecondFilter % RepeatedFilter % tid ThreadName
+ 16 100.00 100.00 75.00 0.00 0.00 1 main
+ 0 0.00 100.00 nan nan nan 2 foo
+ 0 0.00 100.00 nan nan nan 3 bar
+ 0 0.00 100.00 nan nan nan 4 blah
+</pre><br />
+
+Break-down of portion of time spent by each thread while waiting on a filter method.
+<br/><br/>
+<pre>
+Filter: FirstFilter
+Total waiting cycles: 12 ( 75.00% of total)
+Details:
+
+ Waiting cycles % of total waiting time execution time while waiting thread name
+ 12 100.00 100.00 main
+ 0 0.00 0.00 foo
+ 0 0.00 0.00 bar
+ 0 0.00 0.00 blah
+</pre>
+<br/><br/>
+<pre>
+Filter: SecondFilter
+Total waiting cycles: 0 ( 0.00% of total)
+</pre>
+<br/><br/>
+<pre>
+Filter: RepeatedFilter
+Total waiting cycles: 0 ( 0.00% of total)
+</pre>
+<a name="class"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Exclusive elapsed time for each class, summed over all the methods
+in the class.
+
+<br><br>
+<div class="header"><span class="parent"> </span> Cycles %/total Cumul.% Calls+Recur Class</div>
+<div class="link" onClick="javascript:toggle('d0')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd0">+</span> 8 50.0 50.0 3+0 Z</div>
+<div class="parent" id="d0">
+<div class="leaf"><span class="leaf"> </span> 8 8 100.0 100.0 3+0 <a href="#m1">[1]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d1')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd1">+</span> 4 25.0 75.0 1+0 C</div>
+<div class="parent" id="d1">
+<div class="leaf"><span class="leaf"> </span> 4 6 100.0 100.0 1+0 <a href="#m2">[2]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d2')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd2">+</span> 2 12.5 87.5 1+0 A</div>
+<div class="parent" id="d2">
+<div class="leaf"><span class="leaf"> </span> 2 2 100.0 100.0 1+0 <a href="#m3">[3]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d3')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd3">+</span> 2 12.5 100.0 1+0 B</div>
+<div class="parent" id="d3">
+<div class="leaf"><span class="leaf"> </span> 2 2 100.0 100.0 1+0 <a href="#m4">[4]</a> m ()</div>
+</div>
+<a name="method"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Exclusive elapsed time for each method, summed over all the classes
+that contain a method with the same name.
+
+<br><br>
+<div class="header"><span class="parent"> </span> Cycles %/total Cumul.% Calls+Recur Method</div>
+<div class="link" onClick="javascript:toggle('e0')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xe0">+</span> 16 100.0 100.0 6+0 m</div>
+<div class="parent" id="e0">
+<div class="leaf"><span class="leaf"> </span> 8 8 50.0 50.0 3+0 <a href="#m1">[1]</a> Z.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 4 6 25.0 75.0 1+0 <a href="#m2">[2]</a> C.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 2 2 12.5 87.5 1+0 <a href="#m3">[3]</a> A.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 2 2 12.5 100.0 1+0 <a href="#m4">[4]</a> B.m ()</div>
+</div>
+
+</body>
+</html>
--- /dev/null
+# ____ ____ ____ ________ ____ ____ ____
+# __|A ||Z ||B ||Z ||A ||Z ||B |__
+#
+0 1 A
+2 1 A
+2 1 Z
+4 1 Z
+4 1 B
+6 1 B
+6 1 Z
+10 1 Z
+10 1 A
+12 1 A
+12 1 Z
+14 1 Z
+14 1 B
+16 1 B
--- /dev/null
+<html>
+<head>
+<script type="text/javascript" src="(null)sortable.js"></script>
+<script langugage="javascript">
+function toggle(item) {
+ obj=document.getElementById(item);
+ visible=(obj.style.display!="none" && obj.style.display!="");
+ key=document.getElementById("x" + item);
+ if (visible) {
+ obj.style.display="none";
+ key.innerHTML="+";
+ } else {
+ obj.style.display="block";
+ key.innerHTML="-";
+ }
+}
+function onMouseOver(obj) {
+ obj.style.background="lightblue";
+}
+function onMouseOut(obj) {
+ obj.style.background="white";
+}
+</script>
+<style type="text/css">
+div { font-family: courier; font-size: 13 }
+div.parent { margin-left: 15; display: none }
+div.leaf { margin-left: 10 }
+div.header { margin-left: 10 }
+div.link { margin-left: 10; cursor: move }
+span.parent { padding-right: 10; }
+span.leaf { padding-right: 10; }
+a img { border: 0;}
+table.sortable th { border-width: 0px 1px 1px 1px; background-color: #ccc;}
+a { text-decoration: none; }
+a:hover { text-decoration: underline; }
+table.sortable th, table.sortable td { text-align: left;}table.sortable tr.odd td { background-color: #ddd; }
+table.sortable tr.even td { background-color: #fff; }
+</style>
+</head><body>
+
+<a name="contents"></a>
+<h2>Table of Contents</h2>
+<ul>
+ <li><a href="#exclusive">Exclusive profile</a></li>
+ <li><a href="#inclusive">Inclusive profile</a></li>
+ <li><a href="#thread">Thread profile</a></li>
+ <li><a href="#class">Class/method profile</a></li>
+ <li><a href="#method">Method/class profile</a></li>
+</ul>
+
+<a name="exclusive"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+Total cycles: 16
+
+<br><br>
+Exclusive elapsed times for each method, not including time spent in
+children, sorted by exclusive time.
+
+<br><br>
+<pre>
+ Usecs self % sum % Method
+ 8 50.00 50.00 <a href="#m1">[1]</a> Z.m ()
+ 4 25.00 75.00 <a href="#m2">[2]</a> A.m ()
+ 4 25.00 100.00 <a href="#m3">[3]</a> B.m ()
+</pre>
+<a name="inclusive"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Inclusive elapsed times for each method and its parents and children,
+sorted by inclusive time.
+
+<br><br>
+<pre>
+index %/total %/self index calls usecs name
+<a name="m0"></a>----------------------------------------------------
+[0] 100.0% 0+0 16 (toplevel)
+ 0.0% excl 0
+ 50.0% <a href="#m1">[1]</a> 3/3 8 Z.m ()
+ 25.0% <a href="#m2">[2]</a> 2/2 4 A.m ()
+ 25.0% <a href="#m3">[3]</a> 2/2 4 B.m ()
+<a name="m1"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 3/3 8 (toplevel)
+[1] 50.0% 3+0 8 Z.m ()
+ 100.0% excl 8
+<a name="m2"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 2/2 4 (toplevel)
+[2] 25.0% 2+0 4 A.m ()
+ 100.0% excl 4
+<a name="m3"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 2/2 4 (toplevel)
+[3] 25.0% 2+0 4 B.m ()
+ 100.0% excl 4
+</pre>
+<a name="thread"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Elapsed times for each thread, sorted by elapsed time.
+Also includes percentage of time spent during the <i>execution</i> of any filters.
+
+<br><br>
+<pre>
+ Usecs self % sum % FirstFilter % SecondFilter % RepeatedFilter % tid ThreadName
+ 16 100.00 100.00 75.00 0.00 0.00 1 main
+ 0 0.00 100.00 nan nan nan 2 foo
+ 0 0.00 100.00 nan nan nan 3 bar
+ 0 0.00 100.00 nan nan nan 4 blah
+</pre><br />
+
+Break-down of portion of time spent by each thread while waiting on a filter method.
+<br/><br/>
+<pre>
+Filter: FirstFilter
+Total waiting cycles: 12 ( 75.00% of total)
+Details:
+
+ Waiting cycles % of total waiting time execution time while waiting thread name
+ 12 100.00 100.00 main
+ 0 0.00 0.00 foo
+ 0 0.00 0.00 bar
+ 0 0.00 0.00 blah
+</pre>
+<br/><br/>
+<pre>
+Filter: SecondFilter
+Total waiting cycles: 0 ( 0.00% of total)
+</pre>
+<br/><br/>
+<pre>
+Filter: RepeatedFilter
+Total waiting cycles: 0 ( 0.00% of total)
+</pre>
+<a name="class"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Exclusive elapsed time for each class, summed over all the methods
+in the class.
+
+<br><br>
+<div class="header"><span class="parent"> </span> Cycles %/total Cumul.% Calls+Recur Class</div>
+<div class="link" onClick="javascript:toggle('d0')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd0">+</span> 8 50.0 50.0 3+0 Z</div>
+<div class="parent" id="d0">
+<div class="leaf"><span class="leaf"> </span> 8 8 100.0 100.0 3+0 <a href="#m1">[1]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d1')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd1">+</span> 4 25.0 75.0 2+0 A</div>
+<div class="parent" id="d1">
+<div class="leaf"><span class="leaf"> </span> 4 4 100.0 100.0 2+0 <a href="#m2">[2]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d2')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd2">+</span> 4 25.0 100.0 2+0 B</div>
+<div class="parent" id="d2">
+<div class="leaf"><span class="leaf"> </span> 4 4 100.0 100.0 2+0 <a href="#m3">[3]</a> m ()</div>
+</div>
+<a name="method"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Exclusive elapsed time for each method, summed over all the classes
+that contain a method with the same name.
+
+<br><br>
+<div class="header"><span class="parent"> </span> Cycles %/total Cumul.% Calls+Recur Method</div>
+<div class="link" onClick="javascript:toggle('e0')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xe0">+</span> 16 100.0 100.0 7+0 m</div>
+<div class="parent" id="e0">
+<div class="leaf"><span class="leaf"> </span> 8 8 50.0 50.0 3+0 <a href="#m1">[1]</a> Z.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 4 4 25.0 75.0 2+0 <a href="#m2">[2]</a> A.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 4 4 25.0 100.0 2+0 <a href="#m3">[3]</a> B.m ()</div>
+</div>
+
+</body>
+</html>
--- /dev/null
+# ____ ____ ________
+# __|A |_____________________|B ||Z |__
+#
+# ____ ________ ____
+# _______|D ||Z ||E |______________
+#
+#
+0 1 A
+2 1 A
+0 2 D
+2 2 D
+2 2 Z
+6 2 Z
+6 2 E
+8 2 E
+2 1 B
+4 1 B
+4 1 Z
+8 1 Z
--- /dev/null
+<html>
+<head>
+<script type="text/javascript" src="(null)sortable.js"></script>
+<script langugage="javascript">
+function toggle(item) {
+ obj=document.getElementById(item);
+ visible=(obj.style.display!="none" && obj.style.display!="");
+ key=document.getElementById("x" + item);
+ if (visible) {
+ obj.style.display="none";
+ key.innerHTML="+";
+ } else {
+ obj.style.display="block";
+ key.innerHTML="-";
+ }
+}
+function onMouseOver(obj) {
+ obj.style.background="lightblue";
+}
+function onMouseOut(obj) {
+ obj.style.background="white";
+}
+</script>
+<style type="text/css">
+div { font-family: courier; font-size: 13 }
+div.parent { margin-left: 15; display: none }
+div.leaf { margin-left: 10 }
+div.header { margin-left: 10 }
+div.link { margin-left: 10; cursor: move }
+span.parent { padding-right: 10; }
+span.leaf { padding-right: 10; }
+a img { border: 0;}
+table.sortable th { border-width: 0px 1px 1px 1px; background-color: #ccc;}
+a { text-decoration: none; }
+a:hover { text-decoration: underline; }
+table.sortable th, table.sortable td { text-align: left;}table.sortable tr.odd td { background-color: #ddd; }
+table.sortable tr.even td { background-color: #fff; }
+</style>
+</head><body>
+
+<a name="contents"></a>
+<h2>Table of Contents</h2>
+<ul>
+ <li><a href="#exclusive">Exclusive profile</a></li>
+ <li><a href="#inclusive">Inclusive profile</a></li>
+ <li><a href="#thread">Thread profile</a></li>
+ <li><a href="#class">Class/method profile</a></li>
+ <li><a href="#method">Method/class profile</a></li>
+</ul>
+
+<a name="exclusive"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+Total cycles: 16
+
+<br><br>
+Exclusive elapsed times for each method, not including time spent in
+children, sorted by exclusive time.
+
+<br><br>
+<pre>
+ Usecs self % sum % Method
+ 8 50.00 50.00 <a href="#m1">[1]</a> Z.m ()
+ 2 12.50 62.50 <a href="#m2">[2]</a> A.m ()
+ 2 12.50 75.00 <a href="#m3">[3]</a> B.m ()
+ 2 12.50 87.50 <a href="#m4">[4]</a> D.m ()
+ 2 12.50 100.00 <a href="#m5">[5]</a> E.m ()
+</pre>
+<a name="inclusive"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Inclusive elapsed times for each method and its parents and children,
+sorted by inclusive time.
+
+<br><br>
+<pre>
+index %/total %/self index calls usecs name
+<a name="m0"></a>----------------------------------------------------
+[0] 100.0% 0+0 16 (toplevel)
+ 0.0% excl 0
+ 50.0% <a href="#m1">[1]</a> 2/2 8 Z.m ()
+ 12.5% <a href="#m2">[2]</a> 1/1 2 A.m ()
+ 12.5% <a href="#m3">[3]</a> 1/1 2 B.m ()
+ 12.5% <a href="#m4">[4]</a> 1/1 2 D.m ()
+ 12.5% <a href="#m5">[5]</a> 1/1 2 E.m ()
+<a name="m1"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 2/2 8 (toplevel)
+[1] 50.0% 2+0 8 Z.m ()
+ 100.0% excl 8
+<a name="m2"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 2 (toplevel)
+[2] 12.5% 1+0 2 A.m ()
+ 100.0% excl 2
+<a name="m3"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 2 (toplevel)
+[3] 12.5% 1+0 2 B.m ()
+ 100.0% excl 2
+<a name="m4"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 2 (toplevel)
+[4] 12.5% 1+0 2 D.m ()
+ 100.0% excl 2
+<a name="m5"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 2 (toplevel)
+[5] 12.5% 1+0 2 E.m ()
+ 100.0% excl 2
+</pre>
+<a name="thread"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Elapsed times for each thread, sorted by elapsed time.
+Also includes percentage of time spent during the <i>execution</i> of any filters.
+
+<br><br>
+<pre>
+ Usecs self % sum % FirstFilter % SecondFilter % RepeatedFilter % tid ThreadName
+ 8 50.00 50.00 50.00 0.00 0.00 1 main
+ 8 50.00 100.00 0.00 100.00 0.00 2 foo
+ 0 0.00 100.00 nan nan nan 3 bar
+ 0 0.00 100.00 nan nan nan 4 blah
+</pre><br />
+
+Break-down of portion of time spent by each thread while waiting on a filter method.
+<br/><br/>
+<pre>
+Filter: FirstFilter
+Total waiting cycles: 12 ( 75.00% of total)
+Details:
+
+ Waiting cycles % of total waiting time execution time while waiting thread name
+ 12 100.00 33.33 main
+ 0 0.00 66.67 foo
+ 0 0.00 0.00 bar
+ 0 0.00 0.00 blah
+</pre>
+<br/><br/>
+<pre>
+Filter: SecondFilter
+Total waiting cycles: 8 ( 50.00% of total)
+Details:
+
+ Waiting cycles % of total waiting time execution time while waiting thread name
+ 0 0.00 0.00 main
+ 8 100.00 100.00 foo
+ 0 0.00 0.00 bar
+ 0 0.00 0.00 blah
+</pre>
+<br/><br/>
+<pre>
+Filter: RepeatedFilter
+Total waiting cycles: 0 ( 0.00% of total)
+</pre>
+<a name="class"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Exclusive elapsed time for each class, summed over all the methods
+in the class.
+
+<br><br>
+<div class="header"><span class="parent"> </span> Cycles %/total Cumul.% Calls+Recur Class</div>
+<div class="link" onClick="javascript:toggle('d0')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd0">+</span> 8 50.0 50.0 2+0 Z</div>
+<div class="parent" id="d0">
+<div class="leaf"><span class="leaf"> </span> 8 8 100.0 100.0 2+0 <a href="#m1">[1]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d1')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd1">+</span> 2 12.5 62.5 1+0 A</div>
+<div class="parent" id="d1">
+<div class="leaf"><span class="leaf"> </span> 2 2 100.0 100.0 1+0 <a href="#m2">[2]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d2')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd2">+</span> 2 12.5 75.0 1+0 B</div>
+<div class="parent" id="d2">
+<div class="leaf"><span class="leaf"> </span> 2 2 100.0 100.0 1+0 <a href="#m3">[3]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d3')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd3">+</span> 2 12.5 87.5 1+0 D</div>
+<div class="parent" id="d3">
+<div class="leaf"><span class="leaf"> </span> 2 2 100.0 100.0 1+0 <a href="#m4">[4]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d4')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd4">+</span> 2 12.5 100.0 1+0 E</div>
+<div class="parent" id="d4">
+<div class="leaf"><span class="leaf"> </span> 2 2 100.0 100.0 1+0 <a href="#m5">[5]</a> m ()</div>
+</div>
+<a name="method"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Exclusive elapsed time for each method, summed over all the classes
+that contain a method with the same name.
+
+<br><br>
+<div class="header"><span class="parent"> </span> Cycles %/total Cumul.% Calls+Recur Method</div>
+<div class="link" onClick="javascript:toggle('e0')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xe0">+</span> 16 100.0 100.0 6+0 m</div>
+<div class="parent" id="e0">
+<div class="leaf"><span class="leaf"> </span> 8 8 50.0 50.0 2+0 <a href="#m1">[1]</a> Z.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 2 2 12.5 62.5 1+0 <a href="#m2">[2]</a> A.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 2 2 12.5 75.0 1+0 <a href="#m3">[3]</a> B.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 2 2 12.5 87.5 1+0 <a href="#m4">[4]</a> D.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 2 2 12.5 100.0 1+0 <a href="#m5">[5]</a> E.m ()</div>
+</div>
+
+</body>
+</html>
--- /dev/null
+# ____ ____ ________
+# __|R |_____________________|S ||Z |__
+#
+# ____ ________ ____
+# _______|R ||Z ||S |______________
+#
+#
+0 1 R
+2 1 R
+0 2 R
+2 2 R
+2 2 Z
+6 2 Z
+6 2 S
+8 2 S
+2 1 S
+4 1 S
+4 1 Z
+8 1 Z
--- /dev/null
+<html>
+<head>
+<script type="text/javascript" src="(null)sortable.js"></script>
+<script langugage="javascript">
+function toggle(item) {
+ obj=document.getElementById(item);
+ visible=(obj.style.display!="none" && obj.style.display!="");
+ key=document.getElementById("x" + item);
+ if (visible) {
+ obj.style.display="none";
+ key.innerHTML="+";
+ } else {
+ obj.style.display="block";
+ key.innerHTML="-";
+ }
+}
+function onMouseOver(obj) {
+ obj.style.background="lightblue";
+}
+function onMouseOut(obj) {
+ obj.style.background="white";
+}
+</script>
+<style type="text/css">
+div { font-family: courier; font-size: 13 }
+div.parent { margin-left: 15; display: none }
+div.leaf { margin-left: 10 }
+div.header { margin-left: 10 }
+div.link { margin-left: 10; cursor: move }
+span.parent { padding-right: 10; }
+span.leaf { padding-right: 10; }
+a img { border: 0;}
+table.sortable th { border-width: 0px 1px 1px 1px; background-color: #ccc;}
+a { text-decoration: none; }
+a:hover { text-decoration: underline; }
+table.sortable th, table.sortable td { text-align: left;}table.sortable tr.odd td { background-color: #ddd; }
+table.sortable tr.even td { background-color: #fff; }
+</style>
+</head><body>
+
+<a name="contents"></a>
+<h2>Table of Contents</h2>
+<ul>
+ <li><a href="#exclusive">Exclusive profile</a></li>
+ <li><a href="#inclusive">Inclusive profile</a></li>
+ <li><a href="#thread">Thread profile</a></li>
+ <li><a href="#class">Class/method profile</a></li>
+ <li><a href="#method">Method/class profile</a></li>
+</ul>
+
+<a name="exclusive"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+Total cycles: 16
+
+<br><br>
+Exclusive elapsed times for each method, not including time spent in
+children, sorted by exclusive time.
+
+<br><br>
+<pre>
+ Usecs self % sum % Method
+ 8 50.00 50.00 <a href="#m1">[1]</a> Z.m ()
+ 4 25.00 75.00 <a href="#m2">[2]</a> R.m ()
+ 4 25.00 100.00 <a href="#m3">[3]</a> S.m ()
+</pre>
+<a name="inclusive"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Inclusive elapsed times for each method and its parents and children,
+sorted by inclusive time.
+
+<br><br>
+<pre>
+index %/total %/self index calls usecs name
+<a name="m0"></a>----------------------------------------------------
+[0] 100.0% 0+0 16 (toplevel)
+ 0.0% excl 0
+ 50.0% <a href="#m1">[1]</a> 2/2 8 Z.m ()
+ 25.0% <a href="#m2">[2]</a> 2/2 4 R.m ()
+ 25.0% <a href="#m3">[3]</a> 2/2 4 S.m ()
+<a name="m1"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 2/2 8 (toplevel)
+[1] 50.0% 2+0 8 Z.m ()
+ 100.0% excl 8
+<a name="m2"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 2/2 4 (toplevel)
+[2] 25.0% 2+0 4 R.m ()
+ 100.0% excl 4
+<a name="m3"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 2/2 4 (toplevel)
+[3] 25.0% 2+0 4 S.m ()
+ 100.0% excl 4
+</pre>
+<a name="thread"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Elapsed times for each thread, sorted by elapsed time.
+Also includes percentage of time spent during the <i>execution</i> of any filters.
+
+<br><br>
+<pre>
+ Usecs self % sum % FirstFilter % SecondFilter % RepeatedFilter % tid ThreadName
+ 8 50.00 50.00 50.00 0.00 50.00 1 main
+ 8 50.00 100.00 100.00 0.00 100.00 2 foo
+ 0 0.00 100.00 nan nan nan 3 bar
+ 0 0.00 100.00 nan nan nan 4 blah
+</pre><br />
+
+Break-down of portion of time spent by each thread while waiting on a filter method.
+<br/><br/>
+<pre>
+Filter: FirstFilter
+Total waiting cycles: 12 ( 75.00% of total)
+Details:
+
+ Waiting cycles % of total waiting time execution time while waiting thread name
+ 12 100.00 33.33 main
+ 8 66.67 66.67 foo
+ 0 0.00 0.00 bar
+ 0 0.00 0.00 blah
+</pre>
+<br/><br/>
+<pre>
+Filter: SecondFilter
+Total waiting cycles: 0 ( 0.00% of total)
+</pre>
+<br/><br/>
+<pre>
+Filter: RepeatedFilter
+Total waiting cycles: 12 ( 75.00% of total)
+Details:
+
+ Waiting cycles % of total waiting time execution time while waiting thread name
+ 12 100.00 33.33 main
+ 8 66.67 66.67 foo
+ 0 0.00 0.00 bar
+ 0 0.00 0.00 blah
+</pre>
+<a name="class"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Exclusive elapsed time for each class, summed over all the methods
+in the class.
+
+<br><br>
+<div class="header"><span class="parent"> </span> Cycles %/total Cumul.% Calls+Recur Class</div>
+<div class="link" onClick="javascript:toggle('d0')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd0">+</span> 8 50.0 50.0 2+0 Z</div>
+<div class="parent" id="d0">
+<div class="leaf"><span class="leaf"> </span> 8 8 100.0 100.0 2+0 <a href="#m1">[1]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d1')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd1">+</span> 4 25.0 75.0 2+0 R</div>
+<div class="parent" id="d1">
+<div class="leaf"><span class="leaf"> </span> 4 4 100.0 100.0 2+0 <a href="#m2">[2]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d2')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd2">+</span> 4 25.0 100.0 2+0 S</div>
+<div class="parent" id="d2">
+<div class="leaf"><span class="leaf"> </span> 4 4 100.0 100.0 2+0 <a href="#m3">[3]</a> m ()</div>
+</div>
+<a name="method"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Exclusive elapsed time for each method, summed over all the classes
+that contain a method with the same name.
+
+<br><br>
+<div class="header"><span class="parent"> </span> Cycles %/total Cumul.% Calls+Recur Method</div>
+<div class="link" onClick="javascript:toggle('e0')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xe0">+</span> 16 100.0 100.0 6+0 m</div>
+<div class="parent" id="e0">
+<div class="leaf"><span class="leaf"> </span> 8 8 50.0 50.0 2+0 <a href="#m1">[1]</a> Z.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 4 4 25.0 75.0 2+0 <a href="#m2">[2]</a> R.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 4 4 25.0 100.0 2+0 <a href="#m3">[3]</a> S.m ()</div>
+</div>
+
+</body>
+</html>
--- /dev/null
+# ____ ____ ________
+# __|A |_____________________|B ||Z |__
+#
+# ____ ________ ____
+# _______|R ||Z ||S |______________
+#
+#
+0 1 A
+2 1 A
+0 2 R
+2 2 R
+2 2 Z
+6 2 Z
+6 2 S
+8 2 S
+2 1 B
+4 1 B
+4 1 Z
+8 1 Z
--- /dev/null
+<html>
+<head>
+<script type="text/javascript" src="(null)sortable.js"></script>
+<script langugage="javascript">
+function toggle(item) {
+ obj=document.getElementById(item);
+ visible=(obj.style.display!="none" && obj.style.display!="");
+ key=document.getElementById("x" + item);
+ if (visible) {
+ obj.style.display="none";
+ key.innerHTML="+";
+ } else {
+ obj.style.display="block";
+ key.innerHTML="-";
+ }
+}
+function onMouseOver(obj) {
+ obj.style.background="lightblue";
+}
+function onMouseOut(obj) {
+ obj.style.background="white";
+}
+</script>
+<style type="text/css">
+div { font-family: courier; font-size: 13 }
+div.parent { margin-left: 15; display: none }
+div.leaf { margin-left: 10 }
+div.header { margin-left: 10 }
+div.link { margin-left: 10; cursor: move }
+span.parent { padding-right: 10; }
+span.leaf { padding-right: 10; }
+a img { border: 0;}
+table.sortable th { border-width: 0px 1px 1px 1px; background-color: #ccc;}
+a { text-decoration: none; }
+a:hover { text-decoration: underline; }
+table.sortable th, table.sortable td { text-align: left;}table.sortable tr.odd td { background-color: #ddd; }
+table.sortable tr.even td { background-color: #fff; }
+</style>
+</head><body>
+
+<a name="contents"></a>
+<h2>Table of Contents</h2>
+<ul>
+ <li><a href="#exclusive">Exclusive profile</a></li>
+ <li><a href="#inclusive">Inclusive profile</a></li>
+ <li><a href="#thread">Thread profile</a></li>
+ <li><a href="#class">Class/method profile</a></li>
+ <li><a href="#method">Method/class profile</a></li>
+</ul>
+
+<a name="exclusive"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+Total cycles: 16
+
+<br><br>
+Exclusive elapsed times for each method, not including time spent in
+children, sorted by exclusive time.
+
+<br><br>
+<pre>
+ Usecs self % sum % Method
+ 8 50.00 50.00 <a href="#m1">[1]</a> Z.m ()
+ 2 12.50 62.50 <a href="#m2">[2]</a> A.m ()
+ 2 12.50 75.00 <a href="#m3">[3]</a> B.m ()
+ 2 12.50 87.50 <a href="#m4">[4]</a> R.m ()
+ 2 12.50 100.00 <a href="#m5">[5]</a> S.m ()
+</pre>
+<a name="inclusive"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Inclusive elapsed times for each method and its parents and children,
+sorted by inclusive time.
+
+<br><br>
+<pre>
+index %/total %/self index calls usecs name
+<a name="m0"></a>----------------------------------------------------
+[0] 100.0% 0+0 16 (toplevel)
+ 0.0% excl 0
+ 50.0% <a href="#m1">[1]</a> 2/2 8 Z.m ()
+ 12.5% <a href="#m2">[2]</a> 1/1 2 A.m ()
+ 12.5% <a href="#m3">[3]</a> 1/1 2 B.m ()
+ 12.5% <a href="#m4">[4]</a> 1/1 2 R.m ()
+ 12.5% <a href="#m5">[5]</a> 1/1 2 S.m ()
+<a name="m1"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 2/2 8 (toplevel)
+[1] 50.0% 2+0 8 Z.m ()
+ 100.0% excl 8
+<a name="m2"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 2 (toplevel)
+[2] 12.5% 1+0 2 A.m ()
+ 100.0% excl 2
+<a name="m3"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 2 (toplevel)
+[3] 12.5% 1+0 2 B.m ()
+ 100.0% excl 2
+<a name="m4"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 2 (toplevel)
+[4] 12.5% 1+0 2 R.m ()
+ 100.0% excl 2
+<a name="m5"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 2 (toplevel)
+[5] 12.5% 1+0 2 S.m ()
+ 100.0% excl 2
+</pre>
+<a name="thread"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Elapsed times for each thread, sorted by elapsed time.
+Also includes percentage of time spent during the <i>execution</i> of any filters.
+
+<br><br>
+<pre>
+ Usecs self % sum % FirstFilter % SecondFilter % RepeatedFilter % tid ThreadName
+ 8 50.00 50.00 50.00 0.00 0.00 1 main
+ 8 50.00 100.00 100.00 0.00 100.00 2 foo
+ 0 0.00 100.00 nan nan nan 3 bar
+ 0 0.00 100.00 nan nan nan 4 blah
+</pre><br />
+
+Break-down of portion of time spent by each thread while waiting on a filter method.
+<br/><br/>
+<pre>
+Filter: FirstFilter
+Total waiting cycles: 12 ( 75.00% of total)
+Details:
+
+ Waiting cycles % of total waiting time execution time while waiting thread name
+ 12 100.00 33.33 main
+ 8 66.67 66.67 foo
+ 0 0.00 0.00 bar
+ 0 0.00 0.00 blah
+</pre>
+<br/><br/>
+<pre>
+Filter: SecondFilter
+Total waiting cycles: 0 ( 0.00% of total)
+</pre>
+<br/><br/>
+<pre>
+Filter: RepeatedFilter
+Total waiting cycles: 8 ( 50.00% of total)
+Details:
+
+ Waiting cycles % of total waiting time execution time while waiting thread name
+ 0 0.00 0.00 main
+ 8 100.00 100.00 foo
+ 0 0.00 0.00 bar
+ 0 0.00 0.00 blah
+</pre>
+<a name="class"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Exclusive elapsed time for each class, summed over all the methods
+in the class.
+
+<br><br>
+<div class="header"><span class="parent"> </span> Cycles %/total Cumul.% Calls+Recur Class</div>
+<div class="link" onClick="javascript:toggle('d0')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd0">+</span> 8 50.0 50.0 2+0 Z</div>
+<div class="parent" id="d0">
+<div class="leaf"><span class="leaf"> </span> 8 8 100.0 100.0 2+0 <a href="#m1">[1]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d1')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd1">+</span> 2 12.5 62.5 1+0 A</div>
+<div class="parent" id="d1">
+<div class="leaf"><span class="leaf"> </span> 2 2 100.0 100.0 1+0 <a href="#m2">[2]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d2')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd2">+</span> 2 12.5 75.0 1+0 B</div>
+<div class="parent" id="d2">
+<div class="leaf"><span class="leaf"> </span> 2 2 100.0 100.0 1+0 <a href="#m3">[3]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d3')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd3">+</span> 2 12.5 87.5 1+0 R</div>
+<div class="parent" id="d3">
+<div class="leaf"><span class="leaf"> </span> 2 2 100.0 100.0 1+0 <a href="#m4">[4]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d4')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd4">+</span> 2 12.5 100.0 1+0 S</div>
+<div class="parent" id="d4">
+<div class="leaf"><span class="leaf"> </span> 2 2 100.0 100.0 1+0 <a href="#m5">[5]</a> m ()</div>
+</div>
+<a name="method"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Exclusive elapsed time for each method, summed over all the classes
+that contain a method with the same name.
+
+<br><br>
+<div class="header"><span class="parent"> </span> Cycles %/total Cumul.% Calls+Recur Method</div>
+<div class="link" onClick="javascript:toggle('e0')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xe0">+</span> 16 100.0 100.0 6+0 m</div>
+<div class="parent" id="e0">
+<div class="leaf"><span class="leaf"> </span> 8 8 50.0 50.0 2+0 <a href="#m1">[1]</a> Z.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 2 2 12.5 62.5 1+0 <a href="#m2">[2]</a> A.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 2 2 12.5 75.0 1+0 <a href="#m3">[3]</a> B.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 2 2 12.5 87.5 1+0 <a href="#m4">[4]</a> R.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 2 2 12.5 100.0 1+0 <a href="#m5">[5]</a> S.m ()</div>
+</div>
+
+</body>
+</html>
--- /dev/null
+# ____ ____ ________
+# __|A |_____________________|B ||Z |__
+#
+# ____ ________ ____
+# _______|A ||Z ||B |______________
+#
+#
+0 1 A
+2 1 A
+0 2 A
+2 2 A
+2 2 Z
+6 2 Z
+6 2 B
+8 2 B
+2 1 B
+4 1 B
+4 1 Z
+8 1 Z
--- /dev/null
+<html>
+<head>
+<script type="text/javascript" src="(null)sortable.js"></script>
+<script langugage="javascript">
+function toggle(item) {
+ obj=document.getElementById(item);
+ visible=(obj.style.display!="none" && obj.style.display!="");
+ key=document.getElementById("x" + item);
+ if (visible) {
+ obj.style.display="none";
+ key.innerHTML="+";
+ } else {
+ obj.style.display="block";
+ key.innerHTML="-";
+ }
+}
+function onMouseOver(obj) {
+ obj.style.background="lightblue";
+}
+function onMouseOut(obj) {
+ obj.style.background="white";
+}
+</script>
+<style type="text/css">
+div { font-family: courier; font-size: 13 }
+div.parent { margin-left: 15; display: none }
+div.leaf { margin-left: 10 }
+div.header { margin-left: 10 }
+div.link { margin-left: 10; cursor: move }
+span.parent { padding-right: 10; }
+span.leaf { padding-right: 10; }
+a img { border: 0;}
+table.sortable th { border-width: 0px 1px 1px 1px; background-color: #ccc;}
+a { text-decoration: none; }
+a:hover { text-decoration: underline; }
+table.sortable th, table.sortable td { text-align: left;}table.sortable tr.odd td { background-color: #ddd; }
+table.sortable tr.even td { background-color: #fff; }
+</style>
+</head><body>
+
+<a name="contents"></a>
+<h2>Table of Contents</h2>
+<ul>
+ <li><a href="#exclusive">Exclusive profile</a></li>
+ <li><a href="#inclusive">Inclusive profile</a></li>
+ <li><a href="#thread">Thread profile</a></li>
+ <li><a href="#class">Class/method profile</a></li>
+ <li><a href="#method">Method/class profile</a></li>
+</ul>
+
+<a name="exclusive"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+Total cycles: 16
+
+<br><br>
+Exclusive elapsed times for each method, not including time spent in
+children, sorted by exclusive time.
+
+<br><br>
+<pre>
+ Usecs self % sum % Method
+ 8 50.00 50.00 <a href="#m1">[1]</a> Z.m ()
+ 4 25.00 75.00 <a href="#m2">[2]</a> A.m ()
+ 4 25.00 100.00 <a href="#m3">[3]</a> B.m ()
+</pre>
+<a name="inclusive"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Inclusive elapsed times for each method and its parents and children,
+sorted by inclusive time.
+
+<br><br>
+<pre>
+index %/total %/self index calls usecs name
+<a name="m0"></a>----------------------------------------------------
+[0] 100.0% 0+0 16 (toplevel)
+ 0.0% excl 0
+ 50.0% <a href="#m1">[1]</a> 2/2 8 Z.m ()
+ 25.0% <a href="#m2">[2]</a> 2/2 4 A.m ()
+ 25.0% <a href="#m3">[3]</a> 2/2 4 B.m ()
+<a name="m1"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 2/2 8 (toplevel)
+[1] 50.0% 2+0 8 Z.m ()
+ 100.0% excl 8
+<a name="m2"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 2/2 4 (toplevel)
+[2] 25.0% 2+0 4 A.m ()
+ 100.0% excl 4
+<a name="m3"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 2/2 4 (toplevel)
+[3] 25.0% 2+0 4 B.m ()
+ 100.0% excl 4
+</pre>
+<a name="thread"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Elapsed times for each thread, sorted by elapsed time.
+Also includes percentage of time spent during the <i>execution</i> of any filters.
+
+<br><br>
+<pre>
+ Usecs self % sum % FirstFilter % SecondFilter % RepeatedFilter % tid ThreadName
+ 8 50.00 50.00 50.00 0.00 0.00 1 main
+ 8 50.00 100.00 100.00 0.00 0.00 2 foo
+ 0 0.00 100.00 nan nan nan 3 bar
+ 0 0.00 100.00 nan nan nan 4 blah
+</pre><br />
+
+Break-down of portion of time spent by each thread while waiting on a filter method.
+<br/><br/>
+<pre>
+Filter: FirstFilter
+Total waiting cycles: 12 ( 75.00% of total)
+Details:
+
+ Waiting cycles % of total waiting time execution time while waiting thread name
+ 12 100.00 33.33 main
+ 8 66.67 66.67 foo
+ 0 0.00 0.00 bar
+ 0 0.00 0.00 blah
+</pre>
+<br/><br/>
+<pre>
+Filter: SecondFilter
+Total waiting cycles: 0 ( 0.00% of total)
+</pre>
+<br/><br/>
+<pre>
+Filter: RepeatedFilter
+Total waiting cycles: 0 ( 0.00% of total)
+</pre>
+<a name="class"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Exclusive elapsed time for each class, summed over all the methods
+in the class.
+
+<br><br>
+<div class="header"><span class="parent"> </span> Cycles %/total Cumul.% Calls+Recur Class</div>
+<div class="link" onClick="javascript:toggle('d0')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd0">+</span> 8 50.0 50.0 2+0 Z</div>
+<div class="parent" id="d0">
+<div class="leaf"><span class="leaf"> </span> 8 8 100.0 100.0 2+0 <a href="#m1">[1]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d1')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd1">+</span> 4 25.0 75.0 2+0 A</div>
+<div class="parent" id="d1">
+<div class="leaf"><span class="leaf"> </span> 4 4 100.0 100.0 2+0 <a href="#m2">[2]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d2')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd2">+</span> 4 25.0 100.0 2+0 B</div>
+<div class="parent" id="d2">
+<div class="leaf"><span class="leaf"> </span> 4 4 100.0 100.0 2+0 <a href="#m3">[3]</a> m ()</div>
+</div>
+<a name="method"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Exclusive elapsed time for each method, summed over all the classes
+that contain a method with the same name.
+
+<br><br>
+<div class="header"><span class="parent"> </span> Cycles %/total Cumul.% Calls+Recur Method</div>
+<div class="link" onClick="javascript:toggle('e0')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xe0">+</span> 16 100.0 100.0 6+0 m</div>
+<div class="parent" id="e0">
+<div class="leaf"><span class="leaf"> </span> 8 8 50.0 50.0 2+0 <a href="#m1">[1]</a> Z.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 4 4 25.0 75.0 2+0 <a href="#m2">[2]</a> A.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 4 4 25.0 100.0 2+0 <a href="#m3">[3]</a> B.m ()</div>
+</div>
+
+</body>
+</html>
--- /dev/null
+# ____ ____ ____ ____ ____
+# __|A ||D ||E ||B ||Z |__
+#
+0 1 A
+2 1 A
+2 1 D
+4 1 D
+4 1 E
+6 1 E
+6 1 B
+8 1 B
+8 1 Z
+10 1 Z
--- /dev/null
+<html>
+<head>
+<script type="text/javascript" src="(null)sortable.js"></script>
+<script langugage="javascript">
+function toggle(item) {
+ obj=document.getElementById(item);
+ visible=(obj.style.display!="none" && obj.style.display!="");
+ key=document.getElementById("x" + item);
+ if (visible) {
+ obj.style.display="none";
+ key.innerHTML="+";
+ } else {
+ obj.style.display="block";
+ key.innerHTML="-";
+ }
+}
+function onMouseOver(obj) {
+ obj.style.background="lightblue";
+}
+function onMouseOut(obj) {
+ obj.style.background="white";
+}
+</script>
+<style type="text/css">
+div { font-family: courier; font-size: 13 }
+div.parent { margin-left: 15; display: none }
+div.leaf { margin-left: 10 }
+div.header { margin-left: 10 }
+div.link { margin-left: 10; cursor: move }
+span.parent { padding-right: 10; }
+span.leaf { padding-right: 10; }
+a img { border: 0;}
+table.sortable th { border-width: 0px 1px 1px 1px; background-color: #ccc;}
+a { text-decoration: none; }
+a:hover { text-decoration: underline; }
+table.sortable th, table.sortable td { text-align: left;}table.sortable tr.odd td { background-color: #ddd; }
+table.sortable tr.even td { background-color: #fff; }
+</style>
+</head><body>
+
+<a name="contents"></a>
+<h2>Table of Contents</h2>
+<ul>
+ <li><a href="#exclusive">Exclusive profile</a></li>
+ <li><a href="#inclusive">Inclusive profile</a></li>
+ <li><a href="#thread">Thread profile</a></li>
+ <li><a href="#class">Class/method profile</a></li>
+ <li><a href="#method">Method/class profile</a></li>
+</ul>
+
+<a name="exclusive"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+Total cycles: 10
+
+<br><br>
+Exclusive elapsed times for each method, not including time spent in
+children, sorted by exclusive time.
+
+<br><br>
+<pre>
+ Usecs self % sum % Method
+ 2 20.00 20.00 <a href="#m1">[1]</a> A.m ()
+ 2 20.00 40.00 <a href="#m2">[2]</a> B.m ()
+ 2 20.00 60.00 <a href="#m3">[3]</a> D.m ()
+ 2 20.00 80.00 <a href="#m4">[4]</a> E.m ()
+ 2 20.00 100.00 <a href="#m5">[5]</a> Z.m ()
+</pre>
+<a name="inclusive"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Inclusive elapsed times for each method and its parents and children,
+sorted by inclusive time.
+
+<br><br>
+<pre>
+index %/total %/self index calls usecs name
+<a name="m0"></a>----------------------------------------------------
+[0] 100.0% 0+0 10 (toplevel)
+ 0.0% excl 0
+ 20.0% <a href="#m1">[1]</a> 1/1 2 A.m ()
+ 20.0% <a href="#m2">[2]</a> 1/1 2 B.m ()
+ 20.0% <a href="#m3">[3]</a> 1/1 2 D.m ()
+ 20.0% <a href="#m4">[4]</a> 1/1 2 E.m ()
+ 20.0% <a href="#m5">[5]</a> 1/1 2 Z.m ()
+<a name="m1"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 2 (toplevel)
+[1] 20.0% 1+0 2 A.m ()
+ 100.0% excl 2
+<a name="m2"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 2 (toplevel)
+[2] 20.0% 1+0 2 B.m ()
+ 100.0% excl 2
+<a name="m3"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 2 (toplevel)
+[3] 20.0% 1+0 2 D.m ()
+ 100.0% excl 2
+<a name="m4"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 2 (toplevel)
+[4] 20.0% 1+0 2 E.m ()
+ 100.0% excl 2
+<a name="m5"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 2 (toplevel)
+[5] 20.0% 1+0 2 Z.m ()
+ 100.0% excl 2
+</pre>
+<a name="thread"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Elapsed times for each thread, sorted by elapsed time.
+Also includes percentage of time spent during the <i>execution</i> of any filters.
+
+<br><br>
+<pre>
+ Usecs self % sum % FirstFilter % SecondFilter % RepeatedFilter % tid ThreadName
+ 10 100.00 100.00 80.00 40.00 0.00 1 main
+ 0 0.00 100.00 nan nan nan 2 foo
+ 0 0.00 100.00 nan nan nan 3 bar
+ 0 0.00 100.00 nan nan nan 4 blah
+</pre><br />
+
+Break-down of portion of time spent by each thread while waiting on a filter method.
+<br/><br/>
+<pre>
+Filter: FirstFilter
+Total waiting cycles: 8 ( 80.00% of total)
+Details:
+
+ Waiting cycles % of total waiting time execution time while waiting thread name
+ 8 100.00 100.00 main
+ 0 0.00 0.00 foo
+ 0 0.00 0.00 bar
+ 0 0.00 0.00 blah
+</pre>
+<br/><br/>
+<pre>
+Filter: SecondFilter
+Total waiting cycles: 4 ( 40.00% of total)
+Details:
+
+ Waiting cycles % of total waiting time execution time while waiting thread name
+ 4 100.00 100.00 main
+ 0 0.00 0.00 foo
+ 0 0.00 0.00 bar
+ 0 0.00 0.00 blah
+</pre>
+<br/><br/>
+<pre>
+Filter: RepeatedFilter
+Total waiting cycles: 0 ( 0.00% of total)
+</pre>
+<a name="class"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Exclusive elapsed time for each class, summed over all the methods
+in the class.
+
+<br><br>
+<div class="header"><span class="parent"> </span> Cycles %/total Cumul.% Calls+Recur Class</div>
+<div class="link" onClick="javascript:toggle('d0')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd0">+</span> 2 20.0 20.0 1+0 A</div>
+<div class="parent" id="d0">
+<div class="leaf"><span class="leaf"> </span> 2 2 100.0 100.0 1+0 <a href="#m1">[1]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d1')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd1">+</span> 2 20.0 40.0 1+0 B</div>
+<div class="parent" id="d1">
+<div class="leaf"><span class="leaf"> </span> 2 2 100.0 100.0 1+0 <a href="#m2">[2]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d2')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd2">+</span> 2 20.0 60.0 1+0 D</div>
+<div class="parent" id="d2">
+<div class="leaf"><span class="leaf"> </span> 2 2 100.0 100.0 1+0 <a href="#m3">[3]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d3')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd3">+</span> 2 20.0 80.0 1+0 E</div>
+<div class="parent" id="d3">
+<div class="leaf"><span class="leaf"> </span> 2 2 100.0 100.0 1+0 <a href="#m4">[4]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d4')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd4">+</span> 2 20.0 100.0 1+0 Z</div>
+<div class="parent" id="d4">
+<div class="leaf"><span class="leaf"> </span> 2 2 100.0 100.0 1+0 <a href="#m5">[5]</a> m ()</div>
+</div>
+<a name="method"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Exclusive elapsed time for each method, summed over all the classes
+that contain a method with the same name.
+
+<br><br>
+<div class="header"><span class="parent"> </span> Cycles %/total Cumul.% Calls+Recur Method</div>
+<div class="link" onClick="javascript:toggle('e0')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xe0">+</span> 10 100.0 100.0 5+0 m</div>
+<div class="parent" id="e0">
+<div class="leaf"><span class="leaf"> </span> 2 2 20.0 20.0 1+0 <a href="#m1">[1]</a> A.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 2 2 20.0 40.0 1+0 <a href="#m2">[2]</a> B.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 2 2 20.0 60.0 1+0 <a href="#m3">[3]</a> D.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 2 2 20.0 80.0 1+0 <a href="#m4">[4]</a> E.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 2 2 20.0 100.0 1+0 <a href="#m5">[5]</a> Z.m ()</div>
+</div>
+
+</body>
+</html>
--- /dev/null
+# ____ ____ ____ ____ ____
+# __|R ||R ||S ||S ||Z |__
+#
+0 1 R
+2 1 R
+2 1 R
+4 1 R
+4 1 S
+6 1 S
+6 1 S
+8 1 S
+8 1 Z
+10 1 Z
--- /dev/null
+<html>
+<head>
+<script type="text/javascript" src="(null)sortable.js"></script>
+<script langugage="javascript">
+function toggle(item) {
+ obj=document.getElementById(item);
+ visible=(obj.style.display!="none" && obj.style.display!="");
+ key=document.getElementById("x" + item);
+ if (visible) {
+ obj.style.display="none";
+ key.innerHTML="+";
+ } else {
+ obj.style.display="block";
+ key.innerHTML="-";
+ }
+}
+function onMouseOver(obj) {
+ obj.style.background="lightblue";
+}
+function onMouseOut(obj) {
+ obj.style.background="white";
+}
+</script>
+<style type="text/css">
+div { font-family: courier; font-size: 13 }
+div.parent { margin-left: 15; display: none }
+div.leaf { margin-left: 10 }
+div.header { margin-left: 10 }
+div.link { margin-left: 10; cursor: move }
+span.parent { padding-right: 10; }
+span.leaf { padding-right: 10; }
+a img { border: 0;}
+table.sortable th { border-width: 0px 1px 1px 1px; background-color: #ccc;}
+a { text-decoration: none; }
+a:hover { text-decoration: underline; }
+table.sortable th, table.sortable td { text-align: left;}table.sortable tr.odd td { background-color: #ddd; }
+table.sortable tr.even td { background-color: #fff; }
+</style>
+</head><body>
+
+<a name="contents"></a>
+<h2>Table of Contents</h2>
+<ul>
+ <li><a href="#exclusive">Exclusive profile</a></li>
+ <li><a href="#inclusive">Inclusive profile</a></li>
+ <li><a href="#thread">Thread profile</a></li>
+ <li><a href="#class">Class/method profile</a></li>
+ <li><a href="#method">Method/class profile</a></li>
+</ul>
+
+<a name="exclusive"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+Total cycles: 10
+
+<br><br>
+Exclusive elapsed times for each method, not including time spent in
+children, sorted by exclusive time.
+
+<br><br>
+<pre>
+ Usecs self % sum % Method
+ 4 40.00 40.00 <a href="#m1">[1]</a> R.m ()
+ 4 40.00 80.00 <a href="#m2">[2]</a> S.m ()
+ 2 20.00 100.00 <a href="#m3">[3]</a> Z.m ()
+</pre>
+<a name="inclusive"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Inclusive elapsed times for each method and its parents and children,
+sorted by inclusive time.
+
+<br><br>
+<pre>
+index %/total %/self index calls usecs name
+<a name="m0"></a>----------------------------------------------------
+[0] 100.0% 0+0 10 (toplevel)
+ 0.0% excl 0
+ 40.0% <a href="#m1">[1]</a> 2/2 4 R.m ()
+ 40.0% <a href="#m2">[2]</a> 2/2 4 S.m ()
+ 20.0% <a href="#m3">[3]</a> 1/1 2 Z.m ()
+<a name="m1"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 2/2 4 (toplevel)
+[1] 40.0% 2+0 4 R.m ()
+ 100.0% excl 4
+<a name="m2"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 2/2 4 (toplevel)
+[2] 40.0% 2+0 4 S.m ()
+ 100.0% excl 4
+<a name="m3"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 2 (toplevel)
+[3] 20.0% 1+0 2 Z.m ()
+ 100.0% excl 2
+</pre>
+<a name="thread"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Elapsed times for each thread, sorted by elapsed time.
+Also includes percentage of time spent during the <i>execution</i> of any filters.
+
+<br><br>
+<pre>
+ Usecs self % sum % FirstFilter % SecondFilter % RepeatedFilter % tid ThreadName
+ 10 100.00 100.00 80.00 0.00 80.00 1 main
+ 0 0.00 100.00 nan nan nan 2 foo
+ 0 0.00 100.00 nan nan nan 3 bar
+ 0 0.00 100.00 nan nan nan 4 blah
+</pre><br />
+
+Break-down of portion of time spent by each thread while waiting on a filter method.
+<br/><br/>
+<pre>
+Filter: FirstFilter
+Total waiting cycles: 8 ( 80.00% of total)
+Details:
+
+ Waiting cycles % of total waiting time execution time while waiting thread name
+ 8 100.00 100.00 main
+ 0 0.00 0.00 foo
+ 0 0.00 0.00 bar
+ 0 0.00 0.00 blah
+</pre>
+<br/><br/>
+<pre>
+Filter: SecondFilter
+Total waiting cycles: 0 ( 0.00% of total)
+</pre>
+<br/><br/>
+<pre>
+Filter: RepeatedFilter
+Total waiting cycles: 8 ( 80.00% of total)
+Details:
+
+ Waiting cycles % of total waiting time execution time while waiting thread name
+ 8 100.00 100.00 main
+ 0 0.00 0.00 foo
+ 0 0.00 0.00 bar
+ 0 0.00 0.00 blah
+</pre>
+<a name="class"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Exclusive elapsed time for each class, summed over all the methods
+in the class.
+
+<br><br>
+<div class="header"><span class="parent"> </span> Cycles %/total Cumul.% Calls+Recur Class</div>
+<div class="link" onClick="javascript:toggle('d0')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd0">+</span> 4 40.0 40.0 2+0 R</div>
+<div class="parent" id="d0">
+<div class="leaf"><span class="leaf"> </span> 4 4 100.0 100.0 2+0 <a href="#m1">[1]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d1')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd1">+</span> 4 40.0 80.0 2+0 S</div>
+<div class="parent" id="d1">
+<div class="leaf"><span class="leaf"> </span> 4 4 100.0 100.0 2+0 <a href="#m2">[2]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d2')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd2">+</span> 2 20.0 100.0 1+0 Z</div>
+<div class="parent" id="d2">
+<div class="leaf"><span class="leaf"> </span> 2 2 100.0 100.0 1+0 <a href="#m3">[3]</a> m ()</div>
+</div>
+<a name="method"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Exclusive elapsed time for each method, summed over all the classes
+that contain a method with the same name.
+
+<br><br>
+<div class="header"><span class="parent"> </span> Cycles %/total Cumul.% Calls+Recur Method</div>
+<div class="link" onClick="javascript:toggle('e0')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xe0">+</span> 10 100.0 100.0 5+0 m</div>
+<div class="parent" id="e0">
+<div class="leaf"><span class="leaf"> </span> 4 4 40.0 40.0 2+0 <a href="#m1">[1]</a> R.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 4 4 40.0 80.0 2+0 <a href="#m2">[2]</a> S.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 2 2 20.0 100.0 1+0 <a href="#m3">[3]</a> Z.m ()</div>
+</div>
+
+</body>
+</html>
--- /dev/null
+# ____ ____ ____ ____
+# __|A ||C ||B ||Z |__
+#
+0 1 A
+2 1 A
+2 1 C
+4 1 C
+4 1 B
+6 1 B
+6 1 Z
+8 1 Z
--- /dev/null
+<html>
+<head>
+<script type="text/javascript" src="(null)sortable.js"></script>
+<script langugage="javascript">
+function toggle(item) {
+ obj=document.getElementById(item);
+ visible=(obj.style.display!="none" && obj.style.display!="");
+ key=document.getElementById("x" + item);
+ if (visible) {
+ obj.style.display="none";
+ key.innerHTML="+";
+ } else {
+ obj.style.display="block";
+ key.innerHTML="-";
+ }
+}
+function onMouseOver(obj) {
+ obj.style.background="lightblue";
+}
+function onMouseOut(obj) {
+ obj.style.background="white";
+}
+</script>
+<style type="text/css">
+div { font-family: courier; font-size: 13 }
+div.parent { margin-left: 15; display: none }
+div.leaf { margin-left: 10 }
+div.header { margin-left: 10 }
+div.link { margin-left: 10; cursor: move }
+span.parent { padding-right: 10; }
+span.leaf { padding-right: 10; }
+a img { border: 0;}
+table.sortable th { border-width: 0px 1px 1px 1px; background-color: #ccc;}
+a { text-decoration: none; }
+a:hover { text-decoration: underline; }
+table.sortable th, table.sortable td { text-align: left;}table.sortable tr.odd td { background-color: #ddd; }
+table.sortable tr.even td { background-color: #fff; }
+</style>
+</head><body>
+
+<a name="contents"></a>
+<h2>Table of Contents</h2>
+<ul>
+ <li><a href="#exclusive">Exclusive profile</a></li>
+ <li><a href="#inclusive">Inclusive profile</a></li>
+ <li><a href="#thread">Thread profile</a></li>
+ <li><a href="#class">Class/method profile</a></li>
+ <li><a href="#method">Method/class profile</a></li>
+</ul>
+
+<a name="exclusive"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+Total cycles: 8
+
+<br><br>
+Exclusive elapsed times for each method, not including time spent in
+children, sorted by exclusive time.
+
+<br><br>
+<pre>
+ Usecs self % sum % Method
+ 2 25.00 25.00 <a href="#m1">[1]</a> A.m ()
+ 2 25.00 50.00 <a href="#m2">[2]</a> B.m ()
+ 2 25.00 75.00 <a href="#m3">[3]</a> C.m ()
+ 2 25.00 100.00 <a href="#m4">[4]</a> Z.m ()
+</pre>
+<a name="inclusive"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Inclusive elapsed times for each method and its parents and children,
+sorted by inclusive time.
+
+<br><br>
+<pre>
+index %/total %/self index calls usecs name
+<a name="m0"></a>----------------------------------------------------
+[0] 100.0% 0+0 8 (toplevel)
+ 0.0% excl 0
+ 25.0% <a href="#m1">[1]</a> 1/1 2 A.m ()
+ 25.0% <a href="#m2">[2]</a> 1/1 2 B.m ()
+ 25.0% <a href="#m3">[3]</a> 1/1 2 C.m ()
+ 25.0% <a href="#m4">[4]</a> 1/1 2 Z.m ()
+<a name="m1"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 2 (toplevel)
+[1] 25.0% 1+0 2 A.m ()
+ 100.0% excl 2
+<a name="m2"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 2 (toplevel)
+[2] 25.0% 1+0 2 B.m ()
+ 100.0% excl 2
+<a name="m3"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 2 (toplevel)
+[3] 25.0% 1+0 2 C.m ()
+ 100.0% excl 2
+<a name="m4"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 2 (toplevel)
+[4] 25.0% 1+0 2 Z.m ()
+ 100.0% excl 2
+</pre>
+<a name="thread"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Elapsed times for each thread, sorted by elapsed time.
+Also includes percentage of time spent during the <i>execution</i> of any filters.
+
+<br><br>
+<pre>
+ Usecs self % sum % FirstFilter % SecondFilter % RepeatedFilter % tid ThreadName
+ 8 100.00 100.00 75.00 0.00 0.00 1 main
+ 0 0.00 100.00 nan nan nan 2 foo
+ 0 0.00 100.00 nan nan nan 3 bar
+ 0 0.00 100.00 nan nan nan 4 blah
+</pre><br />
+
+Break-down of portion of time spent by each thread while waiting on a filter method.
+<br/><br/>
+<pre>
+Filter: FirstFilter
+Total waiting cycles: 6 ( 75.00% of total)
+Details:
+
+ Waiting cycles % of total waiting time execution time while waiting thread name
+ 6 100.00 100.00 main
+ 0 0.00 0.00 foo
+ 0 0.00 0.00 bar
+ 0 0.00 0.00 blah
+</pre>
+<br/><br/>
+<pre>
+Filter: SecondFilter
+Total waiting cycles: 0 ( 0.00% of total)
+</pre>
+<br/><br/>
+<pre>
+Filter: RepeatedFilter
+Total waiting cycles: 0 ( 0.00% of total)
+</pre>
+<a name="class"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Exclusive elapsed time for each class, summed over all the methods
+in the class.
+
+<br><br>
+<div class="header"><span class="parent"> </span> Cycles %/total Cumul.% Calls+Recur Class</div>
+<div class="link" onClick="javascript:toggle('d0')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd0">+</span> 2 25.0 25.0 1+0 A</div>
+<div class="parent" id="d0">
+<div class="leaf"><span class="leaf"> </span> 2 2 100.0 100.0 1+0 <a href="#m1">[1]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d1')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd1">+</span> 2 25.0 50.0 1+0 B</div>
+<div class="parent" id="d1">
+<div class="leaf"><span class="leaf"> </span> 2 2 100.0 100.0 1+0 <a href="#m2">[2]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d2')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd2">+</span> 2 25.0 75.0 1+0 C</div>
+<div class="parent" id="d2">
+<div class="leaf"><span class="leaf"> </span> 2 2 100.0 100.0 1+0 <a href="#m3">[3]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d3')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd3">+</span> 2 25.0 100.0 1+0 Z</div>
+<div class="parent" id="d3">
+<div class="leaf"><span class="leaf"> </span> 2 2 100.0 100.0 1+0 <a href="#m4">[4]</a> m ()</div>
+</div>
+<a name="method"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Exclusive elapsed time for each method, summed over all the classes
+that contain a method with the same name.
+
+<br><br>
+<div class="header"><span class="parent"> </span> Cycles %/total Cumul.% Calls+Recur Method</div>
+<div class="link" onClick="javascript:toggle('e0')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xe0">+</span> 8 100.0 100.0 4+0 m</div>
+<div class="parent" id="e0">
+<div class="leaf"><span class="leaf"> </span> 2 2 25.0 25.0 1+0 <a href="#m1">[1]</a> A.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 2 2 25.0 50.0 1+0 <a href="#m2">[2]</a> B.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 2 2 25.0 75.0 1+0 <a href="#m3">[3]</a> C.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 2 2 25.0 100.0 1+0 <a href="#m4">[4]</a> Z.m ()</div>
+</div>
+
+</body>
+</html>
--- /dev/null
+# ____ ____ ____ ____ ____
+# __|A ||A ||B ||B ||Z |__
+#
+0 1 A
+2 1 A
+2 1 A
+4 1 A
+4 1 B
+6 1 B
+6 1 B
+8 1 B
+8 1 Z
+10 1 Z
--- /dev/null
+<html>
+<head>
+<script type="text/javascript" src="(null)sortable.js"></script>
+<script langugage="javascript">
+function toggle(item) {
+ obj=document.getElementById(item);
+ visible=(obj.style.display!="none" && obj.style.display!="");
+ key=document.getElementById("x" + item);
+ if (visible) {
+ obj.style.display="none";
+ key.innerHTML="+";
+ } else {
+ obj.style.display="block";
+ key.innerHTML="-";
+ }
+}
+function onMouseOver(obj) {
+ obj.style.background="lightblue";
+}
+function onMouseOut(obj) {
+ obj.style.background="white";
+}
+</script>
+<style type="text/css">
+div { font-family: courier; font-size: 13 }
+div.parent { margin-left: 15; display: none }
+div.leaf { margin-left: 10 }
+div.header { margin-left: 10 }
+div.link { margin-left: 10; cursor: move }
+span.parent { padding-right: 10; }
+span.leaf { padding-right: 10; }
+a img { border: 0;}
+table.sortable th { border-width: 0px 1px 1px 1px; background-color: #ccc;}
+a { text-decoration: none; }
+a:hover { text-decoration: underline; }
+table.sortable th, table.sortable td { text-align: left;}table.sortable tr.odd td { background-color: #ddd; }
+table.sortable tr.even td { background-color: #fff; }
+</style>
+</head><body>
+
+<a name="contents"></a>
+<h2>Table of Contents</h2>
+<ul>
+ <li><a href="#exclusive">Exclusive profile</a></li>
+ <li><a href="#inclusive">Inclusive profile</a></li>
+ <li><a href="#thread">Thread profile</a></li>
+ <li><a href="#class">Class/method profile</a></li>
+ <li><a href="#method">Method/class profile</a></li>
+</ul>
+
+<a name="exclusive"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+Total cycles: 10
+
+<br><br>
+Exclusive elapsed times for each method, not including time spent in
+children, sorted by exclusive time.
+
+<br><br>
+<pre>
+ Usecs self % sum % Method
+ 4 40.00 40.00 <a href="#m1">[1]</a> A.m ()
+ 4 40.00 80.00 <a href="#m2">[2]</a> B.m ()
+ 2 20.00 100.00 <a href="#m3">[3]</a> Z.m ()
+</pre>
+<a name="inclusive"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Inclusive elapsed times for each method and its parents and children,
+sorted by inclusive time.
+
+<br><br>
+<pre>
+index %/total %/self index calls usecs name
+<a name="m0"></a>----------------------------------------------------
+[0] 100.0% 0+0 10 (toplevel)
+ 0.0% excl 0
+ 40.0% <a href="#m1">[1]</a> 2/2 4 A.m ()
+ 40.0% <a href="#m2">[2]</a> 2/2 4 B.m ()
+ 20.0% <a href="#m3">[3]</a> 1/1 2 Z.m ()
+<a name="m1"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 2/2 4 (toplevel)
+[1] 40.0% 2+0 4 A.m ()
+ 100.0% excl 4
+<a name="m2"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 2/2 4 (toplevel)
+[2] 40.0% 2+0 4 B.m ()
+ 100.0% excl 4
+<a name="m3"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 2 (toplevel)
+[3] 20.0% 1+0 2 Z.m ()
+ 100.0% excl 2
+</pre>
+<a name="thread"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Elapsed times for each thread, sorted by elapsed time.
+Also includes percentage of time spent during the <i>execution</i> of any filters.
+
+<br><br>
+<pre>
+ Usecs self % sum % FirstFilter % SecondFilter % RepeatedFilter % tid ThreadName
+ 10 100.00 100.00 80.00 0.00 0.00 1 main
+ 0 0.00 100.00 nan nan nan 2 foo
+ 0 0.00 100.00 nan nan nan 3 bar
+ 0 0.00 100.00 nan nan nan 4 blah
+</pre><br />
+
+Break-down of portion of time spent by each thread while waiting on a filter method.
+<br/><br/>
+<pre>
+Filter: FirstFilter
+Total waiting cycles: 8 ( 80.00% of total)
+Details:
+
+ Waiting cycles % of total waiting time execution time while waiting thread name
+ 8 100.00 100.00 main
+ 0 0.00 0.00 foo
+ 0 0.00 0.00 bar
+ 0 0.00 0.00 blah
+</pre>
+<br/><br/>
+<pre>
+Filter: SecondFilter
+Total waiting cycles: 0 ( 0.00% of total)
+</pre>
+<br/><br/>
+<pre>
+Filter: RepeatedFilter
+Total waiting cycles: 0 ( 0.00% of total)
+</pre>
+<a name="class"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Exclusive elapsed time for each class, summed over all the methods
+in the class.
+
+<br><br>
+<div class="header"><span class="parent"> </span> Cycles %/total Cumul.% Calls+Recur Class</div>
+<div class="link" onClick="javascript:toggle('d0')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd0">+</span> 4 40.0 40.0 2+0 A</div>
+<div class="parent" id="d0">
+<div class="leaf"><span class="leaf"> </span> 4 4 100.0 100.0 2+0 <a href="#m1">[1]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d1')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd1">+</span> 4 40.0 80.0 2+0 B</div>
+<div class="parent" id="d1">
+<div class="leaf"><span class="leaf"> </span> 4 4 100.0 100.0 2+0 <a href="#m2">[2]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d2')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd2">+</span> 2 20.0 100.0 1+0 Z</div>
+<div class="parent" id="d2">
+<div class="leaf"><span class="leaf"> </span> 2 2 100.0 100.0 1+0 <a href="#m3">[3]</a> m ()</div>
+</div>
+<a name="method"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Exclusive elapsed time for each method, summed over all the classes
+that contain a method with the same name.
+
+<br><br>
+<div class="header"><span class="parent"> </span> Cycles %/total Cumul.% Calls+Recur Method</div>
+<div class="link" onClick="javascript:toggle('e0')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xe0">+</span> 10 100.0 100.0 5+0 m</div>
+<div class="parent" id="e0">
+<div class="leaf"><span class="leaf"> </span> 4 4 40.0 40.0 2+0 <a href="#m1">[1]</a> A.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 4 4 40.0 80.0 2+0 <a href="#m2">[2]</a> B.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 2 2 20.0 100.0 1+0 <a href="#m3">[3]</a> Z.m ()</div>
+</div>
+
+</body>
+</html>
--- /dev/null
+# ____ ____ ____
+# __|A |______|B ||Z |__
+#
+# _____
+# ________|Z |_________________
+#
+0 1 A
+2 1 A
+0 2 Z
+2 2 Z
+2 1 B
+4 1 B
+4 1 Z
+6 1 Z
--- /dev/null
+<html>
+<head>
+<script type="text/javascript" src="(null)sortable.js"></script>
+<script langugage="javascript">
+function toggle(item) {
+ obj=document.getElementById(item);
+ visible=(obj.style.display!="none" && obj.style.display!="");
+ key=document.getElementById("x" + item);
+ if (visible) {
+ obj.style.display="none";
+ key.innerHTML="+";
+ } else {
+ obj.style.display="block";
+ key.innerHTML="-";
+ }
+}
+function onMouseOver(obj) {
+ obj.style.background="lightblue";
+}
+function onMouseOut(obj) {
+ obj.style.background="white";
+}
+</script>
+<style type="text/css">
+div { font-family: courier; font-size: 13 }
+div.parent { margin-left: 15; display: none }
+div.leaf { margin-left: 10 }
+div.header { margin-left: 10 }
+div.link { margin-left: 10; cursor: move }
+span.parent { padding-right: 10; }
+span.leaf { padding-right: 10; }
+a img { border: 0;}
+table.sortable th { border-width: 0px 1px 1px 1px; background-color: #ccc;}
+a { text-decoration: none; }
+a:hover { text-decoration: underline; }
+table.sortable th, table.sortable td { text-align: left;}table.sortable tr.odd td { background-color: #ddd; }
+table.sortable tr.even td { background-color: #fff; }
+</style>
+</head><body>
+
+<a name="contents"></a>
+<h2>Table of Contents</h2>
+<ul>
+ <li><a href="#exclusive">Exclusive profile</a></li>
+ <li><a href="#inclusive">Inclusive profile</a></li>
+ <li><a href="#thread">Thread profile</a></li>
+ <li><a href="#class">Class/method profile</a></li>
+ <li><a href="#method">Method/class profile</a></li>
+</ul>
+
+<a name="exclusive"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+Total cycles: 8
+
+<br><br>
+Exclusive elapsed times for each method, not including time spent in
+children, sorted by exclusive time.
+
+<br><br>
+<pre>
+ Usecs self % sum % Method
+ 4 50.00 50.00 <a href="#m1">[1]</a> Z.m ()
+ 2 25.00 75.00 <a href="#m2">[2]</a> A.m ()
+ 2 25.00 100.00 <a href="#m3">[3]</a> B.m ()
+</pre>
+<a name="inclusive"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Inclusive elapsed times for each method and its parents and children,
+sorted by inclusive time.
+
+<br><br>
+<pre>
+index %/total %/self index calls usecs name
+<a name="m0"></a>----------------------------------------------------
+[0] 100.0% 0+0 8 (toplevel)
+ 0.0% excl 0
+ 50.0% <a href="#m1">[1]</a> 2/2 4 Z.m ()
+ 25.0% <a href="#m2">[2]</a> 1/1 2 A.m ()
+ 25.0% <a href="#m3">[3]</a> 1/1 2 B.m ()
+<a name="m1"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 2/2 4 (toplevel)
+[1] 50.0% 2+0 4 Z.m ()
+ 100.0% excl 4
+<a name="m2"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 2 (toplevel)
+[2] 25.0% 1+0 2 A.m ()
+ 100.0% excl 2
+<a name="m3"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 2 (toplevel)
+[3] 25.0% 1+0 2 B.m ()
+ 100.0% excl 2
+</pre>
+<a name="thread"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Elapsed times for each thread, sorted by elapsed time.
+Also includes percentage of time spent during the <i>execution</i> of any filters.
+
+<br><br>
+<pre>
+ Usecs self % sum % FirstFilter % SecondFilter % RepeatedFilter % tid ThreadName
+ 6 75.00 75.00 66.67 0.00 0.00 1 main
+ 2 25.00 100.00 0.00 0.00 0.00 2 foo
+ 0 0.00 100.00 nan nan nan 3 bar
+ 0 0.00 100.00 nan nan nan 4 blah
+</pre><br />
+
+Break-down of portion of time spent by each thread while waiting on a filter method.
+<br/><br/>
+<pre>
+Filter: FirstFilter
+Total waiting cycles: 6 ( 75.00% of total)
+Details:
+
+ Waiting cycles % of total waiting time execution time while waiting thread name
+ 6 100.00 66.67 main
+ 0 0.00 33.33 foo
+ 0 0.00 0.00 bar
+ 0 0.00 0.00 blah
+</pre>
+<br/><br/>
+<pre>
+Filter: SecondFilter
+Total waiting cycles: 0 ( 0.00% of total)
+</pre>
+<br/><br/>
+<pre>
+Filter: RepeatedFilter
+Total waiting cycles: 0 ( 0.00% of total)
+</pre>
+<a name="class"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Exclusive elapsed time for each class, summed over all the methods
+in the class.
+
+<br><br>
+<div class="header"><span class="parent"> </span> Cycles %/total Cumul.% Calls+Recur Class</div>
+<div class="link" onClick="javascript:toggle('d0')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd0">+</span> 4 50.0 50.0 2+0 Z</div>
+<div class="parent" id="d0">
+<div class="leaf"><span class="leaf"> </span> 4 4 100.0 100.0 2+0 <a href="#m1">[1]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d1')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd1">+</span> 2 25.0 75.0 1+0 A</div>
+<div class="parent" id="d1">
+<div class="leaf"><span class="leaf"> </span> 2 2 100.0 100.0 1+0 <a href="#m2">[2]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d2')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd2">+</span> 2 25.0 100.0 1+0 B</div>
+<div class="parent" id="d2">
+<div class="leaf"><span class="leaf"> </span> 2 2 100.0 100.0 1+0 <a href="#m3">[3]</a> m ()</div>
+</div>
+<a name="method"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Exclusive elapsed time for each method, summed over all the classes
+that contain a method with the same name.
+
+<br><br>
+<div class="header"><span class="parent"> </span> Cycles %/total Cumul.% Calls+Recur Method</div>
+<div class="link" onClick="javascript:toggle('e0')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xe0">+</span> 8 100.0 100.0 4+0 m</div>
+<div class="parent" id="e0">
+<div class="leaf"><span class="leaf"> </span> 4 4 50.0 50.0 2+0 <a href="#m1">[1]</a> Z.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 2 2 25.0 75.0 1+0 <a href="#m2">[2]</a> A.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 2 2 25.0 100.0 1+0 <a href="#m3">[3]</a> B.m ()</div>
+</div>
+
+</body>
+</html>
--- /dev/null
+# ____ ____ ____ ____
+# __|A ||Z ||B ||Z |__
+#
+0 1 A
+2 1 A
+2 1 Z
+4 1 Z
+4 1 B
+6 1 B
+6 1 Z
+8 1 Z
--- /dev/null
+<html>
+<head>
+<script type="text/javascript" src="(null)sortable.js"></script>
+<script langugage="javascript">
+function toggle(item) {
+ obj=document.getElementById(item);
+ visible=(obj.style.display!="none" && obj.style.display!="");
+ key=document.getElementById("x" + item);
+ if (visible) {
+ obj.style.display="none";
+ key.innerHTML="+";
+ } else {
+ obj.style.display="block";
+ key.innerHTML="-";
+ }
+}
+function onMouseOver(obj) {
+ obj.style.background="lightblue";
+}
+function onMouseOut(obj) {
+ obj.style.background="white";
+}
+</script>
+<style type="text/css">
+div { font-family: courier; font-size: 13 }
+div.parent { margin-left: 15; display: none }
+div.leaf { margin-left: 10 }
+div.header { margin-left: 10 }
+div.link { margin-left: 10; cursor: move }
+span.parent { padding-right: 10; }
+span.leaf { padding-right: 10; }
+a img { border: 0;}
+table.sortable th { border-width: 0px 1px 1px 1px; background-color: #ccc;}
+a { text-decoration: none; }
+a:hover { text-decoration: underline; }
+table.sortable th, table.sortable td { text-align: left;}table.sortable tr.odd td { background-color: #ddd; }
+table.sortable tr.even td { background-color: #fff; }
+</style>
+</head><body>
+
+<a name="contents"></a>
+<h2>Table of Contents</h2>
+<ul>
+ <li><a href="#exclusive">Exclusive profile</a></li>
+ <li><a href="#inclusive">Inclusive profile</a></li>
+ <li><a href="#thread">Thread profile</a></li>
+ <li><a href="#class">Class/method profile</a></li>
+ <li><a href="#method">Method/class profile</a></li>
+</ul>
+
+<a name="exclusive"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+Total cycles: 8
+
+<br><br>
+Exclusive elapsed times for each method, not including time spent in
+children, sorted by exclusive time.
+
+<br><br>
+<pre>
+ Usecs self % sum % Method
+ 4 50.00 50.00 <a href="#m1">[1]</a> Z.m ()
+ 2 25.00 75.00 <a href="#m2">[2]</a> A.m ()
+ 2 25.00 100.00 <a href="#m3">[3]</a> B.m ()
+</pre>
+<a name="inclusive"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Inclusive elapsed times for each method and its parents and children,
+sorted by inclusive time.
+
+<br><br>
+<pre>
+index %/total %/self index calls usecs name
+<a name="m0"></a>----------------------------------------------------
+[0] 100.0% 0+0 8 (toplevel)
+ 0.0% excl 0
+ 50.0% <a href="#m1">[1]</a> 2/2 4 Z.m ()
+ 25.0% <a href="#m2">[2]</a> 1/1 2 A.m ()
+ 25.0% <a href="#m3">[3]</a> 1/1 2 B.m ()
+<a name="m1"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 2/2 4 (toplevel)
+[1] 50.0% 2+0 4 Z.m ()
+ 100.0% excl 4
+<a name="m2"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 2 (toplevel)
+[2] 25.0% 1+0 2 A.m ()
+ 100.0% excl 2
+<a name="m3"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 2 (toplevel)
+[3] 25.0% 1+0 2 B.m ()
+ 100.0% excl 2
+</pre>
+<a name="thread"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Elapsed times for each thread, sorted by elapsed time.
+Also includes percentage of time spent during the <i>execution</i> of any filters.
+
+<br><br>
+<pre>
+ Usecs self % sum % FirstFilter % SecondFilter % RepeatedFilter % tid ThreadName
+ 8 100.00 100.00 75.00 0.00 0.00 1 main
+ 0 0.00 100.00 nan nan nan 2 foo
+ 0 0.00 100.00 nan nan nan 3 bar
+ 0 0.00 100.00 nan nan nan 4 blah
+</pre><br />
+
+Break-down of portion of time spent by each thread while waiting on a filter method.
+<br/><br/>
+<pre>
+Filter: FirstFilter
+Total waiting cycles: 6 ( 75.00% of total)
+Details:
+
+ Waiting cycles % of total waiting time execution time while waiting thread name
+ 6 100.00 100.00 main
+ 0 0.00 0.00 foo
+ 0 0.00 0.00 bar
+ 0 0.00 0.00 blah
+</pre>
+<br/><br/>
+<pre>
+Filter: SecondFilter
+Total waiting cycles: 0 ( 0.00% of total)
+</pre>
+<br/><br/>
+<pre>
+Filter: RepeatedFilter
+Total waiting cycles: 0 ( 0.00% of total)
+</pre>
+<a name="class"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Exclusive elapsed time for each class, summed over all the methods
+in the class.
+
+<br><br>
+<div class="header"><span class="parent"> </span> Cycles %/total Cumul.% Calls+Recur Class</div>
+<div class="link" onClick="javascript:toggle('d0')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd0">+</span> 4 50.0 50.0 2+0 Z</div>
+<div class="parent" id="d0">
+<div class="leaf"><span class="leaf"> </span> 4 4 100.0 100.0 2+0 <a href="#m1">[1]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d1')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd1">+</span> 2 25.0 75.0 1+0 A</div>
+<div class="parent" id="d1">
+<div class="leaf"><span class="leaf"> </span> 2 2 100.0 100.0 1+0 <a href="#m2">[2]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d2')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd2">+</span> 2 25.0 100.0 1+0 B</div>
+<div class="parent" id="d2">
+<div class="leaf"><span class="leaf"> </span> 2 2 100.0 100.0 1+0 <a href="#m3">[3]</a> m ()</div>
+</div>
+<a name="method"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Exclusive elapsed time for each method, summed over all the classes
+that contain a method with the same name.
+
+<br><br>
+<div class="header"><span class="parent"> </span> Cycles %/total Cumul.% Calls+Recur Method</div>
+<div class="link" onClick="javascript:toggle('e0')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xe0">+</span> 8 100.0 100.0 4+0 m</div>
+<div class="parent" id="e0">
+<div class="leaf"><span class="leaf"> </span> 4 4 50.0 50.0 2+0 <a href="#m1">[1]</a> Z.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 2 2 25.0 75.0 1+0 <a href="#m2">[2]</a> A.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 2 2 25.0 100.0 1+0 <a href="#m3">[3]</a> B.m ()</div>
+</div>
+
+</body>
+</html>
--- /dev/null
+# ____ ____ ____ ____
+# __|A |___________|B ||Z |____|Z |_______
+#
+# ____ ____ ____ ____
+# _______|Z ||D |___________|E |____|Z |__
+#
+#
+0 1 A
+2 1 A
+0 2 Z
+2 2 Z
+2 2 D
+4 2 D
+2 1 B
+4 1 B
+4 1 Z
+6 1 Z
+4 2 E
+6 2 E
+6 1 Z
+8 1 Z
+6 2 Z
+8 2 Z
--- /dev/null
+<html>
+<head>
+<script type="text/javascript" src="(null)sortable.js"></script>
+<script langugage="javascript">
+function toggle(item) {
+ obj=document.getElementById(item);
+ visible=(obj.style.display!="none" && obj.style.display!="");
+ key=document.getElementById("x" + item);
+ if (visible) {
+ obj.style.display="none";
+ key.innerHTML="+";
+ } else {
+ obj.style.display="block";
+ key.innerHTML="-";
+ }
+}
+function onMouseOver(obj) {
+ obj.style.background="lightblue";
+}
+function onMouseOut(obj) {
+ obj.style.background="white";
+}
+</script>
+<style type="text/css">
+div { font-family: courier; font-size: 13 }
+div.parent { margin-left: 15; display: none }
+div.leaf { margin-left: 10 }
+div.header { margin-left: 10 }
+div.link { margin-left: 10; cursor: move }
+span.parent { padding-right: 10; }
+span.leaf { padding-right: 10; }
+a img { border: 0;}
+table.sortable th { border-width: 0px 1px 1px 1px; background-color: #ccc;}
+a { text-decoration: none; }
+a:hover { text-decoration: underline; }
+table.sortable th, table.sortable td { text-align: left;}table.sortable tr.odd td { background-color: #ddd; }
+table.sortable tr.even td { background-color: #fff; }
+</style>
+</head><body>
+
+<a name="contents"></a>
+<h2>Table of Contents</h2>
+<ul>
+ <li><a href="#exclusive">Exclusive profile</a></li>
+ <li><a href="#inclusive">Inclusive profile</a></li>
+ <li><a href="#thread">Thread profile</a></li>
+ <li><a href="#class">Class/method profile</a></li>
+ <li><a href="#method">Method/class profile</a></li>
+</ul>
+
+<a name="exclusive"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+Total cycles: 16
+
+<br><br>
+Exclusive elapsed times for each method, not including time spent in
+children, sorted by exclusive time.
+
+<br><br>
+<pre>
+ Usecs self % sum % Method
+ 8 50.00 50.00 <a href="#m1">[1]</a> Z.m ()
+ 2 12.50 62.50 <a href="#m2">[2]</a> A.m ()
+ 2 12.50 75.00 <a href="#m3">[3]</a> B.m ()
+ 2 12.50 87.50 <a href="#m4">[4]</a> D.m ()
+ 2 12.50 100.00 <a href="#m5">[5]</a> E.m ()
+</pre>
+<a name="inclusive"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Inclusive elapsed times for each method and its parents and children,
+sorted by inclusive time.
+
+<br><br>
+<pre>
+index %/total %/self index calls usecs name
+<a name="m0"></a>----------------------------------------------------
+[0] 100.0% 0+0 16 (toplevel)
+ 0.0% excl 0
+ 50.0% <a href="#m1">[1]</a> 4/4 8 Z.m ()
+ 12.5% <a href="#m2">[2]</a> 1/1 2 A.m ()
+ 12.5% <a href="#m3">[3]</a> 1/1 2 B.m ()
+ 12.5% <a href="#m4">[4]</a> 1/1 2 D.m ()
+ 12.5% <a href="#m5">[5]</a> 1/1 2 E.m ()
+<a name="m1"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 4/4 8 (toplevel)
+[1] 50.0% 4+0 8 Z.m ()
+ 100.0% excl 8
+<a name="m2"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 2 (toplevel)
+[2] 12.5% 1+0 2 A.m ()
+ 100.0% excl 2
+<a name="m3"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 2 (toplevel)
+[3] 12.5% 1+0 2 B.m ()
+ 100.0% excl 2
+<a name="m4"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 2 (toplevel)
+[4] 12.5% 1+0 2 D.m ()
+ 100.0% excl 2
+<a name="m5"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 2 (toplevel)
+[5] 12.5% 1+0 2 E.m ()
+ 100.0% excl 2
+</pre>
+<a name="thread"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Elapsed times for each thread, sorted by elapsed time.
+Also includes percentage of time spent during the <i>execution</i> of any filters.
+
+<br><br>
+<pre>
+ Usecs self % sum % FirstFilter % SecondFilter % RepeatedFilter % tid ThreadName
+ 8 50.00 50.00 50.00 0.00 0.00 1 main
+ 8 50.00 100.00 0.00 50.00 0.00 2 foo
+ 0 0.00 100.00 nan nan nan 3 bar
+ 0 0.00 100.00 nan nan nan 4 blah
+</pre><br />
+
+Break-down of portion of time spent by each thread while waiting on a filter method.
+<br/><br/>
+<pre>
+Filter: FirstFilter
+Total waiting cycles: 8 ( 50.00% of total)
+Details:
+
+ Waiting cycles % of total waiting time execution time while waiting thread name
+ 8 100.00 50.00 main
+ 0 0.00 50.00 foo
+ 0 0.00 0.00 bar
+ 0 0.00 0.00 blah
+</pre>
+<br/><br/>
+<pre>
+Filter: SecondFilter
+Total waiting cycles: 8 ( 50.00% of total)
+Details:
+
+ Waiting cycles % of total waiting time execution time while waiting thread name
+ 0 0.00 50.00 main
+ 8 100.00 50.00 foo
+ 0 0.00 0.00 bar
+ 0 0.00 0.00 blah
+</pre>
+<br/><br/>
+<pre>
+Filter: RepeatedFilter
+Total waiting cycles: 0 ( 0.00% of total)
+</pre>
+<a name="class"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Exclusive elapsed time for each class, summed over all the methods
+in the class.
+
+<br><br>
+<div class="header"><span class="parent"> </span> Cycles %/total Cumul.% Calls+Recur Class</div>
+<div class="link" onClick="javascript:toggle('d0')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd0">+</span> 8 50.0 50.0 4+0 Z</div>
+<div class="parent" id="d0">
+<div class="leaf"><span class="leaf"> </span> 8 8 100.0 100.0 4+0 <a href="#m1">[1]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d1')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd1">+</span> 2 12.5 62.5 1+0 A</div>
+<div class="parent" id="d1">
+<div class="leaf"><span class="leaf"> </span> 2 2 100.0 100.0 1+0 <a href="#m2">[2]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d2')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd2">+</span> 2 12.5 75.0 1+0 B</div>
+<div class="parent" id="d2">
+<div class="leaf"><span class="leaf"> </span> 2 2 100.0 100.0 1+0 <a href="#m3">[3]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d3')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd3">+</span> 2 12.5 87.5 1+0 D</div>
+<div class="parent" id="d3">
+<div class="leaf"><span class="leaf"> </span> 2 2 100.0 100.0 1+0 <a href="#m4">[4]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d4')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd4">+</span> 2 12.5 100.0 1+0 E</div>
+<div class="parent" id="d4">
+<div class="leaf"><span class="leaf"> </span> 2 2 100.0 100.0 1+0 <a href="#m5">[5]</a> m ()</div>
+</div>
+<a name="method"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Exclusive elapsed time for each method, summed over all the classes
+that contain a method with the same name.
+
+<br><br>
+<div class="header"><span class="parent"> </span> Cycles %/total Cumul.% Calls+Recur Method</div>
+<div class="link" onClick="javascript:toggle('e0')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xe0">+</span> 16 100.0 100.0 8+0 m</div>
+<div class="parent" id="e0">
+<div class="leaf"><span class="leaf"> </span> 8 8 50.0 50.0 4+0 <a href="#m1">[1]</a> Z.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 2 2 12.5 62.5 1+0 <a href="#m2">[2]</a> A.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 2 2 12.5 75.0 1+0 <a href="#m3">[3]</a> B.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 2 2 12.5 87.5 1+0 <a href="#m4">[4]</a> D.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 2 2 12.5 100.0 1+0 <a href="#m5">[5]</a> E.m ()</div>
+</div>
+
+</body>
+</html>
--- /dev/null
+# ____ ____ ____ ____
+# __|R |___________|S ||Z |____|Z |_______
+#
+# ____ ____ ____ ____
+# _______|Z ||R |___________|S |____|Z |__
+#
+#
+0 1 R
+2 1 R
+0 2 Z
+2 2 Z
+2 2 R
+4 2 R
+2 1 S
+4 1 S
+4 1 Z
+6 1 Z
+4 2 S
+6 2 S
+6 1 Z
+8 1 Z
+6 2 Z
+8 2 Z
--- /dev/null
+<html>
+<head>
+<script type="text/javascript" src="(null)sortable.js"></script>
+<script langugage="javascript">
+function toggle(item) {
+ obj=document.getElementById(item);
+ visible=(obj.style.display!="none" && obj.style.display!="");
+ key=document.getElementById("x" + item);
+ if (visible) {
+ obj.style.display="none";
+ key.innerHTML="+";
+ } else {
+ obj.style.display="block";
+ key.innerHTML="-";
+ }
+}
+function onMouseOver(obj) {
+ obj.style.background="lightblue";
+}
+function onMouseOut(obj) {
+ obj.style.background="white";
+}
+</script>
+<style type="text/css">
+div { font-family: courier; font-size: 13 }
+div.parent { margin-left: 15; display: none }
+div.leaf { margin-left: 10 }
+div.header { margin-left: 10 }
+div.link { margin-left: 10; cursor: move }
+span.parent { padding-right: 10; }
+span.leaf { padding-right: 10; }
+a img { border: 0;}
+table.sortable th { border-width: 0px 1px 1px 1px; background-color: #ccc;}
+a { text-decoration: none; }
+a:hover { text-decoration: underline; }
+table.sortable th, table.sortable td { text-align: left;}table.sortable tr.odd td { background-color: #ddd; }
+table.sortable tr.even td { background-color: #fff; }
+</style>
+</head><body>
+
+<a name="contents"></a>
+<h2>Table of Contents</h2>
+<ul>
+ <li><a href="#exclusive">Exclusive profile</a></li>
+ <li><a href="#inclusive">Inclusive profile</a></li>
+ <li><a href="#thread">Thread profile</a></li>
+ <li><a href="#class">Class/method profile</a></li>
+ <li><a href="#method">Method/class profile</a></li>
+</ul>
+
+<a name="exclusive"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+Total cycles: 16
+
+<br><br>
+Exclusive elapsed times for each method, not including time spent in
+children, sorted by exclusive time.
+
+<br><br>
+<pre>
+ Usecs self % sum % Method
+ 8 50.00 50.00 <a href="#m1">[1]</a> Z.m ()
+ 4 25.00 75.00 <a href="#m2">[2]</a> R.m ()
+ 4 25.00 100.00 <a href="#m3">[3]</a> S.m ()
+</pre>
+<a name="inclusive"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Inclusive elapsed times for each method and its parents and children,
+sorted by inclusive time.
+
+<br><br>
+<pre>
+index %/total %/self index calls usecs name
+<a name="m0"></a>----------------------------------------------------
+[0] 100.0% 0+0 16 (toplevel)
+ 0.0% excl 0
+ 50.0% <a href="#m1">[1]</a> 4/4 8 Z.m ()
+ 25.0% <a href="#m2">[2]</a> 2/2 4 R.m ()
+ 25.0% <a href="#m3">[3]</a> 2/2 4 S.m ()
+<a name="m1"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 4/4 8 (toplevel)
+[1] 50.0% 4+0 8 Z.m ()
+ 100.0% excl 8
+<a name="m2"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 2/2 4 (toplevel)
+[2] 25.0% 2+0 4 R.m ()
+ 100.0% excl 4
+<a name="m3"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 2/2 4 (toplevel)
+[3] 25.0% 2+0 4 S.m ()
+ 100.0% excl 4
+</pre>
+<a name="thread"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Elapsed times for each thread, sorted by elapsed time.
+Also includes percentage of time spent during the <i>execution</i> of any filters.
+
+<br><br>
+<pre>
+ Usecs self % sum % FirstFilter % SecondFilter % RepeatedFilter % tid ThreadName
+ 8 50.00 50.00 50.00 0.00 50.00 1 main
+ 8 50.00 100.00 50.00 0.00 50.00 2 foo
+ 0 0.00 100.00 nan nan nan 3 bar
+ 0 0.00 100.00 nan nan nan 4 blah
+</pre><br />
+
+Break-down of portion of time spent by each thread while waiting on a filter method.
+<br/><br/>
+<pre>
+Filter: FirstFilter
+Total waiting cycles: 12 ( 75.00% of total)
+Details:
+
+ Waiting cycles % of total waiting time execution time while waiting thread name
+ 8 66.67 50.00 main
+ 8 66.67 50.00 foo
+ 0 0.00 0.00 bar
+ 0 0.00 0.00 blah
+</pre>
+<br/><br/>
+<pre>
+Filter: SecondFilter
+Total waiting cycles: 0 ( 0.00% of total)
+</pre>
+<br/><br/>
+<pre>
+Filter: RepeatedFilter
+Total waiting cycles: 12 ( 75.00% of total)
+Details:
+
+ Waiting cycles % of total waiting time execution time while waiting thread name
+ 8 66.67 50.00 main
+ 8 66.67 50.00 foo
+ 0 0.00 0.00 bar
+ 0 0.00 0.00 blah
+</pre>
+<a name="class"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Exclusive elapsed time for each class, summed over all the methods
+in the class.
+
+<br><br>
+<div class="header"><span class="parent"> </span> Cycles %/total Cumul.% Calls+Recur Class</div>
+<div class="link" onClick="javascript:toggle('d0')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd0">+</span> 8 50.0 50.0 4+0 Z</div>
+<div class="parent" id="d0">
+<div class="leaf"><span class="leaf"> </span> 8 8 100.0 100.0 4+0 <a href="#m1">[1]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d1')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd1">+</span> 4 25.0 75.0 2+0 R</div>
+<div class="parent" id="d1">
+<div class="leaf"><span class="leaf"> </span> 4 4 100.0 100.0 2+0 <a href="#m2">[2]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d2')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd2">+</span> 4 25.0 100.0 2+0 S</div>
+<div class="parent" id="d2">
+<div class="leaf"><span class="leaf"> </span> 4 4 100.0 100.0 2+0 <a href="#m3">[3]</a> m ()</div>
+</div>
+<a name="method"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Exclusive elapsed time for each method, summed over all the classes
+that contain a method with the same name.
+
+<br><br>
+<div class="header"><span class="parent"> </span> Cycles %/total Cumul.% Calls+Recur Method</div>
+<div class="link" onClick="javascript:toggle('e0')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xe0">+</span> 16 100.0 100.0 8+0 m</div>
+<div class="parent" id="e0">
+<div class="leaf"><span class="leaf"> </span> 8 8 50.0 50.0 4+0 <a href="#m1">[1]</a> Z.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 4 4 25.0 75.0 2+0 <a href="#m2">[2]</a> R.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 4 4 25.0 100.0 2+0 <a href="#m3">[3]</a> S.m ()</div>
+</div>
+
+</body>
+</html>
--- /dev/null
+# ____ ____ ____ ____
+# __|A |___________|B ||Z |____|Z |_______
+#
+# ____ ____ ____ ____
+# _______|Z ||R |___________|S |____|Z |__
+#
+#
+0 1 A
+2 1 A
+0 2 Z
+2 2 Z
+2 2 R
+4 2 R
+2 1 B
+4 1 B
+4 1 Z
+6 1 Z
+4 2 S
+6 2 S
+6 1 Z
+8 1 Z
+6 2 Z
+8 2 Z
--- /dev/null
+<html>
+<head>
+<script type="text/javascript" src="(null)sortable.js"></script>
+<script langugage="javascript">
+function toggle(item) {
+ obj=document.getElementById(item);
+ visible=(obj.style.display!="none" && obj.style.display!="");
+ key=document.getElementById("x" + item);
+ if (visible) {
+ obj.style.display="none";
+ key.innerHTML="+";
+ } else {
+ obj.style.display="block";
+ key.innerHTML="-";
+ }
+}
+function onMouseOver(obj) {
+ obj.style.background="lightblue";
+}
+function onMouseOut(obj) {
+ obj.style.background="white";
+}
+</script>
+<style type="text/css">
+div { font-family: courier; font-size: 13 }
+div.parent { margin-left: 15; display: none }
+div.leaf { margin-left: 10 }
+div.header { margin-left: 10 }
+div.link { margin-left: 10; cursor: move }
+span.parent { padding-right: 10; }
+span.leaf { padding-right: 10; }
+a img { border: 0;}
+table.sortable th { border-width: 0px 1px 1px 1px; background-color: #ccc;}
+a { text-decoration: none; }
+a:hover { text-decoration: underline; }
+table.sortable th, table.sortable td { text-align: left;}table.sortable tr.odd td { background-color: #ddd; }
+table.sortable tr.even td { background-color: #fff; }
+</style>
+</head><body>
+
+<a name="contents"></a>
+<h2>Table of Contents</h2>
+<ul>
+ <li><a href="#exclusive">Exclusive profile</a></li>
+ <li><a href="#inclusive">Inclusive profile</a></li>
+ <li><a href="#thread">Thread profile</a></li>
+ <li><a href="#class">Class/method profile</a></li>
+ <li><a href="#method">Method/class profile</a></li>
+</ul>
+
+<a name="exclusive"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+Total cycles: 16
+
+<br><br>
+Exclusive elapsed times for each method, not including time spent in
+children, sorted by exclusive time.
+
+<br><br>
+<pre>
+ Usecs self % sum % Method
+ 8 50.00 50.00 <a href="#m1">[1]</a> Z.m ()
+ 2 12.50 62.50 <a href="#m2">[2]</a> A.m ()
+ 2 12.50 75.00 <a href="#m3">[3]</a> B.m ()
+ 2 12.50 87.50 <a href="#m4">[4]</a> R.m ()
+ 2 12.50 100.00 <a href="#m5">[5]</a> S.m ()
+</pre>
+<a name="inclusive"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Inclusive elapsed times for each method and its parents and children,
+sorted by inclusive time.
+
+<br><br>
+<pre>
+index %/total %/self index calls usecs name
+<a name="m0"></a>----------------------------------------------------
+[0] 100.0% 0+0 16 (toplevel)
+ 0.0% excl 0
+ 50.0% <a href="#m1">[1]</a> 4/4 8 Z.m ()
+ 12.5% <a href="#m2">[2]</a> 1/1 2 A.m ()
+ 12.5% <a href="#m3">[3]</a> 1/1 2 B.m ()
+ 12.5% <a href="#m4">[4]</a> 1/1 2 R.m ()
+ 12.5% <a href="#m5">[5]</a> 1/1 2 S.m ()
+<a name="m1"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 4/4 8 (toplevel)
+[1] 50.0% 4+0 8 Z.m ()
+ 100.0% excl 8
+<a name="m2"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 2 (toplevel)
+[2] 12.5% 1+0 2 A.m ()
+ 100.0% excl 2
+<a name="m3"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 2 (toplevel)
+[3] 12.5% 1+0 2 B.m ()
+ 100.0% excl 2
+<a name="m4"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 2 (toplevel)
+[4] 12.5% 1+0 2 R.m ()
+ 100.0% excl 2
+<a name="m5"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 2 (toplevel)
+[5] 12.5% 1+0 2 S.m ()
+ 100.0% excl 2
+</pre>
+<a name="thread"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Elapsed times for each thread, sorted by elapsed time.
+Also includes percentage of time spent during the <i>execution</i> of any filters.
+
+<br><br>
+<pre>
+ Usecs self % sum % FirstFilter % SecondFilter % RepeatedFilter % tid ThreadName
+ 8 50.00 50.00 50.00 0.00 0.00 1 main
+ 8 50.00 100.00 50.00 0.00 50.00 2 foo
+ 0 0.00 100.00 nan nan nan 3 bar
+ 0 0.00 100.00 nan nan nan 4 blah
+</pre><br />
+
+Break-down of portion of time spent by each thread while waiting on a filter method.
+<br/><br/>
+<pre>
+Filter: FirstFilter
+Total waiting cycles: 12 ( 75.00% of total)
+Details:
+
+ Waiting cycles % of total waiting time execution time while waiting thread name
+ 8 66.67 50.00 main
+ 8 66.67 50.00 foo
+ 0 0.00 0.00 bar
+ 0 0.00 0.00 blah
+</pre>
+<br/><br/>
+<pre>
+Filter: SecondFilter
+Total waiting cycles: 0 ( 0.00% of total)
+</pre>
+<br/><br/>
+<pre>
+Filter: RepeatedFilter
+Total waiting cycles: 8 ( 50.00% of total)
+Details:
+
+ Waiting cycles % of total waiting time execution time while waiting thread name
+ 0 0.00 50.00 main
+ 8 100.00 50.00 foo
+ 0 0.00 0.00 bar
+ 0 0.00 0.00 blah
+</pre>
+<a name="class"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Exclusive elapsed time for each class, summed over all the methods
+in the class.
+
+<br><br>
+<div class="header"><span class="parent"> </span> Cycles %/total Cumul.% Calls+Recur Class</div>
+<div class="link" onClick="javascript:toggle('d0')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd0">+</span> 8 50.0 50.0 4+0 Z</div>
+<div class="parent" id="d0">
+<div class="leaf"><span class="leaf"> </span> 8 8 100.0 100.0 4+0 <a href="#m1">[1]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d1')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd1">+</span> 2 12.5 62.5 1+0 A</div>
+<div class="parent" id="d1">
+<div class="leaf"><span class="leaf"> </span> 2 2 100.0 100.0 1+0 <a href="#m2">[2]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d2')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd2">+</span> 2 12.5 75.0 1+0 B</div>
+<div class="parent" id="d2">
+<div class="leaf"><span class="leaf"> </span> 2 2 100.0 100.0 1+0 <a href="#m3">[3]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d3')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd3">+</span> 2 12.5 87.5 1+0 R</div>
+<div class="parent" id="d3">
+<div class="leaf"><span class="leaf"> </span> 2 2 100.0 100.0 1+0 <a href="#m4">[4]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d4')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd4">+</span> 2 12.5 100.0 1+0 S</div>
+<div class="parent" id="d4">
+<div class="leaf"><span class="leaf"> </span> 2 2 100.0 100.0 1+0 <a href="#m5">[5]</a> m ()</div>
+</div>
+<a name="method"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Exclusive elapsed time for each method, summed over all the classes
+that contain a method with the same name.
+
+<br><br>
+<div class="header"><span class="parent"> </span> Cycles %/total Cumul.% Calls+Recur Method</div>
+<div class="link" onClick="javascript:toggle('e0')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xe0">+</span> 16 100.0 100.0 8+0 m</div>
+<div class="parent" id="e0">
+<div class="leaf"><span class="leaf"> </span> 8 8 50.0 50.0 4+0 <a href="#m1">[1]</a> Z.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 2 2 12.5 62.5 1+0 <a href="#m2">[2]</a> A.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 2 2 12.5 75.0 1+0 <a href="#m3">[3]</a> B.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 2 2 12.5 87.5 1+0 <a href="#m4">[4]</a> R.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 2 2 12.5 100.0 1+0 <a href="#m5">[5]</a> S.m ()</div>
+</div>
+
+</body>
+</html>
--- /dev/null
+# ____ ____ ____ ____
+# __|A |___________|B ||Z |____|Z |_______
+#
+# ____ ____ ____ ____
+# _______|Z ||A |___________|B |____|Z |__
+#
+#
+0 1 A
+2 1 A
+0 2 Z
+2 2 Z
+2 2 A
+4 2 A
+2 1 B
+4 1 B
+4 1 Z
+6 1 Z
+4 2 B
+6 2 B
+6 1 Z
+8 1 Z
+6 2 Z
+8 2 Z
--- /dev/null
+<html>
+<head>
+<script type="text/javascript" src="(null)sortable.js"></script>
+<script langugage="javascript">
+function toggle(item) {
+ obj=document.getElementById(item);
+ visible=(obj.style.display!="none" && obj.style.display!="");
+ key=document.getElementById("x" + item);
+ if (visible) {
+ obj.style.display="none";
+ key.innerHTML="+";
+ } else {
+ obj.style.display="block";
+ key.innerHTML="-";
+ }
+}
+function onMouseOver(obj) {
+ obj.style.background="lightblue";
+}
+function onMouseOut(obj) {
+ obj.style.background="white";
+}
+</script>
+<style type="text/css">
+div { font-family: courier; font-size: 13 }
+div.parent { margin-left: 15; display: none }
+div.leaf { margin-left: 10 }
+div.header { margin-left: 10 }
+div.link { margin-left: 10; cursor: move }
+span.parent { padding-right: 10; }
+span.leaf { padding-right: 10; }
+a img { border: 0;}
+table.sortable th { border-width: 0px 1px 1px 1px; background-color: #ccc;}
+a { text-decoration: none; }
+a:hover { text-decoration: underline; }
+table.sortable th, table.sortable td { text-align: left;}table.sortable tr.odd td { background-color: #ddd; }
+table.sortable tr.even td { background-color: #fff; }
+</style>
+</head><body>
+
+<a name="contents"></a>
+<h2>Table of Contents</h2>
+<ul>
+ <li><a href="#exclusive">Exclusive profile</a></li>
+ <li><a href="#inclusive">Inclusive profile</a></li>
+ <li><a href="#thread">Thread profile</a></li>
+ <li><a href="#class">Class/method profile</a></li>
+ <li><a href="#method">Method/class profile</a></li>
+</ul>
+
+<a name="exclusive"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+Total cycles: 16
+
+<br><br>
+Exclusive elapsed times for each method, not including time spent in
+children, sorted by exclusive time.
+
+<br><br>
+<pre>
+ Usecs self % sum % Method
+ 8 50.00 50.00 <a href="#m1">[1]</a> Z.m ()
+ 4 25.00 75.00 <a href="#m2">[2]</a> A.m ()
+ 4 25.00 100.00 <a href="#m3">[3]</a> B.m ()
+</pre>
+<a name="inclusive"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Inclusive elapsed times for each method and its parents and children,
+sorted by inclusive time.
+
+<br><br>
+<pre>
+index %/total %/self index calls usecs name
+<a name="m0"></a>----------------------------------------------------
+[0] 100.0% 0+0 16 (toplevel)
+ 0.0% excl 0
+ 50.0% <a href="#m1">[1]</a> 4/4 8 Z.m ()
+ 25.0% <a href="#m2">[2]</a> 2/2 4 A.m ()
+ 25.0% <a href="#m3">[3]</a> 2/2 4 B.m ()
+<a name="m1"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 4/4 8 (toplevel)
+[1] 50.0% 4+0 8 Z.m ()
+ 100.0% excl 8
+<a name="m2"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 2/2 4 (toplevel)
+[2] 25.0% 2+0 4 A.m ()
+ 100.0% excl 4
+<a name="m3"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 2/2 4 (toplevel)
+[3] 25.0% 2+0 4 B.m ()
+ 100.0% excl 4
+</pre>
+<a name="thread"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Elapsed times for each thread, sorted by elapsed time.
+Also includes percentage of time spent during the <i>execution</i> of any filters.
+
+<br><br>
+<pre>
+ Usecs self % sum % FirstFilter % SecondFilter % RepeatedFilter % tid ThreadName
+ 8 50.00 50.00 50.00 0.00 0.00 1 main
+ 8 50.00 100.00 50.00 0.00 0.00 2 foo
+ 0 0.00 100.00 nan nan nan 3 bar
+ 0 0.00 100.00 nan nan nan 4 blah
+</pre><br />
+
+Break-down of portion of time spent by each thread while waiting on a filter method.
+<br/><br/>
+<pre>
+Filter: FirstFilter
+Total waiting cycles: 12 ( 75.00% of total)
+Details:
+
+ Waiting cycles % of total waiting time execution time while waiting thread name
+ 8 66.67 50.00 main
+ 8 66.67 50.00 foo
+ 0 0.00 0.00 bar
+ 0 0.00 0.00 blah
+</pre>
+<br/><br/>
+<pre>
+Filter: SecondFilter
+Total waiting cycles: 0 ( 0.00% of total)
+</pre>
+<br/><br/>
+<pre>
+Filter: RepeatedFilter
+Total waiting cycles: 0 ( 0.00% of total)
+</pre>
+<a name="class"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Exclusive elapsed time for each class, summed over all the methods
+in the class.
+
+<br><br>
+<div class="header"><span class="parent"> </span> Cycles %/total Cumul.% Calls+Recur Class</div>
+<div class="link" onClick="javascript:toggle('d0')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd0">+</span> 8 50.0 50.0 4+0 Z</div>
+<div class="parent" id="d0">
+<div class="leaf"><span class="leaf"> </span> 8 8 100.0 100.0 4+0 <a href="#m1">[1]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d1')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd1">+</span> 4 25.0 75.0 2+0 A</div>
+<div class="parent" id="d1">
+<div class="leaf"><span class="leaf"> </span> 4 4 100.0 100.0 2+0 <a href="#m2">[2]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d2')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd2">+</span> 4 25.0 100.0 2+0 B</div>
+<div class="parent" id="d2">
+<div class="leaf"><span class="leaf"> </span> 4 4 100.0 100.0 2+0 <a href="#m3">[3]</a> m ()</div>
+</div>
+<a name="method"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Exclusive elapsed time for each method, summed over all the classes
+that contain a method with the same name.
+
+<br><br>
+<div class="header"><span class="parent"> </span> Cycles %/total Cumul.% Calls+Recur Method</div>
+<div class="link" onClick="javascript:toggle('e0')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xe0">+</span> 16 100.0 100.0 8+0 m</div>
+<div class="parent" id="e0">
+<div class="leaf"><span class="leaf"> </span> 8 8 50.0 50.0 4+0 <a href="#m1">[1]</a> Z.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 4 4 25.0 75.0 2+0 <a href="#m2">[2]</a> A.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 4 4 25.0 100.0 2+0 <a href="#m3">[3]</a> B.m ()</div>
+</div>
+
+</body>
+</html>
--- /dev/null
+# ____ ____ ____ ____ ____
+# __|A ||D ||B ||E ||Z |__
+#
+0 1 A
+2 1 A
+2 1 D
+4 1 D
+4 1 B
+6 1 B
+6 1 E
+8 1 E
+8 1 Z
+10 1 Z
--- /dev/null
+<html>
+<head>
+<script type="text/javascript" src="(null)sortable.js"></script>
+<script langugage="javascript">
+function toggle(item) {
+ obj=document.getElementById(item);
+ visible=(obj.style.display!="none" && obj.style.display!="");
+ key=document.getElementById("x" + item);
+ if (visible) {
+ obj.style.display="none";
+ key.innerHTML="+";
+ } else {
+ obj.style.display="block";
+ key.innerHTML="-";
+ }
+}
+function onMouseOver(obj) {
+ obj.style.background="lightblue";
+}
+function onMouseOut(obj) {
+ obj.style.background="white";
+}
+</script>
+<style type="text/css">
+div { font-family: courier; font-size: 13 }
+div.parent { margin-left: 15; display: none }
+div.leaf { margin-left: 10 }
+div.header { margin-left: 10 }
+div.link { margin-left: 10; cursor: move }
+span.parent { padding-right: 10; }
+span.leaf { padding-right: 10; }
+a img { border: 0;}
+table.sortable th { border-width: 0px 1px 1px 1px; background-color: #ccc;}
+a { text-decoration: none; }
+a:hover { text-decoration: underline; }
+table.sortable th, table.sortable td { text-align: left;}table.sortable tr.odd td { background-color: #ddd; }
+table.sortable tr.even td { background-color: #fff; }
+</style>
+</head><body>
+
+<a name="contents"></a>
+<h2>Table of Contents</h2>
+<ul>
+ <li><a href="#exclusive">Exclusive profile</a></li>
+ <li><a href="#inclusive">Inclusive profile</a></li>
+ <li><a href="#thread">Thread profile</a></li>
+ <li><a href="#class">Class/method profile</a></li>
+ <li><a href="#method">Method/class profile</a></li>
+</ul>
+
+<a name="exclusive"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+Total cycles: 10
+
+<br><br>
+Exclusive elapsed times for each method, not including time spent in
+children, sorted by exclusive time.
+
+<br><br>
+<pre>
+ Usecs self % sum % Method
+ 2 20.00 20.00 <a href="#m1">[1]</a> A.m ()
+ 2 20.00 40.00 <a href="#m2">[2]</a> B.m ()
+ 2 20.00 60.00 <a href="#m3">[3]</a> D.m ()
+ 2 20.00 80.00 <a href="#m4">[4]</a> E.m ()
+ 2 20.00 100.00 <a href="#m5">[5]</a> Z.m ()
+</pre>
+<a name="inclusive"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Inclusive elapsed times for each method and its parents and children,
+sorted by inclusive time.
+
+<br><br>
+<pre>
+index %/total %/self index calls usecs name
+<a name="m0"></a>----------------------------------------------------
+[0] 100.0% 0+0 10 (toplevel)
+ 0.0% excl 0
+ 20.0% <a href="#m1">[1]</a> 1/1 2 A.m ()
+ 20.0% <a href="#m2">[2]</a> 1/1 2 B.m ()
+ 20.0% <a href="#m3">[3]</a> 1/1 2 D.m ()
+ 20.0% <a href="#m4">[4]</a> 1/1 2 E.m ()
+ 20.0% <a href="#m5">[5]</a> 1/1 2 Z.m ()
+<a name="m1"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 2 (toplevel)
+[1] 20.0% 1+0 2 A.m ()
+ 100.0% excl 2
+<a name="m2"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 2 (toplevel)
+[2] 20.0% 1+0 2 B.m ()
+ 100.0% excl 2
+<a name="m3"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 2 (toplevel)
+[3] 20.0% 1+0 2 D.m ()
+ 100.0% excl 2
+<a name="m4"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 2 (toplevel)
+[4] 20.0% 1+0 2 E.m ()
+ 100.0% excl 2
+<a name="m5"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 2 (toplevel)
+[5] 20.0% 1+0 2 Z.m ()
+ 100.0% excl 2
+</pre>
+<a name="thread"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Elapsed times for each thread, sorted by elapsed time.
+Also includes percentage of time spent during the <i>execution</i> of any filters.
+
+<br><br>
+<pre>
+ Usecs self % sum % FirstFilter % SecondFilter % RepeatedFilter % tid ThreadName
+ 10 100.00 100.00 60.00 60.00 0.00 1 main
+ 0 0.00 100.00 nan nan nan 2 foo
+ 0 0.00 100.00 nan nan nan 3 bar
+ 0 0.00 100.00 nan nan nan 4 blah
+</pre><br />
+
+Break-down of portion of time spent by each thread while waiting on a filter method.
+<br/><br/>
+<pre>
+Filter: FirstFilter
+Total waiting cycles: 6 ( 60.00% of total)
+Details:
+
+ Waiting cycles % of total waiting time execution time while waiting thread name
+ 6 100.00 100.00 main
+ 0 0.00 0.00 foo
+ 0 0.00 0.00 bar
+ 0 0.00 0.00 blah
+</pre>
+<br/><br/>
+<pre>
+Filter: SecondFilter
+Total waiting cycles: 6 ( 60.00% of total)
+Details:
+
+ Waiting cycles % of total waiting time execution time while waiting thread name
+ 6 100.00 100.00 main
+ 0 0.00 0.00 foo
+ 0 0.00 0.00 bar
+ 0 0.00 0.00 blah
+</pre>
+<br/><br/>
+<pre>
+Filter: RepeatedFilter
+Total waiting cycles: 0 ( 0.00% of total)
+</pre>
+<a name="class"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Exclusive elapsed time for each class, summed over all the methods
+in the class.
+
+<br><br>
+<div class="header"><span class="parent"> </span> Cycles %/total Cumul.% Calls+Recur Class</div>
+<div class="link" onClick="javascript:toggle('d0')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd0">+</span> 2 20.0 20.0 1+0 A</div>
+<div class="parent" id="d0">
+<div class="leaf"><span class="leaf"> </span> 2 2 100.0 100.0 1+0 <a href="#m1">[1]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d1')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd1">+</span> 2 20.0 40.0 1+0 B</div>
+<div class="parent" id="d1">
+<div class="leaf"><span class="leaf"> </span> 2 2 100.0 100.0 1+0 <a href="#m2">[2]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d2')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd2">+</span> 2 20.0 60.0 1+0 D</div>
+<div class="parent" id="d2">
+<div class="leaf"><span class="leaf"> </span> 2 2 100.0 100.0 1+0 <a href="#m3">[3]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d3')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd3">+</span> 2 20.0 80.0 1+0 E</div>
+<div class="parent" id="d3">
+<div class="leaf"><span class="leaf"> </span> 2 2 100.0 100.0 1+0 <a href="#m4">[4]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d4')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd4">+</span> 2 20.0 100.0 1+0 Z</div>
+<div class="parent" id="d4">
+<div class="leaf"><span class="leaf"> </span> 2 2 100.0 100.0 1+0 <a href="#m5">[5]</a> m ()</div>
+</div>
+<a name="method"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Exclusive elapsed time for each method, summed over all the classes
+that contain a method with the same name.
+
+<br><br>
+<div class="header"><span class="parent"> </span> Cycles %/total Cumul.% Calls+Recur Method</div>
+<div class="link" onClick="javascript:toggle('e0')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xe0">+</span> 10 100.0 100.0 5+0 m</div>
+<div class="parent" id="e0">
+<div class="leaf"><span class="leaf"> </span> 2 2 20.0 20.0 1+0 <a href="#m1">[1]</a> A.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 2 2 20.0 40.0 1+0 <a href="#m2">[2]</a> B.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 2 2 20.0 60.0 1+0 <a href="#m3">[3]</a> D.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 2 2 20.0 80.0 1+0 <a href="#m4">[4]</a> E.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 2 2 20.0 100.0 1+0 <a href="#m5">[5]</a> Z.m ()</div>
+</div>
+
+</body>
+</html>
--- /dev/null
+# ____ ____ ____ ____ ____
+# __|R ||R ||S ||S ||Z |__
+#
+0 1 R
+2 1 R
+2 1 R
+4 1 R
+4 1 S
+6 1 S
+6 1 S
+8 1 S
+8 1 Z
+10 1 Z
--- /dev/null
+<html>
+<head>
+<script type="text/javascript" src="(null)sortable.js"></script>
+<script langugage="javascript">
+function toggle(item) {
+ obj=document.getElementById(item);
+ visible=(obj.style.display!="none" && obj.style.display!="");
+ key=document.getElementById("x" + item);
+ if (visible) {
+ obj.style.display="none";
+ key.innerHTML="+";
+ } else {
+ obj.style.display="block";
+ key.innerHTML="-";
+ }
+}
+function onMouseOver(obj) {
+ obj.style.background="lightblue";
+}
+function onMouseOut(obj) {
+ obj.style.background="white";
+}
+</script>
+<style type="text/css">
+div { font-family: courier; font-size: 13 }
+div.parent { margin-left: 15; display: none }
+div.leaf { margin-left: 10 }
+div.header { margin-left: 10 }
+div.link { margin-left: 10; cursor: move }
+span.parent { padding-right: 10; }
+span.leaf { padding-right: 10; }
+a img { border: 0;}
+table.sortable th { border-width: 0px 1px 1px 1px; background-color: #ccc;}
+a { text-decoration: none; }
+a:hover { text-decoration: underline; }
+table.sortable th, table.sortable td { text-align: left;}table.sortable tr.odd td { background-color: #ddd; }
+table.sortable tr.even td { background-color: #fff; }
+</style>
+</head><body>
+
+<a name="contents"></a>
+<h2>Table of Contents</h2>
+<ul>
+ <li><a href="#exclusive">Exclusive profile</a></li>
+ <li><a href="#inclusive">Inclusive profile</a></li>
+ <li><a href="#thread">Thread profile</a></li>
+ <li><a href="#class">Class/method profile</a></li>
+ <li><a href="#method">Method/class profile</a></li>
+</ul>
+
+<a name="exclusive"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+Total cycles: 10
+
+<br><br>
+Exclusive elapsed times for each method, not including time spent in
+children, sorted by exclusive time.
+
+<br><br>
+<pre>
+ Usecs self % sum % Method
+ 4 40.00 40.00 <a href="#m1">[1]</a> R.m ()
+ 4 40.00 80.00 <a href="#m2">[2]</a> S.m ()
+ 2 20.00 100.00 <a href="#m3">[3]</a> Z.m ()
+</pre>
+<a name="inclusive"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Inclusive elapsed times for each method and its parents and children,
+sorted by inclusive time.
+
+<br><br>
+<pre>
+index %/total %/self index calls usecs name
+<a name="m0"></a>----------------------------------------------------
+[0] 100.0% 0+0 10 (toplevel)
+ 0.0% excl 0
+ 40.0% <a href="#m1">[1]</a> 2/2 4 R.m ()
+ 40.0% <a href="#m2">[2]</a> 2/2 4 S.m ()
+ 20.0% <a href="#m3">[3]</a> 1/1 2 Z.m ()
+<a name="m1"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 2/2 4 (toplevel)
+[1] 40.0% 2+0 4 R.m ()
+ 100.0% excl 4
+<a name="m2"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 2/2 4 (toplevel)
+[2] 40.0% 2+0 4 S.m ()
+ 100.0% excl 4
+<a name="m3"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 2 (toplevel)
+[3] 20.0% 1+0 2 Z.m ()
+ 100.0% excl 2
+</pre>
+<a name="thread"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Elapsed times for each thread, sorted by elapsed time.
+Also includes percentage of time spent during the <i>execution</i> of any filters.
+
+<br><br>
+<pre>
+ Usecs self % sum % FirstFilter % SecondFilter % RepeatedFilter % tid ThreadName
+ 10 100.00 100.00 80.00 0.00 80.00 1 main
+ 0 0.00 100.00 nan nan nan 2 foo
+ 0 0.00 100.00 nan nan nan 3 bar
+ 0 0.00 100.00 nan nan nan 4 blah
+</pre><br />
+
+Break-down of portion of time spent by each thread while waiting on a filter method.
+<br/><br/>
+<pre>
+Filter: FirstFilter
+Total waiting cycles: 8 ( 80.00% of total)
+Details:
+
+ Waiting cycles % of total waiting time execution time while waiting thread name
+ 8 100.00 100.00 main
+ 0 0.00 0.00 foo
+ 0 0.00 0.00 bar
+ 0 0.00 0.00 blah
+</pre>
+<br/><br/>
+<pre>
+Filter: SecondFilter
+Total waiting cycles: 0 ( 0.00% of total)
+</pre>
+<br/><br/>
+<pre>
+Filter: RepeatedFilter
+Total waiting cycles: 8 ( 80.00% of total)
+Details:
+
+ Waiting cycles % of total waiting time execution time while waiting thread name
+ 8 100.00 100.00 main
+ 0 0.00 0.00 foo
+ 0 0.00 0.00 bar
+ 0 0.00 0.00 blah
+</pre>
+<a name="class"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Exclusive elapsed time for each class, summed over all the methods
+in the class.
+
+<br><br>
+<div class="header"><span class="parent"> </span> Cycles %/total Cumul.% Calls+Recur Class</div>
+<div class="link" onClick="javascript:toggle('d0')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd0">+</span> 4 40.0 40.0 2+0 R</div>
+<div class="parent" id="d0">
+<div class="leaf"><span class="leaf"> </span> 4 4 100.0 100.0 2+0 <a href="#m1">[1]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d1')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd1">+</span> 4 40.0 80.0 2+0 S</div>
+<div class="parent" id="d1">
+<div class="leaf"><span class="leaf"> </span> 4 4 100.0 100.0 2+0 <a href="#m2">[2]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d2')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd2">+</span> 2 20.0 100.0 1+0 Z</div>
+<div class="parent" id="d2">
+<div class="leaf"><span class="leaf"> </span> 2 2 100.0 100.0 1+0 <a href="#m3">[3]</a> m ()</div>
+</div>
+<a name="method"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Exclusive elapsed time for each method, summed over all the classes
+that contain a method with the same name.
+
+<br><br>
+<div class="header"><span class="parent"> </span> Cycles %/total Cumul.% Calls+Recur Method</div>
+<div class="link" onClick="javascript:toggle('e0')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xe0">+</span> 10 100.0 100.0 5+0 m</div>
+<div class="parent" id="e0">
+<div class="leaf"><span class="leaf"> </span> 4 4 40.0 40.0 2+0 <a href="#m1">[1]</a> R.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 4 4 40.0 80.0 2+0 <a href="#m2">[2]</a> S.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 2 2 20.0 100.0 1+0 <a href="#m3">[3]</a> Z.m ()</div>
+</div>
+
+</body>
+</html>
--- /dev/null
+# ____
+# ____ ____|B |____ ____
+# __|A ||C ||Z |__
+#
+0 1 A
+2 1 A
+2 1 C
+4 1 B
+6 1 B
+8 1 C
+8 1 Z
+10 1 Z
--- /dev/null
+<html>
+<head>
+<script type="text/javascript" src="(null)sortable.js"></script>
+<script langugage="javascript">
+function toggle(item) {
+ obj=document.getElementById(item);
+ visible=(obj.style.display!="none" && obj.style.display!="");
+ key=document.getElementById("x" + item);
+ if (visible) {
+ obj.style.display="none";
+ key.innerHTML="+";
+ } else {
+ obj.style.display="block";
+ key.innerHTML="-";
+ }
+}
+function onMouseOver(obj) {
+ obj.style.background="lightblue";
+}
+function onMouseOut(obj) {
+ obj.style.background="white";
+}
+</script>
+<style type="text/css">
+div { font-family: courier; font-size: 13 }
+div.parent { margin-left: 15; display: none }
+div.leaf { margin-left: 10 }
+div.header { margin-left: 10 }
+div.link { margin-left: 10; cursor: move }
+span.parent { padding-right: 10; }
+span.leaf { padding-right: 10; }
+a img { border: 0;}
+table.sortable th { border-width: 0px 1px 1px 1px; background-color: #ccc;}
+a { text-decoration: none; }
+a:hover { text-decoration: underline; }
+table.sortable th, table.sortable td { text-align: left;}table.sortable tr.odd td { background-color: #ddd; }
+table.sortable tr.even td { background-color: #fff; }
+</style>
+</head><body>
+
+<a name="contents"></a>
+<h2>Table of Contents</h2>
+<ul>
+ <li><a href="#exclusive">Exclusive profile</a></li>
+ <li><a href="#inclusive">Inclusive profile</a></li>
+ <li><a href="#thread">Thread profile</a></li>
+ <li><a href="#class">Class/method profile</a></li>
+ <li><a href="#method">Method/class profile</a></li>
+</ul>
+
+<a name="exclusive"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+Total cycles: 10
+
+<br><br>
+Exclusive elapsed times for each method, not including time spent in
+children, sorted by exclusive time.
+
+<br><br>
+<pre>
+ Usecs self % sum % Method
+ 4 40.00 40.00 <a href="#m1">[1]</a> C.m ()
+ 2 20.00 60.00 <a href="#m2">[2]</a> A.m ()
+ 2 20.00 80.00 <a href="#m3">[3]</a> B.m ()
+ 2 20.00 100.00 <a href="#m4">[4]</a> Z.m ()
+</pre>
+<a name="inclusive"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Inclusive elapsed times for each method and its parents and children,
+sorted by inclusive time.
+
+<br><br>
+<pre>
+index %/total %/self index calls usecs name
+<a name="m0"></a>----------------------------------------------------
+[0] 100.0% 0+0 10 (toplevel)
+ 0.0% excl 0
+ 60.0% <a href="#m1">[1]</a> 1/1 6 C.m ()
+ 20.0% <a href="#m2">[2]</a> 1/1 2 A.m ()
+ 20.0% <a href="#m4">[4]</a> 1/1 2 Z.m ()
+<a name="m1"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 6 (toplevel)
+[1] 60.0% 1+0 6 C.m ()
+ 66.7% excl 4
+ 33.3% <a href="#m3">[3]</a> 1/1 2 B.m ()
+<a name="m2"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 2 (toplevel)
+[2] 20.0% 1+0 2 A.m ()
+ 100.0% excl 2
+<a name="m3"></a>----------------------------------------------------
+ 100.0% <a href="#m1">[1]</a> 1/1 2 C.m ()
+[3] 20.0% 1+0 2 B.m ()
+ 100.0% excl 2
+<a name="m4"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 2 (toplevel)
+[4] 20.0% 1+0 2 Z.m ()
+ 100.0% excl 2
+</pre>
+<a name="thread"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Elapsed times for each thread, sorted by elapsed time.
+Also includes percentage of time spent during the <i>execution</i> of any filters.
+
+<br><br>
+<pre>
+ Usecs self % sum % FirstFilter % SecondFilter % RepeatedFilter % tid ThreadName
+ 10 100.00 100.00 80.00 0.00 0.00 1 main
+ 0 0.00 100.00 nan nan nan 2 foo
+ 0 0.00 100.00 nan nan nan 3 bar
+ 0 0.00 100.00 nan nan nan 4 blah
+</pre><br />
+
+Break-down of portion of time spent by each thread while waiting on a filter method.
+<br/><br/>
+<pre>
+Filter: FirstFilter
+Total waiting cycles: 8 ( 80.00% of total)
+Details:
+
+ Waiting cycles % of total waiting time execution time while waiting thread name
+ 8 100.00 100.00 main
+ 0 0.00 0.00 foo
+ 0 0.00 0.00 bar
+ 0 0.00 0.00 blah
+</pre>
+<br/><br/>
+<pre>
+Filter: SecondFilter
+Total waiting cycles: 0 ( 0.00% of total)
+</pre>
+<br/><br/>
+<pre>
+Filter: RepeatedFilter
+Total waiting cycles: 0 ( 0.00% of total)
+</pre>
+<a name="class"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Exclusive elapsed time for each class, summed over all the methods
+in the class.
+
+<br><br>
+<div class="header"><span class="parent"> </span> Cycles %/total Cumul.% Calls+Recur Class</div>
+<div class="link" onClick="javascript:toggle('d0')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd0">+</span> 4 40.0 40.0 1+0 C</div>
+<div class="parent" id="d0">
+<div class="leaf"><span class="leaf"> </span> 4 6 100.0 100.0 1+0 <a href="#m1">[1]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d1')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd1">+</span> 2 20.0 60.0 1+0 A</div>
+<div class="parent" id="d1">
+<div class="leaf"><span class="leaf"> </span> 2 2 100.0 100.0 1+0 <a href="#m2">[2]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d2')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd2">+</span> 2 20.0 80.0 1+0 B</div>
+<div class="parent" id="d2">
+<div class="leaf"><span class="leaf"> </span> 2 2 100.0 100.0 1+0 <a href="#m3">[3]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d3')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd3">+</span> 2 20.0 100.0 1+0 Z</div>
+<div class="parent" id="d3">
+<div class="leaf"><span class="leaf"> </span> 2 2 100.0 100.0 1+0 <a href="#m4">[4]</a> m ()</div>
+</div>
+<a name="method"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Exclusive elapsed time for each method, summed over all the classes
+that contain a method with the same name.
+
+<br><br>
+<div class="header"><span class="parent"> </span> Cycles %/total Cumul.% Calls+Recur Method</div>
+<div class="link" onClick="javascript:toggle('e0')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xe0">+</span> 10 100.0 100.0 4+0 m</div>
+<div class="parent" id="e0">
+<div class="leaf"><span class="leaf"> </span> 4 6 40.0 40.0 1+0 <a href="#m1">[1]</a> C.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 2 2 20.0 60.0 1+0 <a href="#m2">[2]</a> A.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 2 2 20.0 80.0 1+0 <a href="#m3">[3]</a> B.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 2 2 20.0 100.0 1+0 <a href="#m4">[4]</a> Z.m ()</div>
+</div>
+
+</body>
+</html>
--- /dev/null
+# ____ ____ ____ ____ ____
+# __|A ||A ||B ||B ||Z |__
+#
+0 1 A
+2 1 A
+2 1 A
+4 1 A
+4 1 B
+6 1 B
+6 1 B
+8 1 B
+8 1 Z
+10 1 Z
--- /dev/null
+<html>
+<head>
+<script type="text/javascript" src="(null)sortable.js"></script>
+<script langugage="javascript">
+function toggle(item) {
+ obj=document.getElementById(item);
+ visible=(obj.style.display!="none" && obj.style.display!="");
+ key=document.getElementById("x" + item);
+ if (visible) {
+ obj.style.display="none";
+ key.innerHTML="+";
+ } else {
+ obj.style.display="block";
+ key.innerHTML="-";
+ }
+}
+function onMouseOver(obj) {
+ obj.style.background="lightblue";
+}
+function onMouseOut(obj) {
+ obj.style.background="white";
+}
+</script>
+<style type="text/css">
+div { font-family: courier; font-size: 13 }
+div.parent { margin-left: 15; display: none }
+div.leaf { margin-left: 10 }
+div.header { margin-left: 10 }
+div.link { margin-left: 10; cursor: move }
+span.parent { padding-right: 10; }
+span.leaf { padding-right: 10; }
+a img { border: 0;}
+table.sortable th { border-width: 0px 1px 1px 1px; background-color: #ccc;}
+a { text-decoration: none; }
+a:hover { text-decoration: underline; }
+table.sortable th, table.sortable td { text-align: left;}table.sortable tr.odd td { background-color: #ddd; }
+table.sortable tr.even td { background-color: #fff; }
+</style>
+</head><body>
+
+<a name="contents"></a>
+<h2>Table of Contents</h2>
+<ul>
+ <li><a href="#exclusive">Exclusive profile</a></li>
+ <li><a href="#inclusive">Inclusive profile</a></li>
+ <li><a href="#thread">Thread profile</a></li>
+ <li><a href="#class">Class/method profile</a></li>
+ <li><a href="#method">Method/class profile</a></li>
+</ul>
+
+<a name="exclusive"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+Total cycles: 10
+
+<br><br>
+Exclusive elapsed times for each method, not including time spent in
+children, sorted by exclusive time.
+
+<br><br>
+<pre>
+ Usecs self % sum % Method
+ 4 40.00 40.00 <a href="#m1">[1]</a> A.m ()
+ 4 40.00 80.00 <a href="#m2">[2]</a> B.m ()
+ 2 20.00 100.00 <a href="#m3">[3]</a> Z.m ()
+</pre>
+<a name="inclusive"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Inclusive elapsed times for each method and its parents and children,
+sorted by inclusive time.
+
+<br><br>
+<pre>
+index %/total %/self index calls usecs name
+<a name="m0"></a>----------------------------------------------------
+[0] 100.0% 0+0 10 (toplevel)
+ 0.0% excl 0
+ 40.0% <a href="#m1">[1]</a> 2/2 4 A.m ()
+ 40.0% <a href="#m2">[2]</a> 2/2 4 B.m ()
+ 20.0% <a href="#m3">[3]</a> 1/1 2 Z.m ()
+<a name="m1"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 2/2 4 (toplevel)
+[1] 40.0% 2+0 4 A.m ()
+ 100.0% excl 4
+<a name="m2"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 2/2 4 (toplevel)
+[2] 40.0% 2+0 4 B.m ()
+ 100.0% excl 4
+<a name="m3"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 2 (toplevel)
+[3] 20.0% 1+0 2 Z.m ()
+ 100.0% excl 2
+</pre>
+<a name="thread"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Elapsed times for each thread, sorted by elapsed time.
+Also includes percentage of time spent during the <i>execution</i> of any filters.
+
+<br><br>
+<pre>
+ Usecs self % sum % FirstFilter % SecondFilter % RepeatedFilter % tid ThreadName
+ 10 100.00 100.00 80.00 0.00 0.00 1 main
+ 0 0.00 100.00 nan nan nan 2 foo
+ 0 0.00 100.00 nan nan nan 3 bar
+ 0 0.00 100.00 nan nan nan 4 blah
+</pre><br />
+
+Break-down of portion of time spent by each thread while waiting on a filter method.
+<br/><br/>
+<pre>
+Filter: FirstFilter
+Total waiting cycles: 8 ( 80.00% of total)
+Details:
+
+ Waiting cycles % of total waiting time execution time while waiting thread name
+ 8 100.00 100.00 main
+ 0 0.00 0.00 foo
+ 0 0.00 0.00 bar
+ 0 0.00 0.00 blah
+</pre>
+<br/><br/>
+<pre>
+Filter: SecondFilter
+Total waiting cycles: 0 ( 0.00% of total)
+</pre>
+<br/><br/>
+<pre>
+Filter: RepeatedFilter
+Total waiting cycles: 0 ( 0.00% of total)
+</pre>
+<a name="class"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Exclusive elapsed time for each class, summed over all the methods
+in the class.
+
+<br><br>
+<div class="header"><span class="parent"> </span> Cycles %/total Cumul.% Calls+Recur Class</div>
+<div class="link" onClick="javascript:toggle('d0')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd0">+</span> 4 40.0 40.0 2+0 A</div>
+<div class="parent" id="d0">
+<div class="leaf"><span class="leaf"> </span> 4 4 100.0 100.0 2+0 <a href="#m1">[1]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d1')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd1">+</span> 4 40.0 80.0 2+0 B</div>
+<div class="parent" id="d1">
+<div class="leaf"><span class="leaf"> </span> 4 4 100.0 100.0 2+0 <a href="#m2">[2]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d2')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd2">+</span> 2 20.0 100.0 1+0 Z</div>
+<div class="parent" id="d2">
+<div class="leaf"><span class="leaf"> </span> 2 2 100.0 100.0 1+0 <a href="#m3">[3]</a> m ()</div>
+</div>
+<a name="method"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Exclusive elapsed time for each method, summed over all the classes
+that contain a method with the same name.
+
+<br><br>
+<div class="header"><span class="parent"> </span> Cycles %/total Cumul.% Calls+Recur Method</div>
+<div class="link" onClick="javascript:toggle('e0')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xe0">+</span> 10 100.0 100.0 5+0 m</div>
+<div class="parent" id="e0">
+<div class="leaf"><span class="leaf"> </span> 4 4 40.0 40.0 2+0 <a href="#m1">[1]</a> A.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 4 4 40.0 80.0 2+0 <a href="#m2">[2]</a> B.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 2 2 20.0 100.0 1+0 <a href="#m3">[3]</a> Z.m ()</div>
+</div>
+
+</body>
+</html>
--- /dev/null
+# ____ ____ ____
+# __|C ||Z |__
+#
+# ____
+# ________|Z |_____________
+#
+0 1 C
+0 2 Z
+2 2 Z
+4 1 C
+4 1 Z
+6 1 Z
--- /dev/null
+<html>
+<head>
+<script type="text/javascript" src="(null)sortable.js"></script>
+<script langugage="javascript">
+function toggle(item) {
+ obj=document.getElementById(item);
+ visible=(obj.style.display!="none" && obj.style.display!="");
+ key=document.getElementById("x" + item);
+ if (visible) {
+ obj.style.display="none";
+ key.innerHTML="+";
+ } else {
+ obj.style.display="block";
+ key.innerHTML="-";
+ }
+}
+function onMouseOver(obj) {
+ obj.style.background="lightblue";
+}
+function onMouseOut(obj) {
+ obj.style.background="white";
+}
+</script>
+<style type="text/css">
+div { font-family: courier; font-size: 13 }
+div.parent { margin-left: 15; display: none }
+div.leaf { margin-left: 10 }
+div.header { margin-left: 10 }
+div.link { margin-left: 10; cursor: move }
+span.parent { padding-right: 10; }
+span.leaf { padding-right: 10; }
+a img { border: 0;}
+table.sortable th { border-width: 0px 1px 1px 1px; background-color: #ccc;}
+a { text-decoration: none; }
+a:hover { text-decoration: underline; }
+table.sortable th, table.sortable td { text-align: left;}table.sortable tr.odd td { background-color: #ddd; }
+table.sortable tr.even td { background-color: #fff; }
+</style>
+</head><body>
+
+<a name="contents"></a>
+<h2>Table of Contents</h2>
+<ul>
+ <li><a href="#exclusive">Exclusive profile</a></li>
+ <li><a href="#inclusive">Inclusive profile</a></li>
+ <li><a href="#thread">Thread profile</a></li>
+ <li><a href="#class">Class/method profile</a></li>
+ <li><a href="#method">Method/class profile</a></li>
+</ul>
+
+<a name="exclusive"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+Total cycles: 8
+
+<br><br>
+Exclusive elapsed times for each method, not including time spent in
+children, sorted by exclusive time.
+
+<br><br>
+<pre>
+ Usecs self % sum % Method
+ 4 50.00 50.00 <a href="#m1">[1]</a> C.m ()
+ 4 50.00 100.00 <a href="#m2">[2]</a> Z.m ()
+</pre>
+<a name="inclusive"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Inclusive elapsed times for each method and its parents and children,
+sorted by inclusive time.
+
+<br><br>
+<pre>
+index %/total %/self index calls usecs name
+<a name="m0"></a>----------------------------------------------------
+[0] 100.0% 0+0 8 (toplevel)
+ 0.0% excl 0
+ 50.0% <a href="#m1">[1]</a> 1/1 4 C.m ()
+ 50.0% <a href="#m2">[2]</a> 2/2 4 Z.m ()
+<a name="m1"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 4 (toplevel)
+[1] 50.0% 1+0 4 C.m ()
+ 100.0% excl 4
+<a name="m2"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 2/2 4 (toplevel)
+[2] 50.0% 2+0 4 Z.m ()
+ 100.0% excl 4
+</pre>
+<a name="thread"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Elapsed times for each thread, sorted by elapsed time.
+Also includes percentage of time spent during the <i>execution</i> of any filters.
+
+<br><br>
+<pre>
+ Usecs self % sum % FirstFilter % SecondFilter % RepeatedFilter % tid ThreadName
+ 6 75.00 75.00 66.67 0.00 0.00 1 main
+ 2 25.00 100.00 0.00 0.00 0.00 2 foo
+ 0 0.00 100.00 nan nan nan 3 bar
+ 0 0.00 100.00 nan nan nan 4 blah
+</pre><br />
+
+Break-down of portion of time spent by each thread while waiting on a filter method.
+<br/><br/>
+<pre>
+Filter: FirstFilter
+Total waiting cycles: 6 ( 75.00% of total)
+Details:
+
+ Waiting cycles % of total waiting time execution time while waiting thread name
+ 6 100.00 66.67 main
+ 0 0.00 33.33 foo
+ 0 0.00 0.00 bar
+ 0 0.00 0.00 blah
+</pre>
+<br/><br/>
+<pre>
+Filter: SecondFilter
+Total waiting cycles: 0 ( 0.00% of total)
+</pre>
+<br/><br/>
+<pre>
+Filter: RepeatedFilter
+Total waiting cycles: 0 ( 0.00% of total)
+</pre>
+<a name="class"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Exclusive elapsed time for each class, summed over all the methods
+in the class.
+
+<br><br>
+<div class="header"><span class="parent"> </span> Cycles %/total Cumul.% Calls+Recur Class</div>
+<div class="link" onClick="javascript:toggle('d0')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd0">+</span> 4 50.0 50.0 1+0 C</div>
+<div class="parent" id="d0">
+<div class="leaf"><span class="leaf"> </span> 4 4 100.0 100.0 1+0 <a href="#m1">[1]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d1')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd1">+</span> 4 50.0 100.0 2+0 Z</div>
+<div class="parent" id="d1">
+<div class="leaf"><span class="leaf"> </span> 4 4 100.0 100.0 2+0 <a href="#m2">[2]</a> m ()</div>
+</div>
+<a name="method"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Exclusive elapsed time for each method, summed over all the classes
+that contain a method with the same name.
+
+<br><br>
+<div class="header"><span class="parent"> </span> Cycles %/total Cumul.% Calls+Recur Method</div>
+<div class="link" onClick="javascript:toggle('e0')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xe0">+</span> 8 100.0 100.0 3+0 m</div>
+<div class="parent" id="e0">
+<div class="leaf"><span class="leaf"> </span> 4 4 50.0 50.0 1+0 <a href="#m1">[1]</a> C.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 4 4 50.0 100.0 2+0 <a href="#m2">[2]</a> Z.m ()</div>
+</div>
+
+</body>
+</html>
--- /dev/null
+# _____
+# ____|Z |____ ____
+# __|C ||Z |__
+#
+0 1 C
+2 1 Z
+4 1 Z
+6 1 C
+6 1 Z
+8 1 Z
--- /dev/null
+<html>
+<head>
+<script type="text/javascript" src="(null)sortable.js"></script>
+<script langugage="javascript">
+function toggle(item) {
+ obj=document.getElementById(item);
+ visible=(obj.style.display!="none" && obj.style.display!="");
+ key=document.getElementById("x" + item);
+ if (visible) {
+ obj.style.display="none";
+ key.innerHTML="+";
+ } else {
+ obj.style.display="block";
+ key.innerHTML="-";
+ }
+}
+function onMouseOver(obj) {
+ obj.style.background="lightblue";
+}
+function onMouseOut(obj) {
+ obj.style.background="white";
+}
+</script>
+<style type="text/css">
+div { font-family: courier; font-size: 13 }
+div.parent { margin-left: 15; display: none }
+div.leaf { margin-left: 10 }
+div.header { margin-left: 10 }
+div.link { margin-left: 10; cursor: move }
+span.parent { padding-right: 10; }
+span.leaf { padding-right: 10; }
+a img { border: 0;}
+table.sortable th { border-width: 0px 1px 1px 1px; background-color: #ccc;}
+a { text-decoration: none; }
+a:hover { text-decoration: underline; }
+table.sortable th, table.sortable td { text-align: left;}table.sortable tr.odd td { background-color: #ddd; }
+table.sortable tr.even td { background-color: #fff; }
+</style>
+</head><body>
+
+<a name="contents"></a>
+<h2>Table of Contents</h2>
+<ul>
+ <li><a href="#exclusive">Exclusive profile</a></li>
+ <li><a href="#inclusive">Inclusive profile</a></li>
+ <li><a href="#thread">Thread profile</a></li>
+ <li><a href="#class">Class/method profile</a></li>
+ <li><a href="#method">Method/class profile</a></li>
+</ul>
+
+<a name="exclusive"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+Total cycles: 8
+
+<br><br>
+Exclusive elapsed times for each method, not including time spent in
+children, sorted by exclusive time.
+
+<br><br>
+<pre>
+ Usecs self % sum % Method
+ 4 50.00 50.00 <a href="#m1">[1]</a> C.m ()
+ 4 50.00 100.00 <a href="#m2">[2]</a> Z.m ()
+</pre>
+<a name="inclusive"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Inclusive elapsed times for each method and its parents and children,
+sorted by inclusive time.
+
+<br><br>
+<pre>
+index %/total %/self index calls usecs name
+<a name="m0"></a>----------------------------------------------------
+[0] 100.0% 0+0 8 (toplevel)
+ 0.0% excl 0
+ 75.0% <a href="#m1">[1]</a> 1/1 6 C.m ()
+ 25.0% <a href="#m2">[2]</a> 1/2 2 Z.m ()
+<a name="m1"></a>----------------------------------------------------
+ 100.0% <a href="#m0">[0]</a> 1/1 6 (toplevel)
+[1] 75.0% 1+0 6 C.m ()
+ 66.7% excl 4
+ 33.3% <a href="#m2">[2]</a> 1/2 2 Z.m ()
+<a name="m2"></a>----------------------------------------------------
+ 50.0% <a href="#m0">[0]</a> 1/2 2 (toplevel)
+ 50.0% <a href="#m1">[1]</a> 1/2 2 C.m ()
+[2] 50.0% 2+0 4 Z.m ()
+ 100.0% excl 4
+</pre>
+<a name="thread"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Elapsed times for each thread, sorted by elapsed time.
+Also includes percentage of time spent during the <i>execution</i> of any filters.
+
+<br><br>
+<pre>
+ Usecs self % sum % FirstFilter % SecondFilter % RepeatedFilter % tid ThreadName
+ 8 100.00 100.00 75.00 0.00 0.00 1 main
+ 0 0.00 100.00 nan nan nan 2 foo
+ 0 0.00 100.00 nan nan nan 3 bar
+ 0 0.00 100.00 nan nan nan 4 blah
+</pre><br />
+
+Break-down of portion of time spent by each thread while waiting on a filter method.
+<br/><br/>
+<pre>
+Filter: FirstFilter
+Total waiting cycles: 6 ( 75.00% of total)
+Details:
+
+ Waiting cycles % of total waiting time execution time while waiting thread name
+ 6 100.00 100.00 main
+ 0 0.00 0.00 foo
+ 0 0.00 0.00 bar
+ 0 0.00 0.00 blah
+</pre>
+<br/><br/>
+<pre>
+Filter: SecondFilter
+Total waiting cycles: 0 ( 0.00% of total)
+</pre>
+<br/><br/>
+<pre>
+Filter: RepeatedFilter
+Total waiting cycles: 0 ( 0.00% of total)
+</pre>
+<a name="class"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Exclusive elapsed time for each class, summed over all the methods
+in the class.
+
+<br><br>
+<div class="header"><span class="parent"> </span> Cycles %/total Cumul.% Calls+Recur Class</div>
+<div class="link" onClick="javascript:toggle('d0')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd0">+</span> 4 50.0 50.0 1+0 C</div>
+<div class="parent" id="d0">
+<div class="leaf"><span class="leaf"> </span> 4 6 100.0 100.0 1+0 <a href="#m1">[1]</a> m ()</div>
+</div>
+<div class="link" onClick="javascript:toggle('d1')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xd1">+</span> 4 50.0 100.0 2+0 Z</div>
+<div class="parent" id="d1">
+<div class="leaf"><span class="leaf"> </span> 4 4 100.0 100.0 2+0 <a href="#m2">[2]</a> m ()</div>
+</div>
+<a name="method"></a>
+<hr>
+<a href="#contents">[Top]</a>
+<a href="#exclusive">[Exclusive]</a>
+<a href="#inclusive">[Inclusive]</a>
+<a href="#thread">[Thread]</a>
+<a href="#class">[Class]</a>
+<a href="#method">[Method]</a>
+<br><br>
+
+Exclusive elapsed time for each method, summed over all the classes
+that contain a method with the same name.
+
+<br><br>
+<div class="header"><span class="parent"> </span> Cycles %/total Cumul.% Calls+Recur Method</div>
+<div class="link" onClick="javascript:toggle('e0')" onMouseOver="javascript:onMouseOver(this)" onMouseOut="javascript:onMouseOut(this)"><span class="parent" id="xe0">+</span> 8 100.0 100.0 3+0 m</div>
+<div class="parent" id="e0">
+<div class="leaf"><span class="leaf"> </span> 4 6 50.0 50.0 1+0 <a href="#m1">[1]</a> C.m ()</div>
+<div class="leaf"><span class="leaf"> </span> 4 4 50.0 100.0 2+0 <a href="#m2">[2]</a> Z.m ()</div>
+</div>
+
+</body>
+</html>
static void releaseThreadId(Thread* thread)
{
assert(thread->threadId > 0);
- dvmClearBit(gDvm.threadIdMap, (thread->threadId >> 1) - 1);
+ dvmClearBit(gDvm.threadIdMap, thread->threadId - 1);
thread->threadId = 0;
}
RETURN_LONG((s8)dvmGetExternalBytesAllocated());
}
+/*
+ * public native void startJitCompilation()
+ *
+ * Callback function from the framework to indicate that an app has gone
+ * through the startup phase and it is time to enable the JIT compiler.
+ */
+static void Dalvik_dalvik_system_VMRuntime_startJitCompilation(const u4* args,
+ JValue* pResult)
+{
+#if defined(WITH_JIT)
+ /*
+ * TODO - experiment the timing and put code here to start JIT'ing
+ * The tentative plan is onResume() will invoke the callback.
+ */
+#endif
+
+ RETURN_VOID();
+}
+
const DalvikNativeMethod dvm_dalvik_system_VMRuntime[] = {
{ "getTargetHeapUtilization", "()F",
Dalvik_dalvik_system_VMRuntime_getTargetHeapUtilization },
Dalvik_dalvik_system_VMRuntime_trackExternalFree },
{ "getExternalBytesAllocated", "()J",
Dalvik_dalvik_system_VMRuntime_getExternalBytesAllocated },
+ { "startJitCompilation", "()V",
+ Dalvik_dalvik_system_VMRuntime_startJitCompilation },
{ NULL, NULL, NULL },
};
-