Debug
class Debug
| kotlin.Any | |
| ↳ | android.os.Debug |
Provides various debugging methods for Android applications, including tracing and allocation counts.
Logging Trace Files
Debug can create log files that give details about an application, such as a call stack and start/stop times for any running methods. See Inspect Trace Logs with Traceview for information about reading trace files. To start logging trace files, call one of the startMethodTracing() methods. To stop tracing, call stopMethodTracing().
Summary
| Nested classes | |
|---|---|
|
API for gathering and querying instruction counts. |
|
|
This class is used to retrieved various statistics about the memory mappings for this process. |
|
| Constants | |
|---|---|
| static Int | |
| static Int |
Flags for printLoadedClasses(). |
| static Int | |
| static Int |
Flags for startMethodTracing(). |
| Public methods | |
|---|---|
| static Unit |
attachJvmtiAgent(library: String, options: String?, classLoader: ClassLoader?)Attach a library as a jvmti agent to the current runtime, with the given classloader determining the library search path. |
| static Unit |
changeDebugPort(port: Int)Change the JDWP port. |
| static Unit |
dumpHprofData(fileName: String!)Dump "hprof" data to the specified file. |
| static Boolean |
dumpService(name: String!, fd: FileDescriptor!, args: Array<String!>!)Get a debugging dump of a system service by name. |
| static Unit |
Enable "emulator traces", in which information about the current method is made available to the "emulator -trace" feature. |
| static Int |
Returns the number of death notification links to Binder objects that exist in the current process. |
| static Int |
Returns the number of active local Binder objects that exist in the current process. |
| static Int |
Returns the number of references to remote proxy Binder objects that exist in the current process. |
| static Int |
Returns the number of received transactions from the binder driver. |
| static Int |
Returns the number of sent transactions from this process. |
| static Int |
Returns the global count of objects allocated by the runtime between a |
| static Int |
Returns the global size, in bytes, of objects allocated by the runtime between a |
| static Int |
Returns the number of classes successfully initialized (ie those that executed without throwing an exception) between a |
| static Int |
Returns the time spent successfully initializing classes between a |
| static Int |
This method exists for compatibility and always returns 0. |
| static Int |
This method exists for compatibility and always returns 0. |
| static Int |
This method exists for compatibility and always returns 0. |
| static Int |
This method exists for compatibility and has no effect. |
| static Int |
Returns the global count of objects freed by the runtime between a |
| static Int |
Returns the global size, in bytes, of objects freed by the runtime between a |
| static Int |
Returns the number of non-concurrent GC invocations between a |
| static Int |
Get the number of loaded classes. |
| static Unit |
getMemoryInfo(memoryInfo: Debug.MemoryInfo!)Retrieves information about this processes memory usages. |
| static Long |
Returns the amount of allocated memory in the native heap. |
| static Long |
Returns the amount of free memory in the native heap. |
| static Long |
Returns the size of the native heap. |
| static Long |
getPss()Retrieves the PSS memory used by the process as given by the smaps. |
| static Long |
getRss()Retrieves the RSS memory used by the process as given by the status file. |
| static String! |
getRuntimeStat(statName: String!)Returns the value of a particular runtime statistic or |
| static MutableMap<String!, String!>! |
Returns a map of the names/values of the runtime statistics that |
| static Int |
Returns the thread-local count of objects allocated by the runtime between a |
| static Int |
Returns the thread-local size of objects allocated by the runtime between a |
| static Int |
This method exists for compatibility and has no effect. |
| static Int |
This method exists for compatibility and has no effect. |
| static Int |
Returns the number of thread-local non-concurrent GC invocations between a |
| static Boolean |
Determine if a debugger is currently attached. |
| static Unit |
printLoadedClasses(flags: Int)Dump a list of all currently loaded class to the log file. |
| static Unit |
Clears all the global and thread-local memory allocation counters. |
| static Unit |
Clears the global count of objects allocated. |
| static Unit |
Clears the global size of objects allocated. |
| static Unit |
Clears the count of classes initialized. |
| static Unit |
Clears the count of time spent initializing classes. |
| static Unit |
This method exists for compatibility and has no effect. |
| static Unit |
This method exists for compatibility and has no effect. |
| static Unit |
This method exists for compatibility and has no effect. |
| static Unit |
This method exists for compatibility and has no effect. |
| static Unit |
Clears the global count of objects freed. |
| static Unit |
Clears the global size of objects freed. |
| static Unit |
Clears the count of non-concurrent GC invocations. |
| static Unit |
Clears the thread-local count of objects allocated. |
| static Unit |
Clears the thread-local count of objects allocated. |
| static Unit |
This method exists for compatibility and has no effect. |
| static Unit |
This method exists for compatibility and has no effect. |
| static Unit |
Clears the thread-local count of non-concurrent GC invocations. |
| static Int |
setAllocationLimit(limit: Int)Establish an object allocation limit in the current thread. |
| static Int |
setGlobalAllocationLimit(limit: Int)Establish a global object allocation limit. |
| static Unit |
Start counting the number and aggregate size of memory allocations. |
| static Unit |
Start method tracing with default log name and buffer size. |
| static Unit |
startMethodTracing(tracePath: String!)Start method tracing, specifying the trace log file path. |
| static Unit |
startMethodTracing(tracePath: String!, bufferSize: Int)Start method tracing, specifying the trace log file name and the buffer size. |
| static Unit |
startMethodTracing(tracePath: String!, bufferSize: Int, flags: Int)Start method tracing, specifying the trace log file name, the buffer size, and flags. |
| static Unit |
startMethodTracingSampling(tracePath: String!, bufferSize: Int, intervalUs: Int)Start sampling-based method tracing, specifying the trace log file name, the buffer size, and the sampling interval. |
| static Unit |
Enable qemu tracing. |
| static Unit |
Stop counting the number and aggregate size of memory allocations. |
| static Unit |
Stop method tracing. |
| static Unit |
Stop qemu tracing. |
| static Long |
Get an indication of thread CPU usage. |
| static Unit |
Wait until a debugger attaches. |
| static Boolean |
Returns "true" if one or more threads is waiting for a debugger to attach. |
Constants
SHOW_FULL_DETAIL
static val SHOW_FULL_DETAIL: Int
Flags for printLoadedClasses(). Default behavior is to only show the class name.
Value: 1TRACE_COUNT_ALLOCS
static valTRACE_COUNT_ALLOCS: Int
Deprecated: Accurate counting is a burden on the runtime and may be removed.
Flags for startMethodTracing(). These can be ORed together. TRACE_COUNT_ALLOCS adds the results from startAllocCounting to the trace key file.
Value: 1Public methods
attachJvmtiAgent
static fun attachJvmtiAgent(
library: String,
options: String?,
classLoader: ClassLoader?
): Unit
Attach a library as a jvmti agent to the current runtime, with the given classloader determining the library search path.
Note: agents may only be attached to debuggable apps. Otherwise, this function will throw a SecurityException.
| Parameters | |
|---|---|
library |
String: the library containing the agent. This value cannot be null. |
options |
String?: the options passed to the agent. This value may be null. |
classLoader |
ClassLoader?: the classloader determining the library search path. This value may be null. |
| Exceptions | |
|---|---|
java.io.IOException |
if the agent could not be attached. |
java.lang.SecurityException |
if the app is not debuggable. |
changeDebugPort
static funchangeDebugPort(port: Int): Unit
Deprecated: no longer needed or useful
Change the JDWP port.
dumpHprofData
static fun dumpHprofData(fileName: String!): Unit
Dump "hprof" data to the specified file. This may cause a GC.
| Parameters | |
|---|---|
fileName |
String!: Full pathname of output file (e.g. "/sdcard/dump.hprof"). |
| Exceptions | |
|---|---|
java.lang.UnsupportedOperationException |
if the VM was built without HPROF support. |
java.io.IOException |
if an error occurs while opening or writing files. |
dumpService
static fun dumpService(
name: String!,
fd: FileDescriptor!,
args: Array<String!>!
): Boolean
Get a debugging dump of a system service by name.
Most services require the caller to hold android.permission.DUMP.
| Parameters | |
|---|---|
name |
String!: of the service to dump |
fd |
FileDescriptor!: to write dump output to (usually an output log file) |
args |
Array<String!>!: to pass to the service's dump method, may be null |
| Return | |
|---|---|
Boolean |
true if the service was dumped successfully, false if the service could not be found or had an error while dumping |
enableEmulatorTraceOutput
static funenableEmulatorTraceOutput(): Unit
Deprecated: Please use other tracing method in this class.
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().
getBinderDeathObjectCount
static fun getBinderDeathObjectCount(): Int
Returns the number of death notification links to Binder objects that exist in the current process.
getBinderLocalObjectCount
static fun getBinderLocalObjectCount(): Int
Returns the number of active local Binder objects that exist in the current process.
getBinderProxyObjectCount
static fun getBinderProxyObjectCount(): Int
Returns the number of references to remote proxy Binder objects that exist in the current process.
getBinderReceivedTransactions
static fun getBinderReceivedTransactions(): Int
Returns the number of received transactions from the binder driver.
| Return | |
|---|---|
Int |
The number of received transactions or -1 if it could not read the stats. |
getBinderSentTransactions
static fun getBinderSentTransactions(): Int
Returns the number of sent transactions from this process.
| Return | |
|---|---|
Int |
The number of sent transactions or -1 if it could not read t. |
getGlobalAllocCount
static fungetGlobalAllocCount(): Int
Deprecated: Accurate counting is a burden on the runtime and may be removed.
Returns the global count of objects allocated by the runtime between a start and stop.
getGlobalAllocSize
static fungetGlobalAllocSize(): Int
Deprecated: Accurate counting is a burden on the runtime and may be removed.
Returns the global size, in bytes, of objects allocated by the runtime between a start and stop.
getGlobalClassInitCount
static fungetGlobalClassInitCount(): Int
Deprecated: Accurate counting is a burden on the runtime and may be removed.
Returns the number of classes successfully initialized (ie those that executed without throwing an exception) between a start and stop.
getGlobalClassInitTime
static fungetGlobalClassInitTime(): Int
Deprecated: Accurate counting is a burden on the runtime and may be removed.
Returns the time spent successfully initializing classes between a start and stop.
getGlobalExternalAllocCount
static fungetGlobalExternalAllocCount(): Int
Deprecated: This method is now obsolete.
This method exists for compatibility and always returns 0.
getGlobalExternalAllocSize
static fungetGlobalExternalAllocSize(): Int
Deprecated: This method is now obsolete.
This method exists for compatibility and always returns 0.
getGlobalExternalFreedCount
static fungetGlobalExternalFreedCount(): Int
Deprecated: This method is now obsolete.
This method exists for compatibility and always returns 0.
getGlobalExternalFreedSize
static fungetGlobalExternalFreedSize(): Int
Deprecated: This method is now obsolete.
This method exists for compatibility and has no effect.
getGlobalFreedCount
static fungetGlobalFreedCount(): Int
Deprecated: Accurate counting is a burden on the runtime and may be removed.
Returns the global count of objects freed by the runtime between a start and stop.
getGlobalFreedSize
static fungetGlobalFreedSize(): Int
Deprecated: Accurate counting is a burden on the runtime and may be removed.
Returns the global size, in bytes, of objects freed by the runtime between a start and stop.
getGlobalGcInvocationCount
static fungetGlobalGcInvocationCount(): Int
Deprecated: Accurate counting is a burden on the runtime and may be removed.
Returns the number of non-concurrent GC invocations between a start and stop.
getLoadedClassCount
static fun getLoadedClassCount(): Int
Get the number of loaded classes.
| Return | |
|---|---|
Int |
the number of loaded classes. |
getMemoryInfo
static fun getMemoryInfo(memoryInfo: Debug.MemoryInfo!): Unit
Retrieves information about this processes memory usages. This information is broken down by how much is in use by dalvik, the native heap, and everything else.
Note: this method directly retrieves memory information for the given process from low-level data available to it. It may not be able to retrieve information about some protected allocations, such as graphics. If you want to be sure you can see all information about allocations by the process, use android.app.ActivityManager#getProcessMemoryInfo(int[]) instead.
getNativeHeapAllocatedSize
static fun getNativeHeapAllocatedSize(): Long
Returns the amount of allocated memory in the native heap.
| Return | |
|---|---|
Long |
The allocated size in bytes. |
getNativeHeapFreeSize
static fun getNativeHeapFreeSize(): Long
Returns the amount of free memory in the native heap.
| Return | |
|---|---|
Long |
The freed size in bytes. |
getNativeHeapSize
static fun getNativeHeapSize(): Long
Returns the size of the native heap.
| Return | |
|---|---|
Long |
The size of the native heap in bytes. |
getPss
static fun getPss(): Long
Retrieves the PSS memory used by the process as given by the smaps.
getRss
static fun getRss(): Long
Retrieves the RSS memory used by the process as given by the status file.
getRuntimeStat
static fun getRuntimeStat(statName: String!): String!
Returns the value of a particular runtime statistic or null if no such runtime statistic exists.
The following table lists the runtime statistics that the runtime supports. All statistics are approximate. Individual allocations may not be immediately reflected in the results. Note runtime statistics may be added or removed in a future API level.
| Runtime statistic name | Meaning | Example | Supported (API Levels) |
|---|---|---|---|
| art.gc.gc-count | The number of garbage collection runs. | 164 |
23 |
| art.gc.gc-time | The total duration of garbage collection runs in ms. | 62364 |
23 |
| art.gc.bytes-allocated | The total number of bytes that the application allocated. | 1463948408 |
23 |
| art.gc.bytes-freed | The total number of bytes that garbage collection reclaimed. | 1313493084 |
23 |
| art.gc.blocking-gc-count | The number of blocking garbage collection runs. | 2 |
23 |
| art.gc.blocking-gc-time | The total duration of blocking garbage collection runs in ms. | 804 |
23 |
| art.gc.gc-count-rate-histogram | Every 10 seconds, the gc-count-rate is computed as the number of garbage collection runs that have occurred over the last 10 seconds. art.gc.gc-count-rate-histogram is a histogram of the gc-count-rate samples taken since the process began. The histogram can be used to identify instances of high rates of garbage collection runs. For example, a histogram of "0:34503,1:45350,2:11281,3:8088,4:43,5:8" shows that most of the time there are between 0 and 2 garbage collection runs every 10 seconds, but there were 8 distinct 10-second intervals in which 5 garbage collection runs occurred. | 0:34503,1:45350,2:11281,3:8088,4:43,5:8 |
23 |
| art.gc.blocking-gc-count-rate-histogram | Every 10 seconds, the blocking-gc-count-rate is computed as the number of blocking garbage collection runs that have occurred over the last 10 seconds. art.gc.blocking-gc-count-rate-histogram is a histogram of the blocking-gc-count-rate samples taken since the process began. The histogram can be used to identify instances of high rates of blocking garbage collection runs. For example, a histogram of "0:99269,1:1,2:1" shows that most of the time there are zero blocking garbage collection runs every 10 seconds, but there was one 10-second interval in which one blocking garbage collection run occurred, and there was one interval in which two blocking garbage collection runs occurred. | 0:99269,1:1,2:1 |
23 |
| Parameters | |
|---|---|
statName |
String!: the name of the runtime statistic to look up. |
| Return | |
|---|---|
String! |
the value of the specified runtime statistic or null if the runtime statistic doesn't exist. |
getRuntimeStats
static fun getRuntimeStats(): MutableMap<String!, String!>!
Returns a map of the names/values of the runtime statistics that getRuntimeStat(java.lang.String) supports.
| Return | |
|---|---|
MutableMap<String!, String!>! |
a map of the names/values of the supported runtime statistics. |
getThreadAllocCount
static fungetThreadAllocCount(): Int
Deprecated: Accurate counting is a burden on the runtime and may be removed.
Returns the thread-local count of objects allocated by the runtime between a start and stop.
getThreadAllocSize
static fungetThreadAllocSize(): Int
Deprecated: Accurate counting is a burden on the runtime and may be removed.
Returns the thread-local size of objects allocated by the runtime between a start and stop.
| Return | |
|---|---|
Int |
The allocated size in bytes. |
getThreadExternalAllocCount
static fungetThreadExternalAllocCount(): Int
Deprecated: This method is now obsolete.
This method exists for compatibility and has no effect.
getThreadExternalAllocSize
static fungetThreadExternalAllocSize(): Int
Deprecated: This method is now obsolete.
This method exists for compatibility and has no effect.
getThreadGcInvocationCount
static fungetThreadGcInvocationCount(): Int
Deprecated: Accurate counting is a burden on the runtime and may be removed.
Returns the number of thread-local non-concurrent GC invocations between a start and stop.
isDebuggerConnected
static fun isDebuggerConnected(): Boolean
Determine if a debugger is currently attached.
printLoadedClasses
static fun printLoadedClasses(flags: Int): Unit
Dump a list of all currently loaded class to the log file.
| Parameters | |
|---|---|
flags |
Int: See constants above. |
resetAllCounts
static funresetAllCounts(): Unit
Deprecated: Accurate counting is a burden on the runtime and may be removed.
Clears all the global and thread-local memory allocation counters.
See Also
resetGlobalAllocCount
static funresetGlobalAllocCount(): Unit
Deprecated: Accurate counting is a burden on the runtime and may be removed.
Clears the global count of objects allocated.
See Also
resetGlobalAllocSize
static funresetGlobalAllocSize(): Unit
Deprecated: Accurate counting is a burden on the runtime and may be removed.
Clears the global size of objects allocated.
See Also
resetGlobalClassInitCount
static funresetGlobalClassInitCount(): Unit
Deprecated: Accurate counting is a burden on the runtime and may be removed.
Clears the count of classes initialized.
See Also
resetGlobalClassInitTime
static funresetGlobalClassInitTime(): Unit
Deprecated: Accurate counting is a burden on the runtime and may be removed.
Clears the count of time spent initializing classes.
See Also
resetGlobalExternalAllocCount
static funresetGlobalExternalAllocCount(): Unit
Deprecated: This method is now obsolete.
This method exists for compatibility and has no effect.
resetGlobalExternalAllocSize
static funresetGlobalExternalAllocSize(): Unit
Deprecated: This method is now obsolete.
This method exists for compatibility and has no effect.
resetGlobalExternalFreedCount
static funresetGlobalExternalFreedCount(): Unit
Deprecated: This method is now obsolete.
This method exists for compatibility and has no effect.
resetGlobalExternalFreedSize
static funresetGlobalExternalFreedSize(): Unit
Deprecated: This method is now obsolete.
This method exists for compatibility and has no effect.
resetGlobalFreedCount
static funresetGlobalFreedCount(): Unit
Deprecated: Accurate counting is a burden on the runtime and may be removed.
Clears the global count of objects freed.
See Also
resetGlobalFreedSize
static funresetGlobalFreedSize(): Unit
Deprecated: Accurate counting is a burden on the runtime and may be removed.
Clears the global size of objects freed.
See Also
resetGlobalGcInvocationCount
static funresetGlobalGcInvocationCount(): Unit
Deprecated: Accurate counting is a burden on the runtime and may be removed.
Clears the count of non-concurrent GC invocations.
See Also
resetThreadAllocCount
static funresetThreadAllocCount(): Unit
Deprecated: Accurate counting is a burden on the runtime and may be removed.
Clears the thread-local count of objects allocated.
See Also
resetThreadAllocSize
static funresetThreadAllocSize(): Unit
Deprecated: Accurate counting is a burden on the runtime and may be removed.
Clears the thread-local count of objects allocated.
See Also
resetThreadExternalAllocCount
static funresetThreadExternalAllocCount(): Unit
Deprecated: This method is now obsolete.
This method exists for compatibility and has no effect.
resetThreadExternalAllocSize
static funresetThreadExternalAllocSize(): Unit
Deprecated: This method is now obsolete.
This method exists for compatibility and has no effect.
resetThreadGcInvocationCount
static funresetThreadGcInvocationCount(): Unit
Deprecated: Accurate counting is a burden on the runtime and may be removed.
Clears the thread-local count of non-concurrent GC invocations.
See Also
setAllocationLimit
static funsetAllocationLimit(limit: Int): Int
Deprecated: This method is now obsolete.
Establish an object allocation limit in the current thread. This feature was never enabled in release builds. The allocation limits feature was removed in Honeycomb. This method exists for compatibility and always returns -1 and has no effect.
setGlobalAllocationLimit
static funsetGlobalAllocationLimit(limit: Int): Int
Deprecated: This method is now obsolete.
Establish a global object allocation limit. This feature was never enabled in release builds. The allocation limits feature was removed in Honeycomb. This method exists for compatibility and always returns -1 and has no effect.
startAllocCounting
static funstartAllocCounting(): Unit
Deprecated: Accurate counting is a burden on the runtime and may be removed.
Start counting the number and aggregate size of memory allocations.
The start method resets the counts and enables counting. The stop method disables the counting so that the analysis code doesn't cause additional allocations. The various get methods return the specified value. And the various reset methods reset the specified count.
Counts are kept for the system as a whole (global) and for each thread. The per-thread counts for threads other than the current thread are not cleared by the "reset" or "start" calls.
startMethodTracing
static fun startMethodTracing(): Unit
Start method tracing with default log name and buffer size.
By default, the trace file is called "dmtrace.trace" and it's placed under your package-specific directory on primary shared/external storage, as returned by Context#getExternalFilesDir(String).
See Inspect Trace Logs with Traceview for information about reading trace files.
When method tracing is enabled, the VM will run more slowly than usual, so the timings from the trace files should only be considered in relative terms (e.g. was run #1 faster than run #2). The times for native methods will not change, so don't try to use this to compare the performance of interpreted and native implementations of the same method. As an alternative, consider using sampling-based method tracing via startMethodTracingSampling(java.lang.String,int,int) or "native" tracing in the emulator via startNativeTracing().
startMethodTracing
static fun startMethodTracing(tracePath: String!): Unit
Start method tracing, specifying the trace log file path.
When a relative file path is given, the trace file will be placed under your package-specific directory on primary shared/external storage, as returned by Context#getExternalFilesDir(String).
See Inspect Trace Logs with Traceview for information about reading trace files.
When method tracing is enabled, the VM will run more slowly than usual, so the timings from the trace files should only be considered in relative terms (e.g. was run #1 faster than run #2). The times for native methods will not change, so don't try to use this to compare the performance of interpreted and native implementations of the same method. As an alternative, consider using sampling-based method tracing via startMethodTracingSampling(java.lang.String,int,int) or "native" tracing in the emulator via startNativeTracing().
| Parameters | |
|---|---|
tracePath |
String!: Path to the trace log file to create. If null, this will default to "dmtrace.trace". If the file already exists, it will be truncated. If the path given does not end in ".trace", it will be appended for you. |
startMethodTracing
static fun startMethodTracing(
tracePath: String!,
bufferSize: Int
): Unit
Start method tracing, specifying the trace log file name and the buffer size.
When a relative file path is given, the trace file will be placed under your package-specific directory on primary shared/external storage, as returned by Context#getExternalFilesDir(String).
See Inspect Trace Logs with Traceview for information about reading trace files.
When method tracing is enabled, the VM will run more slowly than usual, so the timings from the trace files should only be considered in relative terms (e.g. was run #1 faster than run #2). The times for native methods will not change, so don't try to use this to compare the performance of interpreted and native implementations of the same method. As an alternative, consider using sampling-based method tracing via startMethodTracingSampling(java.lang.String,int,int) or "native" tracing in the emulator via startNativeTracing().
| Parameters | |
|---|---|
tracePath |
String!: Path to the trace log file to create. If null, this will default to "dmtrace.trace". If the file already exists, it will be truncated. If the path given does not end in ".trace", it will be appended for you. |
bufferSize |
Int: The maximum amount of trace data we gather. If not given, it defaults to 8MB. |
startMethodTracing
static fun startMethodTracing(
tracePath: String!,
bufferSize: Int,
flags: Int
): Unit
Start method tracing, specifying the trace log file name, the buffer size, and flags.
When a relative file path is given, the trace file will be placed under your package-specific directory on primary shared/external storage, as returned by Context#getExternalFilesDir(String).
See Inspect Trace Logs with Traceview for information about reading trace files.
When method tracing is enabled, the VM will run more slowly than usual, so the timings from the trace files should only be considered in relative terms (e.g. was run #1 faster than run #2). The times for native methods will not change, so don't try to use this to compare the performance of interpreted and native implementations of the same method. As an alternative, consider using sampling-based method tracing via startMethodTracingSampling(java.lang.String,int,int) or "native" tracing in the emulator via startNativeTracing().
| Parameters | |
|---|---|
tracePath |
String!: Path to the trace log file to create. If null, this will default to "dmtrace.trace". If the file already exists, it will be truncated. If the path given does not end in ".trace", it will be appended for you. |
bufferSize |
Int: The maximum amount of trace data we gather. If not given, it defaults to 8MB. |
flags |
Int: Flags to control method tracing. The only one that is currently defined is TRACE_COUNT_ALLOCS. |
startMethodTracingSampling
static fun startMethodTracingSampling(
tracePath: String!,
bufferSize: Int,
intervalUs: Int
): Unit
Start sampling-based method tracing, specifying the trace log file name, the buffer size, and the sampling interval.
When a relative file path is given, the trace file will be placed under your package-specific directory on primary shared/external storage, as returned by Context#getExternalFilesDir(String).
See Inspect Trace Logs with Traceview for information about reading trace files.
| Parameters | |
|---|---|
tracePath |
String!: Path to the trace log file to create. If null, this will default to "dmtrace.trace". If the file already exists, it will be truncated. If the path given does not end in ".trace", it will be appended for you. |
bufferSize |
Int: The maximum amount of trace data we gather. If not given, it defaults to 8MB. |
intervalUs |
Int: The amount of time between each sample in microseconds. |
startNativeTracing
static fun startNativeTracing(): Unit
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 limitation of using this method compared to using startMethodTracing() on the real device is that the emulator does not model all of the real hardware effects such as memory and bus contention. The emulator also has a simple cache model and cannot capture all the complexities of a real cache.
stopAllocCounting
static funstopAllocCounting(): Unit
Deprecated: Accurate counting is a burden on the runtime and may be removed.
Stop counting the number and aggregate size of memory allocations.
stopNativeTracing
static fun stopNativeTracing(): Unit
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.
threadCpuTimeNanos
static fun threadCpuTimeNanos(): Long
Get an indication of thread CPU usage. The value returned indicates the amount of time that the current thread has spent executing code or waiting for certain types of I/O. The time is expressed in nanoseconds, and is only meaningful when compared to the result from an earlier call. Note that nanosecond resolution does not imply nanosecond accuracy. On system which don't support this operation, the call returns -1.
waitForDebugger
static fun waitForDebugger(): Unit
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.
waitingForDebugger
static fun waitingForDebugger(): Boolean
Returns "true" if one or more threads is waiting for a debugger to attach.