Flags for printLoadedClasses(). Default behavior is to only show the class name.

Flags for startMethodTracing(). These can be ORed together. TRACE_COUNT_ALLOCS adds the results from startAllocCounting to the trace key file.

Change the JDWP port -- this is a temporary measure. If a debugger is currently attached the change may not happen until after the debugger disconnects.

Enable "emulator traces", in which information about the current method is made available to the "emulator -trace" feature. There is no corresponding "disable" call -- this is intended for use by the framework when tracing should be turned on and left that way, so that traces captured with F9/F10 will include the necessary data. This puts the VM into "profile" mode, which has performance consequences. To temporarily enable tracing, use startNativeTracing().

Enable object allocation count logging and reporting. Call with a depth of zero to disable. This produces "top N" lists on every GC.

Returns the number of received transactions from the binder driver.

Returns the number of sent transactions from this process.

Determines the number of dirty belonging to the java and native heap segments of this process. pages[0] returns the number of native shared pages, pages[1] returns the number of java shared pages, pages[2] returns the number of native private pages, and pages[3] returns the number of java private pages.

Returns the amount of allocated memory in the native heap.

Returns the amount of free memory in the native heap.

Returns the size of the native heap.

Determine if a debugger is currently attached.

Dump a list of loaded class to the log file.

Count the number and aggregate size of memory allocations between two points. The "start" function resets the counts and enables counting. The "stop" function disables the counting so that the analysis code doesn't cause additional allocations. The "get" function returns the specified value. Counts are kept for the system as a whole and for each thread.

Start method tracing, specifying the trace log file name, which is the base name for the trace files. The trace files will be put under "/tmp" unlessan absolute path is given for the trace name. See Running the Traceview Debugging Program for information about reading trace files.

Start method tracing, specifying the trace name, which is the base name for the trace files, and the buffer size. The trace files will be put under "/tmp" unless an absolute path is given for the trace name. See Running the Traceview Debugging Program for information about reading trace files.

Start method tracing with default log name and buffer size. See Running the Traceview Debugging Program for information about reading these files. Call stopMethodTracing() to stop tracing.

Start method tracing, specifying the trace name, which is the base name for the trace files, and the buffer size. The trace files will be put under "/tmp" unless an absolute path is given for the trace name. See Running the Traceview Debugging Program for information about reading trace files.

Enable qemu tracing. For this to work requires running everything inside the qemu emulator; otherwise, this method will have no effect. The trace file is specified on the command line when the emulator is started. For example, the following command line
emulator -trace foo
will start running the emulator and create a trace file named "foo". This method simply enables writing the trace records to the trace file.

The main differences between this and startMethodTracing() are that tracing in the qemu emulator traces every cpu instruction of every process, including kernel code, so we have more complete information, including all context switches. We can also get more detailed information such as cache misses. The sequence of calls is determined by post-processing the instruction trace. The qemu tracing is also done without modifying the application or perturbing the timing of calls because no instrumentation is added to the application being traced.

One disadvantage is that the qemu emulator is slower than the real device. Also the names of the java methods are known only by the java vm and not by the emulator (but this can be fixed).

Stop method tracing.

Stop qemu tracing. See startNativeTracing() to start tracing.

Tracing can be started and stopped as many times as desired. When the qemu emulator itself is stopped then the buffered trace records are flushed and written to the trace file. In fact, it is not necessary to call this method at all; simply killing qemu is sufficient. But starting and stopping a trace is useful for examining a specific region of code.

Wait until a debugger attaches. As soon as the debugger attaches, this returns, so you will need to place a breakpoint after the waitForDebugger() call if you want to start tracing immediately.

Returns "true" if one or more threads is waiting for a debugger to attach.