Google Git
Sign in
android / platform / prebuilts / fullsdk / sources / android-29 / refs/heads/androidx-emoji-release / . / android / os / Debug.java
blob: 1213eeaa747dc26f1519a93b08eb3af1c538f694 [file] [log] [blame]
/*
* Copyright (C) 2007 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package android.os;
import android.annotation.NonNull;
import android.annotation.Nullable;
import android.annotation.UnsupportedAppUsage;
import android.app.AppGlobals;
import android.content.Context;
import android.util.Log;
import com.android.internal.util.FastPrintWriter;
import com.android.internal.util.Preconditions;
import com.android.internal.util.TypedProperties;
import dalvik.system.VMDebug;
import org.apache.harmony.dalvik.ddmc.Chunk;
import org.apache.harmony.dalvik.ddmc.ChunkHandler;
import org.apache.harmony.dalvik.ddmc.DdmServer;
import java.io.File;
import java.io.FileDescriptor;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.Reader;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.HashMap;
import java.util.Map;
/**
* Provides various debugging methods for Android applications, including
* tracing and allocation counts.
* <p><strong>Logging Trace Files</strong></p>
* <p>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 <a
* href="{@docRoot}studio/profile/traceview.html">Inspect Trace Logs with
* Traceview</a> for information about reading trace files. To start logging
* trace files, call one of the startMethodTracing() methods. To stop tracing,
* call {@link #stopMethodTracing()}.
*/
public final class Debug
{
private static final String TAG = "Debug";
/**
* Flags for startMethodTracing(). These can be ORed together.
*
* TRACE_COUNT_ALLOCS adds the results from startAllocCounting to the
* trace key file.
*
* @deprecated Accurate counting is a burden on the runtime and may be removed.
*/
@Deprecated
public static final int TRACE_COUNT_ALLOCS = VMDebug.TRACE_COUNT_ALLOCS;
/**
* Flags for printLoadedClasses(). Default behavior is to only show
* the class name.
*/
public static final int SHOW_FULL_DETAIL = 1;
public static final int SHOW_CLASSLOADER = (1 << 1);
public static final int SHOW_INITIALIZED = (1 << 2);
// set/cleared by waitForDebugger()
private static volatile boolean mWaiting = false;
@UnsupportedAppUsage
private Debug() {}
/*
* How long to wait for the debugger to finish sending requests. I've
* seen this hit 800msec on the device while waiting for a response
* to travel over USB and get processed, so we take that and add
* half a second.
*/
private static final int MIN_DEBUGGER_IDLE = 1300; // msec
/* how long to sleep when polling for activity */
private static final int SPIN_DELAY = 200; // msec
/**
* Default trace file path and file
*/
private static final String DEFAULT_TRACE_BODY = "dmtrace";
private static final String DEFAULT_TRACE_EXTENSION = ".trace";
/**
* This class is used to retrieved various statistics about the memory mappings for this
* process. The returned info is broken down by dalvik, native, and other. All results are in kB.
*/
public static class MemoryInfo implements Parcelable {
/** The proportional set size for dalvik heap. (Doesn't include other Dalvik overhead.) */
public int dalvikPss;
/** The proportional set size that is swappable for dalvik heap. */
/** @hide We may want to expose this, eventually. */
@UnsupportedAppUsage
public int dalvikSwappablePss;
/** @hide The resident set size for dalvik heap. (Without other Dalvik overhead.) */
@UnsupportedAppUsage
public int dalvikRss;
/** The private dirty pages used by dalvik heap. */
public int dalvikPrivateDirty;
/** The shared dirty pages used by dalvik heap. */
public int dalvikSharedDirty;
/** The private clean pages used by dalvik heap. */
/** @hide We may want to expose this, eventually. */
@UnsupportedAppUsage
public int dalvikPrivateClean;
/** The shared clean pages used by dalvik heap. */
/** @hide We may want to expose this, eventually. */
@UnsupportedAppUsage
public int dalvikSharedClean;
/** The dirty dalvik pages that have been swapped out. */
/** @hide We may want to expose this, eventually. */
@UnsupportedAppUsage
public int dalvikSwappedOut;
/** The dirty dalvik pages that have been swapped out, proportional. */
/** @hide We may want to expose this, eventually. */
@UnsupportedAppUsage
public int dalvikSwappedOutPss;
/** The proportional set size for the native heap. */
public int nativePss;
/** The proportional set size that is swappable for the native heap. */
/** @hide We may want to expose this, eventually. */
@UnsupportedAppUsage
public int nativeSwappablePss;
/** @hide The resident set size for the native heap. */
@UnsupportedAppUsage
public int nativeRss;
/** The private dirty pages used by the native heap. */
public int nativePrivateDirty;
/** The shared dirty pages used by the native heap. */
public int nativeSharedDirty;
/** The private clean pages used by the native heap. */
/** @hide We may want to expose this, eventually. */
@UnsupportedAppUsage
public int nativePrivateClean;
/** The shared clean pages used by the native heap. */
/** @hide We may want to expose this, eventually. */
@UnsupportedAppUsage
public int nativeSharedClean;
/** The dirty native pages that have been swapped out. */
/** @hide We may want to expose this, eventually. */
@UnsupportedAppUsage
public int nativeSwappedOut;
/** The dirty native pages that have been swapped out, proportional. */
/** @hide We may want to expose this, eventually. */
@UnsupportedAppUsage
public int nativeSwappedOutPss;
/** The proportional set size for everything else. */
public int otherPss;
/** The proportional set size that is swappable for everything else. */
/** @hide We may want to expose this, eventually. */
@UnsupportedAppUsage
public int otherSwappablePss;
/** @hide The resident set size for everything else. */
@UnsupportedAppUsage
public int otherRss;
/** The private dirty pages used by everything else. */
public int otherPrivateDirty;
/** The shared dirty pages used by everything else. */
public int otherSharedDirty;
/** The private clean pages used by everything else. */
/** @hide We may want to expose this, eventually. */
@UnsupportedAppUsage
public int otherPrivateClean;
/** The shared clean pages used by everything else. */
/** @hide We may want to expose this, eventually. */
@UnsupportedAppUsage
public int otherSharedClean;
/** The dirty pages used by anyting else that have been swapped out. */
/** @hide We may want to expose this, eventually. */
@UnsupportedAppUsage
public int otherSwappedOut;
/** The dirty pages used by anyting else that have been swapped out, proportional. */
/** @hide We may want to expose this, eventually. */
@UnsupportedAppUsage
public int otherSwappedOutPss;
/** Whether the kernel reports proportional swap usage */
/** @hide */
@UnsupportedAppUsage
public boolean hasSwappedOutPss;
/** @hide */
public static final int HEAP_UNKNOWN = 0;
/** @hide */
public static final int HEAP_DALVIK = 1;
/** @hide */
public static final int HEAP_NATIVE = 2;
/** @hide */
public static final int OTHER_DALVIK_OTHER = 0;
/** @hide */
public static final int OTHER_STACK = 1;
/** @hide */
public static final int OTHER_CURSOR = 2;
/** @hide */
public static final int OTHER_ASHMEM = 3;
/** @hide */
public static final int OTHER_GL_DEV = 4;
/** @hide */
public static final int OTHER_UNKNOWN_DEV = 5;
/** @hide */
public static final int OTHER_SO = 6;
/** @hide */
public static final int OTHER_JAR = 7;
/** @hide */
public static final int OTHER_APK = 8;
/** @hide */
public static final int OTHER_TTF = 9;
/** @hide */
public static final int OTHER_DEX = 10;
/** @hide */
public static final int OTHER_OAT = 11;
/** @hide */
public static final int OTHER_ART = 12;
/** @hide */
public static final int OTHER_UNKNOWN_MAP = 13;
/** @hide */
public static final int OTHER_GRAPHICS = 14;
/** @hide */
public static final int OTHER_GL = 15;
/** @hide */
public static final int OTHER_OTHER_MEMTRACK = 16;
// Needs to be declared here for the DVK_STAT ranges below.
/** @hide */
@UnsupportedAppUsage
public static final int NUM_OTHER_STATS = 17;
// Dalvik subsections.
/** @hide */
public static final int OTHER_DALVIK_NORMAL = 17;
/** @hide */
public static final int OTHER_DALVIK_LARGE = 18;
/** @hide */
public static final int OTHER_DALVIK_ZYGOTE = 19;
/** @hide */
public static final int OTHER_DALVIK_NON_MOVING = 20;
// Section begins and ends for dumpsys, relative to the DALVIK categories.
/** @hide */
public static final int OTHER_DVK_STAT_DALVIK_START =
OTHER_DALVIK_NORMAL - NUM_OTHER_STATS;
/** @hide */
public static final int OTHER_DVK_STAT_DALVIK_END =
OTHER_DALVIK_NON_MOVING - NUM_OTHER_STATS;
// Dalvik Other subsections.
/** @hide */
public static final int OTHER_DALVIK_OTHER_LINEARALLOC = 21;
/** @hide */
public static final int OTHER_DALVIK_OTHER_ACCOUNTING = 22;
/** @hide */
public static final int OTHER_DALVIK_OTHER_CODE_CACHE = 23;
/** @hide */
public static final int OTHER_DALVIK_OTHER_COMPILER_METADATA = 24;
/** @hide */
public static final int OTHER_DALVIK_OTHER_INDIRECT_REFERENCE_TABLE = 25;
/** @hide */
public static final int OTHER_DVK_STAT_DALVIK_OTHER_START =
OTHER_DALVIK_OTHER_LINEARALLOC - NUM_OTHER_STATS;
/** @hide */
public static final int OTHER_DVK_STAT_DALVIK_OTHER_END =
OTHER_DALVIK_OTHER_INDIRECT_REFERENCE_TABLE - NUM_OTHER_STATS;
// Dex subsections (Boot vdex, App dex, and App vdex).
/** @hide */
public static final int OTHER_DEX_BOOT_VDEX = 26;
/** @hide */
public static final int OTHER_DEX_APP_DEX = 27;
/** @hide */
public static final int OTHER_DEX_APP_VDEX = 28;
/** @hide */
public static final int OTHER_DVK_STAT_DEX_START = OTHER_DEX_BOOT_VDEX - NUM_OTHER_STATS;
/** @hide */
public static final int OTHER_DVK_STAT_DEX_END = OTHER_DEX_APP_VDEX - NUM_OTHER_STATS;
// Art subsections (App image, boot image).
/** @hide */
public static final int OTHER_ART_APP = 29;
/** @hide */
public static final int OTHER_ART_BOOT = 30;
/** @hide */
public static final int OTHER_DVK_STAT_ART_START = OTHER_ART_APP - NUM_OTHER_STATS;
/** @hide */
public static final int OTHER_DVK_STAT_ART_END = OTHER_ART_BOOT - NUM_OTHER_STATS;
/** @hide */
@UnsupportedAppUsage
public static final int NUM_DVK_STATS = 14;
/** @hide */
public static final int NUM_CATEGORIES = 9;
/** @hide */
public static final int OFFSET_PSS = 0;
/** @hide */
public static final int OFFSET_SWAPPABLE_PSS = 1;
/** @hide */
public static final int OFFSET_RSS = 2;
/** @hide */
public static final int OFFSET_PRIVATE_DIRTY = 3;
/** @hide */
public static final int OFFSET_SHARED_DIRTY = 4;
/** @hide */
public static final int OFFSET_PRIVATE_CLEAN = 5;
/** @hide */
public static final int OFFSET_SHARED_CLEAN = 6;
/** @hide */
public static final int OFFSET_SWAPPED_OUT = 7;
/** @hide */
public static final int OFFSET_SWAPPED_OUT_PSS = 8;
@UnsupportedAppUsage
private int[] otherStats = new int[(NUM_OTHER_STATS+NUM_DVK_STATS)*NUM_CATEGORIES];
public MemoryInfo() {
}
/**
* @hide Copy contents from another object.
*/
public void set(MemoryInfo other) {
dalvikPss = other.dalvikPss;
dalvikSwappablePss = other.dalvikSwappablePss;
dalvikRss = other.dalvikRss;
dalvikPrivateDirty = other.dalvikPrivateDirty;
dalvikSharedDirty = other.dalvikSharedDirty;
dalvikPrivateClean = other.dalvikPrivateClean;
dalvikSharedClean = other.dalvikSharedClean;
dalvikSwappedOut = other.dalvikSwappedOut;
dalvikSwappedOutPss = other.dalvikSwappedOutPss;
nativePss = other.nativePss;
nativeSwappablePss = other.nativeSwappablePss;
nativeRss = other.nativeRss;
nativePrivateDirty = other.nativePrivateDirty;
nativeSharedDirty = other.nativeSharedDirty;
nativePrivateClean = other.nativePrivateClean;
nativeSharedClean = other.nativeSharedClean;
nativeSwappedOut = other.nativeSwappedOut;
nativeSwappedOutPss = other.nativeSwappedOutPss;
otherPss = other.otherPss;
otherSwappablePss = other.otherSwappablePss;
otherRss = other.otherRss;
otherPrivateDirty = other.otherPrivateDirty;
otherSharedDirty = other.otherSharedDirty;
otherPrivateClean = other.otherPrivateClean;
otherSharedClean = other.otherSharedClean;
otherSwappedOut = other.otherSwappedOut;
otherSwappedOutPss = other.otherSwappedOutPss;
hasSwappedOutPss = other.hasSwappedOutPss;
System.arraycopy(other.otherStats, 0, otherStats, 0, otherStats.length);
}
/**
* Return total PSS memory usage in kB.
*/
public int getTotalPss() {
return dalvikPss + nativePss + otherPss + getTotalSwappedOutPss();
}
/**
* @hide Return total PSS memory usage in kB.
*/
@UnsupportedAppUsage
public int getTotalUss() {
return dalvikPrivateClean + dalvikPrivateDirty
+ nativePrivateClean + nativePrivateDirty
+ otherPrivateClean + otherPrivateDirty;
}
/**
* Return total PSS memory usage in kB mapping a file of one of the following extension:
* .so, .jar, .apk, .ttf, .dex, .odex, .oat, .art .
*/
public int getTotalSwappablePss() {
return dalvikSwappablePss + nativeSwappablePss + otherSwappablePss;
}
/**
* @hide Return total RSS memory usage in kB.
*/
public int getTotalRss() {
return dalvikRss + nativeRss + otherRss;
}
/**
* Return total private dirty memory usage in kB.
*/
public int getTotalPrivateDirty() {
return dalvikPrivateDirty + nativePrivateDirty + otherPrivateDirty;
}
/**
* Return total shared dirty memory usage in kB.
*/
public int getTotalSharedDirty() {
return dalvikSharedDirty + nativeSharedDirty + otherSharedDirty;
}
/**
* Return total shared clean memory usage in kB.
*/
public int getTotalPrivateClean() {
return dalvikPrivateClean + nativePrivateClean + otherPrivateClean;
}
/**
* Return total shared clean memory usage in kB.
*/
public int getTotalSharedClean() {
return dalvikSharedClean + nativeSharedClean + otherSharedClean;
}
/**
* Return total swapped out memory in kB.
* @hide
*/
public int getTotalSwappedOut() {
return dalvikSwappedOut + nativeSwappedOut + otherSwappedOut;
}
/**
* Return total swapped out memory in kB, proportional.
* @hide
*/
public int getTotalSwappedOutPss() {
return dalvikSwappedOutPss + nativeSwappedOutPss + otherSwappedOutPss;
}
/** @hide */
@UnsupportedAppUsage
public int getOtherPss(int which) {
return otherStats[which * NUM_CATEGORIES + OFFSET_PSS];
}
/** @hide */
public int getOtherSwappablePss(int which) {
return otherStats[which * NUM_CATEGORIES + OFFSET_SWAPPABLE_PSS];
}
/** @hide */
public int getOtherRss(int which) {
return otherStats[which * NUM_CATEGORIES + OFFSET_RSS];
}
/** @hide */
@UnsupportedAppUsage
public int getOtherPrivateDirty(int which) {
return otherStats[which * NUM_CATEGORIES + OFFSET_PRIVATE_DIRTY];
}
/** @hide */
@UnsupportedAppUsage
public int getOtherSharedDirty(int which) {
return otherStats[which * NUM_CATEGORIES + OFFSET_SHARED_DIRTY];
}
/** @hide */
public int getOtherPrivateClean(int which) {
return otherStats[which * NUM_CATEGORIES + OFFSET_PRIVATE_CLEAN];
}
/** @hide */
@UnsupportedAppUsage
public int getOtherPrivate(int which) {
return getOtherPrivateClean(which) + getOtherPrivateDirty(which);
}
/** @hide */
public int getOtherSharedClean(int which) {
return otherStats[which * NUM_CATEGORIES + OFFSET_SHARED_CLEAN];
}
/** @hide */
public int getOtherSwappedOut(int which) {
return otherStats[which * NUM_CATEGORIES + OFFSET_SWAPPED_OUT];
}
/** @hide */
public int getOtherSwappedOutPss(int which) {
return otherStats[which * NUM_CATEGORIES + OFFSET_SWAPPED_OUT_PSS];
}
/** @hide */
@UnsupportedAppUsage
public static String getOtherLabel(int which) {
switch (which) {
case OTHER_DALVIK_OTHER: return "Dalvik Other";
case OTHER_STACK: return "Stack";
case OTHER_CURSOR: return "Cursor";
case OTHER_ASHMEM: return "Ashmem";
case OTHER_GL_DEV: return "Gfx dev";
case OTHER_UNKNOWN_DEV: return "Other dev";
case OTHER_SO: return ".so mmap";
case OTHER_JAR: return ".jar mmap";
case OTHER_APK: return ".apk mmap";
case OTHER_TTF: return ".ttf mmap";
case OTHER_DEX: return ".dex mmap";
case OTHER_OAT: return ".oat mmap";
case OTHER_ART: return ".art mmap";
case OTHER_UNKNOWN_MAP: return "Other mmap";
case OTHER_GRAPHICS: return "EGL mtrack";
case OTHER_GL: return "GL mtrack";
case OTHER_OTHER_MEMTRACK: return "Other mtrack";
case OTHER_DALVIK_NORMAL: return ".Heap";
case OTHER_DALVIK_LARGE: return ".LOS";
case OTHER_DALVIK_ZYGOTE: return ".Zygote";
case OTHER_DALVIK_NON_MOVING: return ".NonMoving";
case OTHER_DALVIK_OTHER_LINEARALLOC: return ".LinearAlloc";
case OTHER_DALVIK_OTHER_ACCOUNTING: return ".GC";
case OTHER_DALVIK_OTHER_CODE_CACHE: return ".JITCache";
case OTHER_DALVIK_OTHER_COMPILER_METADATA: return ".CompilerMetadata";
case OTHER_DALVIK_OTHER_INDIRECT_REFERENCE_TABLE: return ".IndirectRef";
case OTHER_DEX_BOOT_VDEX: return ".Boot vdex";
case OTHER_DEX_APP_DEX: return ".App dex";
case OTHER_DEX_APP_VDEX: return ".App vdex";
case OTHER_ART_APP: return ".App art";
case OTHER_ART_BOOT: return ".Boot art";
default: return "????";
}
}
/**
* Returns the value of a particular memory statistic or {@code null} if no
* such memory statistic exists.
*
* <p>The following table lists the memory statistics that are supported.
* Note that memory statistics may be added or removed in a future API level.</p>
*
* <table>
* <thead>
* <tr>
* <th>Memory statistic name</th>
* <th>Meaning</th>
* <th>Example</th>
* <th>Supported (API Levels)</th>
* </tr>
* </thead>
* <tbody>
* <tr>
* <td>summary.java-heap</td>
* <td>The private Java Heap usage in kB. This corresponds to the Java Heap field
* in the App Summary section output by dumpsys meminfo.</td>
* <td>{@code 1442}</td>
* <td>23</td>
* </tr>
* <tr>
* <td>summary.native-heap</td>
* <td>The private Native Heap usage in kB. This corresponds to the Native Heap
* field in the App Summary section output by dumpsys meminfo.</td>
* <td>{@code 1442}</td>
* <td>23</td>
* </tr>
* <tr>
* <td>summary.code</td>
* <td>The memory usage for static code and resources in kB. This corresponds to
* the Code field in the App Summary section output by dumpsys meminfo.</td>
* <td>{@code 1442}</td>
* <td>23</td>
* </tr>
* <tr>
* <td>summary.stack</td>
* <td>The stack usage in kB. This corresponds to the Stack field in the
* App Summary section output by dumpsys meminfo.</td>
* <td>{@code 1442}</td>
* <td>23</td>
* </tr>
* <tr>
* <td>summary.graphics</td>
* <td>The graphics usage in kB. This corresponds to the Graphics field in the
* App Summary section output by dumpsys meminfo.</td>
* <td>{@code 1442}</td>
* <td>23</td>
* </tr>
* <tr>
* <td>summary.private-other</td>
* <td>Other private memory usage in kB. This corresponds to the Private Other
* field output in the App Summary section by dumpsys meminfo.</td>
* <td>{@code 1442}</td>
* <td>23</td>
* </tr>
* <tr>
* <td>summary.system</td>
* <td>Shared and system memory usage in kB. This corresponds to the System
* field output in the App Summary section by dumpsys meminfo.</td>
* <td>{@code 1442}</td>
* <td>23</td>
* </tr>
* <tr>
* <td>summary.total-pss</td>
* <td>Total PPS memory usage in kB.</td>
* <td>{@code 1442}</td>
* <td>23</td>
* </tr>
* <tr>
* <td>summary.total-swap</td>
* <td>Total swap usage in kB.</td>
* <td>{@code 1442}</td>
* <td>23</td>
* </tr>
* </tbody>
* </table>
*/
public String getMemoryStat(String statName) {
switch(statName) {
case "summary.java-heap":
return Integer.toString(getSummaryJavaHeap());
case "summary.native-heap":
return Integer.toString(getSummaryNativeHeap());
case "summary.code":
return Integer.toString(getSummaryCode());
case "summary.stack":
return Integer.toString(getSummaryStack());
case "summary.graphics":
return Integer.toString(getSummaryGraphics());
case "summary.private-other":
return Integer.toString(getSummaryPrivateOther());
case "summary.system":
return Integer.toString(getSummarySystem());
case "summary.total-pss":
return Integer.toString(getSummaryTotalPss());
case "summary.total-swap":
return Integer.toString(getSummaryTotalSwap());
default:
return null;
}
}
/**
* Returns a map of the names/values of the memory statistics
* that {@link #getMemoryStat(String)} supports.
*
* @return a map of the names/values of the supported memory statistics.
*/
public Map<String, String> getMemoryStats() {
Map<String, String> stats = new HashMap<String, String>();
stats.put("summary.java-heap", Integer.toString(getSummaryJavaHeap()));
stats.put("summary.native-heap", Integer.toString(getSummaryNativeHeap()));
stats.put("summary.code", Integer.toString(getSummaryCode()));
stats.put("summary.stack", Integer.toString(getSummaryStack()));
stats.put("summary.graphics", Integer.toString(getSummaryGraphics()));
stats.put("summary.private-other", Integer.toString(getSummaryPrivateOther()));
stats.put("summary.system", Integer.toString(getSummarySystem()));
stats.put("summary.total-pss", Integer.toString(getSummaryTotalPss()));
stats.put("summary.total-swap", Integer.toString(getSummaryTotalSwap()));
return stats;
}
/**
* Pss of Java Heap bytes in KB due to the application.
* Notes:
* * OTHER_ART is the boot image. Anything private here is blamed on
* the application, not the system.
* * dalvikPrivateDirty includes private zygote, which means the
* application dirtied something allocated by the zygote. We blame
* the application for that memory, not the system.
* * Does not include OTHER_DALVIK_OTHER, which is considered VM
* Overhead and lumped into Private Other.
* * We don't include dalvikPrivateClean, because there should be no
* such thing as private clean for the Java Heap.
* @hide
*/
@UnsupportedAppUsage
public int getSummaryJavaHeap() {
return dalvikPrivateDirty + getOtherPrivate(OTHER_ART);
}
/**
* Pss of Native Heap bytes in KB due to the application.
* Notes:
* * Includes private dirty malloc space.
* * We don't include nativePrivateClean, because there should be no
* such thing as private clean for the Native Heap.
* @hide
*/
@UnsupportedAppUsage
public int getSummaryNativeHeap() {
return nativePrivateDirty;
}
/**
* Pss of code and other static resource bytes in KB due to
* the application.
* @hide
*/
@UnsupportedAppUsage
public int getSummaryCode() {
return getOtherPrivate(OTHER_SO)
+ getOtherPrivate(OTHER_JAR)
+ getOtherPrivate(OTHER_APK)
+ getOtherPrivate(OTHER_TTF)
+ getOtherPrivate(OTHER_DEX)
+ getOtherPrivate(OTHER_OAT);
}
/**
* Pss in KB of the stack due to the application.
* Notes:
* * Includes private dirty stack, which includes both Java and Native
* stack.
* * Does not include private clean stack, because there should be no
* such thing as private clean for the stack.
* @hide
*/
@UnsupportedAppUsage
public int getSummaryStack() {
return getOtherPrivateDirty(OTHER_STACK);
}
/**
* Pss in KB of graphics due to the application.
* Notes:
* * Includes private Gfx, EGL, and GL.
* * Warning: These numbers can be misreported by the graphics drivers.
* * We don't include shared graphics. It may make sense to, because
* shared graphics are likely buffers due to the application
* anyway, but it's simpler to implement to just group all shared
* memory into the System category.
* @hide
*/
@UnsupportedAppUsage
public int getSummaryGraphics() {
return getOtherPrivate(OTHER_GL_DEV)
+ getOtherPrivate(OTHER_GRAPHICS)
+ getOtherPrivate(OTHER_GL);
}
/**
* Pss in KB due to the application that haven't otherwise been
* accounted for.
* @hide
*/
@UnsupportedAppUsage
public int getSummaryPrivateOther() {
return getTotalPrivateClean()
+ getTotalPrivateDirty()
- getSummaryJavaHeap()
- getSummaryNativeHeap()
- getSummaryCode()
- getSummaryStack()
- getSummaryGraphics();
}
/**
* Pss in KB due to the system.
* Notes:
* * Includes all shared memory.
* @hide
*/
@UnsupportedAppUsage
public int getSummarySystem() {
return getTotalPss()
- getTotalPrivateClean()
- getTotalPrivateDirty();
}
/**
* Total Pss in KB.
* @hide
*/
public int getSummaryTotalPss() {
return getTotalPss();
}
/**
* Total Swap in KB.
* Notes:
* * Some of this memory belongs in other categories, but we don't
* know if the Swap memory is shared or private, so we don't know
* what to blame on the application and what on the system.
* For now, just lump all the Swap in one place.
* For kernels reporting SwapPss {@link #getSummaryTotalSwapPss()}
* will report the application proportional Swap.
* @hide
*/
public int getSummaryTotalSwap() {
return getTotalSwappedOut();
}
/**
* Total proportional Swap in KB.
* Notes:
* * Always 0 if {@link #hasSwappedOutPss} is false.
* @hide
*/
public int getSummaryTotalSwapPss() {
return getTotalSwappedOutPss();
}
/**
* Return true if the kernel is reporting pss swapped out... that is, if
* {@link #getSummaryTotalSwapPss()} will return non-0 values.
* @hide
*/
public boolean hasSwappedOutPss() {
return hasSwappedOutPss;
}
public int describeContents() {
return 0;
}
public void writeToParcel(Parcel dest, int flags) {
dest.writeInt(dalvikPss);
dest.writeInt(dalvikSwappablePss);
dest.writeInt(dalvikRss);
dest.writeInt(dalvikPrivateDirty);
dest.writeInt(dalvikSharedDirty);
dest.writeInt(dalvikPrivateClean);
dest.writeInt(dalvikSharedClean);
dest.writeInt(dalvikSwappedOut);
dest.writeInt(dalvikSwappedOutPss);
dest.writeInt(nativePss);
dest.writeInt(nativeSwappablePss);
dest.writeInt(nativeRss);
dest.writeInt(nativePrivateDirty);
dest.writeInt(nativeSharedDirty);
dest.writeInt(nativePrivateClean);
dest.writeInt(nativeSharedClean);
dest.writeInt(nativeSwappedOut);
dest.writeInt(nativeSwappedOutPss);
dest.writeInt(otherPss);
dest.writeInt(otherSwappablePss);
dest.writeInt(otherRss);
dest.writeInt(otherPrivateDirty);
dest.writeInt(otherSharedDirty);
dest.writeInt(otherPrivateClean);
dest.writeInt(otherSharedClean);
dest.writeInt(otherSwappedOut);
dest.writeInt(hasSwappedOutPss ? 1 : 0);
dest.writeInt(otherSwappedOutPss);
dest.writeIntArray(otherStats);
}
public void readFromParcel(Parcel source) {
dalvikPss = source.readInt();
dalvikSwappablePss = source.readInt();
dalvikRss = source.readInt();
dalvikPrivateDirty = source.readInt();
dalvikSharedDirty = source.readInt();
dalvikPrivateClean = source.readInt();
dalvikSharedClean = source.readInt();
dalvikSwappedOut = source.readInt();
dalvikSwappedOutPss = source.readInt();
nativePss = source.readInt();
nativeSwappablePss = source.readInt();
nativeRss = source.readInt();
nativePrivateDirty = source.readInt();
nativeSharedDirty = source.readInt();
nativePrivateClean = source.readInt();
nativeSharedClean = source.readInt();
nativeSwappedOut = source.readInt();
nativeSwappedOutPss = source.readInt();
otherPss = source.readInt();
otherSwappablePss = source.readInt();
otherRss = source.readInt();
otherPrivateDirty = source.readInt();
otherSharedDirty = source.readInt();
otherPrivateClean = source.readInt();
otherSharedClean = source.readInt();
otherSwappedOut = source.readInt();
hasSwappedOutPss = source.readInt() != 0;
otherSwappedOutPss = source.readInt();
otherStats = source.createIntArray();
}
public static final @android.annotation.NonNull Creator<MemoryInfo> CREATOR = new Creator<MemoryInfo>() {
public MemoryInfo createFromParcel(Parcel source) {
return new MemoryInfo(source);
}
public MemoryInfo[] newArray(int size) {
return new MemoryInfo[size];
}
};
private MemoryInfo(Parcel source) {
readFromParcel(source);
}
}
/**
* 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.
*/
public static void waitForDebugger() {
if (!VMDebug.isDebuggingEnabled()) {
//System.out.println("debugging not enabled, not waiting");
return;
}
if (isDebuggerConnected())
return;
// if DDMS is listening, inform them of our plight
System.out.println("Sending WAIT chunk");
byte[] data = new byte[] { 0 }; // 0 == "waiting for debugger"
Chunk waitChunk = new Chunk(ChunkHandler.type("WAIT"), data, 0, 1);
DdmServer.sendChunk(waitChunk);
mWaiting = true;
while (!isDebuggerConnected()) {
try { Thread.sleep(SPIN_DELAY); }
catch (InterruptedException ie) {}
}
mWaiting = false;
System.out.println("Debugger has connected");
/*
* There is no "ready to go" signal from the debugger, and we're
* not allowed to suspend ourselves -- the debugger expects us to
* be running happily, and gets confused if we aren't. We need to
* allow the debugger a chance to set breakpoints before we start
* running again.
*
* Sit and spin until the debugger has been idle for a short while.
*/
while (true) {
long delta = VMDebug.lastDebuggerActivity();
if (delta < 0) {
System.out.println("debugger detached?");
break;
}
if (delta < MIN_DEBUGGER_IDLE) {
System.out.println("waiting for debugger to settle...");
try { Thread.sleep(SPIN_DELAY); }
catch (InterruptedException ie) {}
} else {
System.out.println("debugger has settled (" + delta + ")");
break;
}
}
}
/**
* Returns "true" if one or more threads is waiting for a debugger
* to attach.
*/
public static boolean waitingForDebugger() {
return mWaiting;
}
/**
* Determine if a debugger is currently attached.
*/
public static boolean isDebuggerConnected() {
return VMDebug.isDebuggerConnected();
}
/**
* Returns an array of strings that identify VM features. This is
* used by DDMS to determine what sorts of operations the VM can
* perform.
*
* @hide
*/
public static String[] getVmFeatureList() {
return VMDebug.getVmFeatureList();
}
/**
* Change the JDWP port.
*
* @deprecated no longer needed or useful
*/
@Deprecated
public static void changeDebugPort(int port) {}
/**
* This is the pathname to the sysfs file that enables and disables
* tracing on the qemu emulator.
*/
private static final String SYSFS_QEMU_TRACE_STATE = "/sys/qemu_trace/state";
/**
* 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 <br />
* <code>emulator -trace foo</code><br />
* will start running the emulator and create a trace file named "foo". This
* method simply enables writing the trace records to the trace file.
*
* <p>
* The main differences between this and {@link #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.
* </p>
*
* <p>
* One limitation of using this method compared to using
* {@link #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.
* </p>
*/
public static void startNativeTracing() {
// Open the sysfs file for writing and write "1" to it.
PrintWriter outStream = null;
try {
FileOutputStream fos = new FileOutputStream(SYSFS_QEMU_TRACE_STATE);
outStream = new FastPrintWriter(fos);
outStream.println("1");
} catch (Exception e) {
} finally {
if (outStream != null)
outStream.close();
}
VMDebug.startEmulatorTracing();
}
/**
* Stop qemu tracing. See {@link #startNativeTracing()} to start tracing.
*
* <p>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.</p>
*/
public static void stopNativeTracing() {
VMDebug.stopEmulatorTracing();
// Open the sysfs file for writing and write "0" to it.
PrintWriter outStream = null;
try {
FileOutputStream fos = new FileOutputStream(SYSFS_QEMU_TRACE_STATE);
outStream = new FastPrintWriter(fos);
outStream.println("0");
} catch (Exception e) {
// We could print an error message here but we probably want
// to quietly ignore errors if we are not running in the emulator.
} finally {
if (outStream != null)
outStream.close();
}
}
/**
* 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 {@link #startNativeTracing()}.
*/
public static void enableEmulatorTraceOutput() {
VMDebug.startEmulatorTracing();
}
/**
* Start method tracing with default log name and buffer size.
* <p>
* 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 {@link Context#getExternalFilesDir(String)}.
* <p>
* See <a href="{@docRoot}studio/profile/traceview.html">Inspect Trace Logs
* with Traceview</a> for information about reading trace files.
* <p class="note">
* 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
* {@link #startMethodTracingSampling(String, int, int)} or "native" tracing
* in the emulator via {@link #startNativeTracing()}.
* </p>
*/
public static void startMethodTracing() {
VMDebug.startMethodTracing(fixTracePath(null), 0, 0, false, 0);
}
/**
* Start method tracing, specifying the trace log file path.
* <p>
* 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 {@link Context#getExternalFilesDir(String)}.
* <p>
* See <a href="{@docRoot}studio/profile/traceview.html">Inspect Trace Logs
* with Traceview</a> for information about reading trace files.
* <p class="note">
* 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
* {@link #startMethodTracingSampling(String, int, int)} or "native" tracing
* in the emulator via {@link #startNativeTracing()}.
* </p>
*
* @param tracePath Path to the trace log file to create. If {@code 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.
*/
public static void startMethodTracing(String tracePath) {
startMethodTracing(tracePath, 0, 0);
}
/**
* Start method tracing, specifying the trace log file name and the buffer
* size.
* <p>
* 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 {@link Context#getExternalFilesDir(String)}.
* <p>
* See <a href="{@docRoot}studio/profile/traceview.html">Inspect Trace Logs
* with Traceview</a> for information about reading trace files.
* <p class="note">
* 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
* {@link #startMethodTracingSampling(String, int, int)} or "native" tracing
* in the emulator via {@link #startNativeTracing()}.
* </p>
*
* @param tracePath Path to the trace log file to create. If {@code 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.
* @param bufferSize The maximum amount of trace data we gather. If not
* given, it defaults to 8MB.
*/
public static void startMethodTracing(String tracePath, int bufferSize) {
startMethodTracing(tracePath, bufferSize, 0);
}
/**
* Start method tracing, specifying the trace log file name, the buffer
* size, and flags.
* <p>
* 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 {@link Context#getExternalFilesDir(String)}.
* <p>
* See <a href="{@docRoot}studio/profile/traceview.html">Inspect Trace Logs
* with Traceview</a> for information about reading trace files.
* <p class="note">
* 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
* {@link #startMethodTracingSampling(String, int, int)} or "native" tracing
* in the emulator via {@link #startNativeTracing()}.
* </p>
*
* @param tracePath Path to the trace log file to create. If {@code 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.
* @param bufferSize The maximum amount of trace data we gather. If not
* given, it defaults to 8MB.
* @param flags Flags to control method tracing. The only one that is
* currently defined is {@link #TRACE_COUNT_ALLOCS}.
*/
public static void startMethodTracing(String tracePath, int bufferSize, int flags) {
VMDebug.startMethodTracing(fixTracePath(tracePath), bufferSize, flags, false, 0);
}
/**
* Start sampling-based method tracing, specifying the trace log file name,
* the buffer size, and the sampling interval.
* <p>
* 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 {@link Context#getExternalFilesDir(String)}.
* <p>
* See <a href="{@docRoot}studio/profile/traceview.html">Inspect Trace Logs
* with Traceview</a> for information about reading trace files.
*
* @param tracePath Path to the trace log file to create. If {@code 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.
* @param bufferSize The maximum amount of trace data we gather. If not
* given, it defaults to 8MB.
* @param intervalUs The amount of time between each sample in microseconds.
*/
public static void startMethodTracingSampling(String tracePath, int bufferSize,
int intervalUs) {
VMDebug.startMethodTracing(fixTracePath(tracePath), bufferSize, 0, true, intervalUs);
}
/**
* Formats name of trace log file for method tracing.
*/
private static String fixTracePath(String tracePath) {
if (tracePath == null || tracePath.charAt(0) != '/') {
final Context context = AppGlobals.getInitialApplication();
final File dir;
if (context != null) {
dir = context.getExternalFilesDir(null);
} else {
dir = Environment.getExternalStorageDirectory();
}
if (tracePath == null) {
tracePath = new File(dir, DEFAULT_TRACE_BODY).getAbsolutePath();
} else {
tracePath = new File(dir, tracePath).getAbsolutePath();
}
}
if (!tracePath.endsWith(DEFAULT_TRACE_EXTENSION)) {
tracePath += DEFAULT_TRACE_EXTENSION;
}
return tracePath;
}
/**
* Like startMethodTracing(String, int, int), but taking an already-opened
* FileDescriptor in which the trace is written. The file name is also
* supplied simply for logging. Makes a dup of the file descriptor.
*
* Not exposed in the SDK unless we are really comfortable with supporting
* this and find it would be useful.
* @hide
*/
public static void startMethodTracing(String traceName, FileDescriptor fd,
int bufferSize, int flags, boolean streamOutput) {
VMDebug.startMethodTracing(traceName, fd, bufferSize, flags, false, 0, streamOutput);
}
/**
* Starts method tracing without a backing file. When stopMethodTracing
* is called, the result is sent directly to DDMS. (If DDMS is not
* attached when tracing ends, the profiling data will be discarded.)
*
* @hide
*/
public static void startMethodTracingDdms(int bufferSize, int flags,
boolean samplingEnabled, int intervalUs) {
VMDebug.startMethodTracingDdms(bufferSize, flags, samplingEnabled, intervalUs);
}
/**
* Determine whether method tracing is currently active and what type is
* active.
*
* @hide
*/
public static int getMethodTracingMode() {
return VMDebug.getMethodTracingMode();
}
/**
* Stop method tracing.
*/
public static void stopMethodTracing() {
VMDebug.stopMethodTracing();
}
/**
* 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.
*/
public static long threadCpuTimeNanos() {
return VMDebug.threadCpuTimeNanos();
}
/**
* Start counting the number and aggregate size of memory allocations.
*
* <p>The {@link #startAllocCounting() start} method resets the counts and enables counting.
* The {@link #stopAllocCounting() stop} method disables the counting so that the analysis
* code doesn't cause additional allocations. The various <code>get</code> methods return
* the specified value. And the various <code>reset</code> methods reset the specified
* count.</p>
*
* <p>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.</p>
*
* @deprecated Accurate counting is a burden on the runtime and may be removed.
*/
@Deprecated
public static void startAllocCounting() {
VMDebug.startAllocCounting();
}
/**
* Stop counting the number and aggregate size of memory allocations.
*
* @deprecated Accurate counting is a burden on the runtime and may be removed.
*/
@Deprecated
public static void stopAllocCounting() {
VMDebug.stopAllocCounting();
}
/**
* Returns the global count of objects allocated by the runtime between a
* {@link #startAllocCounting() start} and {@link #stopAllocCounting() stop}.
*
* @deprecated Accurate counting is a burden on the runtime and may be removed.
*/
@Deprecated
public static int getGlobalAllocCount() {
return VMDebug.getAllocCount(VMDebug.KIND_GLOBAL_ALLOCATED_OBJECTS);
}
/**
* Clears the global count of objects allocated.
* @see #getGlobalAllocCount()
*
* @deprecated Accurate counting is a burden on the runtime and may be removed.
*/
@Deprecated
public static void resetGlobalAllocCount() {
VMDebug.resetAllocCount(VMDebug.KIND_GLOBAL_ALLOCATED_OBJECTS);
}
/**
* Returns the global size, in bytes, of objects allocated by the runtime between a
* {@link #startAllocCounting() start} and {@link #stopAllocCounting() stop}.
*
* @deprecated Accurate counting is a burden on the runtime and may be removed.
*/
@Deprecated
public static int getGlobalAllocSize() {
return VMDebug.getAllocCount(VMDebug.KIND_GLOBAL_ALLOCATED_BYTES);
}
/**
* Clears the global size of objects allocated.
* @see #getGlobalAllocSize()
*
* @deprecated Accurate counting is a burden on the runtime and may be removed.
*/
@Deprecated
public static void resetGlobalAllocSize() {
VMDebug.resetAllocCount(VMDebug.KIND_GLOBAL_ALLOCATED_BYTES);
}
/**
* Returns the global count of objects freed by the runtime between a
* {@link #startAllocCounting() start} and {@link #stopAllocCounting() stop}.
*
* @deprecated Accurate counting is a burden on the runtime and may be removed.
*/
@Deprecated
public static int getGlobalFreedCount() {
return VMDebug.getAllocCount(VMDebug.KIND_GLOBAL_FREED_OBJECTS);
}
/**
* Clears the global count of objects freed.
* @see #getGlobalFreedCount()
*
* @deprecated Accurate counting is a burden on the runtime and may be removed.
*/
@Deprecated
public static void resetGlobalFreedCount() {
VMDebug.resetAllocCount(VMDebug.KIND_GLOBAL_FREED_OBJECTS);
}
/**
* Returns the global size, in bytes, of objects freed by the runtime between a
* {@link #startAllocCounting() start} and {@link #stopAllocCounting() stop}.
*
* @deprecated Accurate counting is a burden on the runtime and may be removed.
*/
@Deprecated
public static int getGlobalFreedSize() {
return VMDebug.getAllocCount(VMDebug.KIND_GLOBAL_FREED_BYTES);
}
/**
* Clears the global size of objects freed.
* @see #getGlobalFreedSize()
*
* @deprecated Accurate counting is a burden on the runtime and may be removed.
*/
@Deprecated
public static void resetGlobalFreedSize() {
VMDebug.resetAllocCount(VMDebug.KIND_GLOBAL_FREED_BYTES);
}
/**
* Returns the number of non-concurrent GC invocations between a
* {@link #startAllocCounting() start} and {@link #stopAllocCounting() stop}.
*
* @deprecated Accurate counting is a burden on the runtime and may be removed.
*/
@Deprecated
public static int getGlobalGcInvocationCount() {
return VMDebug.getAllocCount(VMDebug.KIND_GLOBAL_GC_INVOCATIONS);
}
/**
* Clears the count of non-concurrent GC invocations.
* @see #getGlobalGcInvocationCount()
*
* @deprecated Accurate counting is a burden on the runtime and may be removed.
*/
@Deprecated
public static void resetGlobalGcInvocationCount() {
VMDebug.resetAllocCount(VMDebug.KIND_GLOBAL_GC_INVOCATIONS);
}
/**
* Returns the number of classes successfully initialized (ie those that executed without
* throwing an exception) between a {@link #startAllocCounting() start} and
* {@link #stopAllocCounting() stop}.
*
* @deprecated Accurate counting is a burden on the runtime and may be removed.
*/
@Deprecated
public static int getGlobalClassInitCount() {
return VMDebug.getAllocCount(VMDebug.KIND_GLOBAL_CLASS_INIT_COUNT);
}
/**
* Clears the count of classes initialized.
* @see #getGlobalClassInitCount()
*
* @deprecated Accurate counting is a burden on the runtime and may be removed.
*/
@Deprecated
public static void resetGlobalClassInitCount() {
VMDebug.resetAllocCount(VMDebug.KIND_GLOBAL_CLASS_INIT_COUNT);
}
/**
* Returns the time spent successfully initializing classes between a
* {@link #startAllocCounting() start} and {@link #stopAllocCounting() stop}.
*
* @deprecated Accurate counting is a burden on the runtime and may be removed.
*/
@Deprecated
public static int getGlobalClassInitTime() {
/* cumulative elapsed time for class initialization, in usec */
return VMDebug.getAllocCount(VMDebug.KIND_GLOBAL_CLASS_INIT_TIME);
}
/**
* Clears the count of time spent initializing classes.
* @see #getGlobalClassInitTime()
*
* @deprecated Accurate counting is a burden on the runtime and may be removed.
*/
@Deprecated
public static void resetGlobalClassInitTime() {
VMDebug.resetAllocCount(VMDebug.KIND_GLOBAL_CLASS_INIT_TIME);
}
/**
* This method exists for compatibility and always returns 0.
* @deprecated This method is now obsolete.
*/
@Deprecated
public static int getGlobalExternalAllocCount() {
return 0;
}
/**
* This method exists for compatibility and has no effect.
* @deprecated This method is now obsolete.
*/
@Deprecated
public static void resetGlobalExternalAllocSize() {}
/**
* This method exists for compatibility and has no effect.
* @deprecated This method is now obsolete.
*/
@Deprecated
public static void resetGlobalExternalAllocCount() {}
/**
* This method exists for compatibility and always returns 0.
* @deprecated This method is now obsolete.
*/
@Deprecated
public static int getGlobalExternalAllocSize() {
return 0;
}
/**
* This method exists for compatibility and always returns 0.
* @deprecated This method is now obsolete.
*/
@Deprecated
public static int getGlobalExternalFreedCount() {
return 0;
}
/**
* This method exists for compatibility and has no effect.
* @deprecated This method is now obsolete.
*/
@Deprecated
public static void resetGlobalExternalFreedCount() {}
/**
* This method exists for compatibility and has no effect.
* @deprecated This method is now obsolete.
*/
@Deprecated
public static int getGlobalExternalFreedSize() {
return 0;
}
/**
* This method exists for compatibility and has no effect.
* @deprecated This method is now obsolete.
*/
@Deprecated
public static void resetGlobalExternalFreedSize() {}
/**
* Returns the thread-local count of objects allocated by the runtime between a
* {@link #startAllocCounting() start} and {@link #stopAllocCounting() stop}.
*
* @deprecated Accurate counting is a burden on the runtime and may be removed.
*/
@Deprecated
public static int getThreadAllocCount() {
return VMDebug.getAllocCount(VMDebug.KIND_THREAD_ALLOCATED_OBJECTS);
}
/**
* Clears the thread-local count of objects allocated.
* @see #getThreadAllocCount()
*
* @deprecated Accurate counting is a burden on the runtime and may be removed.
*/
@Deprecated
public static void resetThreadAllocCount() {
VMDebug.resetAllocCount(VMDebug.KIND_THREAD_ALLOCATED_OBJECTS);
}
/**
* Returns the thread-local size of objects allocated by the runtime between a
* {@link #startAllocCounting() start} and {@link #stopAllocCounting() stop}.
* @return The allocated size in bytes.
*
* @deprecated Accurate counting is a burden on the runtime and may be removed.
*/
@Deprecated
public static int getThreadAllocSize() {
return VMDebug.getAllocCount(VMDebug.KIND_THREAD_ALLOCATED_BYTES);
}
/**
* Clears the thread-local count of objects allocated.
* @see #getThreadAllocSize()
*
* @deprecated Accurate counting is a burden on the runtime and may be removed.
*/
@Deprecated
public static void resetThreadAllocSize() {
VMDebug.resetAllocCount(VMDebug.KIND_THREAD_ALLOCATED_BYTES);
}
/**
* This method exists for compatibility and has no effect.
* @deprecated This method is now obsolete.
*/
@Deprecated
public static int getThreadExternalAllocCount() {
return 0;
}
/**
* This method exists for compatibility and has no effect.
* @deprecated This method is now obsolete.
*/
@Deprecated
public static void resetThreadExternalAllocCount() {}
/**
* This method exists for compatibility and has no effect.
* @deprecated This method is now obsolete.
*/
@Deprecated
public static int getThreadExternalAllocSize() {
return 0;
}
/**
* This method exists for compatibility and has no effect.
* @deprecated This method is now obsolete.
*/
@Deprecated
public static void resetThreadExternalAllocSize() {}
/**
* Returns the number of thread-local non-concurrent GC invocations between a
* {@link #startAllocCounting() start} and {@link #stopAllocCounting() stop}.
*
* @deprecated Accurate counting is a burden on the runtime and may be removed.
*/
@Deprecated
public static int getThreadGcInvocationCount() {
return VMDebug.getAllocCount(VMDebug.KIND_THREAD_GC_INVOCATIONS);
}
/**
* Clears the thread-local count of non-concurrent GC invocations.
* @see #getThreadGcInvocationCount()
*
* @deprecated Accurate counting is a burden on the runtime and may be removed.
*/
@Deprecated
public static void resetThreadGcInvocationCount() {
VMDebug.resetAllocCount(VMDebug.KIND_THREAD_GC_INVOCATIONS);
}
/**
* Clears all the global and thread-local memory allocation counters.
* @see #startAllocCounting()
*
* @deprecated Accurate counting is a burden on the runtime and may be removed.
*/
@Deprecated
public static void resetAllCounts() {
VMDebug.resetAllocCount(VMDebug.KIND_ALL_COUNTS);
}
/**
* Returns the value of a particular runtime statistic or {@code null} if no
* such runtime statistic exists.
*
* <p>The following table lists the runtime statistics that the runtime supports.
* Note runtime statistics may be added or removed in a future API level.</p>
*
* <table>
* <thead>
* <tr>
* <th>Runtime statistic name</th>
* <th>Meaning</th>
* <th>Example</th>
* <th>Supported (API Levels)</th>
* </tr>
* </thead>
* <tbody>
* <tr>
* <td>art.gc.gc-count</td>
* <td>The number of garbage collection runs.</td>
* <td>{@code 164}</td>
* <td>23</td>
* </tr>
* <tr>
* <td>art.gc.gc-time</td>
* <td>The total duration of garbage collection runs in ms.</td>
* <td>{@code 62364}</td>
* <td>23</td>
* </tr>
* <tr>
* <td>art.gc.bytes-allocated</td>
* <td>The total number of bytes that the application allocated.</td>
* <td>{@code 1463948408}</td>
* <td>23</td>
* </tr>
* <tr>
* <td>art.gc.bytes-freed</td>
* <td>The total number of bytes that garbage collection reclaimed.</td>
* <td>{@code 1313493084}</td>
* <td>23</td>
* </tr>
* <tr>
* <td>art.gc.blocking-gc-count</td>
* <td>The number of blocking garbage collection runs.</td>
* <td>{@code 2}</td>
* <td>23</td>
* </tr>
* <tr>
* <td>art.gc.blocking-gc-time</td>
* <td>The total duration of blocking garbage collection runs in ms.</td>
* <td>{@code 804}</td>
* <td>23</td>
* </tr>
* <tr>
* <td>art.gc.gc-count-rate-histogram</td>
* <td>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.</td>
* <td>{@code 0:34503,1:45350,2:11281,3:8088,4:43,5:8}</td>
* <td>23</td>
* </tr>
* <tr>
* <td>art.gc.blocking-gc-count-rate-histogram</td>
* <td>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.</td>
* <td>{@code 0:99269,1:1,2:1}</td>
* <td>23</td>
* </tr>
* </tbody>
* </table>
*
* @param statName
* the name of the runtime statistic to look up.
* @return the value of the specified runtime statistic or {@code null} if the
* runtime statistic doesn't exist.
*/
public static String getRuntimeStat(String statName) {
return VMDebug.getRuntimeStat(statName);
}
/**
* Returns a map of the names/values of the runtime statistics
* that {@link #getRuntimeStat(String)} supports.
*
* @return a map of the names/values of the supported runtime statistics.
*/
public static Map<String, String> getRuntimeStats() {
return VMDebug.getRuntimeStats();
}
/**
* Returns the size of the native heap.
* @return The size of the native heap in bytes.
*/
public static native long getNativeHeapSize();
/**
* Returns the amount of allocated memory in the native heap.
* @return The allocated size in bytes.
*/
public static native long getNativeHeapAllocatedSize();
/**
* Returns the amount of free memory in the native heap.
* @return The freed size in bytes.
*/
public static native long getNativeHeapFreeSize();
/**
* 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.
*
* <p><b>Note:</b> 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
* {@link android.app.ActivityManager#getProcessMemoryInfo(int[])} instead.</p>
*/
public static native void getMemoryInfo(MemoryInfo memoryInfo);
/**
* Note: currently only works when the requested pid has the same UID
* as the caller.
* @hide
*/
@UnsupportedAppUsage
public static native void getMemoryInfo(int pid, MemoryInfo memoryInfo);
/**
* Retrieves the PSS memory used by the process as given by the
* smaps.
*/
public static native long getPss();
/**
* Retrieves the PSS memory used by the process as given by the smaps. Optionally supply a long
* array of up to 3 entries to also receive (up to 3 values in order): the Uss and SwapPss and
* Rss (only filled in as of {@link android.os.Build.VERSION_CODES#P}) of the process, and
* another array to also retrieve the separate memtrack size.
* @hide
*/
public static native long getPss(int pid, long[] outUssSwapPssRss, long[] outMemtrack);
/** @hide */
public static final int MEMINFO_TOTAL = 0;
/** @hide */
public static final int MEMINFO_FREE = 1;
/** @hide */
public static final int MEMINFO_BUFFERS = 2;
/** @hide */
public static final int MEMINFO_CACHED = 3;
/** @hide */
public static final int MEMINFO_SHMEM = 4;
/** @hide */
public static final int MEMINFO_SLAB = 5;
/** @hide */
public static final int MEMINFO_SLAB_RECLAIMABLE = 6;
/** @hide */
public static final int MEMINFO_SLAB_UNRECLAIMABLE = 7;
/** @hide */
public static final int MEMINFO_SWAP_TOTAL = 8;
/** @hide */
public static final int MEMINFO_SWAP_FREE = 9;
/** @hide */
public static final int MEMINFO_ZRAM_TOTAL = 10;
/** @hide */
public static final int MEMINFO_MAPPED = 11;
/** @hide */
public static final int MEMINFO_VM_ALLOC_USED = 12;
/** @hide */
public static final int MEMINFO_PAGE_TABLES = 13;
/** @hide */
public static final int MEMINFO_KERNEL_STACK = 14;
/** @hide */
public static final int MEMINFO_COUNT = 15;
/**
* Retrieves /proc/meminfo. outSizes is filled with fields
* as defined by MEMINFO_* offsets.
* @hide
*/
@UnsupportedAppUsage
public static native void getMemInfo(long[] outSizes);
/**
* 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.
*
* @deprecated This method is now obsolete.
*/
@Deprecated
public static int setAllocationLimit(int limit) {
return -1;
}
/**
* 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.
*
* @deprecated This method is now obsolete.
*/
@Deprecated
public static int setGlobalAllocationLimit(int limit) {
return -1;
}
/**
* Dump a list of all currently loaded class to the log file.
*
* @param flags See constants above.
*/
public static void printLoadedClasses(int flags) {
VMDebug.printLoadedClasses(flags);
}
/**
* Get the number of loaded classes.
* @return the number of loaded classes.
*/
public static int getLoadedClassCount() {
return VMDebug.getLoadedClassCount();
}
/**
* Dump "hprof" data to the specified file. This may cause a GC.
*
* @param fileName Full pathname of output file (e.g. "/sdcard/dump.hprof").
* @throws UnsupportedOperationException if the VM was built without
* HPROF support.
* @throws IOException if an error occurs while opening or writing files.
*/
public static void dumpHprofData(String fileName) throws IOException {
VMDebug.dumpHprofData(fileName);
}
/**
* Like dumpHprofData(String), but takes an already-opened
* FileDescriptor to which the trace is written. The file name is also
* supplied simply for logging. Makes a dup of the file descriptor.
*
* Primarily for use by the "am" shell command.
*
* @hide
*/
public static void dumpHprofData(String fileName, FileDescriptor fd)
throws IOException {
VMDebug.dumpHprofData(fileName, fd);
}
/**
* Collect "hprof" and send it to DDMS. This may cause a GC.
*
* @throws UnsupportedOperationException if the VM was built without
* HPROF support.
* @hide
*/
public static void dumpHprofDataDdms() {
VMDebug.dumpHprofDataDdms();
}
/**
* Writes native heap data to the specified file descriptor.
*
* @hide
*/
@UnsupportedAppUsage
public static native void dumpNativeHeap(FileDescriptor fd);
/**
* Writes malloc info data to the specified file descriptor.
*
* @hide
*/
public static native void dumpNativeMallocInfo(FileDescriptor fd);
/**
* Returns a count of the extant instances of a class.
*
* @hide
*/
@UnsupportedAppUsage
public static long countInstancesOfClass(Class cls) {
return VMDebug.countInstancesOfClass(cls, true);
}
/**
* Returns the number of sent transactions from this process.
* @return The number of sent transactions or -1 if it could not read t.
*/
public static native int getBinderSentTransactions();
/**
* Returns the number of received transactions from the binder driver.
* @return The number of received transactions or -1 if it could not read the stats.
*/
public static native int getBinderReceivedTransactions();
/**
* Returns the number of active local Binder objects that exist in the
* current process.
*/
public static final native int getBinderLocalObjectCount();
/**
* Returns the number of references to remote proxy Binder objects that
* exist in the current process.
*/
public static final native int getBinderProxyObjectCount();
/**
* Returns the number of death notification links to Binder objects that
* exist in the current process.
*/
public static final native int getBinderDeathObjectCount();
/**
* Primes the register map cache.
*
* Only works for classes in the bootstrap class loader. Does not
* cause classes to be loaded if they're not already present.
*
* The classAndMethodDesc argument is a concatentation of the VM-internal
* class descriptor, method name, and method descriptor. Examples:
* Landroid/os/Looper;.loop:()V
* Landroid/app/ActivityThread;.main:([Ljava/lang/String;)V
*
* @param classAndMethodDesc the method to prepare
*
* @hide
*/
public static final boolean cacheRegisterMap(String classAndMethodDesc) {
return VMDebug.cacheRegisterMap(classAndMethodDesc);
}
/**
* Dumps the contents of VM reference tables (e.g. JNI locals and
* globals) to the log file.
*
* @hide
*/
@UnsupportedAppUsage
public static final void dumpReferenceTables() {
VMDebug.dumpReferenceTables();
}
/**
* API for gathering and querying instruction counts.
*
* Example usage:
* <pre>
* Debug.InstructionCount icount = new Debug.InstructionCount();
* icount.resetAndStart();
* [... do lots of stuff ...]
* if (icount.collect()) {
* System.out.println("Total instructions executed: "
* + icount.globalTotal());
* System.out.println("Method invocations: "
* + icount.globalMethodInvocations());
* }
* </pre>
*
* @deprecated Instruction counting is no longer supported.
*/
@Deprecated
public static class InstructionCount {
public InstructionCount() {
}
/**
* Reset counters and ensure counts are running. Counts may
* have already been running.
*
* @return true if counting was started
*/
public boolean resetAndStart() {
return false;
}
/**
* Collect instruction counts. May or may not stop the
* counting process.
*/
public boolean collect() {
return false;
}
/**
* Return the total number of instructions executed globally (i.e. in
* all threads).
*/
public int globalTotal() {
return 0;
}
/**
* Return the total number of method-invocation instructions
* executed globally.
*/
public int globalMethodInvocations() {
return 0;
}
}
/**
* A Map of typed debug properties.
*/
private static final TypedProperties debugProperties;
/*
* Load the debug properties from the standard files into debugProperties.
*/
static {
if (false) {
final String TAG = "DebugProperties";
final String[] files = { "/system/debug.prop", "/debug.prop", "/data/debug.prop" };
final TypedProperties tp = new TypedProperties();
// Read the properties from each of the files, if present.
for (String file : files) {
Reader r;
try {
r = new FileReader(file);
} catch (FileNotFoundException ex) {
// It's ok if a file is missing.
continue;
}
try {
tp.load(r);
} catch (Exception ex) {
throw new RuntimeException("Problem loading " + file, ex);
} finally {
try {
r.close();
} catch (IOException ex) {
// Ignore this error.
}
}
}
debugProperties = tp.isEmpty() ? null : tp;
} else {
debugProperties = null;
}
}
/**
* Returns true if the type of the field matches the specified class.
* Handles the case where the class is, e.g., java.lang.Boolean, but
* the field is of the primitive "boolean" type. Also handles all of
* the java.lang.Number subclasses.
*/
private static boolean fieldTypeMatches(Field field, Class<?> cl) {
Class<?> fieldClass = field.getType();
if (fieldClass == cl) {
return true;
}
Field primitiveTypeField;
try {
/* All of the classes we care about (Boolean, Integer, etc.)
* have a Class field called "TYPE" that points to the corresponding
* primitive class.
*/
primitiveTypeField = cl.getField("TYPE");
} catch (NoSuchFieldException ex) {
return false;
}
try {
return fieldClass == (Class<?>) primitiveTypeField.get(null);
} catch (IllegalAccessException ex) {
return false;
}
}
/**
* Looks up the property that corresponds to the field, and sets the field's value
* if the types match.
*/
private static void modifyFieldIfSet(final Field field, final TypedProperties properties,
final String propertyName) {
if (field.getType() == java.lang.String.class) {
int stringInfo = properties.getStringInfo(propertyName);
switch (stringInfo) {
case TypedProperties.STRING_SET:
// Handle as usual below.
break;
case TypedProperties.STRING_NULL:
try {
field.set(null, null); // null object for static fields; null string
} catch (IllegalAccessException ex) {
throw new IllegalArgumentException(
"Cannot set field for " + propertyName, ex);
}
return;
case TypedProperties.STRING_NOT_SET:
return;
case TypedProperties.STRING_TYPE_MISMATCH:
throw new IllegalArgumentException(
"Type of " + propertyName + " " +
" does not match field type (" + field.getType() + ")");
default:
throw new IllegalStateException(
"Unexpected getStringInfo(" + propertyName + ") return value " +
stringInfo);
}
}
Object value = properties.get(propertyName);
if (value != null) {
if (!fieldTypeMatches(field, value.getClass())) {
throw new IllegalArgumentException(
"Type of " + propertyName + " (" + value.getClass() + ") " +
" does not match field type (" + field.getType() + ")");
}
try {
field.set(null, value); // null object for static fields
} catch (IllegalAccessException ex) {
throw new IllegalArgumentException(
"Cannot set field for " + propertyName, ex);
}
}
}
/**
* Equivalent to <code>setFieldsOn(cl, false)</code>.
*
* @see #setFieldsOn(Class, boolean)
*
* @hide
*/
public static void setFieldsOn(Class<?> cl) {
setFieldsOn(cl, false);
}
/**
* Reflectively sets static fields of a class based on internal debugging
* properties. This method is a no-op if false is
* false.
* <p>
* <strong>NOTE TO APPLICATION DEVELOPERS</strong>: false will
* always be false in release builds. This API is typically only useful
* for platform developers.
* </p>
* Class setup: define a class whose only fields are non-final, static
* primitive types (except for "char") or Strings. In a static block
* after the field definitions/initializations, pass the class to
* this method, Debug.setFieldsOn(). Example:
* <pre>
* package com.example;
*
* import android.os.Debug;
*
* public class MyDebugVars {
* public static String s = "a string";
* public static String s2 = "second string";
* public static String ns = null;
* public static boolean b = false;
* public static int i = 5;
* @Debug.DebugProperty
* public static float f = 0.1f;
* @@Debug.DebugProperty
* public static double d = 0.5d;
*
* // This MUST appear AFTER all fields are defined and initialized!
* static {
* // Sets all the fields
* Debug.setFieldsOn(MyDebugVars.class);
*
* // Sets only the fields annotated with @Debug.DebugProperty
* // Debug.setFieldsOn(MyDebugVars.class, true);
* }
* }
* </pre>
* setFieldsOn() may override the value of any field in the class based
* on internal properties that are fixed at boot time.
* <p>
* These properties are only set during platform debugging, and are not
* meant to be used as a general-purpose properties store.
*
* {@hide}
*
* @param cl The class to (possibly) modify
* @param partial If false, sets all static fields, otherwise, only set
* fields with the {@link android.os.Debug.DebugProperty}
* annotation
* @throws IllegalArgumentException if any fields are final or non-static,
* or if the type of the field does not match the type of
* the internal debugging property value.
*/
public static void setFieldsOn(Class<?> cl, boolean partial) {
if (false) {
if (debugProperties != null) {
/* Only look for fields declared directly by the class,
* so we don't mysteriously change static fields in superclasses.
*/
for (Field field : cl.getDeclaredFields()) {
if (!partial || field.getAnnotation(DebugProperty.class) != null) {
final String propertyName = cl.getName() + "." + field.getName();
boolean isStatic = Modifier.isStatic(field.getModifiers());
boolean isFinal = Modifier.isFinal(field.getModifiers());
if (!isStatic || isFinal) {
throw new IllegalArgumentException(propertyName +
" must be static and non-final");
}
modifyFieldIfSet(field, debugProperties, propertyName);
}
}
}
} else {
Log.wtf(TAG,
"setFieldsOn(" + (cl == null ? "null" : cl.getName()) +
") called in non-DEBUG build");
}
}
/**
* Annotation to put on fields you want to set with
* {@link Debug#setFieldsOn(Class, boolean)}.
*
* @hide
*/
@Target({ ElementType.FIELD })
@Retention(RetentionPolicy.RUNTIME)
public @interface DebugProperty {
}
/**
* Get a debugging dump of a system service by name.
*
* <p>Most services require the caller to hold android.permission.DUMP.
*
* @param name of the service to dump
* @param fd to write dump output to (usually an output log file)
* @param args to pass to the service's dump method, may be null
* @return true if the service was dumped successfully, false if
* the service could not be found or had an error while dumping
*/
public static boolean dumpService(String name, FileDescriptor fd, String[] args) {
IBinder service = ServiceManager.getService(name);
if (service == null) {
Log.e(TAG, "Can't find service to dump: " + name);
return false;
}
try {
service.dump(fd, args);
return true;
} catch (RemoteException e) {
Log.e(TAG, "Can't dump service: " + name, e);
return false;
}
}
/**
* Append the Java stack traces of a given native process to a specified file.
*
* @param pid pid to dump.
* @param file path of file to append dump to.
* @param timeoutSecs time to wait in seconds, or 0 to wait forever.
* @hide
*/
public static native boolean dumpJavaBacktraceToFileTimeout(int pid, String file,
int timeoutSecs);
/**
* Append the native stack traces of a given process to a specified file.
*
* @param pid pid to dump.
* @param file path of file to append dump to.
* @param timeoutSecs time to wait in seconds, or 0 to wait forever.
* @hide
*/
public static native boolean dumpNativeBacktraceToFileTimeout(int pid, String file,
int timeoutSecs);
/**
* Get description of unreachable native memory.
* @param limit the number of leaks to provide info on, 0 to only get a summary.
* @param contents true to include a hex dump of the contents of unreachable memory.
* @return the String containing a description of unreachable memory.
* @hide */
public static native String getUnreachableMemory(int limit, boolean contents);
/**
* Return a String describing the calling method and location at a particular stack depth.
* @param callStack the Thread stack
* @param depth the depth of stack to return information for.
* @return the String describing the caller at that depth.
*/
private static String getCaller(StackTraceElement callStack[], int depth) {
// callStack[4] is the caller of the method that called getCallers()
if (4 + depth >= callStack.length) {
return "<bottom of call stack>";
}
StackTraceElement caller = callStack[4 + depth];
return caller.getClassName() + "." + caller.getMethodName() + ":" + caller.getLineNumber();
}
/**
* Return a string consisting of methods and locations at multiple call stack levels.
* @param depth the number of levels to return, starting with the immediate caller.
* @return a string describing the call stack.
* {@hide}
*/
@UnsupportedAppUsage
public static String getCallers(final int depth) {
final StackTraceElement[] callStack = Thread.currentThread().getStackTrace();
StringBuffer sb = new StringBuffer();
for (int i = 0; i < depth; i++) {
sb.append(getCaller(callStack, i)).append(" ");
}
return sb.toString();
}
/**
* Return a string consisting of methods and locations at multiple call stack levels.
* @param depth the number of levels to return, starting with the immediate caller.
* @return a string describing the call stack.
* {@hide}
*/
public static String getCallers(final int start, int depth) {
final StackTraceElement[] callStack = Thread.currentThread().getStackTrace();
StringBuffer sb = new StringBuffer();
depth += start;
for (int i = start; i < depth; i++) {
sb.append(getCaller(callStack, i)).append(" ");
}
return sb.toString();
}
/**
* Like {@link #getCallers(int)}, but each location is append to the string
* as a new line with <var>linePrefix</var> in front of it.
* @param depth the number of levels to return, starting with the immediate caller.
* @param linePrefix prefix to put in front of each location.
* @return a string describing the call stack.
* {@hide}
*/
public static String getCallers(final int depth, String linePrefix) {
final StackTraceElement[] callStack = Thread.currentThread().getStackTrace();
StringBuffer sb = new StringBuffer();
for (int i = 0; i < depth; i++) {
sb.append(linePrefix).append(getCaller(callStack, i)).append("\n");
}
return sb.toString();
}
/**
* @return a String describing the immediate caller of the calling method.
* {@hide}
*/
@UnsupportedAppUsage
public static String getCaller() {
return getCaller(Thread.currentThread().getStackTrace(), 0);
}
/**
* Attach a library as a jvmti agent to the current runtime, with the given classloader
* determining the library search path.
* <p>
* Note: agents may only be attached to debuggable apps. Otherwise, this function will
* throw a SecurityException.
*
* @param library the library containing the agent.
* @param options the options passed to the agent.
* @param classLoader the classloader determining the library search path.
*
* @throws IOException if the agent could not be attached.
* @throws SecurityException if the app is not debuggable.
*/
public static void attachJvmtiAgent(@NonNull String library, @Nullable String options,
@Nullable ClassLoader classLoader) throws IOException {
Preconditions.checkNotNull(library);
Preconditions.checkArgument(!library.contains("="));
if (options == null) {
VMDebug.attachAgent(library, classLoader);
} else {
VMDebug.attachAgent(library + "=" + options, classLoader);
}
}
/**
* Return the current free ZRAM usage in kilobytes.
*
* @hide
*/
public static native long getZramFreeKb();
}